From 55ea1fb8a2fb1414377d11e9e38ea868d6dd58eb Mon Sep 17 00:00:00 2001
From: Jeff Baskin <jeff.l.baskin@gmail.com>
Date: Sat, 1 Nov 2025 12:49:11 -0400
Subject: [PATCH] Added Field comparason functions.

---
 src/message.rs | 101 +++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 81 insertions(+), 20 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index 3051900..64b6628 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1827,7 +1827,7 @@ mod fieldtypes {
     }
 }
 
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 enum Field {
     Boolean(bool),
     DateTime(DateTime<Utc>),
@@ -1843,25 +1843,6 @@ impl Field {
         self.into()
     }
 
-    fn add(&self, value: Field) -> Result<Self, MTTError> {
-        match self {
-            Self::Duration(ldata) => match value {
-                Self::Duration(rdata) => Ok({ ldata.clone() + rdata }.into()),
-                Self::DateTime(rdata) => Ok({ rdata.clone() + ldata.clone() }.into()),
-                _ => Err(MTTError::FieldInvalidType),
-            },
-            Self::Integer(ldata) => match value {
-                Self::Integer(rdata) => Ok({ ldata + rdata }.into()),
-                _ => Err(MTTError::FieldInvalidType),
-            },
-            Self::DateTime(ldata) => match value {
-                Self::Duration(rdata) => Ok({ ldata.clone() + rdata }.into()),
-                _ => Err(MTTError::FieldInvalidType),
-            },
-            _ => Err(MTTError::FieldInvalidType),
-        }
-    }
-
     fn equal(&self, other: &Field) -> Field {
         if self.get_type() == other.get_type() {
             { self == other }.into()
@@ -1877,6 +1858,38 @@ impl Field {
             Field::None
         }
     }
+
+    fn greater(&self, other: &Self) -> Field {
+        if self.get_type() == other.get_type() {
+            { self > other }.into()
+        } else {
+            Field::None
+        }
+    }
+
+    fn greater_equal(&self, other: &Self) -> Field {
+        if self.get_type() == other.get_type() {
+            { self >= other }.into()
+        } else {
+            Field::None
+        }
+    }
+
+    fn lesser(&self, other: &Self) -> Field {
+        if self.get_type() == other.get_type() {
+            { self < other }.into()
+        } else {
+            Field::None
+        }
+    }
+
+    fn lesser_equal(&self, other: &Self) -> Field {
+        if self.get_type() == other.get_type() {
+            { self <= other }.into()
+        } else {
+            Field::None
+        }
+    }
 }
 
 impl Add for Field {
@@ -2102,6 +2115,54 @@ mod fields {
         assert_eq!(values[0].not_equal(&values[1]), true.into());
         assert_eq!(values[0].not_equal(&"nope".into()), Field::None);
     }
+
+    #[test]
+    fn can_field_have_greater_value() {
+        let value1: Field = 1.into();
+        let value2: Field = 2.into();
+        let value3: Field = 3.into();
+        let mismatch: Field = "bad".into();
+        assert_eq!(value2.greater(&value1), true.into());
+        assert_eq!(value2.greater(&value2), false.into());
+        assert_eq!(value2.greater(&value3), false.into());
+        assert_eq!(value2.greater(&mismatch), Field::None);
+    }
+
+    #[test]
+    fn can_field_have_greater_or_equal_value() {
+        let value1: Field = 1.into();
+        let value2: Field = 2.into();
+        let value3: Field = 3.into();
+        let mismatch: Field = "bad".into();
+        assert_eq!(value2.greater_equal(&value1), true.into());
+        assert_eq!(value2.greater_equal(&value2), true.into());
+        assert_eq!(value2.greater_equal(&value3), false.into());
+        assert_eq!(value2.greater_equal(&mismatch), Field::None);
+    }
+
+    #[test]
+    fn can_field_have_lesser_value() {
+        let value1: Field = 1.into();
+        let value2: Field = 2.into();
+        let value3: Field = 3.into();
+        let mismatch: Field = "bad".into();
+        assert_eq!(value2.lesser(&value1), false.into());
+        assert_eq!(value2.lesser(&value2), false.into());
+        assert_eq!(value2.lesser(&value3), true.into());
+        assert_eq!(value2.lesser(&mismatch), Field::None);
+    }
+
+    #[test]
+    fn can_field_have_lesser_or_equal_value() {
+        let value1: Field = 1.into();
+        let value2: Field = 2.into();
+        let value3: Field = 3.into();
+        let mismatch: Field = "bad".into();
+        assert_eq!(value2.lesser_equal(&value1), false.into());
+        assert_eq!(value2.lesser_equal(&value2), true.into());
+        assert_eq!(value2.lesser_equal(&value3), true.into());
+        assert_eq!(value2.lesser_equal(&mismatch), Field::None);
+    }
 }
 
 #[derive(Clone, Debug)]