14 files changed, 656 insertions, 375 deletions
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7c463ec..1520343 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,13 @@
+# 0.1.0
+
+* Bump minor
+* Export all in crate root
+* Add fixed string type
+* Add new errors
+* Update documentation
+* Add `as_d_stream` method to `SStream`
+* Add `to_s_stream` and `as_slice` methods to `DStream`
+
 # 0.0.2
 
 * Add license files
diff --git a/Cargo.toml b/Cargo.toml
index 5fbdb91..e816a33 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bzipper"
-version = "0.0.2"
+version = "0.1.0"
 authors = ["Gabriel Bjørnager Jensen"]
 edition = "2021"
 description = "Binary (de)serialiser."
diff --git a/src/deserialise/d_stream/mod.rs b/src/d_stream/mod.rs
index 900aee3..088d751 100644
--- a/src/deserialise/d_stream/mod.rs
+++ b/src/d_stream/mod.rs
@@ -19,11 +19,11 @@
 // er General Public License along with bzipper. If
 // not, see <https://www.gnu.org/licenses/>.
 
-use crate::error::{Error, Result};
+use crate::{Error, Result, SStream};
 
 use std::fmt::{Debug, Formatter};
 
-/// A byte stream for deserialisation.
+/// Byte stream for deserialisation.
 ///
 /// This type borrows a byte slice (hence [`new`](DStream::new)), keeping track internally of the used bytes.
 #[derive(Clone)]
@@ -34,6 +34,8 @@ pub struct DStream<'a> {
 
 impl<'a> DStream<'a> {
 /// Constructs a new byte stream.
+ #[inline(always)]
+ #[must_use]
 pub fn new<T: AsRef<[u8]> + ?Sized>(buf: &'a T) -> Self { Self {
 data: buf.as_ref(),
 len: buf.as_ref().len(),
@@ -54,16 +56,31 @@ impl<'a> DStream<'a> {
 
 Ok(&self.data[start..stop])
 }
+
+ /// Takes a slice of the remaining data.
+ #[must_use]
+ pub fn as_slice(&self) -> &[u8] {
+ let stop = self.data.len();
+ let start = stop - self.len;
+
+ &self.data[start..stop]
+ }
+
+ /// Converts the stream to a `SStream` object.
+ ///
+ /// The returned object owns a copy of the remaining data.
+ #[inline(always)]
+ #[must_use]
+ pub fn to_s_stream(&self) -> SStream {
+ SStream(self.as_slice().to_vec())
+ }
 }
 
 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},")? };
+ for v in self.as_slice() { write!(f, "{v:#02X},")? };
 
 write!(f, "]")?;
 
diff --git a/src/deserialise/deserialise/mod.rs b/src/deserialise/deserialise/mod.rs
deleted file mode 100644
index e345b12..0000000
--- a/src/deserialise/deserialise/mod.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-// Copyright 2024 Gabriel Bjørnager Jensen.
-//
-// This file is part of bzipper.
-//
-// bzipper is free software: you can redistribute
-// it and/or modify it under the terms of the GNU
-// Lesser General Public License as published by
-// the Free Software Foundation, either version 3
-// of the License, or (at your option) any later
-// version.
-//
-// bzipper is distributed in the hope that it will
-// be useful, but WITHOUT ANY WARRANTY; without
-// even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Less-
-// er General Public License along with bzipper. If
-// not, see <https://www.gnu.org/licenses/>.
-
-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
index cd0889a..2678670 100644
--- a/src/deserialise/mod.rs
+++ b/src/deserialise/mod.rs
@@ -19,11 +19,169 @@
 // er General Public License along with bzipper. If
 // not, see <https://www.gnu.org/licenses/>.
 
-//! Deserialisation utilities.
-
-use crate::use_mod;
-use_mod!(pub d_stream);
-use_mod!(pub deserialise);
-
 #[cfg(test)]
 mod test;
