Relaced Calculation with CalcValue for FieldSettings.

src/message.rs

@@ -2107,24 +2107,38 @@ mod fields {
 #[derive(Clone, Debug)]
 struct FieldSetting {
     fieldtype: FieldType,
-    default_value: Option<Calculation>,
+    default_value: CalcValue,
 }
 
 impl FieldSetting {
     fn new(ftype: FieldType) -> Self {
         Self {
             fieldtype: ftype,
-            default_value: None,
+            default_value: CalcValue::None,
         }
     }
 
-    fn set_default(&mut self, value: Calculation) -> Result<(), MTTError> {
-        let data = value.calculate(&Field::None);
-        match self.validate(Some(data)) {
-            Ok(_) => {}
-            Err(err) => return Err(err),
+    fn set_default<CV>(&mut self, holder: CV) -> Result<(), MTTError> where CV: Into<CalcValue> {
+        let value = holder.into();
+        match &value {
+            CalcValue::Calculate(calc) => {
+                if self.fieldtype != calc.get_type() {
+                    return Err(MTTError::FieldInvalidType);
+                }
+            }
+            CalcValue::Existing(ftype) | CalcValue::FType(ftype) => {
+                if &self.fieldtype != ftype {
+                    return Err(MTTError::FieldInvalidType);
+                }
+            }
+            CalcValue::Value(ref item) => {
+                if item.get_type() != self.fieldtype {
+                    return Err(MTTError::FieldInvalidType);
+                }
+            }
+            CalcValue::None => {},
         }
-        self.default_value = Some(value);
+        self.default_value = value;
         Ok(())
     }
 
@@ -2141,8 +2155,8 @@ impl FieldSetting {
                 Ok(data.clone())
             }
             None => match &self.default_value {
-                Some(calc) => Ok(calc.calculate(&Field::None)),
-                None => Err(MTTError::InvalidNone),
+                CalcValue::None => Err(MTTError::InvalidNone),
+                _ => Ok(self.default_value.get(&Field::None)),
             },
         }
     }
@@ -2193,9 +2207,7 @@ mod fieldsettings {
     #[test]
     fn returns_value_if_default_is_set() {
         let mut fset = FieldSetting::new(FieldType::StaticString);
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value(FieldType::StaticString);
-        fset.set_default(calc);
+        fset.set_default(FieldType::StaticString);
         match fset.validate(None) {
             Ok(data) => assert_eq!(data, "".into()),
             Err(err) => unreachable!("got {:?}: should have gotten a value", err),
@@ -2206,9 +2218,7 @@ mod fieldsettings {
     fn returns_default_value() {
         let mut fset = FieldSetting::new(FieldType::StaticString);
         let input = "fred";
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value(input);
-        fset.set_default(calc);
+        fset.set_default(input);
         match fset.validate(None) {
             Ok(data) => assert_eq!(data, input.into()),
             Err(err) => unreachable!("got {:?}: should have gotten a value", err),
@@ -2415,7 +2425,7 @@ impl DocDef {
         self.fields.get(&id).unwrap().validate(value)
     }
 
-    fn set_default(&mut self, field_name: &Name, value: Calculation) -> Result<(), MTTError> {
+    fn set_default<CV>(&mut self, field_name: &Name, value: CV) -> Result<(), MTTError> where CV: Into<CalcValue> {
         let id = match self.field_names.get_id(field_name) {
             Ok(data) => data,
             Err(err) => return Err(err),
@@ -2500,9 +2510,7 @@ mod docdefs {
         let mut docdef = DocDef::new(docname);
         let name = Name::english("defaultfunction");
         docdef.add_field(name.clone(), FieldType::StaticString);
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value(FieldType::StaticString);
-        docdef.set_default(&name, calc);
+        docdef.set_default(&name, FieldType::StaticString);
         match docdef.get_field(name).unwrap().validate(None) {
             Ok(data) => match data {
                 Field::StaticString(result) => assert_eq!(result, ""),
@@ -2512,29 +2520,12 @@ mod docdefs {
         }
     }
 
-    #[test]
-    fn does_set_default_function_error_on_bad_field_name() {
-        let docname = Name::english("something");
-        let mut docdef = DocDef::new(docname);
-        let field_name = Name::english("wrong");
-        let calc = Calculation::new(Operand::Assign);
-        match docdef.set_default(&field_name, calc) {
-            Ok(_) => unreachable!("should be an error"),
-            Err(err) => match err {
-                MTTError::NameNotFound(data) => assert_eq!(data, field_name),
-                _ => unreachable!("got {:?}: should have been field not found", err),
-            },
-        }
-    }
-
     #[test]
     fn does_set_default_value_error_on_bad_field_name() {
         let docname = Name::english("something");
         let mut docdef = DocDef::new(docname);
         let field_name = Name::english(Uuid::new_v4().to_string().as_str());
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value(Uuid::new_v4());
-        match docdef.set_default(&field_name, calc) {
+        match docdef.set_default(&field_name, FieldType::Uuid) {
             Ok(_) => unreachable!("should be an error"),
             Err(err) => match err {
                 MTTError::NameNotFound(data) => assert_eq!(data, field_name),
@@ -2549,15 +2540,10 @@ mod docdefs {
         let mut docdef = DocDef::new(docname);
         let name = Name::english("defaultvalue");
         docdef.add_field(name.clone(), FieldType::Uuid);
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value("fred");
-        match docdef.set_default(&name, calc) {
+        match docdef.set_default(&name, "fred") {
             Ok(data) => unreachable!("got {:?}, should be an error", data),
             Err(err) => match err {
-                MTTError::DocumentFieldWrongDataType(expected, got) => {
-                    assert_eq!(expected, FieldType::Uuid);
-                    assert_eq!(got, FieldType::StaticString);
-                }
+                MTTError::FieldInvalidType => {},
                 _ => unreachable!("got {:?}: should have been field not found", err),
             },
         }
@@ -2567,7 +2553,7 @@ mod docdefs {
 #[derive(Clone, Debug)]
 enum Operand {
     Add,
-    Assign,
+    //Assign,
     Equal,
 }
 
@@ -2606,6 +2592,7 @@ enum CalcValue {
     Calculate(Calculation),
     Existing(FieldType),
     FType(FieldType),
+    None,
     Value(Field),
 }
 
@@ -2615,6 +2602,7 @@ impl CalcValue {
             Self::Calculate(calc) => calc.calculate(existing),
             Self::Existing(_) => existing.clone(),
             Self::FType(ftype) => ftype.get_default(),
+            Self::None => Field::None,
             Self::Value(field) => field.clone(),
         }
     }
@@ -2624,6 +2612,7 @@ impl CalcValue {
             Self::Calculate(calc) => calc.get_type(),
             Self::Existing(ftype) => ftype.clone(),
             Self::FType(ftype) => ftype.clone(),
+            Self::None => FieldType::None,
             Self::Value(field) => field.into(),
         }
     }
@@ -2926,7 +2915,7 @@ impl Calculation {
                     }
                 }
             }
-            Operand::Assign => result = self.values[0].get(existing),
+            // Operand::Assign => result = self.values[0].get(existing),
             Operand::Equal => {
                 if self.values.len() >= 2 {
                     result = self.values[0]
@@ -2962,9 +2951,9 @@ mod calculations {
 
     #[test]
     fn returns_reference_to_operand() {
-        let calc = Calculation::new(Operand::Assign);
+        let calc = Calculation::new(Operand::Add);
         match calc.operation() {
-            Operand::Assign => {}
+            Operand::Add => {}
             _ => unreachable!("got {:?}, shold have gotten assign", calc.operation()),
         }
         let calc = Calculation::new(Operand::Equal);
@@ -2974,24 +2963,6 @@ mod calculations {
         }
     }
 
-    #[test]
-    fn can_assign_value() {
-        let mut calc = Calculation::new(Operand::Assign);
-        let data: Field = Uuid::new_v4().into();
-        calc.add_value(data.clone());
-        let result = calc.calculate(&Field::None);
-        assert_eq!(result, data);
-    }
-
-    #[test]
-    fn can_assign_default_function() {
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value(FieldType::Uuid);
-        let result1 = calc.calculate(&Field::None);
-        let result2 = calc.calculate(&Field::None);
-        assert_ne!(result1, result2);
-    }
-
     #[test]
     fn can_equal_true() {
         let mut calc = Calculation::new(Operand::Equal);
@@ -3196,20 +3167,6 @@ mod queries {
             None => unreachable!("should have returned a calculation"),
         }
     }
-
-    #[test]
-    fn does_not_allow_data_changes() {
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value(Uuid::nil());
-        let mut query = Query::new();
-        match query.add(Name::english("name"), calc) {
-            Ok(_) => unreachable!("Should have received an error"),
-            Err(err) => match err {
-                MTTError::QueryCannotChangeData => {}
-                _ => unreachable!("got {:?}, should have gotten cannot change data", err),
-            },
-        }
-    }
 }
 
 #[derive(Clone, Debug)]
@@ -5012,9 +4969,7 @@ mod document_files {
         let mut docdef = DocDef::new(doc_name.clone());
         let field_name = Name::english("holder");
         docdef.add_field(field_name.clone(), FieldType::StaticString);
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value(FieldType::StaticString);
-        docdef.set_default(&field_name, calc);
+        docdef.set_default(&field_name, FieldType::StaticString);
         let mut test_doc: TestDocument = docdef.into();
         test_doc.start();
         let queue = test_doc.get_queue();
@@ -5042,9 +4997,7 @@ mod document_files {
         let mut docdef = DocDef::new(doc_name.clone());
         let field_name = Name::english("id");
         docdef.add_field(field_name.clone(), FieldType::Uuid);
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value(Uuid::nil());
-        docdef.set_default(&field_name, calc);
+        docdef.set_default(&field_name, Uuid::nil());
         let mut test_doc: TestDocument = docdef.into();
         test_doc.start();
         let queue = test_doc.get_queue();
@@ -5072,9 +5025,7 @@ mod document_files {
         let mut docdef = DocDef::new(doc_name.clone());
         let field_name = Name::english("id");
         docdef.add_field(field_name.clone(), FieldType::Uuid);
-        let mut calc = Calculation::new(Operand::Assign);
-        calc.add_value(FieldType::Uuid);
-        docdef.set_default(&field_name, calc);
+        docdef.set_default(&field_name, FieldType::Uuid);
         let mut test_doc: TestDocument = docdef.into();
         test_doc.start();
         let queue = test_doc.get_queue();