add even odd

Author: tomoikey

Cargo.toml

@@ -12,6 +12,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+paste = "1.0.14"
 regex = "1.10.3"
 serde = { version = "1.0.197", features = ["derive"] }
 

src/rule.rs

@@ -1,11 +1,13 @@
 pub mod composer;
 mod empty;
 mod non_empty;
+mod number;
 mod string;
 
 use crate::result::Error;
 pub use empty::*;
 pub use non_empty::*;
+pub use number::*;
 pub use string::*;
 
 /// This is a `trait` that specifies the conditions a type `T` should satisfy

src/rule/number.rs

@@ -0,0 +1,5 @@
+mod even;
+mod odd;
+
+pub use even::*;
+pub use odd::*;

src/rule/number/even.rs

@@ -0,0 +1,45 @@
+macro_rules! even_rule {
+    ($t: ty) => {
+        paste::item! {
+            pub type [<Even $t:upper>] = $crate::Refined<[<EvenRule $t:upper>]>;
+            pub struct [<EvenRule $t:upper>];
+
+            impl $crate::rule::Rule for [<EvenRule $t:upper>] {
+                type Item = $t;
+
+                fn validate(target: Self::Item) -> Result<Self::Item, $crate::result::Error<Self::Item>> {
+                    if target % 2 == 0 {
+                        Ok(target)
+                    } else {
+                        Err($crate::result::Error::new(format!("{} is not even number", target), target))
+                    }
+                }
+            }
+        }
+    };
+    ($t: ty, $($ts: ty),+) => {
+        even_rule! {$t}
+        even_rule! {$($ts), +}
+    };
+}
+
+even_rule!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
+
+#[cfg(test)]
+mod test {
+    use crate::rule::EvenU8;
+
+    #[test]
+    fn test_even_u8_ok() {
+        let n = 8;
+        let even_result = EvenU8::new(n);
+        assert!(even_result.is_ok())
+    }
+
+    #[test]
+    fn test_even_u8_err() {
+        let n = 7;
+        let even_result = EvenU8::new(n);
+        assert!(even_result.is_err())
+    }
+}

src/rule/number/odd.rs

@@ -0,0 +1,45 @@
+macro_rules! odd_rule {
+    ($t: ty) => {
+        paste::item! {
+            pub type [<Odd $t:upper>] = $crate::Refined<[<OddRule $t:upper>]>;
+            pub struct [<OddRule $t:upper>];
+
+            impl $crate::rule::Rule for [<OddRule $t:upper>] {
+                type Item = $t;
+
+                fn validate(target: Self::Item) -> Result<Self::Item, $crate::result::Error<Self::Item>> {
+                    if target % 2 == 1 {
+                        Ok(target)
+                    } else {
+                        Err($crate::result::Error::new(format!("{} is not odd number", target), target))
+                    }
+                }
+            }
+        }
+    };
+    ($t: ty, $($ts: ty),+) => {
+        odd_rule! {$t}
+        odd_rule! {$($ts), +}
+    };
+}
+
+odd_rule!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);
+
+#[cfg(test)]
+mod test {
+    use crate::rule::OddU8;
+
+    #[test]
+    fn test_odd_u8_ok() {
+        let n = 7;
+        let even_result = OddU8::new(n);
+        assert!(even_result.is_ok())
+    }
+
+    #[test]
+    fn test_odd_u8_err() {
+        let n = 8;
+        let even_result = OddU8::new(n);
+        assert!(even_result.is_err())
+    }
+}