summaryrefslogtreecommitdiff
path: root/src/deserialise
diff options
context:
space:
mode:
Diffstat (limited to 'src/deserialise')
-rw-r--r--src/deserialise/d_stream/mod.rs53
-rw-r--r--src/deserialise/deserialise/mod.rs133
-rw-r--r--src/deserialise/mod.rs8
-rw-r--r--src/deserialise/test.rs65
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),
+ );
+}