Made add path return route id.

src/message.rs

@@ -469,7 +469,7 @@ mod includes {
     }
 }
 
-#[derive(Clone, Eq, Hash, PartialEq)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
 struct RouteID {
     action: Option<Action>,
     doc_type: Option<Uuid>,
@@ -991,6 +991,7 @@ enum RegMsg {
     Error(MTTError),
     GetNameID(Name),
     Ok,
+    RouteID(RouteID),
 }
 
 #[derive(Clone, Debug)]
@@ -1266,7 +1267,7 @@ impl DocRegistry {
                     }
                 };
                 senders.insert(reg.get_sender_id().clone());
-                reg.response(RegMsg::Ok)
+                reg.response(RegMsg::RouteID(route_id))
             }
             RegMsg::GetNameID(name) => match self.doc_names.get_id(name) {
                 Ok(id) => reg.response(RegMsg::DocumentNameID(id.clone())),
@@ -1417,7 +1418,8 @@ mod queues {
         sender_id: Uuid,
         queue: Queue,
         receiver: Receiver<Message>,
-        doc_id: HashMap<Name, Uuid>,
+        doc_names: HashMap<Name, Uuid>,
+        doc_tx_id: HashMap<Name, Uuid>,
         doc_rx: HashMap<Name, Receiver<Message>>,
     }
 
@@ -1430,7 +1432,8 @@ mod queues {
                 sender_id: id,
                 queue: queue,
                 receiver: rx,
-                doc_id: HashMap::new(),
+                doc_names: HashMap::new(),
+                doc_tx_id: HashMap::new(),
                 doc_rx: HashMap::new(),
             }
         }
@@ -1441,8 +1444,16 @@ mod queues {
             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();
+            match rx.recv_timeout(TIMEOUT).unwrap().get_action() {
-            self.doc_id.insert(name.clone(), id);
+                MsgAction::Register(doc_data) => match doc_data.get_msg() {
+                    RegMsg::DocumentNameID(data) => {
+                        self.doc_names.insert(name.clone(), data.clone())
+                    }
+                    _ => panic!("should not get here"),
+                },
+                _ => panic!("should not get here"),
+            };
+            self.doc_tx_id.insert(name.clone(), id);
             self.doc_rx.insert(name.clone(), rx);
         }
 
@@ -1454,8 +1465,12 @@ mod queues {
             &self.receiver
         }
 
