make all methods take owned versions & implement Copy

Author: Freax13

src/lib.rs

@@ -207,7 +207,7 @@ where
     /// let mut_reference = unsafe { VolatilePtr::new_read_write(NonNull::from(&mut value)) };
     /// assert_eq!(mut_reference.read(), 50);
     /// ```
-    pub fn read(&self) -> T
+    pub fn read(self) -> T
     where
         R: access::Safe,
     {
@@ -234,7 +234,7 @@ where
     ///
     /// assert_eq!(volatile.read(), 50);
     /// ```
-    pub fn write(&mut self, value: T)
+    pub fn write(self, value: T)
     where
         W: access::Safe,
     {
@@ -259,7 +259,7 @@ where
     ///
     /// assert_eq!(volatile.read(), 43);
     /// ```
-    pub fn update<F>(&mut self, f: F)
+    pub fn update<F>(self, f: F)
     where
         R: access::Safe,
         W: access::Safe,
@@ -300,13 +300,13 @@ where
     ///
     /// assert_eq!(unsafe { *unwrapped }, 50); // non volatile access, be careful!
     /// ```
-    pub fn as_ptr(&self) -> NonNull<T> {
+    pub fn as_ptr(self) -> NonNull<T> {
         self.pointer
     }
 }
 
 /// Transformation methods for accessing struct fields
-impl<T, R, W> VolatilePtr<'_, T, Access<R, W>>
+impl<'a, T, R, W> VolatilePtr<'a, T, Access<R, W>>
 where
     T: ?Sized,
 {
@@ -351,7 +351,7 @@ where
     ///    value
     /// })};
     /// ```
-    pub unsafe fn map<'a, F, U>(&'a self, f: F) -> VolatilePtr<'a, U, Access<R, access::NoAccess>>
+    pub unsafe fn map<F, U>(self, f: F) -> VolatilePtr<'a, U, Access<R, access::NoAccess>>
     where
         F: FnOnce(NonNull<T>) -> NonNull<U>,
         U: ?Sized,
@@ -360,8 +360,8 @@ where
     }
 
     #[cfg(feature = "very_unstable")]
-    pub const unsafe fn map_const<'a, F, U>(
-        &'a self,
+    pub const unsafe fn map_const<F, U>(
+        self,
         f: F,
     ) -> VolatilePtr<'a, U, Access<R, access::NoAccess>>
     where
@@ -371,7 +371,7 @@ where
         unsafe { VolatilePtr::new_generic(f(self.pointer)) }
     }
 
-    pub unsafe fn map_mut<F, U>(&mut self, f: F) -> VolatilePtr<U, Access<R, W>>
+    pub unsafe fn map_mut<F, U>(self, f: F) -> VolatilePtr<'a, U, Access<R, W>>
     where
         F: FnOnce(NonNull<T>) -> NonNull<U>,
         U: ?Sized,
@@ -380,7 +380,7 @@ where
     }
 
     #[cfg(feature = "very_unstable")]
-    pub const unsafe fn map_mut_const<F, U>(&mut self, f: F) -> VolatilePtr<U, Access<R, W>>
+    pub const unsafe fn map_mut_const<F, U>(self, f: F) -> VolatilePtr<'a, U, Access<R, W>>
     where
         F: FnOnce(NonNull<T>) -> NonNull<U>,
         U: ?Sized,
@@ -392,7 +392,7 @@ where
 /// Methods for volatile slices
 #[cfg(feature = "unstable")]
 impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
