From 9e16684ac9cfa83265b6c207234604a08fbdb6a6 Mon Sep 17 00:00:00 2001
From: Jeff Baskin <jeff.l.baskin@gmail.com>
Date: Thu, 8 May 2025 12:07:57 -0400
Subject: [PATCH] Removed Field2.  Bad experiment.

---
 src/field.rs | 188 ---------------------------------------------------
 1 file changed, 188 deletions(-)

diff --git a/src/field.rs b/src/field.rs
index f010d6b..6adcfb1 100644
--- a/src/field.rs
+++ b/src/field.rs
@@ -12,194 +12,6 @@ enum FieldType {
     Uuid,
 }
 
-#[derive(Clone)]
-struct Field2<T> {
-    data: T,
-    field_type: FieldType,
-}
-
-impl<T> Field2<T> {
-    fn data(&self) -> &T {
-        &self.data
-    }
-
-    fn get_type(&self) -> &FieldType {
-        &self.field_type
-    }
-}
-
-impl From<&str> for Field2<String> {
-    fn from(value: &str) -> Self {
-        Self {
-            data: value.to_string(),
-            field_type: FieldType::StaticString,
-        }
-    }
-}
-
-impl From<ActionType> for Field2<ActionType> {
-    fn from(value: ActionType) -> Self {
-        Self {
-            data: value,
-            field_type: FieldType::Action,
-        }
-    }
-}
-
-impl From<DateTime<Utc>> for Field2<DateTime<Utc>> {
-    fn from(value: DateTime<Utc>) -> Self {
-        Self {
-            data: value,
-            field_type: FieldType::DateTime,
-        }
-    }
-}
-
-impl From<ErrorType> for Field2<ErrorType> {
-    fn from(value: ErrorType) -> Self {
-        Self {
-            data: value,
-            field_type: FieldType::Error,
-        }
-    }
-}
-
-impl From<String> for Field2<String> {
-    fn from(value: String) -> Self {
-        Self {
-            data: value,
-            field_type: FieldType::StaticString,
-        }
-    }
-}
-
-impl From<Uuid> for Field2<Uuid>  {
-    fn from(value: Uuid) -> Self {
-        Self {
-            data: value,
-            field_type: FieldType::Uuid,
-        }
-    }
-}
-
-impl TryFrom<&str> for Field2<Uuid> {
-    type Error = String;
-
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
-        match Uuid::try_from(value) {
-            Ok(data) => Ok(Self {
-                data: data.clone(),
-                field_type: FieldType::Uuid,
-            }),
-            Err(err) => Err(err.to_string()),
-        }
-    }
-}
-
-impl TryFrom<String> for Field2<Uuid> {
-    type Error = String;
-
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        match Uuid::try_from(value.as_str()) {
-            Ok(data) => Ok(Self {
-                data: data.clone(),
-                field_type: FieldType::Uuid,
-            }),
-            Err(err) => Err(err.to_string()),
-        }
-    }
-}
-
-#[cfg(test)]
-mod field2s {
-    use super::*;
-
-    #[test]
-    fn from_action_to_field() {
-        let actions = [ActionType::Add, ActionType::Update];
-        for expected in actions.into_iter() {
-            let field: Field2<ActionType> = expected.clone().into();
-            assert_eq!(field.get_type(), &FieldType::Action);
-            assert_eq!(field.data(), &expected);
-        }
-    }
-
-    #[test]
-    fn from_datetime_to_field() {
-        let expected = Utc::now();
-        let field: Field2<DateTime<Utc>> = expected.into();
-        assert_eq!(field.get_type(), &FieldType::DateTime);
-        assert_eq!(field.data(), &expected);
-    }
-
-    #[test]
-    fn from_error_to_field() {
-        let errors = [ErrorType::DocumentAlreadyExists, ErrorType::DocumentInvalidRequest];
-        for expected in errors.into_iter() {
-            let field: Field2<ErrorType> = expected.clone().into();
-            assert_eq!(field.get_type(), &FieldType::Error);
-            assert_eq!(field.data(), &expected);
-        }
-    }
-
-    #[test]
-    fn from_str_to_field() {
-        let expected = format!("string-{}", Uuid::new_v4());
-        let field: Field2<String> = expected.as_str().into();
-        assert_eq!(field.get_type(), &FieldType::StaticString);
-        assert_eq!(field.data(), &expected);
-    }
-
-    #[test]
-    fn from_string_to_field() {
-        let expected = format!("string-{}", Uuid::new_v4());
-        let field: Field2<String> = expected.clone().into();
-        assert_eq!(field.get_type(), &FieldType::StaticString);
-        assert_eq!(field.data(), &expected);
-    }
-
-    #[test]
-    fn from_uuid_to_field() {
-        let expected = Uuid::new_v4();
-        let field: Field2<Uuid> = expected.into();
-        assert_eq!(field.get_type(), &FieldType::Uuid);
-        assert_eq!(field.data(), &expected);
-    }
-
-    #[test]
-    fn from_uuid_str_to_field() {
-        let expected = Uuid::new_v4();
-        let field: Field2<Uuid> = expected.to_string().as_str().try_into().unwrap();
-        assert_eq!(field.get_type(), &FieldType::Uuid);
-        assert_eq!(field.data(), &expected);
-    }
-
-    #[test]
-    fn from_uuid_bad_str_fails() {
-        let expected = "Not a uuid";
-        let result: Result<Field2<Uuid>, String> = expected.try_into();
-        assert!(result.is_err(), "should have been an error");
-    }
-
-    #[test]
-    fn from_uuid_string_to_field() {
-        let expected = Uuid::new_v4();
-        let field: Field2<Uuid> = expected.to_string().try_into().unwrap();
-        assert_eq!(field.get_type(), &FieldType::Uuid);
-        assert_eq!(field.data(), &expected);
-    }
-
-    #[test]
-    fn from_uuid_bad_string_fails() {
-        let expected = "Not a uuid".to_string();
-        let result: Result<Field2<Uuid>, String> = expected.try_into();
-        assert!(result.is_err(), "should have been an error");
-    }
-}
-
-
-
-
 #[derive(Clone, Debug)]
 pub enum Field {
     Action(ActionType),