bitmap: add BaseSlice

The `BaseSlice` abstraction represents slices into `B: Bitmap` objects
that wrap an inner generic smart pointer to `B`. This allows us to
reuse the same slice logic for references, `Arc` objects, and others.
As a result, `RefSlice` is now just a type alias for a `BaseSlice` with
a particular type parameter.

Signed-off-by: Alexandru Agache <[email protected]>

Author: alexandruag

src/bitmap/backend/mod.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0 OR BSD-3-Clause
 
 mod atomic_bitmap;
-mod ref_slice;
+mod slice;
 
 pub use atomic_bitmap::AtomicBitmap;
-pub use ref_slice::RefSlice;
+pub use slice::RefSlice;

src/bitmap/backend/ref_slice.rs renamed to src/bitmap/backend/slice.rs

@@ -4,32 +4,47 @@
 //! Contains a generic implementation of `BitmapSlice`.
 
 use std::fmt::{self, Debug};
+use std::ops::Deref;
 
 use crate::bitmap::{Bitmap, BitmapSlice, WithBitmapSlice};
 
 /// Represents a slice into a `Bitmap` object, starting at `base_offset`.
-pub struct RefSlice<'a, B> {
-    inner: &'a B,
+#[derive(Clone, Copy)]
+pub struct BaseSlice<B> {
+    inner: B,
     base_offset: usize,
 }
 
-impl<'a, B: Bitmap + 'a> RefSlice<'a, B> {
+impl<B> BaseSlice<B> {
     /// Create a new `BitmapSlice`, starting at the specified `offset`.
-    pub fn new(bitmap: &'a B, offset: usize) -> Self {
-        RefSlice {
-            inner: bitmap,
+    pub fn new(inner: B, offset: usize) -> Self {
+        BaseSlice {
+            inner,
             base_offset: offset,
         }
     }
 }
 
-impl<'a, B: Bitmap> WithBitmapSlice<'a> for RefSlice<'_, B> {
+impl<'a, B> WithBitmapSlice<'a> for BaseSlice<B>
+where
+    B: Copy + Deref,
+    B::Target: Bitmap,
+{
     type S = Self;
 }
 
-impl<B: Bitmap> BitmapSlice for RefSlice<'_, B> {}
+impl<B> BitmapSlice for BaseSlice<B>
+where
+    B: Copy + Deref,
+    B::Target: Bitmap,
+{
+}
 
-impl<'a, B: Bitmap> Bitmap for RefSlice<'a, B> {
+impl<B> Bitmap for BaseSlice<B>
+where
+    B: Copy + Deref,
+    B::Target: Bitmap,
+{
     /// Mark the memory range specified by the given `offset` (relative to the base offset of
     /// the slice) and `len` as dirtied.
     fn mark_dirty(&self, offset: usize, len: usize) {
@@ -48,31 +63,32 @@ impl<'a, B: Bitmap> Bitmap for RefSlice<'a, B> {
 
     /// Create a new `BitmapSlice` starting from the specified `offset` into the current slice.
     fn slice_at(&self, offset: usize) -> Self {
-        RefSlice {
-            inner: self.inner,
+        BaseSlice {
+            inner: self.inner.clone(),
             base_offset: self.base_offset.wrapping_add(offset),
         }
     }
 }
 
-impl<'a, B> Clone for RefSlice<'a, B> {
-    fn clone(&self) -> Self {
-        RefSlice {
-            inner: self.inner,
-            base_offset: self.base_offset,
-        }
-    }
-}
-
-impl<'a, B> Copy for RefSlice<'a, B> {}
-
-impl<'a, B> Debug for RefSlice<'a, B> {
+impl<B> Debug for BaseSlice<B> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Dummy impl for now.
         write!(f, "(bitmap slice)")
     }
 }
 
+impl<B: Default> Default for BaseSlice<B> {
+    fn default() -> Self {
+        BaseSlice {
+            inner: B::default(),
+            base_offset: 0,
+        }
+    }
+}
+
+/// A `BitmapSlice` implementation that wraps a reference to a `Bitmap` object.
+pub type RefSlice<'a, B> = BaseSlice<&'a B>;
+
 #[cfg(test)]
 mod tests {
     use super::*;