Added existing to the calculations.

src/message.rs

@@ -1964,7 +1964,7 @@ impl FieldSetting {
     }
 
     fn set_default(&mut self, value: Calculation) -> Result<(), MTTError> {
-        let data = value.calculate();
+        let data = value.calculate(Field::None);
         match self.validate(Some(data)) {
             Ok(_) => {}
             Err(err) => return Err(err),
@@ -1986,7 +1986,7 @@ impl FieldSetting {
                 Ok(data.clone())
             }
             None => match &self.default_value {
-                Some(calc) => Ok(calc.calculate()),
+                Some(calc) => Ok(calc.calculate(Field::None)),
                 None => Err(MTTError::InvalidNone),
             },
         }
@@ -2449,16 +2449,18 @@ mod operands {
 #[derive(Clone, Debug)]
 enum CalcValue {
     Calculate(Calculation),
+    Existing(FieldType),
     FType(FieldType),
     Value(Field),
 }
 
 impl CalcValue {
-    fn get(&self) -> Field {
+    fn get(&self, existing: Field) -> Field {
         match self {
+            Self::Calculate(calc) => calc.calculate(existing),
+            Self::Existing(_) => existing,
             Self::FType(ftype) => ftype.get_default(),
             Self::Value(field) => field.clone(),
-            Self::Calculate(calc) => calc.calculate(),
         }
     }
 }
@@ -2543,7 +2545,7 @@ mod calcvalues {
             CalcValue::Value(data) => assert_eq!(data, expected),
             _ => unreachable!("got {:?}, should have gotten a field", result),
         }
-        assert_eq!(result.get(), expected);
+        assert_eq!(result.get(Field::None), expected);
     }
 
     #[test]
@@ -2555,7 +2557,7 @@ mod calcvalues {
             CalcValue::Value(data) => assert_eq!(data, expected),
             _ => unreachable!("got {:?}, should have gotten a field", result),
         }
-        assert_eq!(result.get(), expected);
+        assert_eq!(result.get(Field::None), expected);
     }
 
     #[test]
@@ -2567,7 +2569,7 @@ mod calcvalues {
             CalcValue::Value(data) => assert_eq!(data, expected),
             _ => unreachable!("got {:?}, should have gotten a field", result),
         }
-        assert_eq!(result.get(), expected);
+        assert_eq!(result.get(Field::None), expected);
     }
 
     #[test]
@@ -2579,7 +2581,7 @@ mod calcvalues {
             CalcValue::Value(data) => assert_eq!(data, expected),
             _ => unreachable!("got {:?}, should have gotten a field", result),
         }
-        assert_eq!(result.get(), expected);
+        assert_eq!(result.get(Field::None), expected);
     }
 
     #[test]
@@ -2591,7 +2593,7 @@ mod calcvalues {
             CalcValue::Value(data) => assert_eq!(data, expected),
             _ => unreachable!("got {:?}, should have gotten a field", result),
         }
-        assert_eq!(result.get(), expected);
+        assert_eq!(result.get(Field::None), expected);
     }
 
     #[test]
@@ -2603,7 +2605,7 @@ mod calcvalues {
             CalcValue::Value(data) => assert_eq!(data, expected),
             _ => unreachable!("got {:?}, should have gotten a field", result),
         }
-        assert_eq!(result.get(), expected);
+        assert_eq!(result.get(Field::None), expected);
     }
 
     #[test]
@@ -2615,7 +2617,7 @@ mod calcvalues {
             CalcValue::Value(data) => assert_eq!(data, expected),
             _ => unreachable!("got {:?}, should have gotten a field", result),
         }
-        assert_eq!(result.get(), expected);
+        assert_eq!(result.get(Field::None), expected);
     }
 
     #[test]
