feat: rewored implementation details for improved performance and developer experiance

Author: WolverinDEV

Cargo.toml

@@ -8,7 +8,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.1.3"
+version = "0.2.0"
 edition = "2021"
 authors = ["Markus Hadenfeldt <[email protected]>"]
 description = "raw_struct is a Rust procedural macro for easily declaring C-style structs that reference local or external memory, based on your memory implementation. It generates appropiate getter methods for easy access."

README.MD

@@ -28,13 +28,13 @@ To reference the declared struct in memory you can ether do so by `Reference` or
 ```rust
 let memory = [0u8; 0x10];
 {
-    let object = Reference::<dyn MyStruct>::new(0x00, Arc::new(memory.clone()));
+    let object = Reference::<MyStruct>::new(0x00, Arc::new(memory.clone()));
     println!("field_a = {}", object.field_a()?);
     println!("field_b = {}", object.field_b()?);
 }
 
 {
-    let object = Copy::<dyn MyStruct>::new(memory);
+    let object = Copy::<MyStruct>::new(memory);
     println!("field_a = {}", object.field_a()?);
     println!("field_b = {}", object.field_b()?);
 }

examples/dyn_memory/src/main.rs

@@ -7,17 +7,17 @@ use std::{
 use raw_struct::{
     raw_struct,
     Copy,
-    FromMemoryView,
-    Viewable,
+    CopyMemory,
+    SizedViewable,
 };
 
 fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
-    let buffer = [0x1122u64, 0x8877, 0x9988];
-    let object = Copy::<dyn Container<u64>>::read_object(&buffer, 0x00)?;
+    let buffer = CopyMemory([0x1122u64, 0x8877, 0x9988]);
+    let object = Copy::<Container<u64>>::read_from_memory(&buffer, 0x00)?;
 
     println!(
         "Memory size: 0x{:X}",
-        <dyn Container::<u64> as Viewable<_>>::MEMORY_SIZE
+        <Container::<u64> as SizedViewable>::memory_size()
     );
     println!("Vat a = 0x{:X}", object.var_a()?);
     println!("Inner = 0x{:X}", object.inner()?);
@@ -26,10 +26,7 @@ fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
 }
 
 #[raw_struct(memory = "([u8; 0x10], T)")]
-struct Container<T>
-where
-    T: marker::Copy + Send + Sync + 'static,
-{
+struct Container<T: marker::Copy + Send + Sync + 'static> {
     #[field(offset = 0x00)]
     pub var_a: u64,
 

examples/minimal/src/main.rs

@@ -1,43 +1,36 @@
 use std::{
     self,
     error::Error,
-    sync::Arc,
 };
 
 use raw_struct::{
-    builtins::{
-        Array,
-        Ptr64,
-        SizedArray,
-    },
+    builtins::Ptr64,
     raw_struct,
     Copy,
-    FromMemoryView,
     Reference,
-    Viewable,
+    SizedViewable,
 };
 
 fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
-    let mut memory = [0u8; 0x20];
+    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::<dyn MyStruct>>::MEMORY_SIZE
+        "MyStruct size = 0x{:X}",
+        <MyStruct as SizedViewable>::memory_size()
     );
 
-    let memory = Arc::new(memory);
     {
-        let object = Reference::<dyn MyStruct>::new(memory.clone(), 0x00);
-        println!("field_a = {}", object.field_a()?);
-        println!("field_b = {}", object.field_b()?);
+        let object = Reference::<MyStruct, _>::new(memory.as_slice(), 0x00);
+        println!("field_a = {:X}", object.field_a()?);
+        println!("field_b = {:X}", object.field_b()?);
     }
 
     {
-        let object = Copy::<dyn MyStruct>::read_object(&*memory, 0x00)?;
-        println!("field_a = {}", object.field_a()?);
-        println!("field_b = {}", object.field_b()?);
+        let object = Copy::<MyStruct>::read_from_memory(&memory.as_slice(), 0x00)?;
+        println!("field_a = {:X}", object.field_a()?);
+        println!("field_b = {:X}", object.field_b()?);
     }
 
     Ok(())
@@ -62,27 +55,26 @@ struct MyStruct {
 
     /// Sized array of other raw_structs
     #[field(offset = 0x10)]
-    pub field_d: Ptr64<dyn SizedArray<dyn MyArrayElement, 0x20>>,
+    pub field_d: Ptr64<[Copy<MyArrayElement>; 0x20]>,
 
     /// Array to another copyable
     #[field(offset = 0x10)]
     pub field_e: Ptr64<[u8]>,
 
     /// Advanced array to other raw_structs
     #[field(offset = 0x18)]
-    pub field_f: Ptr64<dyn Array<dyn MyStruct>>,
+    pub field_f: Ptr64<[Copy<MyStruct>]>,
 
     /// Advanced array to other raw_structs
     #[field(offset = 0x18)]
-    pub field_fb: Ptr64<dyn Array<u64>>,
+    pub field_fb: Ptr64<[u64]>,
 
     #[field(offset = 0x20)]
     pub field_g: [u8; 0x20],
 }
 
 #[raw_struct(size = 0x44)]
-struct MyStructExt {
+struct MyStructExt /* : MyStruct */ {
     #[field(offset = 0x40)]
     pub ext_field_a: u32,
 }
-impl MyStruct for dyn MyStructExt {}

raw_struct/src/builtins/array.rs

@@ -1,156 +1,106 @@
-use alloc::{
-    format,
-    sync::Arc,
-    vec::Vec,
-};
+use alloc::vec::Vec;
 use core::{
-    marker::{
-        self,
-    },
+    self,
     mem,
     ops::Range,
     slice,
 };
 
 use crate::{
-    AccessError,
-    AccessMode,
     Copy,
     FromMemoryView,
+    MemoryDecodeError,
     MemoryView,
     Reference,
-    Viewable,
+    SizedViewable,
 };
 
 #[allow(clippy::len_without_is_empty)]
-pub trait Array<T: ?Sized> {
+pub trait Array<T> {
     fn start_address(&self) -> u64;
 
     fn len(&self) -> Option<usize>;
 }
 
 impl<T: FromMemoryView> dyn Array<T> {
-    pub fn element_at(&self, memory: &dyn MemoryView, index: usize) -> Result<T, AccessError> {
+    pub fn element_at<M: MemoryView>(
+        &self,
+        memory: &M,
+        index: usize,
+    ) -> Result<T, MemoryDecodeError<M::AccessError, T::DecodeError>> {
         let offset = (index * mem::size_of::<T>()) as u64;
-        T::read_object(memory, self.start_address() + offset).map_err(|err| AccessError {
-            source: err,
-            offset: self.start_address() + offset,
-            size: mem::size_of::<T>(),
-            mode: AccessMode::Read,
-            object: "[..]".into(),
-            member: Some(format!("[{}]", index).into()),
-        })
+        T::read_object(memory, self.start_address() + offset)
     }
 
-    pub fn elements(
+    pub fn elements<M: MemoryView>(
         &self,
-        memory: &dyn MemoryView,
+        memory: &M,
         range: Range<usize>,
-    ) -> Result<Vec<T>, AccessError> {
+    ) -> Result<Vec<T>, MemoryDecodeError<M::AccessError, T::DecodeError>> {
         let element_count = range.end - range.start;
         let mut result = Vec::with_capacity(element_count);
 
-        unsafe {
-            let buffer = slice::from_raw_parts_mut(
-                result.as_mut_ptr() as *mut u8,
-                element_count * mem::size_of::<T>(),
-            );
-            let offset = self.start_address() + (range.start * mem::size_of::<T>()) as u64;
-
-            memory
-                .read_memory(offset, buffer)
-                .map_err(|err| AccessError {
-                    source: err,
-                    offset,
-                    size: buffer.len(),
-                    mode: AccessMode::Read,
-                    object: "[..]".into(),
-                    member: Some(format!("[{:#?}]", range).into()),
-                })?;
-
-            result.set_len(element_count);
-        };
+        for index in range {
+            result.push(self.element_at(memory, index)?);
+        }
 
         Ok(result)
     }
 }
 
-impl<T: ?Sized + Viewable<T>> dyn Array<T> {
-    pub fn element_reference(&self, memory: Arc<dyn MemoryView>, index: usize) -> Reference<T> {
-        let offset = (index * T::MEMORY_SIZE) as u64;
+impl<T: SizedViewable> dyn Array<T> {
+    pub fn element_reference<M: MemoryView>(&self, memory: M, index: usize) -> Reference<T, M> {
+        let offset = (index * T::memory_size()) as u64;
         Reference::new(memory, self.start_address() + offset)
     }
 
-    pub fn elements_reference(
+    pub fn elements_reference<M: MemoryView + Clone>(
         &self,
-        memory: Arc<dyn MemoryView>,
+        memory: M,
         range: Range<usize>,
-    ) -> Vec<Reference<T>> {
+    ) -> Vec<Reference<T, M>> {
         Vec::from_iter(range.map(|index| {
             Reference::new(
                 memory.clone(),
-                self.start_address() + (index * T::MEMORY_SIZE) as u64,
+                self.start_address() + (index * T::memory_size()) as u64,
             )
         }))
     }
-}
 
-impl<T: ?Sized + Viewable<T>> dyn Array<T>
-where
-    T::Implementation<T::Memory>: marker::Copy,
-{
-    pub fn element_copy(
+    pub fn element_copy<M: MemoryView>(
         &self,
-        memory: &dyn MemoryView,
+        memory: &M,
         index: usize,
-    ) -> Result<Copy<T>, AccessError> {
-        let offset = (index * T::MEMORY_SIZE) as u64;
-        Copy::read_object(memory, self.start_address() + offset).map_err(|err| AccessError {
-            source: err,
-            offset: self.start_address() + offset,
-            size: T::MEMORY_SIZE,
-            mode: AccessMode::Read,
-            object: format!("[{}]", T::name()).into(),
-            member: Some(format!("[{}]", index).into()),
-        })
+    ) -> Result<Copy<T>, M::AccessError> {
+        let offset = (index * T::memory_size()) as u64;
+        Copy::read_from_memory(memory, self.start_address() + offset)
     }
 
-    pub fn elements_copy(
+    pub fn elements_copy<M: MemoryView>(
         &self,
-        memory: &dyn MemoryView,
+        memory: &M,
         range: Range<usize>,
-    ) -> Result<Vec<Copy<T>>, AccessError> {
+    ) -> Result<Vec<Copy<T>>, M::AccessError> {
         let element_count = range.end - range.start;
         let mut result = Vec::<T::Memory>::with_capacity(element_count);
 
         unsafe {
             let buffer = slice::from_raw_parts_mut(
                 result.as_mut_ptr() as *mut u8,
-                element_count * T::MEMORY_SIZE,
+                element_count * T::memory_size(),
             );
-            let offset = self.start_address() + (range.start * T::MEMORY_SIZE) as u64;
-
-            memory
-                .read_memory(offset, buffer)
-                .map_err(|err| AccessError {
-                    source: err,
-                    offset,
-                    size: buffer.len(),
-                    mode: AccessMode::Read,
-                    object: "[..]".into(),
-                    member: Some(format!("[{:#?}]", range).into()),
-                })?;
-
+            let offset = self.start_address() + (range.start * T::memory_size()) as u64;
+            memory.read_memory(offset, buffer)?;
             result.set_len(element_count);
         };
 
         Ok(result.into_iter().map(Copy::<T>::new).collect::<Vec<_>>())
     }
 }
 
-pub trait SizedArray<T: ?Sized, const N: usize>: Array<T> {}
+pub trait SizedArray<T, const N: usize>: Array<T> {}
 
-impl<T: ?Sized, const N: usize> dyn SizedArray<T, N> {
+impl<T, const N: usize> dyn SizedArray<T, N> {
     pub fn len(&self) -> usize {
         N
     }

raw_struct/src/builtins/mod.rs

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