Add Div arithmetic operation on BlockNumber

Author: Alenar

mithril-common/src/entities/block_number.rs

@@ -4,7 +4,8 @@ use std::ops::{Deref, DerefMut};
 use serde::{Deserialize, Serialize};
 
 use crate::entities::wrapper_helpers::{
-    impl_add_to_wrapper, impl_mul_to_wrapper, impl_partial_eq_to_wrapper, impl_sub_to_wrapper,
+    impl_add_to_wrapper, impl_div_to_wrapper, impl_mul_to_wrapper, impl_partial_eq_to_wrapper,
+    impl_sub_to_wrapper,
 };
 use crate::signable_builder::Beacon;
 
@@ -39,6 +40,7 @@ impl DerefMut for BlockNumber {
 impl_add_to_wrapper!(BlockNumber, u64);
 impl_sub_to_wrapper!(BlockNumber, u64);
 impl_mul_to_wrapper!(BlockNumber, u64);
+impl_div_to_wrapper!(BlockNumber, u64);
 impl_partial_eq_to_wrapper!(BlockNumber, u64);
 
 #[cfg(test)]
@@ -130,6 +132,26 @@ mod tests {
         test_op_assign!(2_u64, *=, &BlockNumber(3) => 6_u64);
     }
 
+    #[test]
+    #[allow(clippy::op_ref)]
+    fn test_div() {
+        assert_eq!(BlockNumber(6), BlockNumber(18) / BlockNumber(3));
+        assert_eq!(BlockNumber(6), BlockNumber(18) / 3_u64);
+        assert_eq!(BlockNumber(6), BlockNumber(18) / &3_u64);
+
+        assert_eq!(BlockNumber(6), 12_u64 / BlockNumber(2));
+        assert_eq!(BlockNumber(6), 12_u64 / &BlockNumber(2));
+        assert_eq!(BlockNumber(6), &12_u64 / BlockNumber(2));
+        assert_eq!(BlockNumber(6), &12_u64 / &BlockNumber(2));
+
+        test_op_assign!(BlockNumber(18), /=, BlockNumber(3) => BlockNumber(6));
+        test_op_assign!(BlockNumber(18), /=, 3_u64 => BlockNumber(6));
+        test_op_assign!(BlockNumber(18), /=, &3_u64 => BlockNumber(6));
+
+        test_op_assign!(18_u64, /=, BlockNumber(3) => 6_u64);
+        test_op_assign!(18_u64, /=, &BlockNumber(3) => 6_u64);
+    }
+
     #[test]
     fn test_eq() {
         assert_eq!(BlockNumber(1), BlockNumber(1));

mithril-common/src/entities/wrapper_helpers.rs

@@ -277,6 +277,99 @@ macro_rules! impl_mul_to_wrapper {
 }
 pub(crate) use impl_mul_to_wrapper;
 
+macro_rules! impl_div_to_wrapper {
+    ( $wrapper:ident, $inner:ty ) => {
+        use std::ops::{Div, DivAssign};
+
+        impl Div for $wrapper {
+            type Output = Self;
+
+            fn div(self, rhs: Self) -> Self::Output {
+                self / *rhs
+            }
+        }
+
+        impl Div<$inner> for $wrapper {
+            type Output = Self;
+
+            fn div(self, rhs: $inner) -> Self::Output {
+                $wrapper(*self / rhs)
+            }
+        }
+
+        impl Div<&$inner> for $wrapper {
+            type Output = Self;
+
+            fn div(self, rhs: &$inner) -> Self::Output {
+                self.div(*rhs)
+            }
+        }
+
+        impl Div<$wrapper> for $inner {
+            type Output = $wrapper;
+
+            fn div(self, rhs: $wrapper) -> Self::Output {
+                $wrapper(self.div(rhs.0))
+            }
+        }
+
+        impl Div<&$wrapper> for $inner {
+            type Output = $wrapper;
+
+            fn div(self, rhs: &$wrapper) -> Self::Output {
+                self.div(*rhs)
+            }
+        }
+
+        impl Div<$wrapper> for &$inner {
+            type Output = $wrapper;
+
+            fn div(self, rhs: $wrapper) -> Self::Output {
+                (*self).div(rhs)
+            }
+        }
+
+        impl Div<&$wrapper> for &$inner {
+            type Output = $wrapper;
+
+            fn div(self, rhs: &$wrapper) -> Self::Output {
+                (*self).div(*rhs)
+            }
+        }
+
+        impl DivAssign for $wrapper {
+            fn div_assign(&mut self, rhs: Self) {
+                *self = self.div(rhs);
+            }
+        }
+
+        impl DivAssign<$inner> for $wrapper {
+            fn div_assign(&mut self, rhs: $inner) {
+                *self = self.div(rhs);
+            }
+        }
+
+        impl DivAssign<&$inner> for $wrapper {
+            fn div_assign(&mut self, rhs: &$inner) {
+                *self = self.div(rhs);
+            }
+        }
+
+        impl DivAssign<$wrapper> for $inner {
+            fn div_assign(&mut self, rhs: $wrapper) {
+                *self = self.div(rhs.0);
+            }
+        }
+
+        impl DivAssign<&$wrapper> for $inner {
+            fn div_assign(&mut self, rhs: &$wrapper) {
+                *self = self.div(rhs.0);
+            }
+        }
+    };
+}
+pub(crate) use impl_div_to_wrapper;
+
 macro_rules! impl_partial_eq_to_wrapper {
     ( $wrapper:ty, $inner:ty ) => {
         impl PartialEq<$inner> for $wrapper {
@@ -348,6 +441,11 @@ pub(crate) mod tests {
             number *= $left;
             assert_eq!($expected, number);
         }};
+        ( $right:expr, /=, $left:expr => $expected:expr ) => {{
+            let mut number = $right;
+            number /= $left;
+            assert_eq!($expected, number);
+        }};
     }
     pub(crate) use test_op_assign;
 }