Refactor: improve mod validate

Add auto implementation of Display.
Add assertion macro `less!`
Add default implementation for primitive types.

openraft/src/engine/engine_impl.rs

@@ -24,7 +24,7 @@ use crate::raft_state::LogStateReader;
 use crate::raft_state::RaftState;
 use crate::raft_types::RaftLogId;
 use crate::summary::MessageSummary;
-use crate::valid::Valid;
+use crate::validate::Valid;
 use crate::LogId;
 use crate::LogIdOptionExt;
 use crate::Membership;

openraft/src/lib.rs

@@ -45,7 +45,7 @@ mod runtime;
 pub mod storage;
 pub mod testing;
 pub mod timer;
-pub(crate) mod valid;
+pub(crate) mod validate;
 pub mod versioned;
 
 #[cfg(test)] mod raft_state_test;

openraft/src/raft_state.rs

@@ -5,7 +5,7 @@ use crate::equal;
 use crate::less_equal;
 use crate::node::Node;
 use crate::raft_types::RaftLogId;
-use crate::valid::Validate;
+use crate::validate::Validate;
 use crate::LogId;
 use crate::LogIdOptionExt;
 use crate::MembershipState;

openraft/src/valid/bench/valid_deref.rs → openraft/src/validate/bench/valid_deref.rs

@@ -8,8 +8,8 @@ use test::Bencher;
 use crate::less_equal;
 use crate::quorum::AsJoint;
 use crate::quorum::QuorumSet;
-use crate::valid::Valid;
-use crate::valid::Validate;
+use crate::validate::Valid;
+use crate::validate::Validate;
 
 struct Foo {
     a: u64,

openraft/src/validate/mod.rs

@@ -0,0 +1,9 @@
+#[cfg(feature = "bench")]
+#[cfg(test)]
+mod bench;
+
+#[allow(clippy::module_inception)] mod validate;
+mod validate_impl;
+
+pub(crate) use validate::Valid;
+pub(crate) use validate::Validate;

openraft/src/valid/valid_impl.rs → openraft/src/validate/validate.rs

@@ -1,9 +1,30 @@
 use std::error::Error;
 use std::fmt::Debug;
+use std::fmt::Display;
 use std::fmt::Formatter;
 use std::ops::Deref;
 use std::ops::DerefMut;
 
+#[macro_export]
+macro_rules! less {
+    ($a: expr, $b: expr) => {{
+        let a = $a;
+        let b = $b;
+        if (a < b) {
+            // Ok
+        } else {
+            Err(::anyerror::AnyError::error(format!(
+                "expect: {}({:?}) {} {}({:?})",
+                stringify!($a),
+                a,
+                "<",
+                stringify!($b),
+                b,
+            )))?;
+        }
+    }};
+}
+
 #[macro_export]
 macro_rules! less_equal {
     ($a: expr, $b: expr) => {{
@@ -171,13 +192,24 @@ where T: Validate
     }
 }
 
+impl<T: Display> Display for Valid<T>
+where T: Validate
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::error::Error;
+    use std::fmt::Display;
+    use std::fmt::Formatter;
 
-    use crate::valid::Valid;
-    use crate::valid::Validate;
+    use crate::validate::Valid;
+    use crate::validate::Validate;
 
+    #[derive(Debug, Clone, Default, PartialEq, Eq)]
     struct Foo {
         a: u64,
     }
@@ -189,6 +221,25 @@ mod tests {
         }
     }
 
+    impl Display for Foo {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            write!(f, "Foo:{}", self.a)
+        }
+    }
+
+    #[test]
+    fn test_trait() {
+        // Display
+        println!("Display: {}", Valid::new(Foo { a: 3 }));
+
+        // Default
+        assert_eq!(Valid::new(Foo { a: 0 }), Valid::<Foo>::default(), "impl Default");
+
+        // Clone
+        #[allow(clippy::redundant_clone)]
+        let _clone = Valid::new(Foo { a: 3 }).clone();
+    }
+
     #[test]
     fn test_validate() {
         // panic when reading an invalid state

openraft/src/validate/validate_impl.rs

@@ -0,0 +1,28 @@
+use std::error::Error;
+
+use crate::validate::Validate;
+
+/// Dummy impl Validate for primitive types
+macro_rules! impl_validate {
+    ($typ: ty) => {
+        impl Validate for $typ {
+            fn validate(&self) -> Result<(), Box<dyn Error>> {
+                Ok(())
+            }
+        }
+    };
+}
+
+impl_validate!(bool);
+impl_validate!(usize);
+impl_validate!(isize);
+impl_validate!(u8);
+impl_validate!(u16);
+impl_validate!(u32);
+impl_validate!(u64);
+impl_validate!(i8);
+impl_validate!(i16);
+impl_validate!(i32);
+impl_validate!(i64);
+impl_validate!(&str);
+impl_validate!(String);