implement more built-in traits

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "byte-unit"
-version = "5.1.0"
+version = "5.1.1"
 authors = ["Magic Len <[email protected]>"]
 edition = "2021"
 rust-version = "1.69"

src/bit/built_in_traits.rs

@@ -1,4 +1,4 @@
-use core::str::FromStr;
+use core::{cmp::Ordering, str::FromStr};
 
 use super::Bit;
 use crate::{ExceededBoundsError, ParseError, TryFromIntError};
@@ -201,3 +201,115 @@ impl FromStr for Bit {
         Bit::parse_str(s)
     }
 }
+
+impl PartialEq<u64> for Bit {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn eq(&self, other: &u64) -> bool {
+        self.0 == *other as u128
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn eq(&self, other: &u64) -> bool {
+        self.0 == *other
+    }
+}
+
+impl PartialEq<u128> for Bit {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn eq(&self, other: &u128) -> bool {
+        self.0 == *other
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn eq(&self, other: &u128) -> bool {
+        self.0 as u128 == *other
+    }
+}
+
+impl PartialEq<Bit> for u64 {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn eq(&self, other: &Bit) -> bool {
+        *self as u128 == other.0
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn eq(&self, other: &Bit) -> bool {
+        *self == other.0
+    }
+}
+
+impl PartialEq<Bit> for u128 {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn eq(&self, other: &Bit) -> bool {
+        *self == other.0
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn eq(&self, other: &Bit) -> bool {
+        *self == other.0 as u128
+    }
+}
+
+impl PartialOrd<u64> for Bit {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
+        self.0.partial_cmp(&(*other as u128))
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
+        self.0.partial_cmp(other)
+    }
+}
+
+impl PartialOrd<u128> for Bit {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn partial_cmp(&self, other: &u128) -> Option<Ordering> {
+        self.0.partial_cmp(other)
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn partial_cmp(&self, other: &u128) -> Option<Ordering> {
+        (self.0 as u128).partial_cmp(other)
+    }
+}
+
+impl PartialOrd<Bit> for u64 {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn partial_cmp(&self, other: &Bit) -> Option<Ordering> {
+        (*self as u128).partial_cmp(&other.0)
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn partial_cmp(&self, other: &Bit) -> Option<Ordering> {
+        self.partial_cmp(&other.0)
+    }
+}
+
+impl PartialOrd<Bit> for u128 {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn partial_cmp(&self, other: &Bit) -> Option<Ordering> {
+        self.partial_cmp(&other.0)
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn partial_cmp(&self, other: &Bit) -> Option<Ordering> {
+        self.partial_cmp(&(other.0 as u128))
+    }
+}

src/byte/built_in_traits.rs

@@ -1,4 +1,4 @@
-use core::str::FromStr;
+use core::{cmp::Ordering, str::FromStr};
 
 use super::Byte;
 use crate::{ExceededBoundsError, ParseError, TryFromIntError};
@@ -202,3 +202,115 @@ impl FromStr for Byte {
         Byte::parse_str(s, false)
     }
 }
+
+impl PartialEq<u64> for Byte {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn eq(&self, other: &u64) -> bool {
+        self.0 == *other as u128
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn eq(&self, other: &u64) -> bool {
+        self.0 == *other
+    }
+}
+
+impl PartialEq<u128> for Byte {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn eq(&self, other: &u128) -> bool {
+        self.0 == *other
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn eq(&self, other: &u128) -> bool {
+        self.0 as u128 == *other
+    }
+}
+
+impl PartialEq<Byte> for u64 {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn eq(&self, other: &Byte) -> bool {
+        *self as u128 == other.0
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn eq(&self, other: &Byte) -> bool {
+        *self == other.0
+    }
+}
+
+impl PartialEq<Byte> for u128 {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn eq(&self, other: &Byte) -> bool {
+        *self == other.0
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn eq(&self, other: &Byte) -> bool {
+        *self == other.0 as u128
+    }
+}
+
+impl PartialOrd<u64> for Byte {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
+        self.0.partial_cmp(&(*other as u128))
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
+        self.0.partial_cmp(other)
+    }
+}
+
+impl PartialOrd<u128> for Byte {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn partial_cmp(&self, other: &u128) -> Option<Ordering> {
+        self.0.partial_cmp(other)
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn partial_cmp(&self, other: &u128) -> Option<Ordering> {
+        (self.0 as u128).partial_cmp(other)
+    }
+}
+
+impl PartialOrd<Byte> for u64 {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn partial_cmp(&self, other: &Byte) -> Option<Ordering> {
+        (*self as u128).partial_cmp(&other.0)
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn partial_cmp(&self, other: &Byte) -> Option<Ordering> {
+        self.partial_cmp(&other.0)
+    }
+}
+
+impl PartialOrd<Byte> for u128 {
+    #[cfg(feature = "u128")]
+    #[inline]
+    fn partial_cmp(&self, other: &Byte) -> Option<Ordering> {
+        self.partial_cmp(&other.0)
+    }
+
+    #[cfg(not(feature = "u128"))]
+    #[inline]
+    fn partial_cmp(&self, other: &Byte) -> Option<Ordering> {
+        self.partial_cmp(&(other.0 as u128))
+    }
+}

tests/bit.rs

@@ -152,6 +152,6 @@ fn tests() {
         let bit = Bit::from_f64_with_unit(case.1 .0, case.1 .1).unwrap();
 
         assert_eq!(case.0, serde_json::to_string(&bit).unwrap(), "{i}");
-        assert_eq!(bit, serde_json::from_str(case.0).unwrap(), "{i}");
+        assert_eq!(bit, serde_json::from_str::<Bit>(case.0).unwrap(), "{i}");
     }
 }

tests/byte.rs

@@ -153,6 +153,6 @@ fn tests() {
         let byte = Byte::from_f64_with_unit(case.1 .0, case.1 .1).unwrap();
 
         assert_eq!(case.0, serde_json::to_string(&byte).unwrap(), "{i}");
-        assert_eq!(byte, serde_json::from_str(case.0).unwrap(), "{i}");
+        assert_eq!(byte, serde_json::from_str::<Byte>(case.0).unwrap(), "{i}");
     }
 }