4 files changed, 225 insertions, 0 deletions
diff --git a/src/serialise/mod.rs b/src/serialise/mod.rs
new file mode 100644
index 0000000..7dd17e3
--- /dev/null
+++ b/src/serialise/mod.rs
@@ -0,0 +1,10 @@
+// Copyright 2022-2024 Gabriel Bjørnager Jensen.
+
+//! Serialisation utilities.
+
+use crate::use_mod;
+use_mod!(pub s_stream);
+use_mod!(pub serialise);
+
+#[cfg(test)]
+mod test;
diff --git a/src/serialise/s_stream/mod.rs b/src/serialise/s_stream/mod.rs
new file mode 100644
index 0000000..a1ae05c
--- /dev/null
+++ b/src/serialise/s_stream/mod.rs
@@ -0,0 +1,54 @@
+// Copyright 2022-2024 Gabriel Bjørnager Jensen.
+
+use crate::serialise::Serialise;
+
+use std::fmt::{Debug, Formatter};
+use std::mem::size_of;
+
+#[derive(Clone, Eq, PartialEq)]
+pub struct SStream(Vec<u8>);
+
+impl SStream {
+	#[must_use]
+	pub const fn new() -> Self { Self(Vec::new()) }
+
+	pub fn append(&mut self, extra: &[u8]) {
+		self.0.extend(extra);
+	}
+}
+
+impl AsRef<[u8]> for SStream {
+	#[inline(always)]
+	fn as_ref(&self) -> &[u8] { self.0.as_ref() }
+}
+
+impl Debug for SStream {
+	fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+		write!(f, "[")?;
+
+		for v in &self.0 { write!(f, "{v:#02X},")? };
+
+		write!(f, "]")?;
+
+		Ok(())
+	}
+}
+
+impl Default for SStream {
+	#[inline(always)]
+	fn default() -> Self { Self::new() }
+}
+
+impl<T: Serialise> From<&T> for SStream {
+	fn from(value: &T) -> Self {
+		let mut stream = Self(Vec::with_capacity(size_of::<T>()));
+		value.serialise(&mut stream);
+
+		stream
+	}
+}
+
+impl From<SStream> for Box<[u8]> {
+	#[inline(always)]
+	fn from(value: SStream) -> Self { value.0.into_boxed_slice() }
+}
diff --git a/src/serialise/serialise/mod.rs b/src/serialise/serialise/mod.rs
new file mode 100644
index 0000000..be637cd
--- /dev/null
+++ b/src/serialise/serialise/mod.rs
@@ -0,0 +1,116 @@
+// Copyright 2022-2024 Gabriel Bjørnager Jensen.
+
+use crate::serialise::SStream;
+
+use std::convert::Infallible;
+use std::mem::size_of;
+use std::num::NonZero;
+
+/// Denotes a type capable of being serialised.
+pub trait Serialise: Sized {
+	/// Serialises `self` into a byte stream.
+	///
+	/// One may assume that the resulting stream has at most the same ammount of bytes as before serialisation.
+	/// Therefore, not observing this rule is a logic error.
+	fn serialise(&self, stream: &mut SStream);
+}
+
+macro_rules! impl_float {
+	($type:ty) => {
+		impl Serialise for $type {
+			fn serialise(&self, stream: &mut SStream) {
+				stream.append(&self.to_be_bytes())
+			}
+		}
+	};
+}
+
+macro_rules! impl_int {
+	($type:ty) => {
+		impl Serialise for $type {
+			fn serialise(&self, stream: &mut SStream) {
+				stream.append(&self.to_be_bytes())
+			}
+		}
+
+		impl Serialise for NonZero<$type> {
+			fn serialise(&self, stream: &mut SStream) {
+				self.get().serialise(stream)
+			}
+		}
+	};
+}
+
+impl<T: Serialise, const N: usize> Serialise for [T; N] {
+	fn serialise(&self, stream: &mut SStream) {
+		u64::try_from(self.len()).unwrap().serialise(stream);
+
+		for v in self { v.serialise(stream) }
+	}
+}
+
+impl Serialise for () {
+	fn serialise(&self, _stream: &mut SStream) { }
+}
+
+impl Serialise for bool {
+	fn serialise(&self, stream: &mut SStream) {
+		u8::from(*self).serialise(stream)
+	}
+}
+
+impl Serialise for char {
+	fn serialise(&self, stream: &mut SStream) {
+		u32::from(*self).serialise(stream)
+	}
+}
+
+impl Serialise for Infallible {
+	fn serialise(&self, _stream: &mut SStream) { unreachable!() }
+}
+
+impl<T: Serialise> Serialise for Option<T> {
+	fn serialise(&self, stream: &mut SStream) {
+		match *self {
+			None => {
+				stream.append(&[0x00]);
+				stream.append(&vec![0x00; size_of::<T>()]);
+			},
+
+			Some(ref v) => {
+				stream.append(&[0x01]);
+				v.serialise(stream);
+			},
+		};
+	}
+}
+
+impl<T: Serialise, E: Serialise> Serialise for Result<T, E> {
+	fn serialise(&self, stream: &mut SStream) {
+		match *self {
+			Ok(ref v) => {
+				stream.append(&[0x00]);
+				v.serialise(stream);
+			},
+
+			Err(ref e) => {
+				stream.append(&[0x01]);
+				e.serialise(stream);
+			},
+		};
+	}
+}
+
+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/serialise/test.rs b/src/serialise/test.rs
new file mode 100644
index 0000000..7ab2393
--- /dev/null
+++ b/src/serialise/test.rs
@@ -0,0 +1,45 @@
+// Copyright 2022-2024 Gabriel Bjørnager Jensen.
+
+use crate::serialise::{SStream, Serialise};
+
+#[test]
+fn test_serialise() {
+	let mut stream = SStream::new();
+
+	0x00_u8.serialise(&mut stream);
+	0xFF_u8.serialise(&mut stream);
+	0x7F_u8.serialise(&mut stream);
+
+	0x0F_7E_u16.serialise(&mut stream);
+
+	0x00_2F_87_E7_u32.serialise(&mut stream);
+
+	0xF3_37_CF_8B_DB_03_2B_39_u64.serialise(&mut stream);
+
+	0x45_A0_15_6A_36_77_17_8A_83_2E_3C_2C_84_10_58_1A_u128.serialise(&mut stream);
+
+	['\u{03B4}', '\u{0190}', '\u{03BB}', '\u{03A4}', '\u{03B1}'].serialise(&mut stream);
+
+	Result::<u16, char>::Ok(0x45_45).serialise(&mut stream);
+	Result::<u16, char>::Err(char::REPLACEMENT_CHARACTER).serialise(&mut stream);
+
+	Option::<()>::None.serialise(&mut stream);
+	Option::<()>::Some(()).serialise(&mut stream);
+
+	let data: Box<[u8]> = stream.into();
+
+	assert_eq!(
+		data.as_ref(),
+		[
+			0x00, 0xFF, 0x7F, 0x0F, 0x7E, 0x00, 0x2F, 0x87,
+			0xE7, 0xF3, 0x37, 0xCF, 0x8B, 0xDB, 0x03, 0x2B,
+			0x39, 0x45, 0xA0, 0x15, 0x6A, 0x36, 0x77, 0x17,
+			0x8A, 0x83, 0x2E, 0x3C, 0x2C, 0x84, 0x10, 0x58,
+			0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x05, 0x00, 0x00, 0x03, 0xB4, 0x00, 0x00, 0x01,
+			0x90, 0x00, 0x00, 0x03, 0xBB, 0x00, 0x00, 0x03,
+			0xA4, 0x00, 0x00, 0x03, 0xB1, 0x00, 0x45, 0x45,
+			0x01, 0x00, 0x00, 0xFF, 0xFD, 0x00, 0x01,
+		]
+	);
+}