Made a specific id for names.

src/name.rs

@@ -1,11 +1,14 @@
 use crate::mtterror::{ErrorID, MTTError};
 use isolang::Language;
-use std::{collections::HashMap, fmt};
+use std::{
+    collections::{HashMap, HashSet},
+    fmt,
+};
 use uuid::Uuid;
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum NameType {
-    ID(Uuid),
+    ID(NameID),
     Name(Name),
     None,
 }
@@ -29,14 +32,14 @@ impl From<&Name> for NameType {
     }
 }
 
-impl From<Uuid> for NameType {
-    fn from(value: Uuid) -> Self {
+impl From<NameID> for NameType {
+    fn from(value: NameID) -> Self {
         Self::ID(value)
     }
 }
 
-impl From<&Uuid> for NameType {
-    fn from(value: &Uuid) -> Self {
+impl From<&NameID> for NameType {
+    fn from(value: &NameID) -> Self {
         let id = value.clone();
         Self::from(id)
     }
@@ -84,10 +87,48 @@ pub mod test_support {
     }
 }
 
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct NameID {
+    data: Uuid,
+}
+
+impl NameID {
+    fn new() -> Self {
+        Self {
+            data: Uuid::new_v4(),
+        }
+    }
+
+    fn nil() -> Self {
+        Self { data: Uuid::nil() }
+    }
+}
+
+#[cfg(test)]
+pub mod name_id_support {
+    use super::*;
+
+    pub fn test_name_id() -> NameID {
+        NameID::new()
+    }
+}
+
+#[cfg(test)]
+mod name_ids {
+    use super::*;
+
+    #[test]
+    fn are_name_ids_random() {
+        let id1 = NameID::new();
+        let id2 = NameID::new();
+        assert_ne!(id1, id2);
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct Names {
-    names: HashMap<Name, Uuid>,
-    ids: HashMap<Uuid, HashMap<Language, Name>>,
+    names: HashMap<Name, NameID>,
+    ids: HashMap<NameID, HashMap<Language, Name>>,
 }
 
 impl Names {
@@ -98,7 +139,7 @@ impl Names {
         }
     }
 
-    pub fn add_names(&mut self, names: Vec<Name>) -> Result<Uuid, MTTError> {
+    pub fn add_names(&mut self, names: Vec<Name>) -> Result<NameID, MTTError> {
         let mut languages: Vec<&Language> = Vec::new();
         for name in names.iter() {
             let lang = name.get_language();
@@ -113,9 +154,9 @@ impl Names {
                 return Err(err);
             }
         }
-        let mut id = Uuid::new_v4();
+        let mut id = NameID::new();
         while self.ids.contains_key(&id) {
-            id = Uuid::new_v4();
+            id = NameID::new();
         }
         for name in names.iter() {
             self.names.insert(name.clone(), id.clone());
@@ -126,7 +167,7 @@ impl Names {
         Ok(id)
     }
 
-    pub fn get_id<NT>(&self, name: NT) -> Result<Uuid, MTTError>
+    pub fn get_id<NT>(&self, name: NT) -> Result<NameID, MTTError>
     where
         NT: Into<NameType>,
     {
@@ -140,16 +181,20 @@ impl Names {
                 if self.ids.contains_key(&data) {
                     Ok(data)
                 } else {
-                    if data == Uuid::nil() {
+                    if data == NameID::nil() {
                         Ok(data)
                     } else {
                         Err(MTTError::new(ErrorID::NameNotFound(name_type)))
                     }
                 }
             }
-            NameType::None => Ok(Uuid::nil()),
+            NameType::None => Ok(NameID::nil()),
         }
     }
+
+    pub fn get_ids(&self) -> HashSet<NameID> {
+        self.ids.keys().cloned().collect()
+    }
 }
 
 #[cfg(test)]
@@ -173,7 +218,7 @@ mod names {
         let mut names = Names::new();
         let id = names.add_names(vec![name.clone()]).unwrap();
         assert_eq!(names.get_id(name).unwrap(), id);
-        assert_eq!(names.get_id(id).unwrap(), id);
+        assert_eq!(names.get_id(&id).unwrap(), id);
     }
 
     #[test]
@@ -192,7 +237,7 @@ mod names {
     fn are_name_ids_unique() {
         let mut names = Names::new();
         let data = ["one", "two", "three", "four", "five"];
-        let mut ids: HashSet<Uuid> = HashSet::new();
+        let mut ids: HashSet<NameID> = HashSet::new();
         for item in data.iter() {
             let name = Name::english(item);
             ids.insert(names.add_names([name].to_vec()).unwrap());
@@ -245,7 +290,7 @@ mod names {
 
     #[test]
     fn errors_on_bad_id() {
-        let id = Uuid::new_v4();
+        let id = NameID::new();
         let expected: NameType = id.clone().into();
         let names = Names::new();
         match names.get_id(id.clone()) {
@@ -256,4 +301,25 @@ mod names {
             },
         }
     }
+
+    #[test]
+    fn able_to_get_name_ids() {
+        let count = 5;
+        let mut data: Vec<Name> = Vec::new();
+        for i in 0..count {
+            let name = Name::english(format!("name{}", i).as_str());
+            data.push(name);
+        }
+        let mut names = Names::new();
+        for name in data.iter() {
+            names.add_names(vec![name.clone()]).unwrap();
+        }
+        let mut result = names.get_ids();
+        assert_eq!(result.len(), count);
+        for name in data.iter() {
+            let id = names.get_id(name).unwrap();
+            assert!(result.remove(&id), "id {:?} was missing", id);
+        }
+        assert_eq!(result.len(), 0, "still has {:?} ids", result);
+    }
 }