+        fn get_doc_id(&self, name: &Name) -> &Uuid {
+            self.doc_names.get(name).unwrap()
+        }
+
         fn get_doc_rx_id(&self, name: &Name) -> &Uuid {
-            self.doc_id.get(name).unwrap()
+            self.doc_tx_id.get(name).unwrap()
         }
 
         fn get_doc_rx(&self, name: &Name) -> &Receiver<Message> {
@@ -1748,7 +1763,22 @@ mod queues {
             let reg = Register::new(tester.get_doc_rx_id(&name).clone(), reg_msg);
             let msg = Message::new(NameType::None, reg);
             queue.send(msg).unwrap();
-            tester.get_doc_rx(&name).recv_timeout(TIMEOUT).unwrap();
+            let result = tester.get_doc_rx(&name).recv_timeout(TIMEOUT).unwrap();
+            let action = result.get_action();
+            match action {
+                MsgAction::Register(data) => match data.get_msg() {
+                    RegMsg::RouteID(output) => {
+                        let expected = RouteID {
+                            action: None,
+                            doc_type: None,
+                            msg_id: Some(input.get_message_id().clone()),
+                        };
+                        assert_eq!(output, &expected);
+                    }
+                    _ => unreachable!("got {:?}, should have been route id", data),
+                },
+                _ => unreachable!("got {:?}, should have been route id", action),
+            }
             inputs.insert(name.clone(), input);
         }
         for msg in inputs.values() {
@@ -1786,7 +1816,22 @@ mod queues {
             let reg = Register::new(tester.get_doc_rx_id(&name).clone(), reg_msg);
             let msg = Message::new(NameType::None, reg);
             queue.send(msg).unwrap();
-            tester.get_doc_rx(&name).recv_timeout(TIMEOUT).unwrap();
+            let result = tester.get_doc_rx(&name).recv_timeout(TIMEOUT).unwrap();
+            let action = result.get_action();
+            match action {
+                MsgAction::Register(data) => match data.get_msg() {
+                    RegMsg::RouteID(output) => {
+                        let expected = RouteID {
+                            action: None,
+                            doc_type: Some(tester.get_doc_id(name).clone()),
+                            msg_id: None,
+                        };
+                        assert_eq!(output, &expected);
+                    }
+                    _ => unreachable!("got {:?}, should have been route id", data),
+                },
+                _ => unreachable!("got {:?}, should have been route id", action),
+            }
             inputs.insert(name.clone(), input);
         }
         for msg in inputs.values() {
@@ -1829,7 +1874,22 @@ mod queues {
             let reg = Register::new(tester.get_doc_rx_id(&name).clone(), reg_msg);
             let msg = Message::new(NameType::None, reg);
             queue.send(msg).unwrap();
-            tester.get_doc_rx(&name).recv_timeout(TIMEOUT).unwrap();
+            let result = tester.get_doc_rx(&name).recv_timeout(TIMEOUT).unwrap();
+            let action = result.get_action();
+            match action {
+                MsgAction::Register(data) => match data.get_msg() {
+                    RegMsg::RouteID(output) => {
+                        let expected = RouteID {
+                            action: Some(actions[count].clone().into()),
+                            doc_type: None,
+                            msg_id: None,
+                        };
+                        assert_eq!(output, &expected);
+                    }
+                    _ => unreachable!("got {:?}, should have been route id", data),
+                },
+                _ => unreachable!("got {:?}, should have been route id", action),
+            }
             inputs.insert(name.clone(), input);
             count += 1;
         }
@@ -3645,278 +3705,6 @@ impl Iterator for RecordIter {
     }
 }
 
-/*
-#[derive(Clone, Debug)]
-struct Record {
-    names: Names,
-    data: InternalRecord,
-}
-
-impl Record {
-    fn new(names: Names) -> Self {
-        Self {
-            names: names,
-            data: InternalRecord::new(),
-        }
-    }
-
-    fn with_data(names: Names, rec: InternalRecord) -> Self {
-        Self {
-            names: names,
-            data: rec,
-        }
-    }
-
-    fn insert<NT, F>(&mut self, field_id: NT, data: F) -> Result<(), MTTError>
-    where
-        F: Into<Field>,
-        NT: Into<NameType>,
-    {
-        let id = match self.names.get_id(field_id) {
-            Ok(data) => data,
-            Err(err) => return Err(err),
-        };
-        self.data.insert(id, data.into());
-        Ok(())
-    }
-
-    fn get<NT>(&self, field_id: NT) -> Result<Field, MTTError>
-    where
-        NT: Into<NameType>,
-    {
-        let id = match self.names.get_id(field_id) {
-            Ok(data) => data,
-            Err(err) => return Err(err),
-        };
-        match self.data.get(&id) {
-            Some(data) => Ok(data.clone()),
-            None => Err(MTTError::FieldMissingData),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-struct RecordIter {
-    names: Names,
-    records: VecDeque<InternalRecord>,
-}
-
-impl RecordIter {
-    fn new() -> Self {
-        Self {
-            names: Names::new(),
-            records: VecDeque::new(),
-        }
-    }
-
-    fn with_names(names: Names) -> Self {
-        Self {
-            names: names,
-            records: VecDeque::new(),
-        }
-    }
-
-    fn push(&mut self, rec: Record) -> Result<(), MTTError> {
-        if self.names.is_empty() {
-            self.names = rec.names;
-            self.records.push_back(rec.data.clone());
-        } else {
-            if rec.names != self.names {
-                return Err(MTTError::RecordMismatch);
-            }
-            let existing: HashSet<Uuid> = self.records.front().unwrap().keys().cloned().collect();
-            let rec_keys: HashSet<Uuid> = rec.data.keys().cloned().collect();
-            if existing == rec_keys {
-                self.records.push_back(rec.data.clone());
-            } else {
-                return Err(MTTError::RecordMismatch);
-            }
-        }
-        Ok(())
-    }
-
-    fn insert(&mut self, rec: InternalRecord) -> Result<(), MTTError> {
-        self.records.push_back(rec.clone());
-        Ok(())
-    }
-}
-
-impl Iterator for RecordIter {
-    type Item = Record;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.records.pop_front() {
-            Some(data) => Some(Record {
-                names: self.names.clone(),
-                data: data,
-            }),
-            None => None,
-        }
-    }
-}
-
-impl ExactSizeIterator for RecordIter {
-    fn len(&self) -> usize {
-        self.records.len()
-    }
-}
-
-#[cfg(test)]
-mod records {
-    use super::*;
-
-    #[test]
-    fn can_create_a_record() {
-        let mut names = Names::new();
-        let count = 5;
-        let mut ids: HashSet<Uuid> = HashSet::new();
-        while ids.len() < count {
-            ids.insert(Uuid::new_v4());
-        }
-        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_names([name.clone()].to_vec()).unwrap();
-            name_ids.insert(name, field_id);
-        }
-        let mut rec = Record::new(names);
-        for id in ids.iter() {
-            let name = Name::english(id.clone().to_string().as_str());
-            rec.insert(name, id.clone());
-        }
-        for (name, id) in name_ids.iter() {
-            let id1 = rec.get(name).unwrap();
-            let id2 = rec.get(id).unwrap();
-            assert_eq!(id1, id2, "id and name should produce the same result");
-            match id1 {
-                Field::Uuid(data) => {
-                    assert_eq!(
-                        data.to_string(),
-                        name.to_string(),
-                        "for this case, name and data should match"
-                    );
-                    assert!(ids.contains(&data), "{:?} not in {:?}", id1, ids);
-                    ids.remove(&data);
-                }
-                _ => unreachable!("got {:?}, should have been uuid", id1),
-            }
-        }
-        assert_eq!(ids.len(), 0, "did not pull {:?}", ids);
-    }
-
-    #[test]
-    fn does_insert_error_on_bad_field_name() {
-        let names = Names::new();
-        let mut rec = Record::new(names);
-        let name = Name::english("wrong");
-        match rec.insert(name.clone(), "bad") {
-            Ok(_) => unreachable!("should return not found error"),
-            Err(err) => match err {
-                MTTError::NameNotFound(data) => assert_eq!(data, name),
-                _ => unreachable!("got {:?}, should have been not found", err),
-            },
-        }
-    }
-
-    #[test]
-    fn does_get_error_on_bad_field_name() {
-        let names = Names::new();
-        let mut rec = Record::new(names);
-        let name = Name::english("missing");
-        match rec.get(&name) {
-            Ok(_) => unreachable!("should return not found error"),
-            Err(err) => match err {
-                MTTError::NameNotFound(data) => assert_eq!(data, name),
-                _ => unreachable!("got {:?}, should have been not found", err),
-            },
-        }
-    }
-
-    #[test]
-    fn does_get_error_on_missing_data() {
-        let mut names = Names::new();
-        let name = Name::english("empty");
-        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"),
-            Err(err) => match err {
-                MTTError::FieldMissingData => {}
-                _ => unreachable!("got {:?}, should have been not found", err),
-            },
-        }
-    }
-
-    #[test]
-    fn can_records_hold_multiple_entries() {
-        let field_name = Name::english("field");
-        let mut names = Names::new();
-        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");
-        for data in 0..count {
-            let mut rec = Record::new(names.clone());
-            rec.insert(field_name.clone(), data.clone());
-            recs.push(rec);
-            let holder: usize = (data + 1).try_into().unwrap();
-            assert_eq!(recs.len(), holder, "should increase the count");
-        }
-        let mut data = 0;
-        for rec in recs {
-            let item = rec.get(&field_name).unwrap();
-            assert_eq!(item, data.into());
-            data += 1;
-        }
-        assert_eq!(data, count, "did not iterate")
-    }
-
-    #[test]
-    fn errors_on_mismatched_names() {
-        let count = 2;
-        let mut recs: Vec<Record> = Vec::new();
-        for i in 0..count {
-            let name = Name::english(i.to_string().as_str());
-            let mut names = Names::new();
-            names.add_names([name].to_vec());
-            recs.push(Record::new(names));
-        }
-        let mut rec_iter = RecordIter::new();
-        rec_iter.push(recs[0].clone()).unwrap();
-        match rec_iter.push(recs[1].clone()) {
-            Ok(_) => unreachable!("should have returned error"),
-            Err(err) => match err {
-                MTTError::RecordMismatch => {}
-                _ => unreachable!("got {:?}, should have gotten mismatched names", err),
-            },
-        }
-    }
-
-    #[test]
-    fn errors_on_mismatched_entries() {
-        let mut names = Names::new();
-        let name1 = Name::english("first");
-        let name2 = Name::english("second");
-        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);
-        let mut rec2 = Record::new(names.clone());
-        rec2.insert(&name1, 1);
-        let mut rec_iter = RecordIter::new();
-        rec_iter.push(rec1).unwrap();
-        match rec_iter.push(rec2) {
-            Ok(_) => unreachable!("should have returned error"),
-            Err(err) => match err {
-                MTTError::RecordMismatch => {}
-                _ => unreachable!("got {:?}, should have gotten mismatched names", err),
-            },
-        }
-    }
-}
-*/
-
 #[derive(Clone, Debug)]
 struct Document {
     data: HashMap<NameType, CalcValue>,
@@ -4599,23 +4387,6 @@ impl DocumentFile {
             self.docs.remove(oid);
         }
         Records::with_data(self.docdef.get_field_names().clone(), records).into()
-
-        /*
-        let oids = match self.run_query(delete.get_query()) {
-            Ok(data) => data,
-            Err(err) => return err.into(),
-        };
-        let mut records = RecordIter::with_names(self.docdef.get_field_names().clone());
-        for oid in oids.iter() {
-            let record = self.docs.get(oid).unwrap().clone();
-            for (field_id, index) in self.indexes.iter_mut() {
-                index.remove(record.get(field_id).unwrap(), oid);
-            }
-            records.insert(record);
-            self.docs.remove(oid);
-        }
-        records.into()
-        */
     }
 
     fn run_query(&self, query: &Query) -> Result<InternalRecords, MTTError> {
@@ -4667,29 +4438,6 @@ impl DocumentFile {
             records.remove(oid);
         }
         Ok(records)
-
-        /*
-        for (field_id, calc) in unindexed.iter() {
-            for oid in oids.clone().iter() {
-                let doc = self.docs.get(oid).unwrap();
-                match calc.calculate(doc.get(field_id).unwrap()) {
-                    Field::Boolean(data) => {
-                        if !data {
-                            oids.remove(oid);
-                        }
-                    }
-                    _ => {
-                        oids.remove(oid);
-                    }
-                }
-            }
-        }
-        let output = InternalRecords::new();
-        for oid in oids.iter() {
-            output.insert(oid.clone(), self.docs.get(oid).unwrap().clone());
-        }
-        Ok(output)
-        */
     }
 
     fn query(&self, query: &Query) -> MsgAction {
@@ -4697,15 +4445,9 @@ impl DocumentFile {
             Ok(data) => data,
             Err(err) => return err.into(),
         };
-        Records::with_data(self.docdef.get_field_names().clone(), records).into()
+        let recs = Records::with_data(self.docdef.get_field_names().clone(), records);
-
+        //self.queue.
-        /*
+        recs.into()
-        let mut records = RecordIter::with_names(self.docdef.get_field_names().clone());
-        for oid in oids.iter() {
-            records.insert(self.docs.get(oid).unwrap().clone());
-        }
-        records.into()
-        */
     }
 
     fn update(&mut self, update: &Update) -> MsgAction {
@@ -4748,53 +4490,6 @@ impl DocumentFile {
             self.docs.insert(oid.clone(), new_rec.clone());
         }
         Records::with_data(self.docdef.get_field_names().clone(), updates).into()
-
-        /*
-        let oids = match self.run_query(update.get_query()) {
-            Ok(result) => result,
-            Err(err) => return err.into(),
-        };
-        let mut changes: HashMap<Uuid, &CalcValue> = HashMap::new();
-        for (key, value) in update.get_values().iter() {
-            let field_id = match self.docdef.get_field_id(key) {
-                Ok(data) => data,
-                Err(err) => return err.into(),
-            };
-            changes.insert(field_id, value);
-        }
-        let mut indexes = self.docdef.create_indexes();
-        let mut old = InternalRecords::new();
-        let mut changed = InternalRecords::new();
-        for oid in oids.iter() {
-            let mut holder = self.docs.get(oid).unwrap().clone();
-            old.insert(oid.clone(), holder.clone());
-            for (field_id, value) in changes.iter() {
-                let field = value.get(holder.get(field_id).unwrap());
-                let correction = match self.validate(field_id, &field) {
-                    Ok(data) => data,
-                    Err(err) => return err.into(),
-                };
-                holder.insert(field_id.clone(), field);
-                match indexes.add_to_index(&field_id, correction, oid.clone()) {
-                    Ok(_) => {}
-                    Err(err) => return err.into(),
-                }
-            }
-            changed.insert(oid.clone(), holder);
-        }
-        let mut output = RecordIter::with_names(self.docdef.get_field_names().clone());
-        for (oid, record) in changed.iter() {
-            let original = old.get(oid).unwrap();
-            let new_rec = changed.get(oid).unwrap();
-            for (field_id, index) in self.indexes.iter_mut() {
-                index.remove(original.get(field_id).unwrap(), oid);
-                index.add(new_rec.get(field_id).unwrap().clone(), oid.clone());
-            }
-            self.docs.insert(oid.clone(), new_rec.clone());
-            output.insert(new_rec.clone());
-        }
-        output.into()
-        */
     }
 }