diff --git a/src/message.rs b/src/message.rs index 641f341..74e4c4f 100644 --- a/src/message.rs +++ b/src/message.rs @@ -469,7 +469,7 @@ mod includes { } } -#[derive(Clone, Eq, Hash, PartialEq)] +#[derive(Clone, Debug, Eq, Hash, PartialEq)] struct RouteID { action: Option, doc_type: Option, @@ -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, - doc_id: HashMap, + doc_names: HashMap, + doc_tx_id: HashMap, doc_rx: HashMap>, } @@ -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(); - self.doc_id.insert(name.clone(), id); + match rx.recv_timeout(TIMEOUT).unwrap().get_action() { + 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 { @@ -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(&mut self, field_id: NT, data: F) -> Result<(), MTTError> - where - F: Into, - NT: Into, - { - 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(&self, field_id: NT) -> Result - where - NT: Into, - { - 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, -} - -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 = self.records.front().unwrap().keys().cloned().collect(); - let rec_keys: HashSet = 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 { - 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 = HashSet::new(); - while ids.len() < count { - ids.insert(Uuid::new_v4()); - } - let mut name_ids: HashMap = 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 = 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, @@ -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 { @@ -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 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() - */ + let recs = Records::with_data(self.docdef.get_field_names().clone(), records); + //self.queue. + recs.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 = 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() - */ } }