Made name ids available to document file.

src/message.rs

@@ -201,7 +201,7 @@ mod msgactions {
         let value = DocDef::new(name.clone());
         let result: MsgAction = value.into();
         match result {
-            MsgAction::Create(def) => assert_eq!(def.get_document_name(), &name),
+            MsgAction::Create(def) => assert_eq!(def.get_document_names(), &[name].to_vec()),
             _ => unreachable!("Got {:?}: dhould have been create", result),
         }
     }
@@ -590,18 +590,22 @@ impl Names {
         }
     }
 
-    fn add_name(&mut self, name: Name) -> Result<Uuid, MTTError> {
-        if self.names.contains_key(&name) {
-            return Err(MTTError::NameDuplicate(name));
+    fn add_names(&mut self, names: Vec<Name>) -> Result<Uuid, MTTError> {
+        for name in names.iter() {
+            if self.names.contains_key(&name) {
+                return Err(MTTError::NameDuplicate(name.clone()));
+            }
         }
         let mut id = Uuid::new_v4();
         while self.ids.contains_key(&id) {
             id = Uuid::new_v4();
         }
-        self.names.insert(name.clone(), id.clone());
-        let mut holder: HashMap<Language, Name> = HashMap::new();
-        holder.insert(name.get_language().clone(), name);
-        self.ids.insert(id.clone(), holder);
+        for name in names.iter() {
+            self.names.insert(name.clone(), id.clone());
+            let mut holder: HashMap<Language, Name> = HashMap::new();
+            holder.insert(name.get_language().clone(), name.clone());
+            self.ids.insert(id.clone(), holder);
+        }
         Ok(id)
     }
 
@@ -701,7 +705,7 @@ mod names {
         let mut ids: HashSet<Uuid> = HashSet::new();
         for item in data.iter() {
             let name = Name::english(item.clone());
-            ids.insert(names.add_name(name).unwrap());
+            ids.insert(names.add_names([name].to_vec()).unwrap());
         }
         assert_eq!(ids.len(), data.len());
     }
@@ -713,7 +717,7 @@ mod names {
         let mut ids: HashMap<Name, Uuid> = HashMap::new();
         for item in data.iter() {
             let name = Name::english(item.clone());
-            ids.insert(name.clone(), names.add_name(name).unwrap());
+            ids.insert(name.clone(), names.add_names([name].to_vec()).unwrap());
         }
         for (name, id) in ids.iter() {
             assert_eq!(
@@ -759,7 +763,7 @@ mod names {
         let mut names = Names::new();
         let name = Name::english("task");
         let lang = Language::from_639_1("ja").unwrap();
-        let id = names.add_name(name).unwrap();
+        let id = names.add_names([name].to_vec()).unwrap();
         let result = names.get_name(&id, &lang);
         match result {
             Ok(_) => unreachable!("got {:?}, should be invalid id error", result),
@@ -775,8 +779,8 @@ mod names {
         let mut names = Names::new();
         let data = "test";
         let name = Name::english(data);
-        let id = names.add_name(name.clone());
-        let output = names.add_name(name.clone());
+        let id = names.add_names([name.clone()].to_vec());
+        let output = names.add_names([name.clone()].to_vec());
         match output {
             Ok(_) => unreachable!(
                 "got {:?}, should have produced duplicate name error",
@@ -796,7 +800,7 @@ mod names {
         let alt = "テスト";
         let english = Name::english(data);
         let japanese = Name::japanese(alt);
-        let id = names.add_name(english.clone()).unwrap();
+        let id = names.add_names([english.clone()].to_vec()).unwrap();
         let result = names.add_translation(english, japanese.clone()).unwrap();
         assert_eq!(result, id);
         let output = names.get_name(&id, &Language::from_639_1("ja").unwrap());
@@ -828,8 +832,8 @@ mod names {
         let alt = "テスト";
         let english = Name::english(data);
         let japanese = Name::japanese(alt);
-        let id = names.add_name(english.clone()).unwrap();
-        let id = names.add_name(japanese.clone()).unwrap();
+        let id = names.add_names([english.clone()].to_vec()).unwrap();
+        let id = names.add_names([japanese.clone()].to_vec()).unwrap();
         let result = names.add_translation(english, japanese.clone());
         match result {
             Ok(_) => unreachable!(
@@ -848,7 +852,7 @@ mod names {
         let mut names = Names::new();
         let data = "data";
         let english = Name::english(data);
-        let id = names.add_name(english.clone()).unwrap();
+        let id = names.add_names([english.clone()].to_vec()).unwrap();
         let msg_id = Uuid::new_v4();
         let action = Action::Query;
         let path = Path::new(
@@ -867,7 +871,7 @@ mod names {
         let mut names = Names::new();
         let data = "data";
         let english = Name::english(data);
-        let id = names.add_name(english.clone()).unwrap();
+        let id = names.add_names([english.clone()].to_vec()).unwrap();
         let msg_id = Uuid::new_v4();
         let action = Action::Error;
         let path = Path::new(
@@ -960,7 +964,8 @@ mod names {
 #[derive(Clone, Debug)]
 enum RegMsg {
     AddRoute(Path),
-    AddDocName(Name),
+    AddDocName(Vec<Name>),
+    DocumentNameID(Uuid),
     Error(MTTError),
     Ok,
 }
@@ -1205,8 +1210,8 @@ impl DocRegistry {
 
     fn register_action(&mut self, reg: &Register) -> Register {
         match reg.get_msg() {
-            RegMsg::AddDocName(name) => match self.doc_names.add_name(name.clone()) {
-                Ok(_) => reg.response(RegMsg::Ok),
+            RegMsg::AddDocName(names) => match self.doc_names.add_names(names.clone()) {
+                Ok(id) => reg.response(RegMsg::DocumentNameID(id.clone())),
                 Err(err) => reg.response(RegMsg::Error(err)),
             },
             RegMsg::AddRoute(path) => {
@@ -1388,7 +1393,7 @@ mod queues {
         fn add_document(&mut self, name: Name) {
             let (tx, rx) = channel();
             let id = self.queue.add_sender(tx);
-            let reg_msg = Register::new(id.clone(), RegMsg::AddDocName(name.clone()));
+            let reg_msg = Register::new(id.clone(), RegMsg::AddDocName([name.clone()].to_vec()));
             let msg = Message::new(NameType::None, reg_msg);
             self.queue.send(msg.clone()).unwrap();
             let result = rx.recv_timeout(TIMEOUT).unwrap();
@@ -1456,26 +1461,49 @@ mod queues {
     }
 
     #[test]
-    fn can_register_document_name() {
+    fn document_names_have_unique_id() {
         let mut tester = TestQueue::new();
         let mut queue = tester.get_queue();
-        let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
+        let names = [
+            Name::english("one"),
+            Name::english("two"),
+            Name::english("three"),
+            Name::english("four"),
+            Name::english("five"),
+        ];
+        let mut ids: Vec<Uuid> = Vec::new();
+        for name in names.iter() {
+            let reg_msg = Register::new(
+                tester.get_preset_id().clone(),
+                RegMsg::AddDocName([name.clone()].to_vec()),
+            );
+            let msg = Message::new(NameType::None, reg_msg);
+            queue.send(msg.clone()).unwrap();
+            let result = tester.get_preset_rx().recv_timeout(TIMEOUT).unwrap();
+            assert_eq!(result.get_message_id(), msg.get_message_id());
+            let action = result.get_action();
+            match action {
+                MsgAction::Register(data) => match data.get_msg() {
+                    RegMsg::DocumentNameID(data) => {
+                        assert!(!ids.contains(data), "{} already in {:?}", data, ids);
+                        ids.push(data.clone());
+                    }
+                    _ => unreachable!("got {:?}, should have been register ok", action),
+                },
+                _ => unreachable!("got {:?}, should have been register ok", action),
+            }
+        }
+    }
+
+    #[test]
+    fn can_register_multiple_names_at_once() {
+        let mut tester = TestQueue::new();
+        let mut queue = tester.get_queue();
+        let names = [Name::english("one"), Name::japanese("一")].to_vec();
         let reg_msg = Register::new(
             tester.get_preset_id().clone(),
-            RegMsg::AddDocName(doc_name.clone()),
+            RegMsg::AddDocName(names.clone()),
         );
-        let msg = Message::new(NameType::None, reg_msg);
-        queue.send(msg.clone()).unwrap();
-        let result = tester.get_preset_rx().recv_timeout(TIMEOUT).unwrap();
-        assert_eq!(result.get_message_id(), msg.get_message_id());
-        let action = result.get_action();
-        match action {
-            MsgAction::Register(data) => match data.get_msg() {
-                RegMsg::Ok => {}
-                _ => unreachable!("got {:?}, should have been register ok", action),
-            },
-            _ => unreachable!("got {:?}, should have been register ok", action),
-        }
     }
 
     #[test]
@@ -1486,7 +1514,7 @@ mod queues {
         let doc_name = Name::english(Uuid::new_v4().to_string().as_str());
         let reg_msg = Register::new(
             tester.get_preset_id().clone(),
-            RegMsg::AddDocName(doc_name.clone()),
+            RegMsg::AddDocName([doc_name.clone()].to_vec()),
         );
         let msg = Message::new(NameType::None, reg_msg.clone());
         queue.send(msg.clone()).unwrap();
@@ -2475,9 +2503,19 @@ impl IndexType {
     }
 }
 
+#[derive(Clone, Debug)]
+struct Triggers {
+    /*
+     * HashMap<DocumentName, HashMap<ActionType, MsgAction>>
+     * document name
+     * action type
+     * response action
+     */
+}
+
 #[derive(Clone, Debug)]
 struct DocDef {
-    doc_name: Name,
+    doc_names: Vec<Name>,
     field_names: Names,
     fields: HashMap<Uuid, FieldSetting>,
     indexes: HashMap<Uuid, IndexType>,
@@ -2486,15 +2524,19 @@ struct DocDef {
 impl DocDef {
     fn new(name: Name) -> Self {
         Self {
-            doc_name: name,
+            doc_names: [name].to_vec(),
             field_names: Names::new(),
             fields: HashMap::new(),
             indexes: HashMap::new(),
         }
     }
 
-    fn get_document_name(&self) -> &Name {
-        &self.doc_name
+    fn with_names(names: Name) -> Self {
+        todo!("with an existing list of names");
+    }
+
+    fn get_document_names(&self) -> &Vec<Name> {
+        &self.doc_names
     }
 
     fn get_field_names(&self) -> &Names {
@@ -2506,7 +2548,7 @@ impl DocDef {
     }
 
     fn add_field(&mut self, name: Name, ftype: FieldType) {
-        let id = self.field_names.add_name(name).unwrap();
+        let id = self.field_names.add_names([name].to_vec()).unwrap();
         self.fields.insert(id, FieldSetting::new(ftype));
     }
 
@@ -3546,7 +3588,7 @@ mod records {
         let mut name_ids: HashMap<Name, Uuid> = HashMap::new();
         for id in ids.iter() {
             let name = Name::english(id.clone().to_string().as_str());
-            let field_id = names.add_name(name.clone()).unwrap();
+            let field_id = names.add_names([name.clone()].to_vec()).unwrap();
             name_ids.insert(name, field_id);
         }
         let mut rec = Record::new(names);
@@ -3606,7 +3648,7 @@ mod records {
     fn does_get_error_on_missing_data() {
         let mut names = Names::new();
         let name = Name::english("empty");
-        names.add_name(name.clone()).unwrap();
+        names.add_names([name.clone()].to_vec()).unwrap();
         let mut rec = Record::new(names);
         match rec.get(&name) {
             Ok(_) => unreachable!("should return not found error"),
@@ -3621,7 +3663,7 @@ mod records {
     fn can_records_hold_multiple_entries() {
         let field_name = Name::english("field");
         let mut names = Names::new();
-        names.add_name(field_name.clone());
+        names.add_names([field_name.clone()].to_vec());
         let count: isize = 5;
         let mut recs = RecordIter::new();
         assert_eq!(recs.len(), 0, "should contain no records");
@@ -3648,7 +3690,7 @@ mod records {
         for i in 0..count {
             let name = Name::english(i.to_string().as_str());
             let mut names = Names::new();
-            names.add_name(name);
+            names.add_names([name].to_vec());
             recs.push(Record::new(names));
         }
         let mut rec_iter = RecordIter::new();
@@ -3667,8 +3709,8 @@ mod records {
         let mut names = Names::new();
         let name1 = Name::english("first");
         let name2 = Name::english("second");
-        names.add_name(name1.clone()).unwrap();
-        names.add_name(name2.clone()).unwrap();
+        names.add_names([name1.clone()].to_vec()).unwrap();
+        names.add_names([name2.clone()].to_vec()).unwrap();
         let mut rec1 = Record::new(names.clone());
         rec1.insert(&name1, 1);
         rec1.insert(&name2, 2);
@@ -4207,46 +4249,48 @@ impl DocumentFile {
             MsgAction::Create(data) => data.clone(),
             _ => unreachable!("got {:?}: should have been a create message", action),
         };
-        let name = docdef.get_document_name();
+        let names = docdef.get_document_names();
         let id = queue.add_sender(tx);
-        let reg_msg = Register::new(id, RegMsg::AddDocName(name.clone()));
+        let reg_msg = Register::new(id, RegMsg::AddDocName(names.clone()));
         let rmsg = msg.response(reg_msg.clone());
         queue.send(rmsg.clone()).unwrap();
         let name_result = rx.recv().unwrap();
-        match name_result.get_action() {
+        let name_id = match name_result.get_action() {
             MsgAction::Register(data) => match data.get_msg() {
+                RegMsg::DocumentNameID(data) => data,
                 RegMsg::Error(err) => {
                     queue.remove_sender(&id);
                     queue.send(msg.response(err.clone())).unwrap();
+                    return;
                 }
-                _ => {}
+                _ => unreachable!("should only return a name id or an error"),
             },
-            _ => unreachable!("should return registration"),
-        }
+            _ => unreachable!("should only return a name id or an error"),
+        };
         let routes = [
             Path::new(
                 Include::All,
-                Include::Some(name.into()),
+                Include::Some(name_id.into()),
                 Include::Some(Action::Addition),
             ),
             Path::new(
                 Include::All,
-                Include::Some(name.into()),
+                Include::Some(name_id.into()),
                 Include::Some(Action::Delete),
             ),
             Path::new(
                 Include::All,
-                Include::Some(name.into()),
+                Include::Some(name_id.into()),
                 Include::Some(Action::Query),
             ),
             Path::new(
                 Include::All,
-                Include::Some(name.into()),
+                Include::Some(name_id.into()),
                 Include::Some(Action::Show),
             ),
             Path::new(
                 Include::All,
-                Include::Some(name.into()),
+                Include::Some(name_id.into()),
                 Include::Some(Action::Update),
             ),
         ];
@@ -4556,12 +4600,15 @@ mod document_files {
         where
             A: Into<MsgAction>,
         {
-            let msg = Message::new(self.docdef.get_document_name().clone(), action);
+            let msg = Message::new(self.docdef.get_document_names()[0].clone(), action);
             self.queue.send(msg)
         }
 
         fn start(&mut self) {
-            let msg = Message::new(self.docdef.get_document_name().clone(), self.docdef.clone());
+            let msg = Message::new(
+                self.docdef.get_document_names()[0].clone(),
+                self.docdef.clone(),
+            );
             DocumentFile::start(self.queue.clone(), msg);
             for route in self.routes.iter() {
                 let request =
@@ -4672,7 +4719,10 @@ mod document_files {
         let mut test_doc: TestDocument = docdef.into();
         test_doc.start();
         let queue = test_doc.get_queue();
-        let reg_msg = Register::new(test_doc.get_sender_id(), RegMsg::AddDocName(alt.clone()));
+        let reg_msg = Register::new(
+            test_doc.get_sender_id(),
+            RegMsg::AddDocName([alt.clone()].to_vec()),
+        );
         let setup = Message::new(NameType::None, reg_msg.clone());
         queue.send(setup).unwrap();
         test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -4798,7 +4848,7 @@ mod document_files {
         addition.add_field(name.clone(), "doesn't matter");
         queue
             .send(Message::new(
-                test_doc.get_docdef().get_document_name(),
+                test_doc.get_docdef().get_document_names()[0].clone(),
                 addition,
             ))
             .unwrap();
@@ -4820,7 +4870,7 @@ mod document_files {
         let mut addition = Addition::new();
         addition.add_field(Name::english("field0"), "string");
         queue.send(Message::new(
-            test_doc.get_docdef().get_document_name(),
+            test_doc.get_docdef().get_document_names()[0].clone(),
             addition,
         ));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -4847,7 +4897,7 @@ mod document_files {
         let mut addition = Addition::new();
         addition.add_field(Name::english("field0"), 1);
         queue.send(Message::new(
-            test_doc.get_docdef().get_document_name(),
+            test_doc.get_docdef().get_document_names()[0].clone(),
             addition,
         ));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -4877,7 +4927,7 @@ mod document_files {
         let mut query = Query::new();
         query.add(Name::english("field0"), calc);
         queue.send(Message::new(
-            test_doc.get_docdef().get_document_name(),
+            test_doc.get_docdef().get_document_names()[0].clone(),
             query,
         ));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -4917,7 +4967,7 @@ mod document_files {
         let mut query = Query::new();
         query.add(Name::english("field0"), calc);
         queue.send(Message::new(
-            test_doc.get_docdef().get_document_name(),
+            test_doc.get_docdef().get_document_names()[0].clone(),
             query,
         ));
         let result = test_doc.get_receiver().recv_timeout(TIMEOUT).unwrap();
@@ -5068,7 +5118,7 @@ mod document_files {
     fn errors_on_bad_field_name() {
         let mut doc = TestDocument::new(Vec::new());
         doc.start();
-        let doc_name = doc.get_docdef().get_document_name().clone();
+        let doc_name = doc.get_docdef().get_document_names()[0].clone();
         let queue = doc.get_queue();
         let rx = doc.get_receiver();
         let field_name = Name::english("wrong");
@@ -5255,7 +5305,7 @@ mod document_files {
     fn changes_information_requested() {
         let mut doc = TestDocument::new([FieldType::Uuid, FieldType::StaticString].to_vec());
         doc.start();
-        let doc_name = doc.get_docdef().get_document_name().clone();
+        let doc_name = doc.get_docdef().get_document_names()[0].clone();
         let old = "old";
         let new = "new";
         let id = Uuid::new_v4();
@@ -5294,7 +5344,7 @@ mod document_files {
     fn changes_only_the_queried() {
         let mut doc = TestDocument::new([FieldType::Integer, FieldType::StaticString].to_vec());
         doc.start();
-        let doc_name = doc.get_docdef().get_document_name().clone();
+        let doc_name = doc.get_docdef().get_document_names()[0].clone();
         let old = "old";
         let new = "new";
         let count = 5;
@@ -5352,7 +5402,7 @@ mod document_files {
     fn can_handle_multiple_updates() {
         let mut doc = TestDocument::new([FieldType::Integer, FieldType::StaticString].to_vec());
         doc.start();
-        let doc_name = doc.get_docdef().get_document_name().clone();
+        let doc_name = doc.get_docdef().get_document_names()[0].clone();
         let old = "old";
         let new = "new";
         let count = 5;
@@ -5845,7 +5895,7 @@ impl Clock {
         let clock = Clock::new(queue.clone());
         let (tx, rx) = channel();
         let id = queue.add_sender(tx);
-        let reg_msg = Register::new(id, RegMsg::AddDocName(Name::english("clock")));
+        let reg_msg = Register::new(id, RegMsg::AddDocName([Name::english("clock")].to_vec()));
         let msg = Message::new(NameType::None, reg_msg.clone());
         queue.send(msg).unwrap();
         rx.recv().unwrap();