Made SenderID a structure.

src/document/create.rs

@@ -401,7 +401,7 @@ impl DocumentFile {
         };
         let names = docdef.get_document_names();
         let id = queue.add_sender(tx);
-        let reg_msg = Register::new(id, RegMsg::AddDocName(names.clone()));
+        let reg_msg = Register::new(id.clone(), RegMsg::AddDocName(names.clone()));
         let rmsg = msg.response(reg_msg.clone());
         queue.send(rmsg.clone());
         let name_result = rx.recv().unwrap();

src/queue.rs

@@ -1,2 +1,4 @@
 pub mod data_director;
 pub mod router;
+
+pub use router::SenderID;

src/queue/data_director.rs

@@ -1,3 +1,4 @@
+use super::SenderID;
 use crate::{
     action::{Action, MsgAction},
     message::{wrapper::Message, MessageAction},
@@ -55,18 +56,18 @@ pub enum RegMsg {
     Error(MTTError),
     GetNameID(Name),
     Ok,
-    RemoveSender(Uuid),
+    RemoveSender(SenderID),
     RouteID(RouteID),
 }
 
 #[derive(Clone, Debug)]
 pub struct Register {
     msg: RegMsg,
-    sender_id: Uuid,
+    sender_id: SenderID,
 }
 
 impl Register {
-    pub fn new(sender_id: Uuid, reg_msg: RegMsg) -> Self {
+    pub fn new(sender_id: SenderID, reg_msg: RegMsg) -> Self {
         Self {
             msg: reg_msg,
             sender_id: sender_id,
@@ -77,7 +78,7 @@ impl Register {
         &self.msg
     }
 
-    pub fn get_sender_id(&self) -> &Uuid {
+    pub fn get_sender_id(&self) -> &SenderID {
         &self.sender_id
     }
 
@@ -99,13 +100,13 @@ mod registries {
     #[test]
     fn does_registry_store_data() {
         let name_id = test_name_id();
-        let sender_data_id = Uuid::new_v4();
+        let sender_data_id = SenderID::new();
         let inputs = [
             RegMsg::DocumentNameID(name_id.clone()),
             RegMsg::RemoveSender(sender_data_id.clone()),
         ];
         for regmsg in inputs.iter() {
-            let sender_id = Uuid::new_v4();
+            let sender_id = SenderID::new();
             let reg = Register::new(sender_id.clone(), regmsg.clone());
             assert_eq!(reg.doc_name(), &NameType::None);
             assert_eq!(reg.get_sender_id(), &sender_id);
@@ -275,7 +276,7 @@ impl From<Route> for RouteID {
 }
 
 struct RouteStorage {
-    data: HashMap<RouteID, HashSet<Uuid>>,
+    data: HashMap<RouteID, HashSet<SenderID>>,
 }
 
 impl RouteStorage {
@@ -285,7 +286,7 @@ impl RouteStorage {
         }
     }
 
-    fn add(&mut self, route: Route, sender_id: Uuid) -> RouteID {
+    fn add(&mut self, route: Route, sender_id: SenderID) -> RouteID {
         let route_id: RouteID = route.into();
         let set = match self.data.get_mut(&route_id) {
             Some(result) => result,
@@ -299,7 +300,7 @@ impl RouteStorage {
         route_id
     }
 
-    fn remove_sender_id(&mut self, sender_id: &Uuid) {
+    fn remove_sender_id(&mut self, sender_id: &SenderID) {
         let mut removal: Vec<RouteID> = Vec::new();
         for (route_id, set) in self.data.iter_mut() {
             set.remove(sender_id);
@@ -312,7 +313,7 @@ impl RouteStorage {
         }
     }
 
-    fn get(&self, route: Route) -> HashSet<Uuid> {
+    fn get(&self, route: Route) -> HashSet<SenderID> {
         let mut output = HashSet::new();
         for (route_id, set) in self.data.iter() {
             if route == route_id.into() {
@@ -330,8 +331,8 @@ mod route_storeage {
     #[test]
     fn can_add_routes() {
         let mut routes = RouteStorage::new();
-        let id1 = Uuid::new_v4();
-        let id2 = Uuid::new_v4();
+        let id1 = SenderID::new();
+        let id2 = SenderID::new();
         let route1 = Route::new(Include::Just(Uuid::new_v4()), Include::All, Include::All);
         let route2 = Route::new(Include::Just(Uuid::new_v4()), Include::All, Include::All);
         let route_id1 = routes.add(route1.clone(), id1.clone());
@@ -368,9 +369,9 @@ mod route_storeage {
     fn returns_all_entries_using_the_same_route() {
         let count = 5;
         let mut routes = RouteStorage::new();
-        let mut ids: HashSet<Uuid> = HashSet::new();
+        let mut ids: HashSet<SenderID> = HashSet::new();
         while ids.len() < count {
-            ids.insert(Uuid::new_v4());
+            ids.insert(SenderID::new());
         }
         let route = Route::new(Include::Just(Uuid::new_v4()), Include::All, Include::All);
         for id in ids.iter() {
@@ -384,7 +385,7 @@ mod route_storeage {
     fn routes_are_not_duplicated() {
         let count = 5;
         let mut routes = RouteStorage::new();
-        let id = Uuid::new_v4();
+        let id = SenderID::new();
         let route = Route::new(Include::Just(Uuid::new_v4()), Include::All, Include::All);
         for _ in 0..count {
             routes.add(route.clone(), id.clone());
@@ -397,8 +398,8 @@ mod route_storeage {
     #[test]
     fn overlapping_routes_are_combined() {
         let mut routes = RouteStorage::new();
-        let id1 = Uuid::new_v4();
-        let id2 = Uuid::new_v4();
+        let id1 = SenderID::new();
+        let id2 = SenderID::new();
         let route1 = Route::new(Include::Just(Uuid::new_v4()), Include::All, Include::All);
         let route2 = Route::new(Include::Just(Uuid::new_v4()), Include::All, Include::All);
         routes.add(route1.clone(), id1.clone());
@@ -414,9 +415,9 @@ mod route_storeage {
     fn can_remove_sender_id() {
         let mut routes = RouteStorage::new();
         let count = 5;
-        let mut ids: HashSet<Uuid> = HashSet::new();
+        let mut ids: HashSet<SenderID> = HashSet::new();
         while ids.len() < count {
-            ids.insert(Uuid::new_v4());
+            ids.insert(SenderID::new());
         }
         let route = Route::new(Include::Just(Uuid::new_v4()), Include::All, Include::All);
         for id in ids.iter() {
@@ -432,7 +433,7 @@ mod route_storeage {
     #[test]
     fn empty_routes_are_release_memory() {
         let mut routes = RouteStorage::new();
-        let id = Uuid::new_v4();
+        let id = SenderID::new();
         let route = Route::new(Include::Just(Uuid::new_v4()), Include::All, Include::All);
         routes.add(route.clone(), id.clone());
         routes.remove_sender_id(&id);

src/queue/router.rs

@@ -12,9 +12,44 @@ use std::{
 };
 use uuid::Uuid;
 
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct SenderID {
+    data: Uuid,
+}
+
+impl SenderID {
+    pub fn new() -> Self {
+        Self {
+            data: Uuid::new_v4(),
+        }
+    }
+
+    fn nil() -> Self {
+        Self { data: Uuid::nil() }
+    }
+}
+
+#[cfg(test)]
+mod sender_ids {
+    use super::*;
+
+    #[test]
+    fn are_sender_ids_unique() {
+        let id1 = SenderID::new();
+        let id2 = SenderID::new();
+        assert!(id1 != id2, "ids should be random");
+    }
+
+    #[test]
+    fn is_nil_available() {
+        let id = SenderID::nil();
+        assert_eq!(id.data, Uuid::nil());
+    }
+}
+
 struct Router {
     doc_registry: Sender<Message>,
-    senders: HashMap<Uuid, Sender<Message>>,
+    senders: HashMap<SenderID, Sender<Message>>,
 }
 
 impl Router {
@@ -25,23 +60,23 @@ impl Router {
         }
     }
 
-    fn add_sender(&mut self, sender: Sender<Message>) -> Uuid {
-        let mut id = Uuid::new_v4();
+    fn add_sender(&mut self, sender: Sender<Message>) -> SenderID {
+        let mut id = SenderID::new();
         while self.senders.contains_key(&id) {
-            id = Uuid::new_v4();
+            id = SenderID::new();
         }
         self.senders.insert(id.clone(), sender);
         id
     }
 
-    fn remove_sender(&mut self, id: &Uuid) {
-        let action = Register::new(Uuid::nil(), RegMsg::RemoveSender(id.clone()));
+    fn remove_sender(&mut self, id: &SenderID) {
+        let action = Register::new(SenderID::nil(), RegMsg::RemoveSender(id.clone()));
         self.doc_registry.send(Message::new(action)).unwrap();
         self.senders.remove(id);
     }
 
-    fn forward(&self, id: &Uuid, msg: Message) {
-        if id == &Uuid::nil() {
+    fn forward(&self, id: &SenderID, msg: Message) {
+        if id == &SenderID::nil() {
             return;
         }
         match self.senders.get(id) {
@@ -70,17 +105,17 @@ impl Queue {
         output
     }
 
-    pub fn add_sender(&mut self, sender: Sender<Message>) -> Uuid {
+    pub fn add_sender(&mut self, sender: Sender<Message>) -> SenderID {
         let mut router = self.router.write().unwrap();
         router.add_sender(sender)
     }
 
-    pub fn remove_sender(&mut self, id: &Uuid) {
+    pub fn remove_sender(&mut self, id: &SenderID) {
         let mut router = self.router.write().unwrap();
         router.remove_sender(id);
     }
 
-    pub fn forward(&self, id: &Uuid, msg: Message) {
+    pub fn forward(&self, id: &SenderID, msg: Message) {
         let router = self.router.read().unwrap();
         router.forward(id, msg);
     }
@@ -145,14 +180,14 @@ mod routers {
     fn can_forward_message() {
         let mut setup = Setup::new();
         let router = setup.get_router_mut();
-        let mut receivers: HashMap<Uuid, Receiver<Message>> = HashMap::new();
+        let mut receivers: HashMap<SenderID, Receiver<Message>> = HashMap::new();
         for _ in 0..10 {
             let (tx, rx) = channel();
             let id = router.add_sender(tx);
             receivers.insert(id, rx);
         }
         for (id, recv) in receivers.iter() {
-            let msg = Message::new(Query::new(Name::english(id.to_string().as_str())));
+            let msg = Message::new(Query::new(Name::english("something")));
             router.forward(id, msg.clone());
             let result = recv.recv_timeout(TIMEOUT).unwrap();
             assert_eq!(result.get_message_id(), msg.get_message_id());
@@ -164,7 +199,7 @@ mod routers {
         let mut setup = Setup::new();
         let router = setup.get_router_mut();
         let count = 10;
-        let mut holder: HashSet<Uuid> = HashSet::new();
+        let mut holder: HashSet<SenderID> = HashSet::new();
         for _ in 0..count {
             let (tx, _) = channel();
             holder.insert(router.add_sender(tx));
@@ -176,7 +211,7 @@ mod routers {
     fn can_remove_sender() {
         let mut setup = Setup::new();
         let router = setup.get_router_mut();
-        let mut receivers: HashMap<Uuid, Receiver<Message>> = HashMap::new();
+        let mut receivers: HashMap<SenderID, Receiver<Message>> = HashMap::new();
         for _ in 0..10 {
             let (tx, rx) = channel();
             let id = router.add_sender(tx);
@@ -207,7 +242,7 @@ mod routers {
             _ => unreachable!("got {:?}, should have been register", action),
         }
         for (id, recv) in receivers.iter() {
-            let msg = Message::new(Query::new(Name::english(id.to_string().as_str())));
+            let msg = Message::new(Query::new(Name::english("something")));
             router.forward(id, msg.clone());
             let result = recv.recv_timeout(TIMEOUT).unwrap();
             assert_eq!(result.get_message_id(), msg.get_message_id());
@@ -218,7 +253,7 @@ mod routers {
     fn ignores_bad_id_removals() {
         let mut setup = Setup::new();
         let router = setup.get_router_mut();
-        let removed = Uuid::new_v4();
+        let removed = SenderID::new();
         router.remove_sender(&removed);
         assert_eq!(router.senders.len(), 0, "should have no senders.");
         let announce = setup.recv().unwrap();
@@ -251,7 +286,7 @@ mod queues {
     struct Setup {
         test_mod: Queue,
         rx: Receiver<Message>,
-        rx_id: Uuid,
+        rx_id: SenderID,
     }
 
     impl Setup {