feat: adding Clone to Reference

Author: WolverinDEV

raw_struct/src/error.rs

@@ -2,12 +2,9 @@ use alloc::{
     borrow::Cow,
     format,
 };
-use core::{
-    convert::Infallible,
-    fmt::{
-        self,
-        Debug,
-    },
+use core::fmt::{
+    self,
+    Debug,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -41,7 +38,7 @@ impl core::error::Error for AccessViolation {}
 impl std::error::Error for AccessViolation {}
 
 #[derive(Debug)]
-pub struct AccessError<S = Infallible> {
+pub struct AccessError<S> {
     pub source: S,
 
     pub offset: u64,

raw_struct/src/memory.rs

@@ -10,16 +10,12 @@ use core::{
 
 use crate::error::AccessViolation;
 
-pub trait MemoryView: Send + Sync {
-    type Error;
-
-    fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), Self::Error>;
+pub trait MemoryView<E> {
+    fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), E>;
 }
 
-impl MemoryView for &[u8] {
-    type Error = AccessViolation;
-
-    fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), Self::Error> {
+impl MemoryView<AccessViolation> for &[u8] {
+    fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), AccessViolation> {
         let offset = offset as usize;
         if offset + buffer.len() > self.len() {
             return Err(AccessViolation);
@@ -41,7 +37,7 @@ impl<T: marker::Copy> CopyMemoryView<T> {
     }
 }
 
-impl<T: marker::Copy + Send + Sync> MemoryView for CopyMemoryView<T> {
+impl<T: marker::Copy> MemoryView for CopyMemoryView<T> {
     type Error = AccessViolation;
 
     fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), Self::Error> {
@@ -56,7 +52,7 @@ impl<T: marker::Copy + Send + Sync> MemoryView for CopyMemoryView<T> {
     }
 }
 
-impl<T: marker::Copy + Send + Sync> From<T> for CopyMemoryView<T> {
+impl<T: marker::Copy> From<T> for CopyMemoryView<T> {
     fn from(value: T) -> Self {
         Self::new(value)
     }

raw_struct/src/reference.rs

@@ -21,34 +21,41 @@ use crate::{
 
 pub struct ReferenceMemory<MemoryError> {
     address: u64,
-    inner: Arc<dyn MemoryView<Error = MemoryError>>,
+    inner: Arc<dyn MemoryView<MemoryError>>,
 }
 
 impl<MemoryError> ReferenceMemory<MemoryError> {
     pub fn address(&self) -> u64 {
         self.address
     }
 
-    pub fn memory_view(&self) -> &Arc<dyn MemoryView<Error = MemoryError>> {
+    pub fn memory_view(&self) -> &Arc<dyn MemoryView<MemoryError>> {
         &self.inner
     }
 }
 
-impl<MemoryError> MemoryView for ReferenceMemory<MemoryError> {
-    type Error = MemoryError;
-
-    fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), Self::Error> {
+impl<MemoryError> MemoryView<MemoryError> for ReferenceMemory<MemoryError> {
+    fn read_memory(&self, offset: u64, buffer: &mut [u8]) -> Result<(), MemoryError> {
         self.inner.read_memory(self.address + offset, buffer)
     }
 }
 
+impl<MemoryError> Clone for ReferenceMemory<MemoryError> {
+    fn clone(&self) -> Self {
+        Self {
+            address: self.address,
+            inner: self.inner.clone(),
+        }
+    }
+}
+
 /// A reference to an object living in the underlying memory view.
 pub struct Reference<T: ?Sized + Viewable, MemoryError: 'static> {
     inner: T::Instance<ReferenceMemory<MemoryError>>,
 }
 
 impl<T: ?Sized + Viewable, MemoryError: 'static> Reference<T, MemoryError> {
-    pub fn new(memory: Arc<dyn MemoryView<Error = MemoryError>>, address: u64) -> Self {
+    pub fn new(memory: Arc<dyn MemoryView<MemoryError>>, address: u64) -> Self {
         Self {
             inner: T::create_view(ReferenceMemory {
                 address,
@@ -62,7 +69,7 @@ impl<T: ?Sized + Viewable, MemoryError: 'static> Reference<T, MemoryError> {
         memory.address
     }
 
-    pub fn base_memory(&self) -> &Arc<dyn MemoryView<Error = MemoryError>> {
+    pub fn base_memory(&self) -> &Arc<dyn MemoryView<MemoryError>> {
         let memory = self.inner.object_memory();
         &memory.inner
     }
@@ -98,3 +105,14 @@ impl<T: Viewable + ?Sized, MemoryError> Deref for Reference<T, MemoryError> {
         self.inner.get_accessor()
     }
 }
+
+impl<T: Viewable + ?Sized, MemoryError> Clone for Reference<T, MemoryError>
+where
+    T::Instance<ReferenceMemory<MemoryError>>: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}

raw_struct/src/view.rs

@@ -2,7 +2,7 @@ use alloc::borrow::Cow;
 
 use crate::memory::MemoryView;
 
-pub trait ViewableBase<M: MemoryView>: Send + Sync {
+pub trait ViewableBase<M: MemoryView> {
     fn object_memory(&self) -> &M;
 }
 
@@ -27,7 +27,7 @@ pub trait Viewable: 'static {
 /// Stronger type of viewable which indicates that the object can be copied
 pub trait Copyable: Viewable {
     /// Const memory used for copying the value
-    type Memory: Copy + Send + Sync;
+    type Memory: Copy;
 
     /// Byte size of the copy memory
     const MEMORY_SIZE: usize = core::mem::size_of::<Self::Memory>();

raw_struct_derive/src/derive_raw_struct.rs

@@ -379,6 +379,7 @@ impl<'a> ViewableGenerator<'a> {
     }
 
     fn generate_instance_struct(&self) -> TokenStream {
+        let vis = &self.source.vis;
         let instance_name = &self.instance_name;
         let accessor_name = &self.accessor_name;
 
@@ -387,12 +388,12 @@ impl<'a> ViewableGenerator<'a> {
 
         quote! {
             #[allow(non_camel_case_types)]
-            struct #instance_name <A: ?Sized, M: ::raw_struct::MemoryView> {
+            #vis struct #instance_name <A: ?Sized, M: ::raw_struct::MemoryView> {
                 _accessor: ::core::marker::PhantomData<A>,
                 memory: M,
             }
 
-            impl<A: ?Sized + Send + Sync, M: ::raw_struct::MemoryView> ::raw_struct::ViewableBase<M> for #instance_name<A, M> {
+            impl<A: ?Sized, M: ::raw_struct::MemoryView> ::raw_struct::ViewableBase<M> for #instance_name<A, M> {
                 fn object_memory(&self) -> &M {
                     &self.memory
                 }