Made document able to hold more than just data.

src/message.rs

@@ -1288,14 +1288,14 @@ impl Addition {
         }
     }
 
-    fn add_field<F>(&mut self, name: String, field: F)
+    fn add_field<CV>(&mut self, name: String, field: CV)
     where
-        F: Into<Field>,
+        CV: Into<CalcValue>,
     {
         self.data.add_field(name, field);
     }
 
-    fn get_field(&self, name: &str) -> Option<&Field> {
+    fn get_field(&self, name: &str) -> Option<Field> {
         self.data.get_field(name)
     }
 
@@ -1316,7 +1316,7 @@ mod additions {
         add.add_field(name.clone(), data.clone());
         let result = add.get_field(&name).unwrap();
         match result {
-            Field::StaticString(result) => assert_eq!(result, &data),
+            Field::StaticString(result) => assert_eq!(result, data),
             _ => unreachable!("got {:?}: should have received static string", result),
         }
     }
@@ -1328,7 +1328,7 @@ mod additions {
         add.add_field(name.clone(), data.clone());
         let result = add.get_field(&name).unwrap();
         match result {
-            Field::Uuid(result) => assert_eq!(result, &data),
+            Field::Uuid(result) => assert_eq!(result, data),
             _ => unreachable!("got {:?}: should have received uuid", result),
         }
     }
@@ -1340,7 +1340,7 @@ mod additions {
         add.add_field(name.clone(), data.clone());
         let doc: Document = add.get_document();
         match doc.get_field(&name).unwrap() {
-            Field::Uuid(result) => assert_eq!(result, &data),
+            Field::Uuid(result) => assert_eq!(result, data),
             _ => unreachable!("should have received uuid"),
         }
     }
@@ -2204,7 +2204,7 @@ mod replies {
 
 #[derive(Clone, Debug)]
 struct Document {
-    data: HashMap<String, Field>,
+    data: HashMap<String, CalcValue>,
 }
 
 impl Document {
@@ -2214,19 +2214,50 @@ impl Document {
         }
     }
 
-    fn add_field<F>(&mut self, name: String, field: F)
+    fn add_field<CV>(&mut self, name: String, field: CV)
     where
-        F: Into<Field>,
+        CV: Into<CalcValue>,
     {
         self.data.insert(name, field.into());
     }
 
-    fn get_field(&self, name: &str) -> Option<&Field> {
-        self.data.get(name)
+    fn get_field(&self, name: &str) -> Option<Field> {
+        match self.data.get(name) {
+            Some(data) => Some(data.get()),
+            None => None,
+        }
     }
 
-    fn iter(&self) -> impl Iterator<Item = (&String, &Field)> {
-        self.data.iter()
+    fn get_all(&self) -> Vec<(String, Field)> {
+        let mut output = Vec::new();
+        for (key, value) in self.data.iter() {
+            output.push((key.clone(), value.get()));
+        }
+        output
+    }
+
+    fn iter(&self) -> DocIter {
+        DocIter::new(self)
+    }
+}
+
+struct DocIter {
+    storage: Vec<(String, Field)>,
+}
+
+impl DocIter {
+    fn new(doc: &Document) -> Self {
+        Self {
+            storage: doc.get_all(),
+        }
+    }
+}
+
+impl Iterator for DocIter {
+    type Item = (String, Field);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.storage.pop()
     }
 }
 
@@ -2242,7 +2273,7 @@ mod documents {
         add.add_field(name.clone(), data.clone());
         let result = add.get_field(&name).unwrap();
         match result {
-            Field::StaticString(result) => assert_eq!(result, &data),
+            Field::StaticString(result) => assert_eq!(result, data),
             _ => unreachable!("got {:?}: should have received static string", result),
         }
     }
@@ -2254,7 +2285,7 @@ mod documents {
         add.add_field(name.clone(), data.clone());
         let result = add.get_field(&name).unwrap();
         match result {
-            Field::Uuid(result) => assert_eq!(result, &data),
+            Field::Uuid(result) => assert_eq!(result, data),
             _ => unreachable!("got {:?}: should have received uuid", result),
         }
     }
@@ -2673,7 +2704,7 @@ impl DocumentFile {
         let mut holder = Document::new();
         let doc = addition.get_document();
         for (key, value) in doc.iter() {
-            match self.validate(key, Some(value.clone())) {
+            match self.validate(&key, Some(value.clone())) {
                 Ok(data) => {
                     holder.add_field(key.clone(), value.clone());
                 }
@@ -2695,7 +2726,7 @@ impl DocumentFile {
         }
         self.docs.insert(oid.clone(), holder.clone());
         for (key, value) in holder.iter() {
-            self.add_to_index(key, value.clone(), oid.clone());
+            self.add_to_index(&key, value.clone(), oid.clone());
         }
         let mut reply = Reply::new();
         reply.add(holder);
@@ -2760,10 +2791,10 @@ impl DocumentFile {
         for (oid, docs) in holder.iter_mut() {
             let mut updated = Document::new();
             for (key, value) in update.get_values().iter() {
-                match self.validate(key, Some(value.clone())) {
-                    Ok(field) => match index_holder.validate(key, &field) {
+                match self.validate(&key, Some(value.clone())) {
+                    Ok(field) => match index_holder.validate(&key, &field) {
                         Ok(_) => {
-                            index_holder.add_to_index(key, field.clone(), oid.clone());
+                            index_holder.add_to_index(&key, field.clone(), oid.clone());
                             docs[1].add_field(key.clone(), field.clone());
                         }
                         Err(err) => return Self::add_field_to_error(key.to_string(), err).into(),
@@ -2777,8 +2808,8 @@ impl DocumentFile {
             self.docs.insert(oid.clone(), docs[1].clone());
             reply.add(docs[1].clone());
             for (key, value) in docs[0].iter() {
-                self.remove_from_index(key, value, oid);
-                self.add_to_index(key, docs[1].get_field(key).unwrap().clone(), oid.clone());
+                self.remove_from_index(&key, &value, oid);
+                self.add_to_index(&key, docs[1].get_field(&key).unwrap().clone(), oid.clone());
             }
         }
         reply.into()
@@ -3007,7 +3038,7 @@ mod document_files {
                 let holder = output.iter().next().unwrap();
                 match holder.get_field(name) {
                     Some(field) => match field {
-                        Field::Uuid(store) => assert_eq!(store, &data),
+                        Field::Uuid(store) => assert_eq!(store, data),
                         _ => unreachable!(
                             "got {:?}: should have received uuid",
                             holder.get_field(name).unwrap()
@@ -3028,7 +3059,7 @@ mod document_files {
                 let holder = output.iter().next().unwrap();
                 match holder.get_field(name) {
                     Some(field) => match field {
-                        Field::Uuid(store) => assert_eq!(store, &data),
+                        Field::Uuid(store) => assert_eq!(store, data),
                         _ => unreachable!(
                             "got {:?}: should have received uuid",
                             holder.get_field(name).unwrap()
@@ -3176,7 +3207,7 @@ mod document_files {
                     action
                 );
                 for doc in data.iter() {
-                    assert_eq!(doc.get_field("field0").unwrap(), &expected);
+                    assert_eq!(doc.get_field("field0").unwrap(), expected);
                 }
             }
             _ => unreachable!("got {:?}: should have been a reply", action),
@@ -3212,7 +3243,7 @@ mod document_files {
             MsgAction::Reply(data) => {
                 assert_eq!(data.len(), 4, "should return 4 entries");
                 for doc in data.iter() {
-                    assert_eq!(doc.get_field("field0").unwrap(), &input);
+                    assert_eq!(doc.get_field("field0").unwrap(), input);
                 }
             }
             _ => unreachable!("got {:?}: should have been a reply", action),
@@ -3249,8 +3280,8 @@ mod document_files {
                 let bfield: Field = "b".into();
                 assert_eq!(data.len(), 1, "should return one entry:\n{:?}", action);
                 for doc in data.iter() {
-                    assert_eq!(doc.get_field("field0").unwrap(), &afield);
-                    assert_eq!(doc.get_field("field1").unwrap(), &bfield);
+                    assert_eq!(doc.get_field("field0").unwrap(), afield);
+                    assert_eq!(doc.get_field("field1").unwrap(), bfield);
                 }
             }
             _ => unreachable!("got {:?}: should have been a reply", action),
@@ -3320,7 +3351,7 @@ mod document_files {
                 assert_eq!(docs.len(), 1);
                 for doc in docs.iter() {
                     let expected: Field = "".into();
-                    assert_eq!(doc.get_field("field0").unwrap(), &expected);
+                    assert_eq!(doc.get_field("field0").unwrap(), expected);
                 }
             }
             _ => unreachable!("got {:?}: should have gotten a reply", action),
@@ -3345,7 +3376,7 @@ mod document_files {
                 assert_eq!(docs.len(), 1);
                 let expected: Field = input.into();
                 for doc in docs.iter() {
-                    assert_eq!(doc.get_field("field0").unwrap(), &expected);
+                    assert_eq!(doc.get_field("field0").unwrap(), expected);
                 }
             }
             _ => unreachable!("got {:?}: should have gotten a reply", action),
@@ -3370,7 +3401,7 @@ mod document_files {
                 assert_eq!(docs.len(), 1);
                 let expected: Field = Uuid::nil().into();
                 for doc in docs.iter() {
-                    assert_eq!(doc.get_field("field0").unwrap(), &expected);
+                    assert_eq!(doc.get_field("field0").unwrap(), expected);
                 }
             }
             _ => unreachable!("got {:?}: should have gotten a reply", action),
@@ -3465,8 +3496,8 @@ mod document_files {
                 MsgAction::Reply(docs) => {
                     assert_eq!(docs.len(), 1, "{}", key);
                     for doc in docs.iter() {
-                        assert_eq!(doc.get_field("field0").unwrap(), &expected_id, "{}", key);
-                        assert_eq!(doc.get_field("field1").unwrap(), &output, "{}", key);
+                        assert_eq!(doc.get_field("field0").unwrap(), expected_id, "{}", key);
+                        assert_eq!(doc.get_field("field1").unwrap(), output, "{}", key);
                     }
                 }
                 _ => unreachable!("got {:?}: should have gotten a reply", action),
@@ -3515,8 +3546,8 @@ mod document_files {
                 let expected_id: Field = expected.clone().into();
                 let output: Field = new.into();
                 for doc in docs.iter() {
-                    assert_eq!(doc.get_field("field0").unwrap(), &expected_id);
-                    assert_eq!(doc.get_field("field1").unwrap(), &output);
+                    assert_eq!(doc.get_field("field0").unwrap(), expected_id);
+                    assert_eq!(doc.get_field("field1").unwrap(), output);
                 }
             }
             _ => unreachable!("got {:?}: should have gotten a reply", action),
@@ -3562,8 +3593,8 @@ mod document_files {
                 MsgAction::Reply(docs) => {
                     assert_eq!(docs.len(), count, "{}", key);
                     for doc in docs.iter() {
-                        assert_eq!(doc.get_field("field0").unwrap(), &expected_id, "{}", key);
-                        assert_eq!(doc.get_field("field1").unwrap(), &output, "{}", key);
+                        assert_eq!(doc.get_field("field0").unwrap(), expected_id, "{}", key);
+                        assert_eq!(doc.get_field("field1").unwrap(), output, "{}", key);
                     }
                 }
                 _ => unreachable!("got {:?}: should have gotten a reply", action),
@@ -3704,7 +3735,7 @@ mod document_files {
             MsgAction::Reply(data) => {
                 assert_eq!(data.len(), 1);
                 for doc in data.iter() {
-                    assert_eq!(doc.get_field("field0").unwrap(), &fold);
+                    assert_eq!(doc.get_field("field0").unwrap(), fold);
                 }
             }
             _ => unreachable!("got {:?}: should have gotten a reply", action),
@@ -3774,7 +3805,7 @@ mod document_files {
                 assert_eq!(data.len(), ids.len());
                 for doc in data.iter() {
                     match doc.get_field("field0").unwrap() {
-                        Field::Uuid(id) => assert!(ids.contains(id)),
+                        Field::Uuid(id) => assert!(ids.contains(&id)),
                         _ => unreachable!("did not get uuid"),
                     }
                 }