+
+use crate::{DStream, 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.
+ ///
+ /// # Errors
+ ///
+ /// If deserialisation failed, e.g. by an invalid value being found, an error is returned.
+ 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/test.rs b/src/deserialise/test.rs
index fb95cc6..394ed64 100644
--- a/src/deserialise/test.rs
+++ b/src/deserialise/test.rs
@@ -19,18 +19,20 @@
 // er General Public License along with bzipper. If
 // not, see <https://www.gnu.org/licenses/>.
 
-use crate::deserialise::{Deserialise, DStream};
+use crate::{Deserialise, DStream, FixedString};
 
 #[test]
-fn test_serialise() {
+fn test_deserialise() {
 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,
+ 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);
@@ -50,6 +52,11 @@ fn test_serialise() {
 );
 
 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}'],
 );
diff --git a/src/error/mod.rs b/src/error/mod.rs
index 964d83e..6eb6c15 100644
--- a/src/error/mod.rs
+++ b/src/error/mod.rs
@@ -23,6 +23,7 @@
 
 use std::error::Error as StdError;
 use std::fmt::{Display, Formatter};
+use std::str::Utf8Error;
 
 /// Mapping of [`std::result::Result`].
 pub type Result<T> = std::result::Result<T, Error>;
@@ -37,10 +38,14 @@ pub enum Error {
 
 EndOfDStream { len: usize, ok_len: usize },
 
+ FixedStringTooShort { len: usize, s: String },
+
 InvalidBoolean { value: u8 },
 
 InvalidCodePoint { value: u32 },
 
+ InvalidUtf8 { source: Utf8Error },
+
 NullInteger,
 }
 
@@ -57,13 +62,21 @@ impl Display for Error {
 write!(f, "({ok_len}) byte(s) were requested but only ({len}) byte(s) were left")
 },
 
+ FixedStringTooShort { len, ref s } => {
+ write!(f, "fixed string with `N = {len}` cannot hold {s:?}")
+ },
+
 InvalidBoolean { value } => {
 write!(f, "expected boolean but got {value:#02X}")
 },
 
 InvalidCodePoint { value } => {
 write!(f, "code point U+{value:04X} is not valid")
- }
+ },
+
+ InvalidUtf8 { ref source } =>{
+ write!(f, "unable to parse utf8: \"{source}\"")
+ },
 
 NullInteger => {
 write!(f, "expected non-zero integer but got (0)")
@@ -72,4 +85,14 @@ impl Display for Error {
 }
 }
 
