From 78cb27f782d5a6711e7be26979a55346a60c5160 Mon Sep 17 00:00:00 2001 From: Victor Koenders Date: Wed, 22 Sep 2021 09:54:09 +0200 Subject: [PATCH] Added decode_ fns --- src/de/decoder.rs | 210 ++++++++++++++++++++++++++++++++++++ src/de/impls.rs | 135 +++++++++++++++++++++++ src/de/mod.rs | 64 ++++------- src/enc/encoder.rs | 19 ++-- src/varint/decode_signed.rs | 43 ++++++++ src/varint/mod.rs | 5 + 6 files changed, 418 insertions(+), 58 deletions(-) create mode 100644 src/de/decoder.rs create mode 100644 src/varint/decode_signed.rs diff --git a/src/de/decoder.rs b/src/de/decoder.rs new file mode 100644 index 0000000..f94592c --- /dev/null +++ b/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 { + reader: R, + config: PhantomData, +} + +impl<'de, R: Reader<'de>, C: Config> Decoder { + pub fn new(reader: R) -> Decoder { + 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 { + fn decode_u8(&mut self) -> Result { + let mut bytes = [0u8; 1]; + self.reader.read(&mut bytes)?; + Ok(bytes[0]) + } + + fn decode_u16(&mut self) -> Result { + 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 { + 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 { + 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 { + 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 { + 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 { + let mut bytes = [0u8; 1]; + self.reader.read(&mut bytes)?; + Ok(bytes[0] as i8) + } + + fn decode_i16(&mut self) -> Result { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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(&mut self) -> Result<[u8; N], DecodeError> { + let mut array = [0u8; N]; + self.reader.read(&mut array)?; + Ok(array) + } +} diff --git a/src/de/impls.rs b/src/de/impls.rs index da515f3..4360cfd 100644 --- a/src/de/impls.rs +++ b/src/de/impls.rs @@ -1,8 +1,143 @@ use super::{Decodable, Decode}; use crate::error::DecodeError; +impl Decodable for u8 { + fn decode(mut decoder: D) -> Result { + decoder.decode_u8() + } +} + +impl Decodable for u16 { + fn decode(mut decoder: D) -> Result { + decoder.decode_u16() + } +} + impl Decodable for u32 { fn decode(mut decoder: D) -> Result { decoder.decode_u32() } } + +impl Decodable for u64 { + fn decode(mut decoder: D) -> Result { + decoder.decode_u64() + } +} + +impl Decodable for u128 { + fn decode(mut decoder: D) -> Result { + decoder.decode_u128() + } +} + +impl Decodable for usize { + fn decode(mut decoder: D) -> Result { + decoder.decode_usize() + } +} + +impl Decodable for i8 { + fn decode(mut decoder: D) -> Result { + decoder.decode_i8() + } +} + +impl Decodable for i16 { + fn decode(mut decoder: D) -> Result { + decoder.decode_i16() + } +} + +impl Decodable for i32 { + fn decode(mut decoder: D) -> Result { + decoder.decode_i32() + } +} + +impl Decodable for i64 { + fn decode(mut decoder: D) -> Result { + decoder.decode_i64() + } +} + +impl Decodable for i128 { + fn decode(mut decoder: D) -> Result { + decoder.decode_i128() + } +} + +impl Decodable for isize { + fn decode(mut decoder: D) -> Result { + decoder.decode_isize() + } +} + +impl<'a, T> Decode for &'a mut T +where + T: Decode, +{ + fn decode_u8(&mut self) -> Result { + T::decode_u8(self) + } + + fn decode_u16(&mut self) -> Result { + T::decode_u16(self) + } + + fn decode_u32(&mut self) -> Result { + T::decode_u32(self) + } + + fn decode_u64(&mut self) -> Result { + T::decode_u64(self) + } + + fn decode_u128(&mut self) -> Result { + T::decode_u128(self) + } + + fn decode_usize(&mut self) -> Result { + T::decode_usize(self) + } + + fn decode_i8(&mut self) -> Result { + T::decode_i8(self) + } + + fn decode_i16(&mut self) -> Result { + T::decode_i16(self) + } + + fn decode_i32(&mut self) -> Result { + T::decode_i32(self) + } + + fn decode_i64(&mut self) -> Result { + T::decode_i64(self) + } + + fn decode_i128(&mut self) -> Result { + T::decode_i128(self) + } + + fn decode_isize(&mut self) -> Result { + T::decode_isize(self) + } + + fn decode_f32(&mut self) -> Result { + T::decode_f32(self) + } + + fn decode_f64(&mut self) -> Result { + T::decode_f64(self) + } + + fn decode_slice(&mut self, slice: &mut [u8]) -> Result<(), DecodeError> { + T::decode_slice(self, slice) + } + + fn decode_array(&mut self) -> Result<[u8; N], DecodeError> { + T::decode_array::(self) + } +} diff --git a/src/de/mod.rs b/src/de/mod.rs index 8ee5567..dca66a2 100644 --- a/src/de/mod.rs +++ b/src/de/mod.rs @@ -1,58 +1,32 @@ -use core::marker::PhantomData; - -use crate::{ - config::{Config, Endian, IntEncoding}, - error::DecodeError, -}; -use read::Reader; +use crate::error::DecodeError; +mod decoder; mod impls; + pub mod read; +pub use self::decoder::Decoder; pub trait Decodable: Sized { fn decode(decoder: D) -> Result; } pub trait Decode { + fn decode_u8(&mut self) -> Result; + fn decode_u16(&mut self) -> Result; fn decode_u32(&mut self) -> Result; -} + fn decode_u64(&mut self) -> Result; + fn decode_u128(&mut self) -> Result; + fn decode_usize(&mut self) -> Result; -pub struct Decoder { - reader: R, - config: PhantomData, -} + fn decode_i8(&mut self) -> Result; + fn decode_i16(&mut self) -> Result; + fn decode_i32(&mut self) -> Result; + fn decode_i64(&mut self) -> Result; + fn decode_i128(&mut self) -> Result; + fn decode_isize(&mut self) -> Result; -impl<'de, R: Reader<'de>, C: Config> Decoder { - pub fn new(reader: R) -> Decoder { - Decoder { - reader, - config: PhantomData, - } - } -} - -impl<'a, 'de, R: Reader<'de>, C: Config> Decode for &'a mut Decoder { - fn decode_u32(&mut self) -> Result { - 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 { - T::decode_u32(self) - } + fn decode_f32(&mut self) -> Result; + fn decode_f64(&mut self) -> Result; + fn decode_slice(&mut self, slice: &mut [u8]) -> Result<(), DecodeError>; + fn decode_array(&mut self) -> Result<[u8; N], DecodeError>; } diff --git a/src/enc/encoder.rs b/src/enc/encoder.rs index 524c58f..c01ba62 100644 --- a/src/enc/encoder.rs +++ b/src/enc/encoder.rs @@ -154,27 +154,20 @@ impl<'a, W: Writer, C: Config> Encode for &'a mut Encoder { } fn encode_f32(&mut self, val: f32) -> Result<(), EncodeError> { - match C::INT_ENCODING { - IntEncoding::Variable => unimplemented!(), // crate::int_encoding::varint_encode_f32(&mut self.writer, C::ENDIAN, val), - IntEncoding::Fixed => match C::ENDIAN { - Endian::Big => self.writer.write(&val.to_be_bytes()), - Endian::Little => self.writer.write(&val.to_le_bytes()), - }, + match C::ENDIAN { + 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 { - IntEncoding::Variable => unimplemented!(), // crate::int_encoding::varint_encode_f64(&mut self.writer, C::ENDIAN, val), - IntEncoding::Fixed => match C::ENDIAN { - Endian::Big => self.writer.write(&val.to_be_bytes()), - Endian::Little => self.writer.write(&val.to_le_bytes()), - }, + match C::ENDIAN { + 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) } } diff --git a/src/varint/decode_signed.rs b/src/varint/decode_signed.rs new file mode 100644 index 0000000..cc14951 --- /dev/null +++ b/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 { + unimplemented!() +} + +#[allow(dead_code)] +pub fn varint_decode_i32<'a, R: Reader<'a>>( + read: &mut R, + endian: Endian, +) -> Result { + unimplemented!() +} + +#[allow(dead_code)] +pub fn varint_decode_i64<'a, R: Reader<'a>>( + read: &mut R, + endian: Endian, +) -> Result { + unimplemented!() +} + +#[allow(dead_code)] +pub fn varint_decode_i128<'a, R: Reader<'a>>( + read: &mut R, + endian: Endian, +) -> Result { + unimplemented!() +} + +#[allow(dead_code)] +pub fn varint_decode_isize<'a, R: Reader<'a>>( + read: &mut R, + endian: Endian, +) -> Result { + unimplemented!() +} diff --git a/src/varint/mod.rs b/src/varint/mod.rs index 54d19e5..a104586 100644 --- a/src/varint/mod.rs +++ b/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,