Add from bytes impl

Author: febo

src/collections/array_set.rs

@@ -1,6 +1,10 @@
 use core::{cmp::Ordering, mem::size_of, ops::Deref, ptr::copy};
 
-use crate::transmute::{cast_slice_unchecked, cast_slice_unchecked_mut, Transmute};
+use crate::{
+    error::{Result, TranslationError},
+    from_bytes::{FromBytes, FromBytesMut},
+    transmute::{cast_slice_unchecked, cast_slice_unchecked_mut, Transmute},
+};
 
 pub trait Prefix: Transmute {
     fn as_usize(&self) -> usize;
@@ -62,27 +66,6 @@ where
     values: &'a [V],
 }
 
-impl<'a, P, V> ArraySet<'a, P, V>
-where
-    P: Prefix,
-    V: Copy + Clone + Default + PartialOrd + Transmute,
-{
-    /// Loads a sorted array from its byte representation.
-    ///
-    /// # Safety
-    ///
-    /// This method does not check the length of the byte slice nor its
-    /// alignment. The caller must ensure that the byte slice contains a
-    /// valid representation.
-    pub unsafe fn from_bytes_unchecked(bytes: &'a [u8]) -> Self {
-        let (length, values) = bytes.split_at(size_of::<P>());
-        Self {
-            length: P::transmute_unchecked(length),
-            values: cast_slice_unchecked(values),
-        }
-    }
-}
-
 /// Macro to implement the read-only interface for an array set type.
 macro_rules! readonly_impl {
     ( $name:tt ) => {
@@ -202,26 +185,11 @@ where
     values: &'a mut [V],
 }
 
-impl<'a, P, V> ArraySetMut<'a, P, V>
+impl<P, V> ArraySetMut<'_, P, V>
 where
     P: Prefix,
     V: Default + Copy + Clone + Ord + Transmute,
 {
-    /// Loads a sorted array from its byte representation.
-    ///
-    /// # Safety
-    ///
-    /// This method does not check the length of the byte slice nor its
-    /// alignment. The caller must ensure that the byte slice contains a
-    /// valid representation.
-    pub unsafe fn from_bytes_unchecked_mut(bytes: &'a mut [u8]) -> Self {
-        let (length, values) = bytes.split_at_mut(size_of::<P>());
-        Self {
-            length: P::transmute_unchecked_mut(length),
-            values: cast_slice_unchecked_mut(values),
-        }
-    }
-
     /// Returns a mutable reference to the value in the set, if any, that is equal to the
     /// given value.
     ///
@@ -311,6 +279,74 @@ where
     }
 }
 
+unsafe impl<'a, P, V> FromBytes<'a> for ArraySet<'a, P, V>
+where
+    P: Prefix,
+    V: Default + Copy + Clone + Ord + Transmute,
+{
+    /// Loads a sorted array from its byte representation.
+    fn from_bytes(bytes: &'a [u8]) -> Result<Self> {
+        if bytes.len() < size_of::<P>() {
+            return Err(TranslationError::InvalidLength);
+        }
+
+        if align_of_val(bytes) != align_of::<Self>() {
+            return Err(TranslationError::InvalidLength);
+        }
+
+        Ok(unsafe { Self::from_bytes_unchecked(bytes) })
+    }
+
+    /// Loads a sorted array from its byte representation.
+    ///
+    /// # Safety
+    ///
+    /// This method does not check the length of the byte slice nor its
+    /// alignment. The caller must ensure that the byte slice contains a
+    /// valid representation.
+    unsafe fn from_bytes_unchecked(bytes: &'a [u8]) -> Self {
+        let (length, values) = bytes.split_at(size_of::<P>());
+        Self {
+            length: P::transmute_unchecked(length),
+            values: cast_slice_unchecked(values),
+        }
+    }
+}
+
+unsafe impl<'a, P, V> FromBytesMut<'a> for ArraySetMut<'a, P, V>
+where
+    P: Prefix,
+    V: Default + Copy + Clone + Ord + Transmute,
+{
+    /// Loads a sorted array from its byte representation.
+    fn from_bytes_mut(bytes: &'a mut [u8]) -> Result<Self> {
+        if bytes.len() < size_of::<P>() {
+            return Err(TranslationError::InvalidLength);
+        }
+
+        if align_of_val(bytes) != align_of::<Self>() {
+            return Err(TranslationError::InvalidLength);
+        }
+
+        Ok(unsafe { Self::from_bytes_unchecked_mut(bytes) })
+    }
+
+    /// Loads a sorted array from its byte representation.
+    ///
+    /// # Safety
+    ///
+    /// This method does not check the length of the byte slice nor its
+    /// alignment. The caller must ensure that the byte slice contains a
+    /// valid representation.
+    unsafe fn from_bytes_unchecked_mut(bytes: &'a mut [u8]) -> Self {
+        let (length, values) = bytes.split_at_mut(size_of::<P>());
+        Self {
+            length: P::transmute_unchecked_mut(length),
+            values: cast_slice_unchecked_mut(values),
+        }
+    }
+}
+
 readonly_impl!(ArraySet);
 readonly_impl!(ArraySetMut);
 