-impl StdError for Error { }
+impl StdError for Error {
+ fn source(&self) -> Option<&(dyn StdError + 'static)> {
+ use Error::*;
+
+ match *self {
+ InvalidUtf8 { ref source } => Some(source),
+
+ _ => None,
+ }
+ }
+}
diff --git a/src/fixed_string/mod.rs b/src/fixed_string/mod.rs
new file mode 100644
index 0000000..ca369ce
--- /dev/null
+++ b/src/fixed_string/mod.rs
@@ -0,0 +1,223 @@
+// Copyright 2024 Gabriel Bjørnager Jensen.
+//
+// This file is part of bzipper.
+//
+// bzipper is free software: you can redistribute
+// it and/or modify it under the terms of the GNU
+// Lesser General Public License as published by
+// the Free Software Foundation, either version 3
+// of the License, or (at your option) any later
+// version.
+//
+// bzipper is distributed in the hope that it will
+// be useful, but WITHOUT ANY WARRANTY; without
+// even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Less-
+// er General Public License along with bzipper. If
+// not, see <https://www.gnu.org/licenses/>.
+
+use crate::{
+ Deserialise,
+ DStream,
+ Error,
+ FixedStringIter,
+ Serialise,
+ SStream,
+};
+
+use std::fmt::{Display, Debug, Formatter};
+use std::str::FromStr;
+
+/// Owned string with maximum size.
+///
+/// This is in contrast to [String], which has no size limit is practice, and [str], which is unsized.
+#[derive(Clone)]
+pub struct FixedString<const N: usize> {
+ buf: [char; N],
+ len: usize,
+}
+
+impl<const N: usize> FixedString<N> {
+ /// Constructs a new fixed string.
+ ///
+ /// The contents of the provided string are copied into the internal buffer.
+ /// All residual characters are instanced as U+0000 `NULL`.
+ ///
+ /// # Errors
+ ///
+ /// If the given string `s` cannot fit into `N` characters, a [`FixedStringTooShort`](Error::FixedStringTooShort) error is returned.
+ pub fn new(s: &str) -> Result<Self, Error> {
+ let mut buf = ['\0'; N];
+ let len = s.chars().count();
+
+ for (i, c) in s.chars().enumerate() {
+ if i >= N { return Err(Error::FixedStringTooShort { len: N, s: s.to_owned() }) }
+
+ buf[i] = c;
+ }
+
+ Ok(Self { buf, len })
+ }
+
+ /// Returns the length of the string.
+ ///
+ /// This does not necessarily equal the value of `N`, as the internal buffer is not required to be used fully.
+ #[inline(always)]
+ #[must_use]
+ pub const fn len(&self) -> usize { self.len }
+
+ /// Checks if the string is empty, i.e. `self.len() == 0x0`.
+ #[inline(always)]
+ #[must_use]
+ pub const fn is_empty(&self) -> bool { self.len == 0x0 }
+
+ /// Returns an iterator to the contained characters.
+ #[inline(always)]
+ pub fn iter(&self) -> std::slice::Iter<'_, char> { self.buf[0x0..self.len].iter() }
+
+ /// Returns a mutable iterator to the contained characters.
+ #[inline(always)]
+ pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, char> { self.buf[0x0..self.len].iter_mut() }
+}
+
+impl<const N: usize> Debug for FixedString<N> {
+ fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+ write!(f, "\"")?;
+
+ for c in self {
+ if c.is_ascii_graphic() {
+ write!(f, "{c}")?;
+ } else if *c == '\0' {
+ write!(f, "\\0")?;
+ } else {
+ write!(f, "{c}")?;
+ }
+ }
+
+ write!(f, "\"")?;
+
+ Ok(())
+ }
+}
+
+impl<const N: usize> Deserialise for FixedString<N> {
+ type Error = Error;
+
+ fn deserialise(stream: &mut DStream) -> Result<Self, Self::Error> {
+ let len = usize::try_from(u64::deserialise(stream)?).unwrap();
+
+ let data = stream.take(len)?;
+ let s = std::str::from_utf8(data)
+ .map_err(|e| Error::InvalidUtf8 { source: e })?;
+
+ let len = s.chars().count();
+ if len > N {
+ return Err(Error::FixedStringTooShort { len, s: s.to_owned() });
+ }
+
+ let mut buf = ['\0'; N];
+ for (i, c) in s.chars().enumerate() {
+ buf[i] = c;
+ }
+
+ Ok(Self { buf, len })
+ }
+}
+
+impl<const N: usize> Default for FixedString<N> {
+ #[inline(always)]
+ fn default() -> Self { Self {
+ buf: ['\0'; N],
+ len: 0x0,
+ } }
+}
+
+impl<const N: usize> Display for FixedString<N> {
+ fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+ for c in self { write!(f, "{c}")? }
+
+ Ok(())
+ }
+}
+
+impl<const N: usize> Eq for FixedString<N> { }
+
+impl<const N: usize> FromStr for FixedString<N> {
+ type Err = Error;
+
+ fn from_str(s: &str) -> Result<Self, Error> { Self::new(s) }
+}
+
+impl<const N: usize> IntoIterator for FixedString<N> {
+ type Item = char;
+
+ type IntoIter = FixedStringIter<N>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ FixedStringIter {
+ buf: self.buf,
+ len: self.len,
+
+ pos: Some(0x0),
+ }
+ }
+}
+
+impl<'a, const N: usize> IntoIterator for &'a FixedString<N> {
+ type Item = &'a char;
+
+ type IntoIter = std::slice::Iter<'a, char>;
+
+ fn into_iter(self) -> Self::IntoIter { self.iter() }
+}
+
+impl<'a, const N: usize> IntoIterator for &'a mut FixedString<N> {
+ type Item = &'a mut char;
+
+ type IntoIter = std::slice::IterMut<'a, char>;
+
+ fn into_iter(self) -> Self::IntoIter { self.iter_mut() }
+}
+
+impl<const N: usize> PartialEq for FixedString<N> {
+ fn eq(&self, other: &Self) -> bool {
+ if self.len() != other.len() { return false };
+
+ for i in 0x0..self.len() {
+ if self.buf[i] != other.buf[i] { return false };
+ }
+
+ true
+ }
+}
+
+impl<const N: usize> PartialEq<&str> for FixedString<N> {
+ fn eq(&self, other: &&str) -> bool {
+ for (i, c) in other.chars().enumerate() {
+ if self.buf.get(i) != Some(&c) { return false };
+ }
+
+ true
+ }
+}
+
+impl<const N: usize> Serialise for FixedString<N> {
+ fn serialise(&self, stream: &mut SStream) {
+ let s: String = self.iter().collect();
+
+ let len = u64::try_from(s.len()).unwrap();
+
+ stream.append(&len.to_be_bytes());
+ stream.append(&s.into_bytes());
+ }
+}
+
+impl<const N: usize> TryFrom<&str> for FixedString<N> {
+ type Error = Error;
+
+ #[inline(always)]
+ fn try_from(value: &str) -> Result<Self, Self::Error> { Self::new(value) }
+}
diff --git a/src/fixed_string_iter/mod.rs b/src/fixed_string_iter/mod.rs
new file mode 100644
index 0000000..088f61f
--- /dev/null
+++ b/src/fixed_string_iter/mod.rs
@@ -0,0 +1,43 @@
+// Copyright 2024 Gabriel Bjørnager Jensen.
+//
+// This file is part of bzipper.
+//
+// bzipper is free software: you can redistribute
+// it and/or modify it under the terms of the GNU
+// Lesser General Public License as published by
+// the Free Software Foundation, either version 3
+// of the License, or (at your option) any later
+// version.
+//
+// bzipper is distributed in the hope that it will
+// be useful, but WITHOUT ANY WARRANTY; without
+// even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Less-
+// er General Public License along with bzipper. If
+// not, see <https://www.gnu.org/licenses/>.
+
+/// Iterator to a fixed string.
+pub struct FixedStringIter<const N: usize> {
+ pub(in crate) buf: [char; N],
+ pub(in crate) len: usize,
+
+ pub(in crate) pos: Option<usize>,
+}
+
+impl<const N: usize> Iterator for FixedStringIter<N> {
+ type Item = char;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let pos = self.pos.as_mut()?;
+
+ if *pos >= self.len { return None };
+
+ let item = self.buf[*pos];
+ *pos += 0x1;
+
+ Some(item)
+ }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 82f75cb..cfe616b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -28,10 +28,6 @@
 //!
 //! This crate does not require any dependencies at the moment.
 
