Merge #276

276: Implement To/FromBytes r=cuviper a=cuviper Co-authored-by: Josh Stone <cuviper@gmail.com>
rust-num · Jul 21, 2023 · b9db55d · b9db55d
2 parents 6f2b8e0 + 6d2ff5e
commit b9db55d
Show file tree

Hide file tree

Showing 5 changed files with 74 additions and 32 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -45,7 +45,7 @@ default-features = false
 features = ["i128"]
 
 [dependencies.num-traits]
-version = "0.2.11"
+version = "0.2.16"
 default-features = false
 features = ["i128"]
 

diff --git a/src/bigint.rs b/src/bigint.rs
@@ -1097,6 +1097,30 @@ impl BigInt {
     }
 }
 
+impl num_traits::FromBytes for BigInt {
+    type Bytes = [u8];
+
+    fn from_be_bytes(bytes: &Self::Bytes) -> Self {
+        Self::from_signed_bytes_be(bytes)
+    }
+
+    fn from_le_bytes(bytes: &Self::Bytes) -> Self {
+        Self::from_signed_bytes_le(bytes)
+    }
+}
+
+impl num_traits::ToBytes for BigInt {
+    type Bytes = Vec<u8>;
+
+    fn to_be_bytes(&self) -> Self::Bytes {
+        self.to_signed_bytes_be()
+    }
+
+    fn to_le_bytes(&self) -> Self::Bytes {
+        self.to_signed_bytes_le()
+    }
+}
+
 #[test]
 fn test_from_biguint() {
     fn check(inp_s: Sign, inp_n: usize, ans_s: Sign, ans_n: usize) {

diff --git a/src/biguint.rs b/src/biguint.rs
@@ -959,6 +959,30 @@ impl BigUint {
     }
 }
 
+impl num_traits::FromBytes for BigUint {
+    type Bytes = [u8];
+
+    fn from_be_bytes(bytes: &Self::Bytes) -> Self {
+        Self::from_bytes_be(bytes)
+    }
+
+    fn from_le_bytes(bytes: &Self::Bytes) -> Self {
+        Self::from_bytes_le(bytes)
+    }
+}
+
+impl num_traits::ToBytes for BigUint {
+    type Bytes = Vec<u8>;
+
+    fn to_be_bytes(&self) -> Self::Bytes {
+        self.to_bytes_be()
+    }
+
+    fn to_le_bytes(&self) -> Self::Bytes {
+        self.to_bytes_le()
+    }
+}
+
 pub(crate) trait IntDigits {
     fn digits(&self) -> &[BigDigit];
     fn digits_mut(&mut self) -> &mut Vec<BigDigit>;

diff --git a/tests/bigint.rs b/tests/bigint.rs
@@ -13,7 +13,9 @@ use std::{i16, i32, i64, i8, isize};
 use std::{u16, u32, u64, u8, usize};
 
 use num_integer::Integer;
-use num_traits::{pow, FromPrimitive, Num, One, Pow, Signed, ToPrimitive, Zero};
+use num_traits::{
+    pow, FromBytes, FromPrimitive, Num, One, Pow, Signed, ToBytes, ToPrimitive, Zero,
+};
 
 mod consts;
 use crate::consts::*;
@@ -94,12 +96,9 @@ fn test_to_bytes_le() {
 #[test]
 fn test_to_signed_bytes_le() {
     fn check(s: &str, result: Vec<u8>) {
-        assert_eq!(
-            BigInt::parse_bytes(s.as_bytes(), 10)
-                .unwrap()
-                .to_signed_bytes_le(),
-            result
-        );
+        let b = BigInt::parse_bytes(s.as_bytes(), 10).unwrap();
+        assert_eq!(b.to_signed_bytes_le(), result);
+        assert_eq!(<BigInt as ToBytes>::to_le_bytes(&b), result);
     }
 
     check("0", vec![0]);
@@ -115,10 +114,9 @@ fn test_to_signed_bytes_le() {
 #[test]
 fn test_from_signed_bytes_le() {
     fn check(s: &[u8], result: &str) {
-        assert_eq!(
-            BigInt::from_signed_bytes_le(s),
-            BigInt::parse_bytes(result.as_bytes(), 10).unwrap()
-        );
+        let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap();
+        assert_eq!(BigInt::from_signed_bytes_le(s), b);
+        assert_eq!(<BigInt as FromBytes>::from_le_bytes(s), b);
     }
 
     check(&[], "0");
@@ -136,12 +134,9 @@ fn test_from_signed_bytes_le() {
 #[test]
 fn test_to_signed_bytes_be() {
     fn check(s: &str, result: Vec<u8>) {
-        assert_eq!(
-            BigInt::parse_bytes(s.as_bytes(), 10)
-                .unwrap()
-                .to_signed_bytes_be(),
-            result
-        );
+        let b = BigInt::parse_bytes(s.as_bytes(), 10).unwrap();
+        assert_eq!(b.to_signed_bytes_be(), result);
+        assert_eq!(<BigInt as ToBytes>::to_be_bytes(&b), result);
     }
 
     check("0", vec![0]);
@@ -157,10 +152,9 @@ fn test_to_signed_bytes_be() {
 #[test]
 fn test_from_signed_bytes_be() {
     fn check(s: &[u8], result: &str) {
-        assert_eq!(
-            BigInt::from_signed_bytes_be(s),
-            BigInt::parse_bytes(result.as_bytes(), 10).unwrap()
-        );
+        let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap();
+        assert_eq!(BigInt::from_signed_bytes_be(s), b);
+        assert_eq!(<BigInt as FromBytes>::from_be_bytes(s), b);
     }
 
     check(&[], "0");

diff --git a/tests/biguint.rs b/tests/biguint.rs
@@ -14,8 +14,8 @@ use std::{i128, u128};
 use std::{u16, u32, u64, u8, usize};
 
 use num_traits::{
-    pow, CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, FromPrimitive, Num, One, Pow, ToPrimitive,
-    Zero,
+    pow, CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, FromBytes, FromPrimitive, Num, One, Pow,
+    ToBytes, ToPrimitive, Zero,
 };
 
 mod consts;
@@ -27,10 +27,9 @@ mod macros;
 #[test]
 fn test_from_bytes_be() {
     fn check(s: &str, result: &str) {
-        assert_eq!(
-            BigUint::from_bytes_be(s.as_bytes()),
-            BigUint::parse_bytes(result.as_bytes(), 10).unwrap()
-        );
+        let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
+        assert_eq!(BigUint::from_bytes_be(s.as_bytes()), b);
+        assert_eq!(<BigUint as FromBytes>::from_be_bytes(s.as_bytes()), b);
     }
     check("A", "65");
     check("AA", "16705");
@@ -44,6 +43,7 @@ fn test_to_bytes_be() {
     fn check(s: &str, result: &str) {
         let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
         assert_eq!(b.to_bytes_be(), s.as_bytes());
+        assert_eq!(<BigUint as ToBytes>::to_be_bytes(&b), s.as_bytes());
     }
     check("A", "65");
     check("AA", "16705");
@@ -60,10 +60,9 @@ fn test_to_bytes_be() {
 #[test]
 fn test_from_bytes_le() {
     fn check(s: &str, result: &str) {
-        assert_eq!(
-            BigUint::from_bytes_le(s.as_bytes()),
-            BigUint::parse_bytes(result.as_bytes(), 10).unwrap()
-        );
+        let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
+        assert_eq!(BigUint::from_bytes_le(s.as_bytes()), b);
+        assert_eq!(<BigUint as FromBytes>::from_le_bytes(s.as_bytes()), b);
     }
     check("A", "65");
     check("AA", "16705");
@@ -77,6 +76,7 @@ fn test_to_bytes_le() {
     fn check(s: &str, result: &str) {
         let b = BigUint::parse_bytes(result.as_bytes(), 10).unwrap();
         assert_eq!(b.to_bytes_le(), s.as_bytes());
+        assert_eq!(<BigUint as ToBytes>::to_le_bytes(&b), s.as_bytes());
     }
     check("A", "65");
     check("AA", "16705");