4 files changed, 290 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..f6adbd9
--- /dev/null
+++ b/src/deserialise/d_stream/mod.rs
@@ -0,0 +1,61 @@
+// Copyright 2022-2024 Gabriel Bjørnager Jensen.
+
+use crate::error::{Error, Result};
+
+use std::fmt::{Debug, Formatter};
+
+/// A byte stream for deserialisation.
+///
+/// This type borrows a byte slice (hence [`new`](DStream::new)), keeping track internally of the used bytes.
+#[derive(Clone)]
+pub struct DStream<'a> {
+	data: &'a [u8],
+	len:  usize,
+}
+
+impl<'a> DStream<'a> {
+	/// Constructs a new byte stream.
+	pub fn new<T: AsRef<[u8]> + ?Sized>(buf: &'a T) -> Self { Self {
+		data: buf.as_ref(),
+		len:  buf.as_ref().len(),
+	} }
+
+	/// Takes bytes from the stream.
+	///
+	/// # Errors
+	///
+	/// If the internal buffer doesn't hold at least the requested ammount of bytes, an [`EndOfDStream`](Error::EndOfDStream) error is returned.
+	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::new(value) }
+}
+
+impl<'a, const N: usize> From<&'a [u8; N]> for DStream<'a> {
+	fn from(value: &'a [u8; N]) -> Self { Self::new(value) }
+}
diff --git a/src/deserialise/deserialise/mod.rs b/src/deserialise/deserialise/mod.rs
new file mode 100644
index 0000000..d24b290
--- /dev/null
+++ b/src/deserialise/deserialise/mod.rs
@@ -0,0 +1,162 @@
+// 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;
+
+/// Denotes a type capable of being deserialised.
+pub trait Deserialise: Sized {
+	type Error;
+
+	/// Deserialises the byte stream to an object.
+	fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error>;
+}
+
+macro_rules! impl_float {
+	($type:ty) => {
+		impl Deserialise for $type {
+			type Error = Error;
+
+			fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error> {
+				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 {
+			type Error = Error;
+
+			fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error> {
+				let data = stream
+					.take(size_of::<Self>())?
+					.try_into()
+					.unwrap();
+
+				Ok(Self::from_be_bytes(data))
+			}
+		}
+
+		impl Deserialise for NonZero<$type> {
+			type Error = Error;
+
+			fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error> {
+				let value = <$type>::deserialise(stream)?;
+
+				NonZero::new(value)
+					.ok_or(Error::NullInteger)
+			}
+		}
+	};
+}
+
+impl<T: Deserialise<Error: StdError + 'static>, const N: usize> Deserialise for [T; N] {
+	type Error = Box<dyn StdError>;
+
+	fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error> {
+		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 () {
+	type Error = Error;
+
+	fn deserialise(_stream: &mut DStream) -> Result<Self, Self::Error> { Ok(()) }
+}
+
+impl Deserialise for bool {
+	type Error = Error;
+
+	fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error> {
+		let value = u8::deserialise(stream)?;
+
+		match value {
+			0x00 => Ok(false),
+			0x01 => Ok(true),
+			_    => Err(Error::InvalidBoolean { value })
+		}
+	}
+}
+
+impl Deserialise for char {
+	type Error = Error;
+
+	fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error> {
+		let value = u32::deserialise(stream)?;
+
+		Self::from_u32(value)
+			.ok_or(Error::InvalidCodePoint { value })
+	}
+}
+
+impl Deserialise for Infallible {
+	type Error = Error;
+
+	fn deserialise(_stream: &mut DStream) -> Result<Self, Self::Error> { unreachable!() }
+}
+
+impl<T: Deserialise<Error: StdError + 'static>> Deserialise for Option<T> {
+	type Error = Box<dyn StdError>;
+
+	fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error> {
+		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>
+where
+	<T as Deserialise>::Error: StdError + 'static,
+	<E as Deserialise>::Error: StdError + 'static, {
+	type Error = Box<dyn StdError>;
+
+	fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error> {
+		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..7941a98
--- /dev/null
+++ b/src/deserialise/mod.rs
@@ -0,0 +1,10 @@
+// Copyright 2022-2024 Gabriel Bjørnager Jensen.
+
+//! Deserialisation utilities.
+
+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..1844e3a
--- /dev/null
+++ b/src/deserialise/test.rs
@@ -0,0 +1,57 @@
+// Copyright 2022-2024 Gabriel Bjørnager Jensen.
+
+use crate::deserialise::{Deserialise, DStream};
+
+#[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, 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!(
+		<[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),
+	);
+}