-pub mod deserialise;
-pub mod error;
-pub mod serialise;
-
 macro_rules! use_mod {
 ($vis:vis $name:ident) => {
 mod $name;
@@ -39,3 +35,11 @@ macro_rules! use_mod {
 };
 }
 pub(in crate) use use_mod;
+
+use_mod!(pub d_stream);
+use_mod!(pub deserialise);
+use_mod!(pub error);
+use_mod!(pub fixed_string);
+use_mod!(pub fixed_string_iter);
+use_mod!(pub s_stream);
+use_mod!(pub serialise);
diff --git a/src/serialise/s_stream/mod.rs b/src/s_stream/mod.rs
index 20f3fb9..454adb8 100644
--- a/src/serialise/s_stream/mod.rs
+++ b/src/s_stream/mod.rs
@@ -19,21 +19,36 @@
 // er General Public License along with bzipper. If
 // not, see <https://www.gnu.org/licenses/>.
 
-use crate::serialise::Serialise;
+use crate::{DStream, Serialise};
 
 use std::fmt::{Debug, Formatter};
 use std::mem::size_of;
 
+/// Byte stream for serialisation.
+///
+/// The bytes themselves are contained by the type.
+/// The stream can
 #[derive(Clone, Eq, PartialEq)]
-pub struct SStream(Vec<u8>);
+pub struct SStream(pub(in crate) Vec<u8>);
 
 impl SStream {
+ /// Constructs a new, empty byte stream.
+ #[inline(always)]
 #[must_use]
 pub const fn new() -> Self { Self(Vec::new()) }
 
+ /// Extends the byte stream.
+ #[inline(always)]
 pub fn append(&mut self, extra: &[u8]) {
 self.0.extend(extra);
 }
+
+ /// Converts the stream to a `DStream` object.
+ ///
+ /// The returned object references the original stream.
+ #[inline(always)]
+ #[must_use]
+ pub fn as_d_stream(&self) -> DStream { DStream::new(&self.0) }
 }
 
 impl AsRef<[u8]> for SStream {
diff --git a/src/serialise/mod.rs b/src/serialise/mod.rs
index 9fb56e3..1a63080 100644
--- a/src/serialise/mod.rs
+++ b/src/serialise/mod.rs
@@ -19,11 +19,120 @@
 // er General Public License along with bzipper. If
 // not, see <https://www.gnu.org/licenses/>.
 
-//! Serialisation utilities.
-
-use crate::use_mod;
-use_mod!(pub s_stream);
-use_mod!(pub serialise);
-
 #[cfg(test)]
 mod test;
+
+use crate::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/serialise/mod.rs b/src/serialise/serialise/mod.rs
deleted file mode 100644
index 8ee610c..0000000
--- a/src/serialise/serialise/mod.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright 2024 Gabriel Bjørnager Jensen.
-//
-// This file is part of bzipper.
-//
-// bzipper is free software: you can redistribute
-// it and/or modify it under the terms of the GNU
-// Lesser General Public License as published by
-// the Free Software Foundation, either version 3
-// of the License, or (at your option) any later
-// version.
-//
-// bzipper is distributed in the hope that it will
-// be useful, but WITHOUT ANY WARRANTY; without
-// even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Less-
-// er General Public License along with bzipper. If
-// not, see <https://www.gnu.org/licenses/>.
-
-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
index 8b06ed2..e0a0004 100644
--- a/src/serialise/test.rs
+++ b/src/serialise/test.rs
@@ -1,25 +1,6 @@
-// Copyright 2024 Gabriel Bjørnager Jensen.
-//
-// This file is part of bzipper.
-//
-// bzipper is free software: you can redistribute
-// it and/or modify it under the terms of the GNU
-// Lesser General Public License as published by
-// the Free Software Foundation, either version 3
-// of the License, or (at your option) any later
-// version.
-//
-// bzipper is distributed in the hope that it will
-// be useful, but WITHOUT ANY WARRANTY; without
-// even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Less-
-// er General Public License along with bzipper. If
-// not, see <https://www.gnu.org/licenses/>.
+// Copyright 2022-2024 Gabriel Bjørnager Jensen.
 
-use crate::serialise::{SStream, Serialise};
+use crate::{FixedString, SStream, Serialise};
 
 #[test]
 fn test_serialise() {
@@ -37,6 +18,9 @@ fn test_serialise() {
 
 0x45_A0_15_6A_36_77_17_8A_83_2E_3C_2C_84_10_58_1A_u128.serialise(&mut stream);
 
+ FixedString::<0x1>::new("A").unwrap().serialise(&mut stream);
+ FixedString::<0x8>::new("l\u{00F8}gma\u{00F0}ur").unwrap().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);
@@ -55,10 +39,14 @@ fn test_serialise() {
 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,
+ 0x01, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x0A, 0x6C, 0xC3, 0xB8, 0x67, 0x6D, 0x61,
+ 0xC3, 0xB0, 0x75, 0x72, 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,
 ]
 );
-}
+}
+\ No newline at end of file