feat: (breaking change) require explicit implementation of MemoryView and do not implicitly implement it for all Copy types

Author: WolverinDEV

examples/dyn_memory/src/main.rs

@@ -9,21 +9,22 @@ use std::{
 use raw_struct::{
     raw_struct,
     Copy,
+    CopyMemoryView,
+    Copyable,
     FromMemoryView,
-    Viewable,
 };
 
 fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     /*
      * Note:
      * Accessing all the container entries evaluates in release mode to just a mov instruction.
      */
-    let buffer = [0x1122u64, 0x8877, 0x9988];
+    let buffer = CopyMemoryView::new([0x1122u64, 0x8877, 0x9988]);
     let object = Copy::<dyn Container<u64>>::read_object(&buffer, 0x00)?;
 
     println!(
         "Memory size: 0x{:X}",
-        <dyn Container::<u64> as Viewable>::MEMORY_SIZE
+        <dyn Container::<u64> as Copyable>::MEMORY_SIZE
     );
     println!("Vat a = 0x{:X}", object.var_a()?);
     println!("Inner = 0x{:X}", object.inner()?);

examples/minimal/src/main.rs

@@ -12,19 +12,20 @@ use raw_struct::{
     },
     raw_struct,
     Copy,
+    CopyMemoryView,
+    Copyable,
     FromMemoryView,
     Reference,
-    Viewable,
 };
 
 fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let mut memory = [0u8; 0x40];
     memory[0..4].copy_from_slice(&0x6Fu32.to_le_bytes());
     memory[4..8].copy_from_slice(&0x99u32.to_le_bytes());
 
-    println!("{}", <dyn MyStruct as Viewable>::MEMORY_SIZE);
+    println!("{}", <dyn MyStruct as Copyable>::MEMORY_SIZE);
 
-    let memory = Arc::new(memory);
+    let memory = Arc::new(CopyMemoryView::new(memory));
     {
         let object = Reference::<dyn MyStruct, _>::new(memory.clone(), 0x00);
         println!("field_a = {}", object.field_a()?);

raw_struct/src/builtins/array.rs

@@ -4,22 +4,21 @@ use alloc::{
     vec::Vec,
 };
 use core::{
-    marker::{
-        self,
-    },
+    self,
+    marker,
     mem,
     ops::Range,
     slice,
 };
 
 use crate::{
+    view::Copyable,
     AccessError,
     AccessMode,
     Copy,
     FromMemoryView,
     MemoryView,
     Reference,
-    Viewable,
 };
 
 #[allow(clippy::len_without_is_empty)]
@@ -79,7 +78,8 @@ impl<T: FromMemoryView> dyn Array<T> {
     }
 }
 
