Added decode_ fns

src/de/decoder.rs

@@ -0,0 +1,210 @@
+use super::{read::Reader, Decode};
+use crate::{
+    config::{Config, Endian, IntEncoding},
+    error::DecodeError,
+};
+use std::marker::PhantomData;
+
+pub struct Decoder<R, C: Config> {
+    reader: R,
+    config: PhantomData<C>,
+}
+
+impl<'de, R: Reader<'de>, C: Config> Decoder<R, C> {
+    pub fn new(reader: R) -> Decoder<R, C> {
+        Decoder {
+            reader,
+            config: PhantomData,
+        }
+    }
+
+    pub fn into_reader(self) -> R {
+        self.reader
+    }
+}
+
+impl<'a, 'de, R: Reader<'de>, C: Config> Decode for &'a mut Decoder<R, C> {
+    fn decode_u8(&mut self) -> Result<u8, DecodeError> {
+        let mut bytes = [0u8; 1];
+        self.reader.read(&mut bytes)?;
+        Ok(bytes[0])
+    }
+
+    fn decode_u16(&mut self) -> Result<u16, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => crate::varint::varint_decode_u16(&mut self.reader, C::ENDIAN),
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 2];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => u16::from_le_bytes(bytes),
+                    Endian::Big => u16::from_be_bytes(bytes),
+                })
+            }
+        }
+    }
+
+    fn decode_u32(&mut self) -> Result<u32, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => crate::varint::varint_decode_u32(&mut self.reader, C::ENDIAN),
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 4];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => u32::from_le_bytes(bytes),
+                    Endian::Big => u32::from_be_bytes(bytes),
+                })
+            }
+        }
+    }
+
+    fn decode_u64(&mut self) -> Result<u64, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => crate::varint::varint_decode_u64(&mut self.reader, C::ENDIAN),
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 8];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => u64::from_le_bytes(bytes),
+                    Endian::Big => u64::from_be_bytes(bytes),
+                })
+            }
+        }
+    }
+
+    fn decode_u128(&mut self) -> Result<u128, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => crate::varint::varint_decode_u128(&mut self.reader, C::ENDIAN),
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 16];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => u128::from_le_bytes(bytes),
+                    Endian::Big => u128::from_be_bytes(bytes),
+                })
+            }
+        }
+    }
+
+    fn decode_usize(&mut self) -> Result<usize, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => {
+                crate::varint::varint_decode_usize(&mut self.reader, C::ENDIAN)
+            }
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 8];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => u64::from_le_bytes(bytes),
+                    Endian::Big => u64::from_be_bytes(bytes),
+                } as usize)
+            }
+        }
+    }
+
+    fn decode_i8(&mut self) -> Result<i8, DecodeError> {
+        let mut bytes = [0u8; 1];
+        self.reader.read(&mut bytes)?;
+        Ok(bytes[0] as i8)
+    }
+
+    fn decode_i16(&mut self) -> Result<i16, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => crate::varint::varint_decode_i16(&mut self.reader, C::ENDIAN),
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 2];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => i16::from_le_bytes(bytes),
+                    Endian::Big => i16::from_be_bytes(bytes),
+                })
+            }
+        }
+    }
+
+    fn decode_i32(&mut self) -> Result<i32, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => crate::varint::varint_decode_i32(&mut self.reader, C::ENDIAN),
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 4];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => i32::from_le_bytes(bytes),
+                    Endian::Big => i32::from_be_bytes(bytes),
+                })
+            }
+        }
+    }
+
+    fn decode_i64(&mut self) -> Result<i64, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => crate::varint::varint_decode_i64(&mut self.reader, C::ENDIAN),
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 8];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => i64::from_le_bytes(bytes),
+                    Endian::Big => i64::from_be_bytes(bytes),
+                })
+            }
+        }
+    }
+
+    fn decode_i128(&mut self) -> Result<i128, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => crate::varint::varint_decode_i128(&mut self.reader, C::ENDIAN),
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 16];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => i128::from_le_bytes(bytes),
+                    Endian::Big => i128::from_be_bytes(bytes),
+                })
+            }
+        }
+    }
+
+    fn decode_isize(&mut self) -> Result<isize, DecodeError> {
+        match C::INT_ENCODING {
+            IntEncoding::Variable => {
+                crate::varint::varint_decode_isize(&mut self.reader, C::ENDIAN)
+            }
+            IntEncoding::Fixed => {
+                let mut bytes = [0u8; 8];
+                self.reader.read(&mut bytes)?;
+                Ok(match C::ENDIAN {
+                    Endian::Little => i64::from_le_bytes(bytes),
+                    Endian::Big => i64::from_be_bytes(bytes),
+                } as isize)
+            }
+        }
+    }
+
+    fn decode_f32(&mut self) -> Result<f32, DecodeError> {
+        let mut bytes = [0u8; 4];
+        self.reader.read(&mut bytes)?;
+        Ok(match C::ENDIAN {
+            Endian::Little => f32::from_le_bytes(bytes),
+            Endian::Big => f32::from_be_bytes(bytes),
+        })
+    }
+
+    fn decode_f64(&mut self) -> Result<f64, DecodeError> {
+        let mut bytes = [0u8; 8];
+        self.reader.read(&mut bytes)?;
+        Ok(match C::ENDIAN {
+            Endian::Little => f64::from_le_bytes(bytes),
+            Endian::Big => f64::from_be_bytes(bytes),
+        })
+    }
+
+    fn decode_slice(&mut self, slice: &mut [u8]) -> Result<(), DecodeError> {
+        self.reader.read(slice)
+    }
+
+    fn decode_array<const N: usize>(&mut self) -> Result<[u8; N], DecodeError> {
+        let mut array = [0u8; N];
+        self.reader.read(&mut array)?;
+        Ok(array)
+    }
+}

