avocado_schema/core/field/
mod.rs

1use crate::core::constraint::Constraint;
2use crate::core::field::array::ArrayField;
3use crate::core::field::boolean::BooleanField;
4use crate::core::field::date::DateField;
5use crate::core::field::datetime::DatetimeField;
6use crate::core::field::email::EmailField;
7use crate::core::field::float::FloatField;
8use crate::core::field::integer::IntegerField;
9use crate::core::field::object::ObjectField;
10use crate::core::field::string::StringField;
11use crate::core::field::time::TimeField;
12use crate::core::field::uinteger::UIntegerField;
13use serde::{Deserialize, Serialize, Serializer};
14use std::fmt;
15use std::fmt::{Debug, Formatter};
16
17#[derive(Debug)]
18pub enum FieldType {
19    String,
20    Integer,
21    UInteger,
22    Float,
23    Boolean,
24    Object,
25    Array,
26    Email,
27    DateTime,
28    Date,
29    Time,
30}
31
32impl fmt::Display for FieldType {
33    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
34        match self {
35            FieldType::String => write!(f, "string"),
36            FieldType::Integer => write!(f, "integer"),
37            FieldType::UInteger => write!(f, "unsigned integer"),
38            FieldType::Float => write!(f, "float"),
39            FieldType::Boolean => write!(f, "boolean"),
40            FieldType::Array => write!(f, "array"),
41            FieldType::Object => write!(f, "object"),
42            FieldType::Email => write!(f, "email"),
43            FieldType::DateTime => write!(f, "datetime"),
44            FieldType::Date => write!(f, "date"),
45            FieldType::Time => write!(f, "time"),
46        }
47    }
48}
49
50pub trait Field: Debug + Into<FieldEnum> {
51    const FIELD_TYPE: FieldType;
52
53    fn name(&self) -> String;
54    fn constrains(&self) -> Vec<Box<dyn Constraint>>;
55}
56
57pub mod array;
58pub mod boolean;
59pub mod date;
60pub mod datetime;
61pub mod email;
62pub mod float;
63pub mod integer;
64pub mod object;
65pub mod string;
66pub mod time;
67pub mod uinteger;
68
69macro_rules! field_enum {
70    ($($field_name:ident($field:ident)),*) => {
71        #[derive(Debug, Deserialize)]
72        #[serde(tag = "type", rename_all = "lowercase")]
73        pub enum FieldEnum { $(
74            $field_name($field),
75        )*}
76
77        impl Serialize for FieldEnum {
78            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
79            where
80                S: Serializer,
81            {
82                match &self {
83                    $(FieldEnum::$field_name(f) => f.serialize(serializer),)*
84                }
85            }
86        }
87
88        $(
89        impl From<$field> for FieldEnum {
90            fn from(value: $field) -> Self {
91                FieldEnum::$field_name(value)
92            }
93        }
94        )*
95    }
96}
97
98field_enum!(
99    Array(ArrayField),
100    Boolean(BooleanField),
101    Float(FloatField),
102    Integer(IntegerField),
103    UInteger(UIntegerField),
104    Object(ObjectField),
105    String(StringField),
106    Email(EmailField),
107    Datetime(DatetimeField),
108    Date(DateField),
109    Time(TimeField)
110);