feat: migrating to a new pattern to improve compiler performance and user dx

Author: WolverinDEV

examples/dyn_memory/src/main.rs

@@ -9,7 +9,7 @@ use raw_struct::{
     Copy,
     CopyMemory,
     FromMemoryView,
-    SizedViewable,
+    ViewableSized,
 };
 
 fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
@@ -18,7 +18,7 @@ fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
 
     println!(
         "Memory size: 0x{:X}",
-        <Container::<u64> as SizedViewable>::memory_size()
+        <Container::<u64> as ViewableSized>::memory_size()
     );
     println!("Vat a = 0x{:X}", object.var_a()?);
     println!("Inner = 0x{:X}", object.inner()?);

examples/minimal/src/main.rs

@@ -9,7 +9,7 @@ use raw_struct::{
     Copy,
     FromMemoryView,
     Reference,
-    SizedViewable,
+    ViewableSized,
 };
 
 fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
@@ -21,7 +21,7 @@ fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
 
     println!(
         "MyStruct size = 0x{:X}",
-        <MyStruct as SizedViewable>::memory_size()
+        <MyStruct as ViewableSized>::memory_size()
     );
 
     {

raw_struct/src/builtins/mod.rs

@@ -1,8 +1,8 @@
-mod array;
-pub use array::{
-    Array,
-    SizedArray,
-};
+// mod array;
+// pub use array::{
+//     Array,
+//     SizedArray,
+// };
 
-mod ptr;
-pub use ptr::Ptr64;
+// mod ptr;
+// pub use ptr::Ptr64;

raw_struct/src/copy.rs

@@ -4,17 +4,19 @@ use core::{
         self,
         MaybeUninit,
     },
-    ops::Deref,
+    ops::{
+        Deref,
+        DerefMut,
+    },
     slice,
 };
 
 use crate::{
-    CopyConstructable,
+    memory::FromMemoryView,
     MemoryView,
     OutOfBoundsViolation,
     Reference,
-    SizedViewable,
-    ViewableImplementation,
+    ViewableSized,
 };
 
 #[derive(Clone, Copy)]
@@ -32,15 +34,15 @@ impl<M: marker::Copy> MemoryView for CopyMemory<M> {
 }
 
 /// A Copy represents an owned copy of the struct binary contents
-#[repr(transparent)]
-pub struct Copy<T: SizedViewable> {
-    inner: T::Implementation<CopyMemory<T::Memory>>,
+#[derive(Clone)]
+pub struct Copy<V: ViewableSized> {
+    inner: Reference<V, CopyMemory<V::Memory>>,
 }
 
-impl<T: SizedViewable> Copy<T> {
-    pub fn new(inner: T::Memory) -> Self {
+impl<V: ViewableSized> Copy<V> {
+    pub fn new(inner: V::Memory) -> Self {
         Self {
-            inner: T::from_memory(CopyMemory(inner)),
+            inner: Reference::new(CopyMemory(inner), 0x00),
         }
     }
 
@@ -55,52 +57,56 @@ impl<T: SizedViewable> Copy<T> {
         memory: &M,
         offset: u64,
     ) -> Result<Self, M::AccessError> {
-        let mut copy_memory = MaybeUninit::<T::Memory>::uninit();
-        memory.read_memory(offset, unsafe {
-            slice::from_raw_parts_mut(
-                copy_memory.as_mut_ptr() as *mut u8,
-                mem::size_of::<T::Memory>(),
-            )
-        })?;
-
-        Ok(Self::new(unsafe { copy_memory.assume_init() }))
-    }
-
-    pub fn as_reference(&self) -> Reference<T, &CopyMemory<T::Memory>> {
-        Reference::new(self.inner.memory_view(), 0x00)
-    }
-}
-
-impl<T> Clone for Copy<T>
-where
-    T: SizedViewable,
-    T::Implementation<CopyMemory<T::Memory>>: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-        }
+        Ok(Self::new(
+            V::Memory::read_object(memory, offset).map_err(|err| err.into_access_error())?,
+        ))
     }
 }
 
-impl<T> marker::Copy for Copy<T>
-where
-    T: SizedViewable,
-    T::Implementation<CopyMemory<T::Memory>>: marker::Copy,
-{
-}
-
-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>>;
+impl<V: ViewableSized> Deref for Copy<V> {
+    type Target = Reference<V, CopyMemory<V::Memory>>;
 
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
+
+impl<V: ViewableSized> DerefMut for Copy<V> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+// impl<T> Clone for Copy<T>
+// where
+//     T: SizedViewable,
+//     T::Implementation<CopyMemory<T::Memory>>: Clone,
+// {
+//     fn clone(&self) -> Self {
+//         Self {
+//             inner: self.inner.clone(),
+//         }
+//     }
+// }
+
+// impl<T> marker::Copy for Copy<T>
+// where
+//     T: SizedViewable,
+//     T::Implementation<CopyMemory<T::Memory>>: marker::Copy,
+// {
+// }
+
+// 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>>;
+
+//     fn deref(&self) -> &Self::Target {
+//         &self.inner
+//     }
+// }

raw_struct/src/error.rs

@@ -1,7 +1,10 @@
-use core::fmt::{
-    self,
-    Debug,
-    Display,
+use core::{
+    convert::Infallible,
+    fmt::{
+        self,
+        Debug,
+        Display,
+    },
 };
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
@@ -30,6 +33,24 @@ pub enum MemoryDecodeError<A, V> {
     ValueDecode(V),
 }
 
+impl<A> MemoryDecodeError<A, Infallible> {
+    pub fn into_access_error(self) -> A {
+        match self {
+            Self::MemoryAccess(inner) => inner,
+            Self::ValueDecode(_) => unreachable!(),
+        }
+    }
+}
+
+impl<V> MemoryDecodeError<Infallible, V> {
+    pub fn into_decode_error(self) -> V {
+        match self {
+            Self::MemoryAccess(_) => unreachable!(),
+            Self::ValueDecode(inner) => inner,
+        }
+    }
+}
+
 impl<A: Display, V: Display> fmt::Display for MemoryDecodeError<A, V> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

raw_struct/src/lib.rs

@@ -1,10 +1,9 @@
 #![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(rustfmt, rustfmt_skip)]
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
 
-pub mod builtins;
-
 mod error;
 pub use error::{
     MemoryDecodeError,
@@ -18,23 +17,24 @@ pub use memory::{
     MemoryView,
 };
 
-mod view;
-pub use view::{
-    SizedViewable,
-    Viewable,
-    ViewableImplementation,
-};
-
 mod reference;
-pub use reference::{
-    Reference,
-    ReferenceMemory,
-};
+pub use reference::Reference;
 
 mod copy;
-
 pub use copy::{
     Copy,
     CopyMemory,
 };
-pub use raw_struct_derive::raw_struct;
+
+mod view;
+pub use view::{
+    Viewable,
+    ViewableExtends,
+    ViewableField,
+    ViewableSized,
+};
+
+pub mod builtins;
+
+// Re-exports
+pub use raw_struct_derive::raw_struct;