@@ -2626,7 +2628,7 @@ mod calcvalues {
         calc.add_value(FieldType::DateTime);
         calc.add_value(duration.clone());
         let result: CalcValue = calc.into();
-        let data = match result.get() {
+        let data = match result.get(Field::None) {
             Field::DateTime(data) => data,
             _ => unreachable!(),
         };
@@ -2656,10 +2658,10 @@ impl Calculation {
         &self.operation
     }
 
-    fn get_fields(&self) -> Vec<Field> {
+    fn get_fields(&self, existing: Field) -> Vec<Field> {
         let mut output = Vec::new();
         for item in self.values.iter() {
-            output.push(item.get());
+            output.push(item.get(existing.clone()));
         }
         output
     }
@@ -2678,39 +2680,45 @@ impl Calculation {
         Ok(())
     }
 
+    fn get_type(calc_value: CalcValue) -> FieldType {
+        match calc_value {
+            CalcValue::Existing(field_type) => field_type,
+            _ => calc_value.get(Field::None).get_type(),
+        }
+    }
+
     fn add_value<CV>(&mut self, data: CV) -> Result<(), MTTError>
     where
         CV: Into<CalcValue>,
     {
         let holder: CalcValue = data.into();
-        if self.values.len() == 0 {
+        if self.values.is_empty() {
             self.values.push(holder);
-            Ok(())
-        } else {
-            let mut base = self.values[0].get().get_type();
-            let ftype = holder.get().get_type();
-            match self.operation {
-                Operand::Add => {
-                    if base == FieldType::DateTime {
-                        base = FieldType::Duration;
-                    }
-                    match self.push_value(base, ftype, holder) {
-                        Ok(_) => Ok(()),
-                        Err(err) => Err(err),
-                    }
+            return Ok(());
+        }
+        let ftype = Self::get_type(holder.clone());
+        let mut base = Self::get_type(self.values[0].clone());
+        match self.operation {
+            Operand::Add => {
+                if base == FieldType::DateTime {
+                    base = FieldType::Duration;
                 }
-                _ => match self.push_value(base, ftype, holder) {
+                match self.push_value(base, ftype, holder) {
                     Ok(_) => Ok(()),
                     Err(err) => Err(err),
-                },
+                }
             }
+            _ => match self.push_value(base, ftype, holder) {
+                Ok(_) => Ok(()),
+                Err(err) => Err(err),
+            },
         }
     }
 
-    fn calculate(&self) -> Field {
+    fn calculate(&self, existing: Field) -> Field {
         match self.operation {
             Operand::Add => {
-                let values = self.get_fields();
+                let values = self.get_fields(existing);
                 match values[0].get_type() {
                     FieldType::DateTime => {
                         let mut output = Utc::now();
@@ -2736,8 +2744,10 @@ impl Calculation {
                     _ => unreachable!("{:?} does not handle addition", values[0].get_type()),
                 }
             }
-            Operand::Assign => self.values[0].get(),
-            Operand::Equal => { self.values[0].get() == self.values[1].get() }.into(),
+            Operand::Assign => self.values[0].get(Field::None),
+            Operand::Equal => {
+                { self.values[0].get(Field::None) == self.values[1].get(Field::None) }.into()
+            }
         }
     }
 }
@@ -2782,7 +2792,7 @@ mod calculations {
         let mut calc = Calculation::new(Operand::Assign);
         let data: Field = Uuid::new_v4().into();
         calc.add_value(data.clone());
-        let result = calc.calculate();
+        let result = calc.calculate(Field::None);
         assert_eq!(result, data);
     }
 
@@ -2790,8 +2800,8 @@ mod calculations {
     fn can_assign_default_function() {
         let mut calc = Calculation::new(Operand::Assign);
         calc.add_value(FieldType::Uuid);
-        let result1 = calc.calculate();
-        let result2 = calc.calculate();
+        let result1 = calc.calculate(Field::None);
+        let result2 = calc.calculate(Field::None);
         assert_ne!(result1, result2);
     }
 
@@ -2802,7 +2812,7 @@ mod calculations {
         calc.add_value(data.clone());
         calc.add_value(data.clone());
         let expected: Field = true.into();
-        let result = calc.calculate();
+        let result = calc.calculate(Field::None);
         assert_eq!(result, expected);
     }
 
@@ -2814,7 +2824,7 @@ mod calculations {
         calc.add_value(value1);
         calc.add_value(value2);
         let expected: Field = false.into();
-        let result = calc.calculate();
+        let result = calc.calculate(Field::None);
         assert_eq!(result, expected);
     }
 
@@ -2826,10 +2836,32 @@ mod calculations {
         let expected: Field = { value1 + value2 }.into();
         let value1: Field = value1.into();
         let value2: Field = value2.into();
-        calc.add_value(value1);
-        calc.add_value(value2);
-        let result = calc.calculate();
-        assert_eq!(result, expected);
+        calc.add_value(value1.clone());
+        calc.add_value(value2.clone());
+        let result = calc.calculate(Field::None);
+        assert_eq!(
+            result, expected,
+            "{:?} plus {:?} should equal {:?}",
+            value1, value2, expected
+        );
+    }
+
+    #[test]
+    fn can_use_existing_values() {
+        let mut calc = Calculation::new(Operand::Add);
+        let value1: i128 = random::<u8>().into();
+        let value2: i128 = random::<u8>().into();
+        let expected: Field = { value1 + value2 }.into();
+        let value1: Field = value1.into();
+        let value2: Field = value2.into();
+        calc.add_value(value1.clone());
+        calc.add_value(CalcValue::Existing(FieldType::Integer));
+        let result = calc.calculate(value2.clone());
+        assert_eq!(
+            result, expected,
+            "{:?} plus {:?} should equal {:?}",
+            value1, value2, expected
+        );
     }
 
     #[test]
@@ -2858,7 +2890,7 @@ mod calculations {
             Ok(_) => {}
             Err(err) => unreachable!("got {:?}, should have returned normally", err),
         }
-        let result = calc.calculate();
+        let result = calc.calculate(Field::None);
         let stop = Utc::now() + duration;
         match result {
             Field::DateTime(data) => {
@@ -2964,7 +2996,7 @@ mod queries {
                 let expected: Field = true.into();
                 let mut holder = op.clone();
                 holder.add_value(data);
-                assert_eq!(holder.calculate(), expected);
+                assert_eq!(holder.calculate(Field::None), expected);
             }
             None => unreachable!("should have returned a calculation"),
         }
@@ -2973,7 +3005,7 @@ mod queries {
                 let expected: Field = false.into();
                 let mut holder = op.clone();
                 holder.add_value(bad_data);
-                assert_eq!(holder.calculate(), expected);
+                assert_eq!(holder.calculate(Field::None), expected);
             }
             None => unreachable!("should have returned a calculation"),
         }
@@ -3392,7 +3424,7 @@ impl Document {
         NT: Into<NameType>,
     {
         match self.data.get(&name.into()) {
-            Some(data) => Some(data.get()),
+            Some(data) => Some(data.get(Field::None)),
             None => None,
         }
     }
@@ -3400,7 +3432,7 @@ impl Document {
     fn get_all(&self) -> Vec<(NameType, Field)> {
         let mut output = Vec::new();
         for (key, value) in self.data.iter() {
-            output.push((key.clone(), value.get()));
+            output.push((key.clone(), value.get(Field::None)));
         }
         output
     }
@@ -3612,7 +3644,7 @@ impl Index {
                 Ok(_) => {}
                 Err(err) => return Err(err),
             }
-            if op.calculate() == true.into() {
+            if op.calculate(Field::None) == true.into() {
                 output = output.union(&value).cloned().collect();
             }
         }
@@ -4070,7 +4102,7 @@ impl DocumentFile {
                     Ok(_) => {}
                     Err(err) => return Err(err),
                 }
-                if calc.calculate() == false.into() {
+                if calc.calculate(Field::None) == false.into() {
                     oids.remove(oid);
                 }
             }