diff options
Diffstat (limited to 'src/deserialise')
-rw-r--r-- | src/deserialise/d_stream/mod.rs | 53 | ||||
-rw-r--r-- | src/deserialise/deserialise/mod.rs | 133 | ||||
-rw-r--r-- | src/deserialise/mod.rs | 8 | ||||
-rw-r--r-- | src/deserialise/test.rs | 65 |
4 files changed, 259 insertions, 0 deletions
diff --git a/src/deserialise/d_stream/mod.rs b/src/deserialise/d_stream/mod.rs new file mode 100644 index 0000000..05ed6a2 --- /dev/null +++ b/src/deserialise/d_stream/mod.rs @@ -0,0 +1,53 @@ +// Copyright 2022-2024 Gabriel Bjørnager Jensen. + +use crate::error::{Error, Result}; + +use std::fmt::{Debug, Formatter}; + +#[derive(Clone)] +pub struct DStream<'a> { + data: &'a [u8], + len: usize, +} + +impl DStream<'_> { + pub fn take(&mut self, len: usize) -> Result<&[u8]> { + if self.len < len { return Err(Error::EndOfDStream { len: self.len, ok_len: len } ) } + + let start = self.data.len() - self.len; + let stop = start + len; + + self.len -= len; + + Ok(&self.data[start..stop]) + } +} + +impl Debug for DStream<'_> { + fn fmt(&self, f: &mut Formatter) -> std::fmt::Result { + let stop = self.data.len(); + let start = self.data.len() - self.len; + + write!(f, "[")?; + + for v in &self.data[start..stop] { write!(f, "{v:#02X},")? }; + + write!(f, "]")?; + + Ok(()) + } +} + +impl<'a> From<&'a [u8]> for DStream<'a> { + fn from(value: &'a [u8]) -> Self { Self { + data: value, + len: value.len(), + } } +} + +impl<'a, const N: usize> From<&'a [u8; N]> for DStream<'a> { + fn from(value: &'a [u8; N]) -> Self { Self { + data: value, + len: N, + } } +} diff --git a/src/deserialise/deserialise/mod.rs b/src/deserialise/deserialise/mod.rs new file mode 100644 index 0000000..a51ec18 --- /dev/null +++ b/src/deserialise/deserialise/mod.rs @@ -0,0 +1,133 @@ +// Copyright 2022-2024 Gabriel Bjørnager Jensen. + +use crate::deserialise::DStream; +use crate::error::Error; + +use std::convert::Infallible; +use std::error::Error as StdError; +use std::mem::size_of; +use std::num::NonZero; + +pub trait Deserialise: Sized { + fn deserialise(stream: &mut DStream) -> Result<Self, Box<dyn StdError>>; +} + +macro_rules! impl_float { + ($type:ty) => { + impl Deserialise for $type { + fn deserialise(stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { + let data = stream + .take(size_of::<Self>())? + .try_into() + .unwrap(); + + Ok(Self::from_be_bytes(data)) + } + } + }; +} + +macro_rules! impl_int { + ($type:ty) => { + impl Deserialise for $type { + fn deserialise(stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { + let data = stream + .take(size_of::<Self>())? + .try_into() + .unwrap(); + + Ok(Self::from_be_bytes(data)) + } + } + + impl Deserialise for NonZero<$type> { + fn deserialise(stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { + Ok(Option::<Self>::deserialise(stream)? + .ok_or(Error::NullInteger)?) + } + } + }; +} + +impl<T: Deserialise, const N: usize> Deserialise for [T; N] { + fn deserialise(stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { + let len = usize::try_from(u64::deserialise(stream)?).unwrap(); + if len != N { return Err(Box::new(Error::ArrayLengthMismatch { len, ok_len: N })) }; + + let mut buf = Vec::with_capacity(len); + for _ in 0x0..len { buf.push(Deserialise::deserialise(stream)?); } + + // If we had used the checked unwrap, we would also + // have to require `T: Debug`. + Ok(unsafe { buf.try_into().unwrap_unchecked() }) + } +} + +impl Deserialise for () { + fn deserialise(_stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { Ok(()) } +} + +impl Deserialise for bool { + fn deserialise(stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { + let value = u8::deserialise(stream)?; + + match value { + 0x00 => Ok(false), + 0x01 => Ok(true), + _ => Err(Box::new(Error::InvalidBoolean { value })) + } + } +} + +impl Deserialise for char { + fn deserialise(stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { + let value = u32::deserialise(stream)?; + + Self::from_u32(value) + .ok_or(Box::new(Error::InvalidCodePoint { value })) + } +} + +impl Deserialise for Infallible { + fn deserialise(_stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { unreachable!() } +} + +impl<T: Deserialise> Deserialise for Option<T> { + fn deserialise(stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { + let sign = bool::deserialise(stream)?; + + if sign { + Ok(Some(T::deserialise(stream)?)) + } else { + Ok(None) + } + } +} + +impl<T: Deserialise, E: Deserialise> Deserialise for Result<T, E> { + fn deserialise(stream: &mut DStream) -> Result<Self, Box<dyn StdError>> { + let sign = bool::deserialise(stream)?; + + let value = if sign { + Err(E::deserialise(stream)?) + } else { + Ok(T::deserialise(stream)?) + }; + + Ok(value) + } +} + +impl_float!(f32); +impl_float!(f64); + +impl_int!(i128); +impl_int!(i16); +impl_int!(i32); +impl_int!(i64); +impl_int!(i8); +impl_int!(u128); +impl_int!(u16); +impl_int!(u32); +impl_int!(u64); +impl_int!(u8); diff --git a/src/deserialise/mod.rs b/src/deserialise/mod.rs new file mode 100644 index 0000000..17b102c --- /dev/null +++ b/src/deserialise/mod.rs @@ -0,0 +1,8 @@ +// Copyright 2022-2024 Gabriel Bjørnager Jensen. + +use crate::use_mod; +use_mod!(pub d_stream); +use_mod!(pub deserialise); + +#[cfg(test)] +mod test; diff --git a/src/deserialise/test.rs b/src/deserialise/test.rs new file mode 100644 index 0000000..38ad694 --- /dev/null +++ b/src/deserialise/test.rs @@ -0,0 +1,65 @@ +// Copyright 2022-2024 Gabriel Bjørnager Jensen. + +use crate::deserialise::{Deserialise, DStream}; +use crate::fixed_string::FixedString; + +#[test] +fn test_serialise() { + let data = [ + 0x00, 0xFF, 0xFF, 0x0F, 0xEF, 0x1F, 0xDF, 0x2F, + 0xCF, 0x3F, 0xBF, 0x4F, 0xAF, 0x5F, 0x9F, 0x6F, + 0x8F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x09, 0x6D, 0xC3, 0xA1, 0x6E, 0x61, 0xC3, + 0xB0, 0x75, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x05, 0x00, 0x00, 0x03, 0xBB, 0x00, + 0x00, 0x03, 0x91, 0x00, 0x00, 0x03, 0xBC, 0x00, + 0x00, 0x03, 0x94, 0x00, 0x00, 0x03, 0xB1, 0x01, + 0x00, 0x00, 0x01, 0x80, + ]; + + let mut stream = DStream::from(&data); + + assert_eq!( + u8::deserialise(&mut stream).unwrap(), + 0x00, + ); + assert_eq!( + u8::deserialise(&mut stream).unwrap(), + 0xFF, + ); + + assert_eq!( + u128::deserialise(&mut stream).unwrap(), + 0xFF_0F_EF_1F_DF_2F_CF_3F_BF_4F_AF_5F_9F_6F_8F_7F, + ); + + assert_eq!( + FixedString::<0x10>::deserialise(&mut stream).unwrap(), + "m\u{00E1}na\u{00F0}ur", + ); + + assert_eq!( + <[char; 0x5]>::deserialise(&mut stream).unwrap(), + ['\u{03BB}', '\u{0391}', '\u{03BC}', '\u{0394}', '\u{03B1}'], + ); + + assert_eq!( + Option::<()>::deserialise(&mut stream).unwrap(), + Some(()), + ); + + assert_eq!( + Option::<()>::deserialise(&mut stream).unwrap(), + None, + ); + + assert_eq!( + Result::<(), i8>::deserialise(&mut stream).unwrap(), + Ok(()), + ); + + assert_eq!( + Result::<(), i8>::deserialise(&mut stream).unwrap(), + Err(i8::MIN), + ); +} |