Replace group fields with accessors, too

This does the same thing: it hides the fact that a group's name is actually within an Arc.

examples/example.rs

@@ -11,5 +11,5 @@ fn main() {
 	println!("Your username is {}", you.name());
 
 	let primary_group = cache.get_group_by_gid(you.primary_group_id()).expect("No entry for your primary group!");
-	println!("Your primary group has ID {} and name {}", primary_group.gid, primary_group.name);
+	println!("Your primary group has ID {} and name {}", primary_group.gid(), primary_group.name());
 }

examples/os.rs

@@ -14,7 +14,7 @@ fn main() {
 	println!("Your home directory is {}", you.home_dir().display());
 
 	let primary_group = cache.get_group_by_gid(you.primary_group_id()).expect("No entry for your primary group!");
-	println!("Your primary group has ID {} and name {}", primary_group.gid, primary_group.name);
+	println!("Your primary group has ID {} and name {}", primary_group.gid(), primary_group.name());
 
 	if primary_group.members().is_empty() {
 		println!("There are no other members of that group.");

src/base.rs

@@ -134,20 +134,13 @@ impl User {
 /// Information about a particular group.
 #[derive(Clone)]
 pub struct Group {
-
-    /// This group's ID
-    pub gid: gid_t,
-
-    /// This group's name
-    pub name: Arc<String>,
-
+    gid: gid_t,
+    pub name_arc: Arc<String>,
     extras: os::GroupExtras,
-
-    // Vector of the names of the users who belong to this group as a non-primary member
-    //pub members: Vec<String>,
 }
 
 impl Group {
+
     /// Create a new `Group` with the given group ID and name, with the
     /// rest of the fields filled in with dummy values.
     ///
@@ -156,10 +149,18 @@ impl Group {
     pub fn new(gid: gid_t, name: &str) -> Self {
         Group {
             gid: gid,
-            name: Arc::new(String::from(name)),
+            name_arc: Arc::new(String::from(name)),
             extras: os::GroupExtras::default(),
         }
     }
+
+    pub fn gid(&self) -> gid_t {
+        self.gid.clone()
+    }
+
+    pub fn name(&self) -> &str {
+        &**self.name_arc
+    }
 }
 
 /// Reads data from a `*char` field in `c_passwd` or `g_group` into a UTF-8
@@ -208,9 +209,9 @@ unsafe fn struct_to_group(pointer: *const c_group) -> Option<Group> {
         let name = Arc::new(from_raw_buf(group.gr_name));
 
         Some(Group {
-            gid:     group.gr_gid,
-            name:    name,
-            extras:  os::GroupExtras::from_struct(group),
+            gid:       group.gr_gid,
+            name_arc:  name,
+            extras:    os::GroupExtras::from_struct(group),
         })
     }
     else {
@@ -325,7 +326,7 @@ pub fn get_current_gid() -> gid_t {
 /// Returns the groupname of the user running the process.
 pub fn get_current_groupname() -> Option<String> {
     let gid = get_current_gid();
-    get_group_by_gid(gid).map(|g| Arc::try_unwrap(g.name).unwrap())
+    get_group_by_gid(gid).map(|g| Arc::try_unwrap(g.name_arc).unwrap())
 }
 
 /// Returns the group ID for the effective user running the process.
@@ -336,7 +337,7 @@ pub fn get_effective_gid() -> gid_t {
 /// Returns the groupname of the effective user running the process.
 pub fn get_effective_groupname() -> Option<String> {
     let gid = get_effective_gid();
-    get_group_by_gid(gid).map(|g| Arc::try_unwrap(g.name).unwrap())
+    get_group_by_gid(gid).map(|g| Arc::try_unwrap(g.name_arc).unwrap())
 }
 
 
@@ -600,10 +601,10 @@ mod test {
         let cur_uid = get_current_uid();
         let cur_user = get_user_by_uid(cur_uid).unwrap();
         let cur_group = get_group_by_gid(cur_user.primary_group).unwrap();
-        let group_by_name = get_group_by_name(&cur_group.name);
+        let group_by_name = get_group_by_name(&cur_group.name());
 
         assert!(group_by_name.is_some());
-        assert_eq!(group_by_name.unwrap().name, cur_group.name);
+        assert_eq!(group_by_name.unwrap().name(), cur_group.name());
 
         // Group names containing '\0' cannot be used (for now)
         let group = get_group_by_name("users\0");

src/cache.rs

@@ -228,7 +228,7 @@ impl Groups for UsersCache {
                 let group = super::get_group_by_gid(gid);
                 match group {
                     Some(group) => {
-                        let new_group_name = group.name.clone();
+                        let new_group_name = group.name_arc.clone();
                         let mut groups_backward = self.groups.backward.borrow_mut();
                         groups_backward.insert(new_group_name, Some(gid));
 
@@ -257,7 +257,7 @@ impl Groups for UsersCache {
                 match user {
                     Some(group) => {
                         let group_arc = Arc::new(group.clone());
-                        let gid = group.gid;
+                        let gid = group.gid();
 
                         let mut groups_forward = self.groups.forward.borrow_mut();
                         groups_forward.insert(gid, Some(group_arc.clone()));
@@ -294,7 +294,7 @@ impl Groups for UsersCache {
 
     fn get_current_groupname(&self) -> Option<Arc<String>> {
         let gid = self.get_current_gid();
-        self.get_group_by_gid(gid).map(|g| g.name.clone())
+        self.get_group_by_gid(gid).map(|g| g.name_arc.clone())
     }
 
     fn get_effective_gid(&self) -> gid_t {
@@ -310,6 +310,6 @@ impl Groups for UsersCache {
 
     fn get_effective_groupname(&self) -> Option<Arc<String>> {
         let gid = self.get_effective_gid();
-        self.get_group_by_gid(gid).map(|g| g.name.clone())
+        self.get_group_by_gid(gid).map(|g| g.name_arc.clone())
     }
 }

src/lib.rs

@@ -91,7 +91,7 @@
 //! use users::{Users, Groups, UsersCache};
 //! let mut cache = UsersCache::new();
 //! let group = cache.get_group_by_name("admin").expect("No such group 'admin'!");
-//! println!("The '{}' group has the ID {}", group.name, group.gid);
+//! println!("The '{}' group has the ID {}", group.name(), group.gid());
 //! ```
 //!
 //!

src/mock.rs

@@ -89,7 +89,7 @@ impl MockUsers {
 
     /// Add a group to the groups table.
     pub fn add_group(&mut self, group: Group) -> Option<Arc<Group>> {
-        self.groups.insert(group.gid, Arc::new(group))
+        self.groups.insert(group.gid(), Arc::new(group))
     }
 }
 
@@ -125,7 +125,7 @@ impl Groups for MockUsers {
     }
 
     fn get_group_by_name(&self, group_name: &str) -> Option<Arc<Group>> {
-        self.groups.values().find(|g| &*g.name == group_name).cloned()
+        self.groups.values().find(|g| g.name() == group_name).cloned()
     }
 
     fn get_current_gid(&self) -> uid_t {
@@ -133,7 +133,7 @@ impl Groups for MockUsers {
     }
 
     fn get_current_groupname(&self) -> Option<Arc<String>> {
-        self.groups.get(&self.uid).map(|u| u.name.clone())
+        self.groups.get(&self.uid).map(|u| u.name_arc.clone())
     }
 
     fn get_effective_gid(&self) -> uid_t {
@@ -141,7 +141,7 @@ impl Groups for MockUsers {
     }
 
     fn get_effective_groupname(&self) -> Option<Arc<String>> {
-        self.groups.get(&self.uid).map(|u| u.name.clone())
+        self.groups.get(&self.uid).map(|u| u.name_arc.clone())
     }
 }
 
@@ -198,26 +198,26 @@ mod test {
     fn gid() {
         let mut users = MockUsers::with_current_uid(0);
         users.add_group(Group::new(1337, "fred"));
-        assert_eq!(Some(Arc::new("fred".into())), users.get_group_by_gid(1337).map(|g| g.name.clone()))
+        assert_eq!(Some(Arc::new("fred".into())), users.get_group_by_gid(1337).map(|g| g.name_arc.clone()))
     }
 
     #[test]
     fn group_name() {
         let mut users = MockUsers::with_current_uid(0);
         users.add_group(Group::new(1337, "fred"));
-        assert_eq!(Some(1337), users.get_group_by_name("fred").map(|g| g.gid))
+        assert_eq!(Some(1337), users.get_group_by_name("fred").map(|g| g.gid()))
     }
 
     #[test]
     fn no_group_name() {
         let mut users = MockUsers::with_current_uid(0);
         users.add_group(Group::new(1337, "fred"));
-        assert_eq!(None, users.get_group_by_name("santa").map(|g| g.gid))
+        assert_eq!(None, users.get_group_by_name("santa").map(|g| g.gid()))
     }
 
     #[test]
     fn no_gid() {
         let users = MockUsers::with_current_uid(0);
-        assert_eq!(None, users.get_group_by_gid(1337).map(|g| g.name.clone()))
+        assert_eq!(None, users.get_group_by_gid(1337).map(|g| g.name_arc.clone()))
     }
 }