fixed-hash: remove byteorder feature (#872)

* fixed-hash: remove byteorder features

* fix fixed-hash part of CI

* fix tests

* update readme

.github/workflows/ci.yml

@@ -67,7 +67,7 @@ jobs:
           args: -p uint --all-features
 
       - name: Test fixed-hash no_std
-        run: cargo test -p fixed-hash --no-default-features --features='byteorder,rustc-hex'
+        run: cargo test -p fixed-hash --no-default-features --features='rustc-hex'
 
       - name: Test fixed-hash all-features
         uses: actions-rs/cargo@v1

ethereum-types/Cargo.toml

@@ -10,9 +10,9 @@ rust-version = "1.60.0"
 
 [dependencies]
 ethbloom = { path = "../ethbloom", version = "0.14", optional = true, default-features = false }
-fixed-hash = { path = "../fixed-hash", version = "0.8", default-features = false, features = ["byteorder", "rustc-hex"] }
+fixed-hash = { path = "../fixed-hash", version = "0.8", default-features = false, features = ["rustc-hex"] }
 uint-crate = { path = "../uint", package = "uint", version = "0.10", default-features = false }
-primitive-types = { path = "../primitive-types", version = "0.13", features = ["byteorder", "rustc-hex"], default-features = false }
+primitive-types = { path = "../primitive-types", version = "0.13", features = ["rustc-hex"], default-features = false }
 impl-serde = { path = "../primitive-types/impls/serde", version = "0.5.0", default-features = false, optional = true }
 impl-rlp = { path = "../primitive-types/impls/rlp", version = "0.4", default-features = false, optional = true }
 impl-codec = { version = "0.7.0", path = "../primitive-types/impls/codec", default-features = false, optional = true }

fixed-hash/Cargo.toml

@@ -15,7 +15,6 @@ rust-version = "1.60"
 features = ["quickcheck", "api-dummy"]
 
 [dependencies]
-byteorder = { version = "1.4.2", optional = true, default-features = false }
 quickcheck = { version = "1", optional = true }
 rand = { version = "0.8.0", optional = true, default-features = false }
 rustc-hex = { version = "2.0.1", optional = true, default-features = false }
@@ -28,8 +27,8 @@ criterion = "0.5.1"
 rand = { version = "0.8.0", default-features = false, features = ["std_rng"] }
 
 [features]
-default = ["std", "rand", "rustc-hex", "byteorder"]
-std = ["rustc-hex/std", "rand?/std", "byteorder/std"]
+default = ["std", "rand", "rustc-hex"]
+std = ["rustc-hex/std", "rand?/std"]
 
 api-dummy = [] # Feature used by docs.rs to display documentation of hash types
 

fixed-hash/README.md

@@ -39,7 +39,7 @@ construct_fixed_hash!{
 
 ## Features
 
-By default this is an standard library depending crate.  
+By default this is an standard library depending crate.
 For a `#[no_std]` environment use it as follows:
 
 ```
@@ -52,17 +52,12 @@ fixed-hash = { version = "0.3", default-features = false }
 	- Using this feature enables the following features
 		- `rustc-hex/std`
 		- `rand/std`
-		- `byteorder/std`
-    - Enabled by default.
-- `libc`: Use `libc` for implementations of `PartialEq` and `Ord`.
     - Enabled by default.
 - `rand`: Provide API based on the `rand` crate.
     - Enabled by default.
-- `byteorder`: Provide API based on the `byteorder` crate.
-    - Enabled by default.
 - `quickcheck`: Provide `quickcheck` implementation for hash types.
     - Disabled by default.
-- `api-dummy`: Generate a dummy hash type for API documentation.
-    - Enabled by default at `docs.rs`
 - `arbitrary`: Allow for creation of a hash from random unstructured input.
     - Disabled by default.
+- `api-dummy`: Generate a dummy hash type for API documentation.
+	- Enabled by default at `docs.rs`

fixed-hash/benches/cmp.rs

@@ -14,7 +14,7 @@ use fixed_hash::construct_fixed_hash;
 
 construct_fixed_hash! { pub struct H256(32); }
 
-criterion_group!(cmp, eq_equal, eq_nonequal, compare,);
+criterion_group!(cmp, eq_equal, eq_nonequal, compare);
 criterion_main!(cmp);
 
 fn eq_equal(c: &mut Criterion) {
@@ -26,7 +26,7 @@ fn eq_equal(c: &mut Criterion) {
 			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEF, 0x2D, 0x6D, 0x19, 0x40, 0x84,
 			0xC2, 0xDE, 0x36, 0xE0, 0xDA, 0xBF, 0xCE, 0x45, 0xD0, 0x46, 0xB3, 0x7D, 0x11, 0x06,
 		]),
-		H256([u8::max_value(); 32]),
+		H256([u8::MAX; 32]),
 	] {
 		group.bench_with_input(BenchmarkId::from_parameter(input), &input, |b, x| {
 			b.iter(|| black_box(x.eq(black_box(x))))

fixed-hash/src/hash.rs

@@ -262,8 +262,23 @@ macro_rules! construct_fixed_hash {
 		}
 
 		impl $crate::core_::cmp::PartialOrd for $name {
+			#[inline]
 			fn partial_cmp(&self, other: &Self) -> Option<$crate::core_::cmp::Ordering> {
-				Some(self.cmp(other))
+				self.as_bytes().partial_cmp(other.as_bytes())
+			}
+		}
+
+		impl $crate::core_::cmp::Ord for $name {
+			#[inline]
+			fn cmp(&self, other: &Self) -> $crate::core_::cmp::Ordering {
+				self.as_bytes().cmp(other.as_bytes())
+			}
+		}
+
+		impl $crate::core_::default::Default for $name {
+			#[inline]
+			fn default() -> Self {
+				Self::zero()
 			}
 		}
 
@@ -295,53 +310,71 @@ macro_rules! construct_fixed_hash {
 			}
 		}
 
-		impl $crate::core_::default::Default for $name {
-			#[inline]
-			fn default() -> Self {
-				Self::zero()
-			}
-		}
-
-		impl_ops_for_hash!($name, BitOr, bitor, BitOrAssign, bitor_assign, |, |=);
-		impl_ops_for_hash!($name, BitAnd, bitand, BitAndAssign, bitand_assign, &, &=);
-		impl_ops_for_hash!($name, BitXor, bitxor, BitXorAssign, bitxor_assign, ^, ^=);
+		impl_bit_ops_for_fixed_hash!($name, BitOr, bitor, BitOrAssign, bitor_assign, |, |=);
+		impl_bit_ops_for_fixed_hash!($name, BitAnd, bitand, BitAndAssign, bitand_assign, &, &=);
+		impl_bit_ops_for_fixed_hash!($name, BitXor, bitxor, BitXorAssign, bitxor_assign, ^, ^=);
 
 		impl_byteorder_for_fixed_hash!($name);
+
 		impl_rand_for_fixed_hash!($name);
-		impl_cmp_for_fixed_hash!($name);
 		impl_rustc_hex_for_fixed_hash!($name);
 		impl_quickcheck_for_fixed_hash!($name);
 		impl_arbitrary_for_fixed_hash!($name);
 	}
 }
 
-// Implementation for disabled byteorder crate support.
-//
-// # Note
-//
-// Feature guarded macro definitions instead of feature guarded impl blocks
-// to work around the problems of introducing `byteorder` crate feature in
-// a user crate.
-#[cfg(not(feature = "byteorder"))]
 #[macro_export]
 #[doc(hidden)]
-macro_rules! impl_byteorder_for_fixed_hash {
-	( $name:ident ) => {};
+macro_rules! impl_bit_ops_for_fixed_hash {
+	(
+		$impl_for:ident,
+		$ops_trait_name:ident,
+		$ops_fn_name:ident,
+		$ops_assign_trait_name:ident,
+		$ops_assign_fn_name:ident,
+		$ops_tok:tt,
+		$ops_assign_tok:tt
+	) => {
+		impl<'r> $crate::core_::ops::$ops_assign_trait_name<&'r $impl_for> for $impl_for {
+			fn $ops_assign_fn_name(&mut self, rhs: &'r $impl_for) {
+				for (lhs, rhs) in self.as_bytes_mut().iter_mut().zip(rhs.as_bytes()) {
+					*lhs $ops_assign_tok rhs;
+				}
+			}
+		}
+
+		impl $crate::core_::ops::$ops_assign_trait_name<$impl_for> for $impl_for {
+			#[inline]
+			fn $ops_assign_fn_name(&mut self, rhs: $impl_for) {
+				*self $ops_assign_tok &rhs;
+			}
+		}
+
+		impl<'l, 'r> $crate::core_::ops::$ops_trait_name<&'r $impl_for> for &'l $impl_for {
+			type Output = $impl_for;
+
+			fn $ops_fn_name(self, rhs: &'r $impl_for) -> Self::Output {
+				let mut ret = self.clone();
+				ret $ops_assign_tok rhs;
+				ret
+			}
+		}
+
+		impl $crate::core_::ops::$ops_trait_name<$impl_for> for $impl_for {
+			type Output = $impl_for;
+
+			#[inline]
+			fn $ops_fn_name(self, rhs: Self) -> Self::Output {
+				&self $ops_tok &rhs
+			}
+		}
+	};
 }
 
-// Implementation for enabled byteorder crate support.
-//
-// # Note
-//
-// Feature guarded macro definitions instead of feature guarded impl blocks
-// to work around the problems of introducing `byteorder` crate feature in
-// a user crate.
-#[cfg(feature = "byteorder")]
 #[macro_export]
 #[doc(hidden)]
 macro_rules! impl_byteorder_for_fixed_hash {
 	( $name:ident ) => {
-		/// Utilities using the `byteorder` crate.
 		impl $name {
 			/// Returns the least significant `n` bytes as slice.
 			///
@@ -354,14 +387,11 @@ macro_rules! impl_byteorder_for_fixed_hash {
 				&self[(Self::len_bytes() - n)..]
 			}
 
-			fn to_low_u64_with_byteorder<B>(&self) -> u64
-			where
-				B: $crate::byteorder::ByteOrder,
-			{
+			fn to_low_u64_with_fn(&self, from_bytes: fn([u8; 8]) -> u64) -> u64 {
 				let mut buf = [0x0; 8];
 				let capped = $crate::core_::cmp::min(Self::len_bytes(), 8);
 				buf[(8 - capped)..].copy_from_slice(self.least_significant_bytes(capped));
-				B::read_u64(&buf)
+				from_bytes(buf)
 			}
 
 			/// Returns the lowest 8 bytes interpreted as big-endian.
@@ -372,7 +402,7 @@ macro_rules! impl_byteorder_for_fixed_hash {
 			/// are interpreted as being zero.
 			#[inline]
 			pub fn to_low_u64_be(&self) -> u64 {
-				self.to_low_u64_with_byteorder::<$crate::byteorder::BigEndian>()
+				self.to_low_u64_with_fn(u64::from_be_bytes)
 			}
 
 			/// Returns the lowest 8 bytes interpreted as little-endian.
@@ -383,7 +413,7 @@ macro_rules! impl_byteorder_for_fixed_hash {
 			/// are interpreted as being zero.
 			#[inline]
 			pub fn to_low_u64_le(&self) -> u64 {
-				self.to_low_u64_with_byteorder::<$crate::byteorder::LittleEndian>()
+				self.to_low_u64_with_fn(u64::from_le_bytes)
 			}
 
 			/// Returns the lowest 8 bytes interpreted as native-endian.
@@ -394,15 +424,11 @@ macro_rules! impl_byteorder_for_fixed_hash {
 			/// are interpreted as being zero.
 			#[inline]
 			pub fn to_low_u64_ne(&self) -> u64 {
-				self.to_low_u64_with_byteorder::<$crate::byteorder::NativeEndian>()
+				self.to_low_u64_with_fn(u64::from_ne_bytes)
 			}
 
-			fn from_low_u64_with_byteorder<B>(val: u64) -> Self
-			where
-				B: $crate::byteorder::ByteOrder,
-			{
-				let mut buf = [0x0; 8];
-				B::write_u64(&mut buf, val);
+			fn from_low_u64_with_fn(val: u64, to_bytes: fn(u64) -> [u8; 8]) -> Self {
+				let buf = to_bytes(val);
 				let capped = $crate::core_::cmp::min(Self::len_bytes(), 8);
 				let mut bytes = [0x0; $crate::core_::mem::size_of::<Self>()];
 				bytes[(Self::len_bytes() - capped)..].copy_from_slice(&buf[..capped]);
@@ -418,7 +444,7 @@ macro_rules! impl_byteorder_for_fixed_hash {
 			///   if the hash type has less than 8 bytes.
 			#[inline]
 			pub fn from_low_u64_be(val: u64) -> Self {
-				Self::from_low_u64_with_byteorder::<$crate::byteorder::BigEndian>(val)
+				Self::from_low_u64_with_fn(val, u64::to_be_bytes)
 			}
 
 			/// Creates a new hash type from the given `u64` value.
@@ -430,7 +456,7 @@ macro_rules! impl_byteorder_for_fixed_hash {
 			///   if the hash type has less than 8 bytes.
 			#[inline]
 			pub fn from_low_u64_le(val: u64) -> Self {
-				Self::from_low_u64_with_byteorder::<$crate::byteorder::LittleEndian>(val)
+				Self::from_low_u64_with_fn(val, u64::to_le_bytes)
 			}
 
 			/// Creates a new hash type from the given `u64` value.
@@ -442,7 +468,7 @@ macro_rules! impl_byteorder_for_fixed_hash {
 			///   if the hash type has less than 8 bytes.
 			#[inline]
 			pub fn from_low_u64_ne(val: u64) -> Self {
-				Self::from_low_u64_with_byteorder::<$crate::byteorder::NativeEndian>(val)
+				Self::from_low_u64_with_fn(val, u64::to_ne_bytes)
 			}
 		}
 	};
@@ -523,19 +549,6 @@ macro_rules! impl_rand_for_fixed_hash {
 	};
 }
 
-#[macro_export]
-#[doc(hidden)]
-macro_rules! impl_cmp_for_fixed_hash {
-	( $name:ident ) => {
-		impl $crate::core_::cmp::Ord for $name {
-			#[inline]
-			fn cmp(&self, other: &Self) -> $crate::core_::cmp::Ordering {
-				self.as_bytes().cmp(other.as_bytes())
-			}
-		}
-	};
-}
-
 // Implementation for disabled rustc-hex crate support.
 //
 // # Note
@@ -662,54 +675,6 @@ macro_rules! impl_arbitrary_for_fixed_hash {
 	};
 }
 
-#[macro_export]
-#[doc(hidden)]
-macro_rules! impl_ops_for_hash {
-	(
-		$impl_for:ident,
-		$ops_trait_name:ident,
-		$ops_fn_name:ident,
-		$ops_assign_trait_name:ident,
-		$ops_assign_fn_name:ident,
-		$ops_tok:tt,
-		$ops_assign_tok:tt
-	) => {
-		impl<'r> $crate::core_::ops::$ops_assign_trait_name<&'r $impl_for> for $impl_for {
-			fn $ops_assign_fn_name(&mut self, rhs: &'r $impl_for) {
-				for (lhs, rhs) in self.as_bytes_mut().iter_mut().zip(rhs.as_bytes()) {
-					*lhs $ops_assign_tok rhs;
-				}
-			}
-		}
-
-		impl $crate::core_::ops::$ops_assign_trait_name<$impl_for> for $impl_for {
-			#[inline]
-			fn $ops_assign_fn_name(&mut self, rhs: $impl_for) {
-				*self $ops_assign_tok &rhs;
-			}
-		}
-
-		impl<'l, 'r> $crate::core_::ops::$ops_trait_name<&'r $impl_for> for &'l $impl_for {
-			type Output = $impl_for;
-
-			fn $ops_fn_name(self, rhs: &'r $impl_for) -> Self::Output {
-				let mut ret = self.clone();
-				ret $ops_assign_tok rhs;
-				ret
-			}
-		}
-
-		impl $crate::core_::ops::$ops_trait_name<$impl_for> for $impl_for {
-			type Output = $impl_for;
-
-			#[inline]
-			fn $ops_fn_name(self, rhs: Self) -> Self::Output {
-				&self $ops_tok &rhs
-			}
-		}
-	};
-}
-
 /// Implements lossy conversions between the given types.
 ///
 /// # Note

fixed-hash/src/lib.rs

@@ -30,10 +30,6 @@ pub use static_assertions;
 #[doc(hidden)]
 pub use static_assertions::const_assert;
 
-#[cfg(feature = "byteorder")]
-#[doc(hidden)]
-pub use byteorder;
-
 #[cfg(feature = "rustc-hex")]
 #[doc(hidden)]
 pub use rustc_hex;