Consolidate fixed integer API methods

Author: dermesser

src/fixed.rs

@@ -10,17 +10,18 @@ pub trait FixedInt: Sized + Copy {
     type Bytes: AsRef<[u8]>;
     const ENCODED_SIZE: usize = size_of::<Self>();
 
-    /// Encode a value into the given slice using machine endianness. Returns `None` if `dst`
+    /// Encode a value into the given slice using little-endian. Returns `None` if `dst`
     /// doesn't provide enough space to encode this integer.
+    ///
+    /// Use `switch_endianness()` if machine endianness doesn't match the desired target encoding.
     fn encode_fixed(self, dst: &mut [u8]) -> Option<()>;
     /// Returns the representation of [`FixedInt`] as [`Bytes`], the little-endian representation
     /// of self in the stack.
     fn encode_fixed_light(self) -> Self::Bytes;
 
-    /// Decode a value from the given slice assuming little-endian.
-    fn decode_le_fixed(src: &[u8]) -> Option<Self>;
-    /// Decode a value from the given slice assuming big-endian.
-    fn decode_be_fixed(src: &[u8]) -> Option<Self>;
+    /// Decode a value from the given slice assuming little-endian. Use `switch_endianness()` on
+    /// the returned value if the source was not encoded in little-endian.
+    fn decode_fixed(src: &[u8]) -> Option<Self>;
 
     /// Helper: Encode the value and return a Vec.
     fn encode_fixed_vec(self) -> Vec<u8> {
@@ -51,22 +52,14 @@ macro_rules! impl_fixedint {
                 self.to_le_bytes()
             }
 
-            fn decode_le_fixed(src: &[u8]) -> Option<Self> {
+            fn decode_fixed(src: &[u8]) -> Option<Self> {
                 if src.len() == size_of::<Self>() {
                     Some(Self::from_le_bytes(src.try_into().unwrap()))
                 } else {
                     None
                 }
             }
 
-            fn decode_be_fixed(src: &[u8]) -> Option<Self> {
-                if src.len() == size_of::<Self>() {
-                    Some(Self::from_be_bytes(src.try_into().unwrap()))
-                } else {
-                    None
-                }
-            }
-
             fn switch_endianness(self) -> Self {
                 Self::from_le_bytes(self.to_be_bytes())
             }

src/fixed_tests.rs

@@ -92,23 +92,14 @@ mod tests {
         let g: i32 = -17;
         let h: i64 = -17;
 
-        assert_eq!(a, FixedInt::decode_fixed_vec(&a.encode_fixed_vec()));
-        assert_eq!(b, FixedInt::decode_fixed_vec(&b.encode_fixed_vec()));
-        assert_eq!(c, FixedInt::decode_fixed_vec(&c.encode_fixed_vec()));
-        assert_eq!(d, FixedInt::decode_fixed_vec(&d.encode_fixed_vec()));
-        assert_eq!(e, FixedInt::decode_fixed_vec(&e.encode_fixed_vec()));
-        assert_eq!(f, FixedInt::decode_fixed_vec(&f.encode_fixed_vec()));
-        assert_eq!(g, FixedInt::decode_fixed_vec(&g.encode_fixed_vec()));
-        assert_eq!(h, FixedInt::decode_fixed_vec(&h.encode_fixed_vec()));
-
-        assert_eq!(a, FixedInt::decode_fixed(&a.encode_fixed_light()));
-        assert_eq!(b, FixedInt::decode_fixed(&b.encode_fixed_light()));
-        assert_eq!(c, FixedInt::decode_fixed(&c.encode_fixed_light()));
-        assert_eq!(d, FixedInt::decode_fixed(&d.encode_fixed_light()));
-        assert_eq!(e, FixedInt::decode_fixed(&e.encode_fixed_light()));
-        assert_eq!(f, FixedInt::decode_fixed(&f.encode_fixed_light()));
-        assert_eq!(g, FixedInt::decode_fixed(&g.encode_fixed_light()));
-        assert_eq!(h, FixedInt::decode_fixed(&h.encode_fixed_light()));
+        assert_eq!(a, FixedInt::decode_fixed(&a.encode_fixed_light()).unwrap());
+        assert_eq!(b, FixedInt::decode_fixed(&b.encode_fixed_light()).unwrap());
+        assert_eq!(c, FixedInt::decode_fixed(&c.encode_fixed_light()).unwrap());
+        assert_eq!(d, FixedInt::decode_fixed(&d.encode_fixed_light()).unwrap());
+        assert_eq!(e, FixedInt::decode_fixed(&e.encode_fixed_light()).unwrap());
+        assert_eq!(f, FixedInt::decode_fixed(&f.encode_fixed_light()).unwrap());
+        assert_eq!(g, FixedInt::decode_fixed(&g.encode_fixed_light()).unwrap());
+        assert_eq!(h, FixedInt::decode_fixed(&h.encode_fixed_light()).unwrap());
     }
 
     #[test]
@@ -141,13 +132,13 @@ mod tests {
     #[should_panic]
     #[test]
     fn test_invalid_decode_size() {
-        assert_eq!(33, u64::decode_fixed(&[1, 0, 0, 0, 0, 1]));
+        assert_eq!(33, u64::decode_fixed(&[1, 0, 0, 0, 0, 1]).unwrap());
     }
     #[should_panic]
     #[test]
     fn test_invalid_encode_size() {
         let mut buf = [0 as u8; 4];
-        (11 as u64).encode_fixed(&mut buf);
+        (11 as u64).encode_fixed(&mut buf).unwrap();
     }
 
     #[cfg(any(feature = "tokio_async", feature = "futures_async"))]

src/lib.rs

@@ -14,7 +14,7 @@
 //! fn main() {
 //!     let a: u32 = 344;
 //!     let encoded_byte_slice = a.encode_fixed_light();
-//!     assert_eq!(a, u32::decode_fixed(&encoded_byte_slice));
+//!     assert_eq!(Some(a), u32::decode_fixed(&encoded_byte_slice));
 //!     assert_eq!(4, encoded_byte_slice.len());
 //!
 //!     let b: i32 = -111;

src/reader.rs

@@ -115,47 +115,35 @@ impl<R: Read> VarIntReader for R {
 }
 
 /// A trait for reading FixedInts from any other `Reader`.
-///
-/// On EOF, an io::Error with io::ErrorKind::UnexpectedEof is returned.
 pub trait FixedIntReader {
-    fn read_le_fixedint<FI: FixedInt>(&mut self) -> Result<FI>;
-    fn read_be_fixedint<FI: FixedInt>(&mut self) -> Result<FI>;
+    /// Read a fixed integer from a reader. How many bytes are read depends on `FI`.
+    ///
+    /// On EOF, an io::Error with io::ErrorKind::UnexpectedEof is returned.
+    fn read_fixedint<FI: FixedInt>(&mut self) -> Result<FI>;
 }
 
 /// Like FixedIntReader, but returns a future.
 #[cfg(any(feature = "tokio_async", feature = "futures_async"))]
 #[async_trait::async_trait]
 pub trait FixedIntAsyncReader {
-    async fn read_le_fixedint_async<FI: FixedInt>(&mut self) -> Result<FI>;
-    async fn read_be_fixedint_async<FI: FixedInt>(&mut self) -> Result<FI>;
+    async fn read_fixedint_async<FI: FixedInt>(&mut self) -> Result<FI>;
 }
 
 #[cfg(any(feature = "tokio_async", feature = "futures_async"))]
 #[async_trait::async_trait]
 impl<AR: AsyncRead + Unpin + Send> FixedIntAsyncReader for AR {
-    async fn read_le_fixedint_async<FI: FixedInt>(&mut self) -> Result<FI> {
-        let mut buf = [0 as u8; 8];
-        self.read_exact(&mut buf[0..std::mem::size_of::<FI>()])
-            .await?;
-        Ok(FI::decode_le_fixed(&buf[0..std::mem::size_of::<FI>()]).unwrap())
-    }
-    async fn read_be_fixedint_async<FI: FixedInt>(&mut self) -> Result<FI> {
+    async fn read_fixedint_async<FI: FixedInt>(&mut self) -> Result<FI> {
         let mut buf = [0 as u8; 8];
         self.read_exact(&mut buf[0..std::mem::size_of::<FI>()])
             .await?;
-        Ok(FI::decode_be_fixed(&buf[0..std::mem::size_of::<FI>()]).unwrap())
+        Ok(FI::decode_fixed(&buf[0..std::mem::size_of::<FI>()]).unwrap())
     }
 }
 
 impl<R: Read> FixedIntReader for R {
-    fn read_le_fixedint<FI: FixedInt>(&mut self) -> Result<FI> {
-        let mut buf = [0 as u8; 8];
-        self.read_exact(&mut buf[0..std::mem::size_of::<FI>()])?;
-        Ok(FI::decode_le_fixed(&buf[0..std::mem::size_of::<FI>()]).unwrap())
-    }
-    fn read_be_fixedint<FI: FixedInt>(&mut self) -> Result<FI> {
+    fn read_fixedint<FI: FixedInt>(&mut self) -> Result<FI> {
         let mut buf = [0 as u8; 8];
         self.read_exact(&mut buf[0..std::mem::size_of::<FI>()])?;
-        Ok(FI::decode_be_fixed(&buf[0..std::mem::size_of::<FI>()]).unwrap())
+        Ok(FI::decode_fixed(&buf[0..std::mem::size_of::<FI>()]).unwrap())
     }
 }