From 6709a9628569d31f82b8d826a3f516508891ff62 Mon Sep 17 00:00:00 2001 From: Jeff Baskin Date: Tue, 28 Oct 2025 15:23:40 -0400 Subject: [PATCH] Added existing to the calculations. --- src/message.rs | 132 ++++++++++++++++++++++++++++++------------------- 1 file changed, 82 insertions(+), 50 deletions(-) diff --git a/src/message.rs b/src/message.rs index 8c6a290..11d1116 100644 --- a/src/message.rs +++ b/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 { + fn get_fields(&self, existing: Field) -> Vec { 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(&mut self, data: CV) -> Result<(), MTTError> where CV: Into, { 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::().into(); + let value2: i128 = random::().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, { 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); } }