1 files changed, 75 insertions, 17 deletions
diff --git a/src/deserialise/mod.rs b/src/deserialise/mod.rs
index 59e2b69..eaebe2b 100644
--- a/src/deserialise/mod.rs
+++ b/src/deserialise/mod.rs
@@ -22,20 +22,25 @@
 #[cfg(test)]
 mod test;
 
-use crate::{Dstream, Error, Serialise};
-
-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: Serialise + Sized {
+use crate::{Error, Dstream};
+
+use alloc::boxed::Box;
+use core::convert::Infallible;
+use core::error::Error as StdError;
+use core::mem::{MaybeUninit, size_of};
+use core::num::NonZero;
+use core::ptr::read;
+
+/// Types capable of being deserialised.
+pub trait Deserialise: Sized {
+ /// The error of deserialisation.
+ ///
+ /// Use [`Infallible`] if **all** deserialisations are infallible, as is the case of zero-length types.
 type Error;
 
 /// Deserialises the byte stream to an object.
 ///
- /// This function should not take *more* bytes than specified by [`SERIALISE_LIMIT`](Serialise::SERIALISE_LIMIT).
+ /// This function should **not** take more bytes than specified by [`T::SERIALISE_LIMIT`](crate::Serialise::SERIALISE_LIMIT).
 /// Doing so is considered a logic error.
 ///
 /// # Errors
@@ -75,7 +80,11 @@ macro_rules! impl_int {
 Ok(Self::from_be_bytes(data))
 }
 }
+ };
+}
 
+macro_rules! impl_non_zero {
+ ($type:ty) => {
 impl Deserialise for NonZero<$type> {
 type Error = Error;
 
@@ -353,19 +362,33 @@ where
 }
 }
 
-impl<T: Deserialise<Error: StdError + 'static>, const N: usize> Deserialise for [T; N] {
+impl<T, const N: usize> Deserialise for [T; N]
+where
+ T: Default + Deserialise<Error: StdError + 'static>, {
 type Error = Box<dyn StdError>;
 
 fn deserialise(stream: &mut Dstream) -> Result<Self, Self::Error> {
- let len = usize::try_from(u64::deserialise(stream)?).unwrap();
+ let len = usize::deserialise(stream)?;
+
 if len != N { return Err(Box::new(Error::ArrayTooShort { req: len, len: N })) };
 
- let mut buf = Vec::with_capacity(len);
- for _ in 0x0..len { buf.push(Deserialise::deserialise(stream)?); }
+ let mut buf: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
 
- // If we had used the checked unwrap, we would also
- // have to require `T: Debug`.
- Ok(unsafe { buf.try_into().unwrap_unchecked() })
+ // Deserialise t
+ for item in buf.iter_mut().take(len) {
+ item.write(Deserialise::deserialise(stream)?);
+ }
+
+ for item in buf.iter_mut().skip(len) {
+ item.write(Default::default());
+ }
+
+ // This should be safe as `MaybeUninit<T>` is
+ // transparent to `T`. The original buffer is
+ // NOT dropped automatically, so we can just
+ // forget about it from this point on.
+ let buf = unsafe { read(core::ptr::from_ref(&buf).cast::<[T; N]>()) };
+ Ok(buf)
 }
 }
 
@@ -406,6 +429,17 @@ impl Deserialise for Infallible {
 fn deserialise(_stream: &mut Dstream) -> Result<Self, Self::Error> { unreachable!() }
 }
 
+impl Deserialise for isize {
+ type Error = Error;
+
+ fn deserialise(stream: &mut Dstream) -> Result<Self, Self::Error> {
+ let value = i16::deserialise(stream)?
+ .into();
+
+ Ok(value)
+ }
+}
+
 impl<T: Deserialise<Error: StdError + 'static>> Deserialise for Option<T> {
 type Error = Box<dyn StdError>;
 
@@ -439,6 +473,17 @@ where
 }
 }
 
+impl Deserialise for usize {
+ type Error = Error;
+
+ fn deserialise(stream: &mut Dstream) -> Result<Self, Self::Error> {
+ let value = u16::deserialise(stream)?
+ .into();
+
+ Ok(value)
+ }
+}
+
 impl_float!(f32);
 impl_float!(f64);
 
@@ -452,3 +497,16 @@ impl_int!(u16);
 impl_int!(u32);
 impl_int!(u64);
 impl_int!(u8);
+
+impl_non_zero!(i128);
+impl_non_zero!(i16);
+impl_non_zero!(i32);
+impl_non_zero!(i64);
+impl_non_zero!(i8);
+impl_non_zero!(isize);
+impl_non_zero!(u128);
+impl_non_zero!(u16);
+impl_non_zero!(u32);
+impl_non_zero!(u64);
+impl_non_zero!(u8);
+impl_non_zero!(usize);