feat: introducing CopyConstructable to indicate that a struct is constructable from memory just by copying the underlying data

Author: WolverinDEV

raw_struct/src/builtins/array.rs

@@ -8,6 +8,7 @@ use core::{
 
 use crate::{
     Copy,
+    CopyConstructable,
     FromMemoryView,
     MemoryDecodeError,
     MemoryView,
@@ -31,17 +32,26 @@ impl<T: FromMemoryView> dyn Array<T> {
         let offset = (index * mem::size_of::<T>()) as u64;
         T::read_object(memory, self.start_address() + offset)
     }
+}
 
+impl<T: CopyConstructable> dyn Array<T> {
     pub fn elements<M: MemoryView>(
         &self,
         memory: &M,
         range: Range<usize>,
-    ) -> Result<Vec<T>, MemoryDecodeError<M::AccessError, T::DecodeError>> {
+    ) -> Result<Vec<T>, M::AccessError> {
         let element_count = range.end - range.start;
         let mut result = Vec::with_capacity(element_count);
 
-        for index in range {
-            result.push(self.element_at(memory, index)?);
+        let result_buffer = unsafe {
+            slice::from_raw_parts_mut(
+                result.as_mut_ptr() as *mut u8,
+                element_count * mem::size_of::<T>(),
+            )
+        };
+        memory.read_memory((range.start * mem::size_of::<T>()) as u64, result_buffer)?;
+        unsafe {
+            result.set_len(element_count);
         }
 
         Ok(result)

raw_struct/src/builtins/ptr.rs

@@ -9,6 +9,7 @@ use core::{
 use crate::{
     builtins::Array,
     Copy,
+    CopyConstructable,
     FromMemoryView,
     MemoryDecodeError,
     MemoryView,
@@ -30,19 +31,7 @@ impl<T: ?Sized> Clone for Ptr64<T> {
 }
 impl<T: ?Sized> marker::Copy for Ptr64<T> {}
 
-impl<T: ?Sized> FromMemoryView for Ptr64<T> {
-    type DecodeError = <u64 as FromMemoryView>::DecodeError;
-
-    fn read_object<M: MemoryView>(
-        view: &M,
-        offset: u64,
-    ) -> Result<Self, MemoryDecodeError<M::AccessError, Self::DecodeError>> {
-        Ok(Self {
-            address: u64::read_object(view, offset)?,
-            _type: Default::default(),
-        })
-    }
-}
+impl<T: ?Sized> CopyConstructable for Ptr64<T> {}
 
 impl<T: ?Sized> Ptr64<T> {
     pub fn is_null(&self) -> bool {

raw_struct/src/copy.rs

@@ -1,5 +1,4 @@
 use core::{
-    convert::Infallible,
     marker,
     mem::{
         self,
@@ -10,8 +9,7 @@ use core::{
 };
 
 use crate::{
-    FromMemoryView,
-    MemoryDecodeError,
+    CopyConstructable,
     MemoryView,
     OutOfBoundsViolation,
     Reference,
@@ -73,17 +71,6 @@ impl<T: SizedViewable> Copy<T> {
     }
 }
 
-impl<T: SizedViewable> FromMemoryView for Copy<T> {
-    type DecodeError = Infallible;
-
-    fn read_object<M: MemoryView>(
-        view: &M,
-        offset: u64,
-    ) -> Result<Self, MemoryDecodeError<M::AccessError, Self::DecodeError>> {
-        Self::read_from_memory(view, offset).map_err(MemoryDecodeError::MemoryAccess)
-    }
-}
-
 impl<T> Clone for Copy<T>
 where
     T: SizedViewable,
@@ -103,6 +90,13 @@ where
 {
 }
 
+impl<T> CopyConstructable for Copy<T>
+where
+    T: SizedViewable,
+    T::Implementation<CopyMemory<T::Memory>>: marker::Copy,
+{
+}
+
 impl<T: SizedViewable> Deref for Copy<T> {
     type Target = T::Implementation<CopyMemory<T::Memory>>;
 

raw_struct/src/lib.rs

@@ -10,6 +10,7 @@ pub use error::{
 
 mod memory;
 pub use memory::{
+    CopyConstructable,
     FromMemoryView,
     MemoryView,
 };

raw_struct/src/memory.rs

@@ -58,71 +58,51 @@ pub trait FromMemoryView: Sized {
     // fn read_boxed(view: &dyn MemoryView, offset: u64) -> Result<Box<Self>, Box<dyn error::ErrorType>>;
 }
 
-macro_rules! impl_from_memory_copy {
-    ($type:ty) => {
-        impl FromMemoryView for $type {
-            type DecodeError = Infallible;
-
-            fn read_object<M: MemoryView>(
-                view: &M,
-                offset: u64,
-            ) -> Result<Self, MemoryDecodeError<M::AccessError, Self::DecodeError>> {
-                let mut result = MaybeUninit::uninit();
-
-                {
-                    let result_memory = unsafe {
-                        slice::from_raw_parts_mut(
-                            result.as_mut_ptr() as *mut u8,
-                            mem::size_of::<$type>(),
-                        )
-                    };
-
-                    view.read_memory(offset, result_memory)
-                        .map_err(MemoryDecodeError::MemoryAccess)?;
-                }
-
-                Ok(unsafe { result.assume_init() })
-            }
-        }
+/// Marker trait for types that can be trivially constructed by copying their
+/// underlying data.
+///
+/// For types implementing this trait:
+/// - [`FromMemoryView`] is automatically implemented.
+/// - The associated [`DecodeError`] is fixed to [`Infallible`], since decoding
+///   cannot fail.
+pub trait CopyConstructable: Copy {}
+
+impl<T: CopyConstructable> FromMemoryView for T {
+    type DecodeError = Infallible;
 
-        impl<const N: usize> FromMemoryView for [$type; N] {
-            type DecodeError = Infallible;
-
-            fn read_object<M: MemoryView>(
-                view: &M,
-                offset: u64,
-            ) -> Result<Self, MemoryDecodeError<M::AccessError, Self::DecodeError>> {
-                let mut result = MaybeUninit::uninit();
-
-                {
-                    let result_memory = unsafe {
-                        slice::from_raw_parts_mut(
-                            result.as_mut_ptr() as *mut u8,
-                            mem::size_of::<$type>() * N,
-                        )
-                    };
-
-                    view.read_memory(offset, result_memory)
-                        .map_err(MemoryDecodeError::MemoryAccess)?;
-                }
-
-                Ok(unsafe { result.assume_init() })
-            }
-        }
-    };
+    fn read_object<M: MemoryView>(
+        view: &M,
+        offset: u64,
+    ) -> Result<Self, MemoryDecodeError<M::AccessError, Self::DecodeError>> {
+        let mut result = MaybeUninit::uninit();
+
+        let result_memory = unsafe {
+            slice::from_raw_parts_mut(result.as_mut_ptr() as *mut u8, mem::size_of::<T>())
+        };
+
+        view.read_memory(offset, result_memory)
+            .map_err(MemoryDecodeError::MemoryAccess)?;
+
+        Ok(unsafe { result.assume_init() })
+    }
 }
 
-impl_from_memory_copy!(i8);
-impl_from_memory_copy!(u8);
-impl_from_memory_copy!(i16);
-impl_from_memory_copy!(u16);
-impl_from_memory_copy!(i32);
-impl_from_memory_copy!(u32);
-impl_from_memory_copy!(i64);
-impl_from_memory_copy!(u64);
-
-impl_from_memory_copy!(f32);
-impl_from_memory_copy!(f64);
+impl<T: CopyConstructable, const N: usize> CopyConstructable for [T; N] {}
+
+impl CopyConstructable for u8 {}
+impl CopyConstructable for i8 {}
+
+impl CopyConstructable for u16 {}
+impl CopyConstructable for i16 {}
+
+impl CopyConstructable for u32 {}
+impl CopyConstructable for i32 {}
+
+impl CopyConstructable for u64 {}
+impl CopyConstructable for i64 {}
+
+impl CopyConstructable for f32 {}
+impl CopyConstructable for f64 {}
 
 impl FromMemoryView for bool {
     type DecodeError = Infallible;