feat: adding utilities for arrays and introducing MemoryViewDereferenceable trait

Author: WolverinDEV

examples/dyn_memory/src/main.rs

@@ -1,14 +1,13 @@
 use std::{
     self,
     error::Error,
-    marker,
 };
 
 use raw_struct::{
     raw_struct,
     Copy,
+    CopyConstructable,
     CopyMemory,
-    FromMemoryView,
     ViewableSized,
 };
 
@@ -20,14 +19,23 @@ fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
         "Memory size: 0x{:X}",
         <Container::<u64> as ViewableSized>::memory_size()
     );
-    println!("Vat a = 0x{:X}", object.var_a()?);
-    println!("Inner = 0x{:X}", object.inner()?);
-    println!("Vat b = 0x{:X}", object.var_b()?);
+    println!(
+        "Vat a = 0x{:X}",
+        object.read_field(Container::<u64>::var_a)?
+    );
+    println!(
+        "Inner = 0x{:X}",
+        object.read_field(Container::<u64>::inner)?
+    );
+    println!(
+        "Vat b = 0x{:X}",
+        object.read_field(Container::<u64>::var_b)?
+    );
     Ok(())
 }
 
 #[raw_struct(memory = "([u8; 0x10], T)")]
-struct Container<T: marker::Copy + FromMemoryView> {
+struct Container<T: CopyConstructable + 'static> {
     #[field(offset = 0x00)]
     pub var_a: u64,
 

examples/minimal/src/main.rs

@@ -8,6 +8,8 @@ use raw_struct::{
     raw_struct,
     Copy,
     FromMemoryView,
+    MemoryView,
+    MemoryViewDereferenceable,
     Reference,
     ViewableSized,
 };
@@ -26,18 +28,24 @@ fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
 
     {
         let object = Reference::<MyStruct, _>::new(memory.as_slice(), 0x00);
-        println!("field_a = {:X}", object.field_a()?);
-        println!("field_b = {:X}", object.field_b()?);
+        println!("field_a = {:X}", object.read_field(MyStruct::field_a)?);
+        println!("field_b = {:X}", object.read_field(MyStruct::field_b)?);
 
         let object = object.cast::<MyStructExt>();
-        println!("ext_field_a = {:X}", object.ext_field_a()?);
-        println!("field_base = {:X}", object.field_base()?);
+        println!(
+            "ext_field_a = {:X}",
+            object.read_field(MyStructExt::ext_field_a)?
+        );
+        println!(
+            "field_base = {:X}",
+            object.read_field(MyStructExt::ext_field_a)?
+        );
     }
 
     {
         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()?);
+        println!("field_a = {:X}", object.read_field(MyStruct::field_a)?);
+        println!("field_b = {:X}", object.read_field(MyStruct::field_b)?);
     }
 
     Ok(())
@@ -56,21 +64,20 @@ struct MyStruct {
     #[field(offset = 0x04)]
     pub field_b: u32,
 
-    /// Showcasing the custom getter name
-    #[field(offset = 0x08, getter = "get_field_c")]
+    #[field(offset = 0x08)]
     pub field_c: [u8; 0x8],
 
     /// Sized array of other raw_structs
     #[field(offset = 0x10)]
-    pub field_d: Ptr64<[Copy<MyArrayElement>; 0x20]>,
+    pub field_d: Ptr64<[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<[Copy<MyStruct>]>,
+    pub field_f: Ptr64<[MyStruct]>,
 
     /// Advanced array to other raw_structs
     #[field(offset = 0x18)]
@@ -81,7 +88,7 @@ struct MyStruct {
 }
 
 #[raw_struct]
-struct MyStructBase<T: FromMemoryView> {
+struct MyStructBase<T: FromMemoryView + 'static> {
     #[field(offset = 0x00)]
     pub field_base: T,
 }

raw_struct/src/builtins/array.rs

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

raw_struct/src/builtins/mod.rs

@@ -1,26 +1,22 @@
-use core::{
-    marker::{
-        self,
-        PhantomData,
-    },
-    ops::Deref,
+use core::marker::{
+    self,
+    PhantomData,
 };
 
 use crate::{
-    builtins::Array,
     Copy,
     CopyConstructable,
     FromMemoryView,
     MemoryDecodeError,
     MemoryView,
     Reference,
-    SizedViewable,
     Viewable,
+    ViewableSized,
 };
 
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Ptr64<T: ?Sized> {
-    pub address: u64,
+    address: u64,
     _type: PhantomData<T>,
 }
 
@@ -29,19 +25,24 @@ impl<T: ?Sized> Clone for Ptr64<T> {
         *self
     }
 }
+
 impl<T: ?Sized> marker::Copy for Ptr64<T> {}
 
 impl<T: ?Sized> CopyConstructable for Ptr64<T> {}
 
 impl<T: ?Sized> Ptr64<T> {
-    pub fn is_null(&self) -> bool {
+    pub const fn address(&self) -> u64 {
+        self.address
+    }
+
+    pub const fn is_null(&self) -> bool {
         self.address == 0
     }
 
-    pub fn cast<V>(&self) -> Ptr64<V> {
+    pub const fn cast<V>(&self) -> Ptr64<V> {
         Ptr64::<V> {
             address: self.address,
-            _type: Default::default(),
+            _type: PhantomData {},
         }
     }
 }
@@ -61,53 +62,17 @@ impl<T: FromMemoryView> Ptr64<T> {
 
 impl<T: Viewable> Ptr64<T> {
     #[must_use]
-    pub fn value_reference<M: MemoryView>(&self, memory: M) -> Option<Reference<T, M>> {
+    pub fn reference_value<M: MemoryView>(&self, memory: M) -> Option<Reference<T, M>> {
         (self.address > 0).then(|| Reference::new(memory, self.address))
     }
 }
 
-impl<T: SizedViewable> Ptr64<T> {
+impl<T: ViewableSized> Ptr64<T> {
     /// Create a copy of the value the pointer points to
     #[must_use = "copied result must be used"]
-    pub fn value_copy<M: MemoryView>(&self, memory: &M) -> Result<Option<Copy<T>>, M::AccessError> {
+    pub fn copy_value<M: MemoryView>(&self, memory: &M) -> Result<Option<Copy<T>>, M::AccessError> {
         (self.address > 0)
             .then(|| Copy::<T>::read_from_memory(memory, self.address))
             .transpose()
     }
 }
-
-impl<T> Array<T> for Ptr64<[T]> {
-    fn start_address(&self) -> u64 {
-        self.address
-    }
-
-    fn len(&self) -> Option<usize> {
-        None
-    }
-}
-
-impl<T: 'static> Deref for Ptr64<[T]> {
-    type Target = dyn Array<T>;
-
-    fn deref(&self) -> &Self::Target {
-        self
-    }
-}
-
-impl<T, const N: usize> Array<T> for Ptr64<[T; N]> {
-    fn start_address(&self) -> u64 {
-        self.address
-    }
-
-    fn len(&self) -> Option<usize> {
-        Some(N)
-    }
-}
-
-impl<T: 'static, const N: usize> Deref for Ptr64<[T; N]> {
-    type Target = dyn Array<T>;
-
-    fn deref(&self) -> &Self::Target {
-        self
-    }
-}