-impl<T: ?Sized + Viewable> dyn Array<T> {
+/* We need T to be a Copyable as we need to know the element size */
+impl<T: ?Sized + Copyable> dyn Array<T> {
     pub fn element_reference<E: 'static>(
         &self,
         memory: Arc<dyn MemoryView<Error = E>>,
@@ -103,15 +103,15 @@ impl<T: ?Sized + Viewable> dyn Array<T> {
     }
 }
 
-impl<T: ?Sized + Viewable> dyn Array<T>
-where
-    T::Instance<T::Memory>: marker::Copy,
-{
+impl<T: ?Sized + Copyable> dyn Array<T> {
     pub fn element_copy<E>(
         &self,
         memory: &dyn MemoryView<Error = E>,
         index: usize,
-    ) -> Result<Copy<T>, AccessError<E>> {
+    ) -> Result<Copy<T>, AccessError<E>>
+    where
+        Copy<T>: marker::Copy,
+    {
         let offset = (index * T::MEMORY_SIZE) as u64;
         Copy::read_object(memory, self.start_address() + offset).map_err(|err| AccessError {
             source: err,

raw_struct/src/builtins/ptr.rs

@@ -13,6 +13,7 @@ use super::{
     Array,
 };
 use crate::{
+    view::Copyable,
     AccessError,
     AccessMode,
     Copy,
@@ -89,7 +90,9 @@ impl<T: ?Sized + Viewable> Ptr64<T> {
             None
         }
     }
+}
 
+impl<T: ?Sized + Copyable> Ptr64<T> {
     /// Create a copy of the value the pointer points to
     #[must_use = "copied result must be used"]
     pub fn value_copy<E>(

raw_struct/src/copy.rs

@@ -4,18 +4,22 @@ use core::{
     ops::Deref,
 };
 
-use crate::view::Viewable;
+use crate::{
+    memory::CopyMemoryView,
+    view::Copyable,
+    ViewableBase,
+};
 
 /// A Copy represents an owned copy of the struct binary contents
 #[repr(transparent)]
-pub struct Copy<T: ?Sized + Viewable> {
-    inner: T::Instance<T::Memory>,
+pub struct Copy<T: ?Sized + Copyable> {
+    inner: T::Instance<CopyMemoryView<T::Memory>>,
 }
 
-impl<T: ?Sized + Viewable> Copy<T> {
+impl<T: ?Sized + Copyable> Copy<T> {
     pub fn new(inner: T::Memory) -> Self {
         Self {
-            inner: T::create_view(inner),
+            inner: T::create_view(CopyMemoryView::new(inner)),
         }
     }
 
@@ -25,10 +29,16 @@ impl<T: ?Sized + Viewable> Copy<T> {
     pub unsafe fn new_zerod() -> Self {
         Self::new(MaybeUninit::zeroed().assume_init())
     }
+
+    // pub fn read_object<E>(view: &dyn MemoryView<Error = E>, offset: u64) -> Result<Self, E> {
+    //     Ok(Self {
+    //         inner: T::create_view(CopyMemoryView::<T::Memory>::read_object(view, offset)?),
+    //     })
+    // }
 }
 
-impl<T: ?Sized + Viewable> Deref for Copy<T> {
-    type Target = T::Instance<T::Memory>;
+impl<T: ?Sized + Copyable> Deref for Copy<T> {
+    type Target = T::Instance<CopyMemoryView<T::Memory>>;
 
     fn deref(&self) -> &Self::Target {
         &self.inner
@@ -37,19 +47,18 @@ impl<T: ?Sized + Viewable> Deref for Copy<T> {
 
 impl<T> Clone for Copy<T>
 where
-    T: ?Sized + Viewable,
-    T::Instance<T::Memory>: Clone,
+    T: ?Sized + Copyable,
 {
     fn clone(&self) -> Self {
         Self {
-            inner: self.inner.clone(),
+            inner: T::create_view(self.inner.object_memory().clone()),
         }
     }
 }
 
 impl<T> marker::Copy for Copy<T>
 where
-    T: ?Sized + Viewable,
-    T::Instance<T::Memory>: marker::Copy,
+    T: ?Sized + Copyable,
+    T::Instance<CopyMemoryView<T::Memory>>: marker::Copy,
 {
 }

raw_struct/src/error.rs

@@ -2,14 +2,13 @@ use alloc::{
     borrow::Cow,
     format,
 };
-#[cfg(feature = "no_std")]
-pub use core::error::Error as ErrorType;
 use core::{
     convert::Infallible,
-    fmt,
+    fmt::{
+        self,
+        Debug,
+    },
 };
-#[cfg(not(feature = "no_std"))]
-pub use std::error::Error as ErrorType;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum AccessMode {
@@ -35,7 +34,11 @@ impl fmt::Display for AccessViolation {
     }
 }
 
-impl ErrorType for AccessViolation {}
+#[cfg(feature = "no_std")]
+impl core::error::Error for AccessViolation {}
+
+#[cfg(not(feature = "no_std"))]
+impl std::error::Error for AccessViolation {}
 
 #[derive(Debug)]
 pub struct AccessError<S = Infallible> {
@@ -67,8 +70,16 @@ impl<S: fmt::Display> fmt::Display for AccessError<S> {
     }
 }
 
-impl<S: ErrorType + 'static> ErrorType for AccessError<S> {
-    fn source(&self) -> Option<&(dyn ErrorType + 'static)> {
+#[cfg(feature = "no_std")]
+impl<S: core::error::Error + 'static> core::error::Error for AccessError<S> {
+    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
+        Some(&self.source)
+    }
+}
+
+#[cfg(not(feature = "no_std"))]
+impl<S: std::error::Error + 'static> std::error::Error for AccessError<S> {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         Some(&self.source)
     }
 }

raw_struct/src/lib.rs

@@ -14,12 +14,14 @@ pub use error::{
     AccessViolation,
 };
 pub use memory::{
+    CopyMemoryView,
     FromMemoryView,
     MemoryView,
 };
 pub use raw_struct_derive::raw_struct;
 pub use reference::Reference;
 pub use view::{
+    Copyable,
     Viewable,
     ViewableBase,
     ViewableInstance,

raw_struct/src/memory.rs

@@ -1,4 +1,5 @@
 use core::{
+    marker,
     mem::{
         self,
         MaybeUninit,
@@ -14,42 +15,88 @@ pub trait MemoryView: Send + Sync {
     fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), Self::Error>;
 }
 
-/*
- * Attention:
- * This is dangarous MemoryView should only explicitly be implemented because
- * this implementation allows to read from &0 (aka references) as 8 byte values.
- */
-impl<T: Copy + Send + Sync> MemoryView for T {
+impl MemoryView for &[u8] {
     type Error = AccessViolation;
 
     fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), Self::Error> {
-        let src_buffer = unsafe {
-            core::slice::from_raw_parts(self as *const _ as *const u8, core::mem::size_of_val(self))
-        };
-
         let offset = offset as usize;
-        if offset + buffer.len() > src_buffer.len() {
+        if offset + buffer.len() > self.len() {
             return Err(AccessViolation);
         }
 
-        buffer.copy_from_slice(&src_buffer[offset..offset + buffer.len()]);
+        buffer.copy_from_slice(&self[offset..offset + buffer.len()]);
         Ok(())
     }
 }
 
+#[derive(Clone)]
+pub struct CopyMemoryView<T: marker::Copy> {
+    inner: T,
+}
+
+impl<T: marker::Copy> CopyMemoryView<T> {
+    pub fn new(value: T) -> Self {
+        Self { inner: value }
+    }
+}
+
+impl<T: marker::Copy + Send + Sync> MemoryView for CopyMemoryView<T> {
+    type Error = AccessViolation;
+
+    fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), Self::Error> {
+        let src_buffer = unsafe {
+            core::slice::from_raw_parts(
+                &self.inner as *const _ as *const u8,
+                core::mem::size_of_val(self),
+            )
+        };
+
+        src_buffer.read_memory(offset, buffer)
+    }
+}
+
+impl<T: marker::Copy + Send + Sync> From<T> for CopyMemoryView<T> {
+    fn from(value: T) -> Self {
+        Self::new(value)
+    }
+}
+
+impl<T: marker::Copy> marker::Copy for CopyMemoryView<T> {}
+
 pub trait FromMemoryView: Sized {
+    /// Read an instance of this byte by byte and interpret it as this.
     fn read_object<E>(view: &dyn MemoryView<Error = E>, offset: u64) -> Result<Self, E>;
-    // fn read_boxed(view: &dyn MemoryView, offset: u64) -> Result<Box<Self>, Box<dyn error::ErrorType>>;
+
+    /// Read an instance of this byte by byte into heap memory
+    fn read_boxed<E>(view: &dyn MemoryView<Error = E>, offset: u64) -> Result<Box<Self>, E>;
 }
 
 impl<T: Copy> FromMemoryView for T {
     fn read_object<E>(view: &dyn MemoryView<Error = E>, offset: u64) -> Result<Self, E> {
         let mut result = MaybeUninit::uninit();
         let size = mem::size_of_val(&result);
 
-        let buffer = unsafe { slice::from_raw_parts_mut(&mut result as *mut _ as *mut u8, size) };
-        view.read_memory(offset, buffer)?;
+        // Safety:
+        // As T is marker::Copy it is safe to access it's memory byte by byte
+        let result = unsafe {
+            let buffer = slice::from_raw_parts_mut(&mut result as *mut _ as *mut u8, size);
+            view.read_memory(offset, buffer)?;
+            result.assume_init()
+        };
+        Ok(result)
+    }
+
+    fn read_boxed<E>(view: &dyn MemoryView<Error = E>, offset: u64) -> Result<Box<Self>, E> {
+        let mut result = Box::new_uninit();
+        let size = mem::size_of_val(&result);
 
-        Ok(unsafe { result.assume_init() })
+        // Safety:
+        // As T is marker::Copy it is safe to access it's memory byte by byte
+        let result = unsafe {
+            let buffer = slice::from_raw_parts_mut(result.as_mut_ptr() as *mut _ as *mut u8, size);
+            view.read_memory(offset, buffer)?;
+            result.assume_init()
+        };
+        Ok(result)
     }
 }