src/error.rs

@@ -16,6 +16,9 @@ pub enum TranslationError {
 
     /// Invalid value found for type.
     InvalidValue,
+
+    /// Misaligned memory for translation.
+    Misaligned,
 }
 
 impl Error for TranslationError {}
@@ -25,6 +28,7 @@ impl Display for TranslationError {
         match self {
             TranslationError::InvalidLength => write!(f, "invalid length for translation"),
             TranslationError::InvalidValue => write!(f, "invalid value found for type"),
+            TranslationError::Misaligned => write!(f, "misaligned memory for translation"),
         }
     }
 }

src/from_bytes.rs

@@ -6,21 +6,21 @@ use crate::error::Result;
 ///
 /// Types implementing this trait must ensure that the byte slice is
 /// properly aligned and that the bytes represent a valid instance of the type.
-pub unsafe trait FromBytes<T> {
+pub unsafe trait FromBytes<'bytes>: Sized {
     /// Creates an instance of `Self` from a byte slice.
     ///
     /// # Errors
     ///
     /// Returns an error if the byte slice does not have the correct length.
-    fn from_bytes(bytes: &[u8]) -> Result<T>;
+    fn from_bytes(bytes: &'bytes [u8]) -> Result<Self>;
 
     /// Creates an instance of `Self` from a byte slice.
     ///
     /// # Safety
     ///
     /// The caller must ensure that `bytes` contains a valid representation of
     /// the implementing type.
-    unsafe fn from_bytes_unchecked(bytes: &[u8]) -> T;
+    unsafe fn from_bytes_unchecked(bytes: &'bytes [u8]) -> Self;
 }
 
 /// Marker trait for types that can be created from a mutable byte slice.
@@ -32,19 +32,19 @@ pub unsafe trait FromBytes<T> {
 ///
 /// Caution should be taken when the type offers interior mutability, given that
 /// the source byte slice is mutable.
-pub unsafe trait FromBytesMut<T> {
+pub unsafe trait FromBytesMut<'bytes>: Sized {
     /// Creates an instance of `Self` from a byte slice.
     ///
     /// # Errors
     ///
     /// Returns an error if the byte slice does not have the correct length.
-    fn from_bytes_mut(bytes: &mut [u8]) -> Result<T>;
+    fn from_bytes_mut(bytes: &'bytes mut [u8]) -> Result<Self>;
 
     /// Creates an instance of `Self` from a byte slice.
     ///
     /// # Safety
     ///
     /// The caller must ensure that `bytes` contains a valid representation of
     /// the implementing type.
-    fn from_bytes_unchecked_mut(bytes: &mut [u8]) -> T;
+    unsafe fn from_bytes_unchecked_mut(bytes: &'bytes mut [u8]) -> Self;
 }