-    pub fn len(&self) -> usize {
+    pub fn len(self) -> usize {
         self.pointer.len()
     }
 
@@ -433,9 +433,9 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     /// assert_eq!(subslice.index(0).read(), 2);
     /// ```
     pub fn index<I>(
-        &self,
+        self,
         index: I,
-    ) -> VolatilePtr<<I as SliceIndex<[T]>>::Output, Access<R, access::NoAccess>>
+    ) -> VolatilePtr<'a, <I as SliceIndex<[T]>>::Output, Access<R, access::NoAccess>>
     where
         I: SliceIndex<[T]> + SliceIndex<[()]> + Clone,
     {
@@ -445,7 +445,10 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     #[cfg(feature = "very_unstable")]
-    pub const fn index_const(&self, index: usize) -> VolatilePtr<T, Access<R, access::NoAccess>> {
+    pub const fn index_const(
+        self,
+        index: usize,
+    ) -> VolatilePtr<'a, T, Access<R, access::NoAccess>> {
         assert!(index < self.pointer.len(), "index out of bounds");
         unsafe {
             self.map_const(|slice| {
@@ -455,9 +458,9 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     pub fn index_mut<I>(
-        &mut self,
+        self,
         index: I,
-    ) -> VolatilePtr<<I as SliceIndex<[T]>>::Output, Access<R, W>>
+    ) -> VolatilePtr<'a, <I as SliceIndex<[T]>>::Output, Access<R, W>>
     where
         I: SliceIndex<[T]> + SliceIndex<[()]> + Clone,
     {
@@ -467,7 +470,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     #[cfg(feature = "very_unstable")]
-    pub const fn index_mut_const(&mut self, index: usize) -> VolatilePtr<T, Access<R, W>> {
+    pub const fn index_mut_const(self, index: usize) -> VolatilePtr<'a, T, Access<R, W>> {
         assert!(index < self.pointer.len(), "index out of bounds");
         unsafe {
             self.map_mut_const(|slice| {
@@ -510,7 +513,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     /// assert_eq!(src, [1, 2]);
     /// assert_eq!(dst, [5, 1, 2]);
     /// ```
-    pub fn copy_into_slice(&self, dst: &mut [T])
+    pub fn copy_into_slice(self, dst: &mut [T])
     where
         T: Copy,
     {
@@ -566,7 +569,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     /// assert_eq!(src, [1, 2, 3, 4]);
     /// assert_eq!(dst, [3, 4]);
     /// ```
-    pub fn copy_from_slice(&mut self, src: &[T])
+    pub fn copy_from_slice(self, src: &[T])
     where
         T: Copy,
     {
@@ -619,7 +622,7 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     /// volatile.copy_within(1..5, 8);
     ///
     /// assert_eq!(&byte_array, b"Hello, Wello!");
-    pub fn copy_within(&mut self, src: impl RangeBounds<usize>, dest: usize)
+    pub fn copy_within(self, src: impl RangeBounds<usize>, dest: usize)
     where
         T: Copy,
     {
@@ -643,11 +646,11 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     pub fn split_at(
-        &self,
+        self,
         mid: usize,
     ) -> (
-        VolatilePtr<[T], Access<R, access::NoAccess>>,
-        VolatilePtr<[T], Access<R, access::NoAccess>>,
+        VolatilePtr<'a, [T], Access<R, access::NoAccess>>,
+        VolatilePtr<'a, [T], Access<R, access::NoAccess>>,
     ) {
         assert!(mid <= self.pointer.len());
         // SAFETY: `[ptr; mid]` and `[mid; len]` are inside `self`, which
@@ -656,11 +659,11 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     pub fn split_at_mut(
-        &mut self,
+        self,
         mid: usize,
     ) -> (
-        VolatilePtr<[T], Access<R, W>>,
-        VolatilePtr<[T], Access<R, W>>,
+        VolatilePtr<'a, [T], Access<R, W>>,
+        VolatilePtr<'a, [T], Access<R, W>>,
     ) {
         assert!(mid <= self.pointer.len());
         // SAFETY: `[ptr; mid]` and `[mid; len]` are inside `self`, which
@@ -669,11 +672,11 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     unsafe fn split_at_unchecked(
-        &self,
+        self,
         mid: usize,
     ) -> (
-        VolatilePtr<[T], Access<R, access::NoAccess>>,
-        VolatilePtr<[T], Access<R, access::NoAccess>>,
+        VolatilePtr<'a, [T], Access<R, access::NoAccess>>,
+        VolatilePtr<'a, [T], Access<R, access::NoAccess>>,
     ) {
         // SAFETY: Caller has to check that `0 <= mid <= self.len()`
         unsafe {
@@ -685,11 +688,11 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     unsafe fn split_at_mut_unchecked(
-        &mut self,
+        self,
         mid: usize,
     ) -> (
-        VolatilePtr<[T], Access<R, W>>,
-        VolatilePtr<[T], Access<R, W>>,
+        VolatilePtr<'a, [T], Access<R, W>>,
+        VolatilePtr<'a, [T], Access<R, W>>,
     ) {
         let len = self.pointer.len();
         let ptr = self.pointer.as_mut_ptr();
@@ -711,10 +714,10 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     pub fn as_chunks<const N: usize>(
-        &self,
+        self,
     ) -> (
-        VolatilePtr<[[T; N]], Access<R, access::NoAccess>>,
-        VolatilePtr<[T], Access<R, access::NoAccess>>,
+        VolatilePtr<'a, [[T; N]], Access<R, access::NoAccess>>,
+        VolatilePtr<'a, [T], Access<R, access::NoAccess>>,
     ) {
         assert_ne!(N, 0);
         let len = self.pointer.len() / N;
@@ -726,8 +729,8 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     pub unsafe fn as_chunks_unchecked<const N: usize>(
-        &self,
-    ) -> VolatilePtr<[[T; N]], Access<R, access::NoAccess>> {
+        self,
+    ) -> VolatilePtr<'a, [[T; N]], Access<R, access::NoAccess>> {
         debug_assert_ne!(N, 0);
         debug_assert_eq!(self.pointer.len() % N, 0);
         let new_len =
@@ -744,10 +747,10 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     pub fn as_chunks_mut<const N: usize>(
-        &mut self,
+        self,
     ) -> (
-        VolatilePtr<[[T; N]], Access<R, W>>,
-        VolatilePtr<[T], Access<R, W>>,
+        VolatilePtr<'a, [[T; N]], Access<R, W>>,
+        VolatilePtr<'a, [T], Access<R, W>>,
     ) {
         assert_ne!(N, 0);
         let len = self.pointer.len() / N;
@@ -759,8 +762,8 @@ impl<'a, T, R, W> VolatilePtr<'a, [T], Access<R, W>> {
     }
 
     pub unsafe fn as_chunks_unchecked_mut<const N: usize>(
-        &mut self,
-    ) -> VolatilePtr<[[T; N]], Access<R, W>> {
+        self,
+    ) -> VolatilePtr<'a, [[T; N]], Access<R, W>> {
         debug_assert_ne!(N, 0);
         debug_assert_eq!(self.pointer.len() % N, 0);
         let new_len =
@@ -819,7 +822,7 @@ impl<A> VolatilePtr<'_, [u8], A> {
     /// buf.fill(1);
     /// assert_eq!(unsafe { buf.as_ptr().as_mut() }, &mut vec![1; 10]);
     /// ```
-    pub fn fill(&mut self, value: u8) {
+    pub fn fill(self, value: u8) {
         unsafe {
             intrinsics::volatile_set_memory(self.pointer.as_mut_ptr(), value, self.pointer.len());
         }
@@ -831,7 +834,7 @@ impl<A> VolatilePtr<'_, [u8], A> {
 /// These methods are only available with the `unstable` feature enabled (requires a nightly
 /// Rust compiler).
 #[cfg(feature = "unstable")]
-impl<T, R, W, const N: usize> VolatilePtr<'_, [T; N], Access<R, W>> {
+impl<'a, T, R, W, const N: usize> VolatilePtr<'a, [T; N], Access<R, W>> {
     /// Converts an array reference to a shared slice.
     ///
     /// This makes it possible to use the methods defined on slices.
@@ -856,7 +859,7 @@ impl<T, R, W, const N: usize> VolatilePtr<'_, [T; N], Access<R, W>> {
     ///
     /// assert_eq!(dst, [1, 2]);
     /// ```
-    pub fn as_slice(&self) -> VolatilePtr<[T], Access<R, access::NoAccess>> {
+    pub fn as_slice(self) -> VolatilePtr<'a, [T], Access<R, access::NoAccess>> {
         unsafe {
             self.map(|array| {
                 NonNull::new(ptr::slice_from_raw_parts_mut(array.as_ptr() as *mut T, N)).unwrap()
@@ -920,21 +923,21 @@ impl<T, R, W> VolatilePtr<'_, T, Access<R, W>>
 where
     T: Copy + ?Sized,
 {
-    pub unsafe fn read_unsafe(&self) -> T
+    pub unsafe fn read_unsafe(self) -> T
     where
         R: access::Unsafe,
     {
         unsafe { ptr::read_volatile(self.pointer.as_ptr()) }
     }
 
-    pub unsafe fn write_unsafe(&mut self, value: T)
+    pub unsafe fn write_unsafe(self, value: T)
     where
         W: access::Unsafe,
     {
         unsafe { ptr::write_volatile(self.pointer.as_ptr(), value) };
     }
 
-    pub unsafe fn update_unsafe<F>(&mut self, f: F)
+    pub unsafe fn update_unsafe<F>(self, f: F)
     where
         R: access::Unsafe,
         W: access::Unsafe,
@@ -946,6 +949,17 @@ where
     }
 }
 
+impl<'a, T, A> Clone for VolatilePtr<'a, T, A>
+where
+    T: ?Sized,
+{
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'a, T, A> Copy for VolatilePtr<'a, T, A> where T: ?Sized {}
+
 impl<T, W> fmt::Debug for VolatilePtr<'_, T, Access<access::SafeAccess, W>>
 where
     T: Copy + fmt::Debug + ?Sized,