src/de/impls.rs

@@ -1,8 +1,143 @@
 use super::{Decodable, Decode};
 use crate::error::DecodeError;
 
+impl Decodable for u8 {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_u8()
+    }
+}
+
+impl Decodable for u16 {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_u16()
+    }
+}
+
 impl Decodable for u32 {
     fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
         decoder.decode_u32()
     }
 }
+
+impl Decodable for u64 {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_u64()
+    }
+}
+
+impl Decodable for u128 {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_u128()
+    }
+}
+
+impl Decodable for usize {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_usize()
+    }
+}
+
+impl Decodable for i8 {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_i8()
+    }
+}
+
+impl Decodable for i16 {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_i16()
+    }
+}
+
+impl Decodable for i32 {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_i32()
+    }
+}
+
+impl Decodable for i64 {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_i64()
+    }
+}
+
+impl Decodable for i128 {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_i128()
+    }
+}
+
+impl Decodable for isize {
+    fn decode<D: Decode>(mut decoder: D) -> Result<Self, DecodeError> {
+        decoder.decode_isize()
+    }
+}
+
+impl<'a, T> Decode for &'a mut T
+where
+    T: Decode,
+{
+    fn decode_u8(&mut self) -> Result<u8, DecodeError> {
+        T::decode_u8(self)
+    }
+
+    fn decode_u16(&mut self) -> Result<u16, DecodeError> {
+        T::decode_u16(self)
+    }
+
+    fn decode_u32(&mut self) -> Result<u32, DecodeError> {
+        T::decode_u32(self)
+    }
+
+    fn decode_u64(&mut self) -> Result<u64, DecodeError> {
+        T::decode_u64(self)
+    }
+
+    fn decode_u128(&mut self) -> Result<u128, DecodeError> {
+        T::decode_u128(self)
+    }
+
+    fn decode_usize(&mut self) -> Result<usize, DecodeError> {
+        T::decode_usize(self)
+    }
+
+    fn decode_i8(&mut self) -> Result<i8, DecodeError> {
+        T::decode_i8(self)
+    }
+
+    fn decode_i16(&mut self) -> Result<i16, DecodeError> {
+        T::decode_i16(self)
+    }
+
+    fn decode_i32(&mut self) -> Result<i32, DecodeError> {
+        T::decode_i32(self)
+    }
+
+    fn decode_i64(&mut self) -> Result<i64, DecodeError> {
+        T::decode_i64(self)
+    }
+
+    fn decode_i128(&mut self) -> Result<i128, DecodeError> {
+        T::decode_i128(self)
+    }
+
+    fn decode_isize(&mut self) -> Result<isize, DecodeError> {
+        T::decode_isize(self)
+    }
+
+    fn decode_f32(&mut self) -> Result<f32, DecodeError> {
+        T::decode_f32(self)
+    }
+
+    fn decode_f64(&mut self) -> Result<f64, DecodeError> {
+        T::decode_f64(self)
+    }
+
+    fn decode_slice(&mut self, slice: &mut [u8]) -> Result<(), DecodeError> {
+        T::decode_slice(self, slice)
+    }
+
+    fn decode_array<const N: usize>(&mut self) -> Result<[u8; N], DecodeError> {
+        T::decode_array::<N>(self)
+    }
+}

src/de/mod.rs

@@ -1,58 +1,32 @@
-use core::marker::PhantomData;
+use crate::error::DecodeError;
-
-use crate::{
-    config::{Config, Endian, IntEncoding},
-    error::DecodeError,
-};
-use read::Reader;
 
+mod decoder;
 mod impls;
+
 pub mod read;
+pub use self::decoder::Decoder;
 
 pub trait Decodable: Sized {
     fn decode<D: Decode>(decoder: D) -> Result<Self, DecodeError>;
 }
 
 pub trait Decode {
+    fn decode_u8(&mut self) -> Result<u8, DecodeError>;
+    fn decode_u16(&mut self) -> Result<u16, DecodeError>;
     fn decode_u32(&mut self) -> Result<u32, DecodeError>;
-}
+    fn decode_u64(&mut self) -> Result<u64, DecodeError>;
+    fn decode_u128(&mut self) -> Result<u128, DecodeError>;
+    fn decode_usize(&mut self) -> Result<usize, DecodeError>;
 
