vec: rework part 2

crates/brk_vec/src/variants/raw.rs

@@ -11,7 +11,9 @@ use axum::Json;
 use memmap2::Mmap;
 use rayon::prelude::*;
 
-use crate::{AnyVec, Error, Result, StoredIndex, StoredType, UnsafeSlice, Value, Version};
+use crate::{
+    DynamicVec, Error, GenericVec, Result, StoredIndex, StoredType, UnsafeSlice, Value, Version,
+};
 
 #[derive(Debug)]
 pub struct RawVec<I, T> {
@@ -63,13 +65,16 @@ where
     }
 }
 
-impl<I, T> AnyVec<I, T> for RawVec<I, T>
+impl<I, T> DynamicVec for RawVec<I, T>
 where
     I: StoredIndex,
     T: StoredType,
 {
+    type I = I;
+    type T = T;
+
     #[inline]
-    fn get_(&mut self, index: usize) -> Result<Option<Value<T>>> {
+    fn get_(&self, index: usize) -> Result<Option<Value<T>>> {
         match self.index_to_pushed_index(index) {
             Ok(index) => {
                 if let Some(index) = index {
@@ -81,18 +86,42 @@ where
             Err(error) => return Err(error),
         }
 
-        let v = if let Some(guard) = self.guard.as_ref() {
-            Self::guard_to_value(guard, index)
-        } else {
-            Self::guard_to_value(&self.new_guard(), index)
-        };
+        let guard = self.guard.as_ref().unwrap();
+        let index = index * Self::SIZE_OF_T;
+        let slice = &guard[index..(index + Self::SIZE_OF_T)];
+
+        let v = Self::T::try_read_from_bytes(slice)?;
 
         Ok(Some(Value::Owned(v)))
     }
 
+    #[inline]
+    fn stored_len(&self) -> usize {
+        if let Some(guard) = self.guard() {
+            guard.len() / Self::SIZE_OF_T
+        } else {
+            self.new_guard().len() / Self::SIZE_OF_T
+        }
+    }
+
+    #[inline]
+    fn pushed(&self) -> &[T] {
+        self.pushed.as_slice()
+    }
+    #[inline]
+    fn mut_pushed(&mut self) -> &mut Vec<T> {
+        &mut self.pushed
+    }
+}
+
+impl<I, T> GenericVec<I, T> for RawVec<I, T>
+where
+    I: StoredIndex + Send + Sync,
+    T: StoredType + Send + Sync,
+{
     fn iter_from<F>(&mut self, index: I, mut f: F) -> Result<()>
     where
-        F: FnMut((I, T, &mut Self)) -> Result<()>,
+        F: FnMut((I, T, &mut dyn DynamicVec<I = Self::I, T = Self::T>)) -> Result<()>,
     {
         if !self.is_pushed_empty() {
             return Err(Error::UnsupportedUnflushedState);
@@ -107,7 +136,7 @@ where
             .enumerate()
             .try_for_each(|(i, chunk)| {
                 let v = T::try_read_from_bytes(chunk).unwrap();
-                f((I::from(i), v, self))
+                f((I::from(i), v, self as &mut dyn DynamicVec<I = I, T = T>))
             })?;
 
         Ok(())
@@ -168,8 +197,8 @@ where
             return Ok(Json(vec![]));
         }
 
-        let from = from.map_or(0, |i| Self::fix_i64(i, len, true)) * Self::SIZE_OF_T;
-        let to = to.map_or(len, |i| Self::fix_i64(i, len, false)) * Self::SIZE_OF_T;
+        let from = from.map_or(0, |i| Self::fix_i64(i, len, true));
+        let to = to.map_or(len, |i| Self::fix_i64(i, len, false));
 
         Ok(Json(
             guard[from * Self::SIZE_OF_T..to * Self::SIZE_OF_T]
@@ -193,15 +222,6 @@ where
         &mut self.guard
     }
 
-    #[inline]
-    fn pushed(&self) -> &[T] {
-        self.pushed.as_slice()
-    }
-    #[inline]
-    fn mut_pushed(&mut self) -> &mut Vec<T> {
-        &mut self.pushed
-    }
-
     #[inline]
     fn path(&self) -> &Path {
         self.pathbuf.as_path()
@@ -212,3 +232,21 @@ where
         self.version
     }
 }
+
+impl<I, T> Clone for RawVec<I, T>
+where
+    I: StoredIndex,
+    T: StoredType,
+{
+    fn clone(&self) -> Self {
+        Self {
+            version: self.version,
+            pathbuf: self.pathbuf.clone(),
+            // Consider  Arc<ArcSwap<Option<Mmap>>> for dataraces when reorg ?
+            mmap: self.mmap.clone(),
+            guard: None,
+            pushed: vec![],
+            phantom: PhantomData,
+        }
+    }
+}