Add as_slice/as_mut_slice methods for volatile array references

Author: phil-opp

src/lib.rs

@@ -9,6 +9,8 @@
 
 #![no_std]
 #![cfg_attr(feature = "nightly", feature(core_intrinsics))]
+#![cfg_attr(feature = "nightly", feature(const_generics))]
+#![cfg_attr(feature = "nightly", allow(incomplete_features))]
 
 use access::{ReadOnly, ReadWrite, Readable, Writable, WriteOnly};
 #[cfg(feature = "nightly")]
@@ -293,6 +295,77 @@ where
     }
 }
 
+/// Methods for converting arrays to slices
+///
+/// These methods are only available with the `nightly` feature enabled (requires a nightly
+/// Rust compiler).
+#[cfg(feature = "nightly")]
+impl<R, A, T, const N: usize> Volatile<R, A>
+where
+    R: Deref<Target = [T; N]>,
+{
+    /// Converts an array reference to a shared slice.
+    ///
+    /// This makes it possible to use the methods defined on slices.
+    ///
+    /// ## Example
+    ///
+    /// Copying two elements from a volatile array reference using `copy_into_slice`:
+    ///
+    /// ```
+    /// use volatile::Volatile;
+    ///
+    /// let src = [1, 2];
+    /// let volatile = Volatile::new(&src);
+    /// let mut dst = [0, 0];
+    ///
+    /// // convert the `Volatile<&[i32; 2]>` array reference to a `Volatile<&[i32]>` slice
+    /// let volatile_slice = volatile.as_slice();
+    /// // we can now use the slice methods
+    /// volatile_slice.copy_into_slice(&mut dst);
+    ///
+    /// assert_eq!(dst, [1, 2]);
+    /// ```
+    pub fn as_slice(&self) -> Volatile<&[T], A> {
+        Volatile {
+            reference: &*self.reference,
+            access: self.access,
+        }
+    }
+
+    /// Converts a mutable array reference to a mutable slice.
+    ///
+    /// This makes it possible to use the methods defined on slices.
+    ///
+    /// ## Example
+    ///
+    /// Copying two elements from a slice into a mutable array reference:
+    ///
+    /// ```
+    /// use volatile::Volatile;
+    ///
+    /// let src = [1, 2, 3, 4];
+    /// let mut dst = [0, 0];
+    /// let mut volatile = Volatile::new(&mut dst);
+    ///
+    /// // convert the `Volatile<&mut [i32; 2]>` array reference to a `Volatile<&mut [i32]>` slice
+    /// let mut volatile_slice = volatile.as_mut_slice();
+    /// // we can now use the slice methods
+    /// volatile_slice.copy_from_slice(&src[2..]);
+    ///
+    /// assert_eq!(dst, [3, 4]);
+    /// ```
+    pub fn as_mut_slice(&mut self) -> Volatile<&mut [T], A>
+    where
+        R: DerefMut,
+    {
+        Volatile {
+            reference: &mut *self.reference,
+            access: self.access,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::Volatile;