-pub struct Decoder<R, C: Config> {
+    fn decode_i8(&mut self) -> Result<i8, DecodeError>;
-    reader: R,
+    fn decode_i16(&mut self) -> Result<i16, DecodeError>;
-    config: PhantomData<C>,
+    fn decode_i32(&mut self) -> Result<i32, DecodeError>;
-}
+    fn decode_i64(&mut self) -> Result<i64, DecodeError>;
+    fn decode_i128(&mut self) -> Result<i128, DecodeError>;
+    fn decode_isize(&mut self) -> Result<isize, DecodeError>;
 
-impl<'de, R: Reader<'de>, C: Config> Decoder<R, C> {
+    fn decode_f32(&mut self) -> Result<f32, DecodeError>;
-    pub fn new(reader: R) -> Decoder<R, C> {
+    fn decode_f64(&mut self) -> Result<f64, DecodeError>;
-        Decoder {
+    fn decode_slice(&mut self, slice: &mut [u8]) -> Result<(), DecodeError>;
-            reader,
+    fn decode_array<const N: usize>(&mut self) -> Result<[u8; N], DecodeError>;
-            config: PhantomData,
-        }
-    }
-}
-
-impl<'a, 'de, R: Reader<'de>, C: Config> Decode for &'a mut Decoder<R, C> {
-    fn decode_u32(&mut self) -> Result<u32, DecodeError> {
-        Ok(match C::INT_ENCODING {
-            IntEncoding::Variable => crate::varint::varint_decode_u32(&mut self.reader, C::ENDIAN)?,
-            IntEncoding::Fixed => {
-                let mut bytes = [0u8; 4];
-
-                self.reader.read(bytes.as_mut())?;
-                match C::ENDIAN {
-                    Endian::Little => u32::from_le_bytes(bytes),
-                    Endian::Big => u32::from_be_bytes(bytes),
-                }
-            }
-        })
-    }
-}
-
-impl<'a, T> Decode for &'a mut T
-where
-    T: Decode,
-{
-    fn decode_u32(&mut self) -> Result<u32, DecodeError> {
-        T::decode_u32(self)
-    }
 }

src/enc/encoder.rs

@@ -154,27 +154,20 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder<W, C> {
     }
 
     fn encode_f32(&mut self, val: f32) -> Result<(), EncodeError> {
-        match C::INT_ENCODING {
+        match C::ENDIAN {
-            IntEncoding::Variable => unimplemented!(), // crate::int_encoding::varint_encode_f32(&mut self.writer, C::ENDIAN, val),
+            Endian::Big => self.writer.write(&val.to_be_bytes()),
-            IntEncoding::Fixed => match C::ENDIAN {
+            Endian::Little => self.writer.write(&val.to_le_bytes()),
-                Endian::Big => self.writer.write(&val.to_be_bytes()),
-                Endian::Little => self.writer.write(&val.to_le_bytes()),
-            },
         }
     }
 
     fn encode_f64(&mut self, val: f64) -> Result<(), EncodeError> {
-        match C::INT_ENCODING {
+        match C::ENDIAN {
-            IntEncoding::Variable => unimplemented!(), // crate::int_encoding::varint_encode_f64(&mut self.writer, C::ENDIAN, val),
+            Endian::Big => self.writer.write(&val.to_be_bytes()),
-            IntEncoding::Fixed => match C::ENDIAN {
+            Endian::Little => self.writer.write(&val.to_le_bytes()),
-                Endian::Big => self.writer.write(&val.to_be_bytes()),
-                Endian::Little => self.writer.write(&val.to_le_bytes()),
-            },
         }
     }
 
     fn encode_slice(&mut self, val: &[u8]) -> Result<(), EncodeError> {
-        // TODO: Should this be swapped if we're big or little endian?
         self.writer.write(val)
     }
 }

src/varint/decode_signed.rs

@@ -0,0 +1,43 @@
+#![allow(unused_variables)]
+
+use crate::{config::Endian, de::read::Reader, error::DecodeError};
+
+#[allow(dead_code)]
+pub fn varint_decode_i16<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<i16, DecodeError> {
+    unimplemented!()
+}
+
+#[allow(dead_code)]
+pub fn varint_decode_i32<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<i32, DecodeError> {
+    unimplemented!()
+}
+
+#[allow(dead_code)]
+pub fn varint_decode_i64<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<i64, DecodeError> {
+    unimplemented!()
+}
+
+#[allow(dead_code)]
+pub fn varint_decode_i128<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<i128, DecodeError> {
+    unimplemented!()
+}
+
+#[allow(dead_code)]
+pub fn varint_decode_isize<'a, R: Reader<'a>>(
+    read: &mut R,
+    endian: Endian,
+) -> Result<isize, DecodeError> {
+    unimplemented!()
+}

src/varint/mod.rs

@@ -1,7 +1,12 @@
+mod decode_signed;
 mod decode_unsigned;
 mod encode_signed;
 mod encode_unsigned;
 
+pub use self::decode_signed::{
+    varint_decode_i128, varint_decode_i16, varint_decode_i32, varint_decode_i64,
+    varint_decode_isize,
+};
 pub use self::decode_unsigned::{
     varint_decode_u128, varint_decode_u16, varint_decode_u32, varint_decode_u64,
     varint_decode_usize,