vec: rework part 2

crates/brk_vec/src/lib.rs

@@ -8,18 +8,25 @@ mod structs;
 mod traits;
 mod variants;
 
-use std::{path::Path, sync::Arc};
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 use arc_swap::{ArcSwap, Guard};
-use axum::Json;
+use axum::{Json, response::Response};
 pub use enums::*;
 use memmap2::Mmap;
 pub use structs::*;
 pub use traits::*;
-pub use variants::*;
+use variants::*;
 
-#[derive(Debug)]
-pub enum StoredVec<I, T> {
+#[derive(Debug, Clone)]
+pub enum StoredVec<I, T>
+where
+    I: StoredIndex,
+    T: StoredType,
+{
     Raw(RawVec<I, T>),
     Compressed(CompressedVec<I, T>),
 }
@@ -38,30 +45,68 @@ where
             Ok(Self::Raw(RawVec::forced_import(path, version)?))
         }
     }
+
+    pub fn enable_large_cache_if_needed(&mut self) {
+        match self {
+            StoredVec::Compressed(v) => v.enable_large_cache(),
+            Self::Raw(_) => {}
+        }
+    }
 }
 
-impl<I, T> AnyVec<I, T> for StoredVec<I, T>
+impl<I, T> DynamicVec for StoredVec<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 {
             StoredVec::Raw(v) => v.get_(index),
             StoredVec::Compressed(v) => v.get_(index),
         }
     }
 
-    fn iter_from<F>(&mut self, index: I, mut f: F) -> Result<()>
+    #[inline]
+    fn stored_len(&self) -> usize {
+        match self {
+            StoredVec::Raw(v) => v.stored_len(),
+            StoredVec::Compressed(v) => v.stored_len(),
+        }
+    }
+
+    #[inline]
+    fn pushed(&self) -> &[T] {
+        match self {
+            StoredVec::Raw(v) => v.pushed(),
+            StoredVec::Compressed(v) => v.pushed(),
+        }
+    }
+    #[inline]
+    fn mut_pushed(&mut self) -> &mut Vec<T> {
+        match self {
+            StoredVec::Raw(v) => v.mut_pushed(),
+            StoredVec::Compressed(v) => v.mut_pushed(),
+        }
+    }
+}
+
+impl<I, T> GenericVec<I, T> for StoredVec<I, T>
+where
+    I: StoredIndex + Send + Sync,
+    T: StoredType + Send + Sync,
+{
+    fn iter_from<F>(&mut self, index: I, f: F) -> Result<()>
     where
-        F: FnMut((I, T, &mut Self)) -> Result<()>,
+        F: FnMut((I, T, &mut dyn DynamicVec<I = I, T = T>)) -> Result<()>,
     {
-        todo!();
-        // match self {
-        //     StoredVec::Raw(v) => v.iter_from(index, |(i, t, inner)| f((i, t, self))),
-        //     StoredVec::Compressed(v) => v.iter_from(index, |(i, t, inner)| f((i, t, self))),
-        // }
+        match self {
+            StoredVec::Raw(v) => v.iter_from(index, f),
+            StoredVec::Compressed(v) => v.iter_from(index, f),
+        }
     }
 
     fn collect_range(&self, from: Option<i64>, to: Option<i64>) -> Result<Json<Vec<T>>> {
@@ -108,21 +153,6 @@ where
         }
     }
 
-    #[inline]
-    fn pushed(&self) -> &[T] {
-        match self {
-            StoredVec::Raw(v) => v.pushed(),
-            StoredVec::Compressed(v) => v.pushed(),
-        }
-    }
-    #[inline]
-    fn mut_pushed(&mut self) -> &mut Vec<T> {
-        match self {
-            StoredVec::Raw(v) => v.mut_pushed(),
-            StoredVec::Compressed(v) => v.mut_pushed(),
-        }
-    }
-
     #[inline]
     fn path(&self) -> &Path {
         match self {
@@ -139,3 +169,51 @@ where
         }
     }
 }
+
+pub trait AnyStoredVec: Send + Sync {
+    fn file_name(&self) -> String;
+    fn index_type_to_string(&self) -> &str;
+    fn len(&self) -> usize;
+    fn is_empty(&self) -> bool;
+    fn flush(&mut self) -> Result<()>;
+    fn collect_range_response(&self, from: Option<i64>, to: Option<i64>) -> Result<Response>;
+    fn path_vec(&self) -> PathBuf;
+}
+
+impl<I, T> AnyStoredVec for StoredVec<I, T>
+where
+    I: StoredIndex,
+    T: StoredType,
+{
+    #[inline]
+    fn len(&self) -> usize {
+        DynamicVec::len(self)
+    }
+
+    #[inline]
+    fn is_empty(&self) -> bool {
+        DynamicVec::is_empty(self)
+    }
+
+    #[inline]
+    fn index_type_to_string(&self) -> &str {
+        GenericVec::index_type_to_string(self)
+    }
+
+    fn flush(&mut self) -> Result<()> {
+        GenericVec::flush(self)
+    }
+
+    fn collect_range_response(&self, from: Option<i64>, to: Option<i64>) -> Result<Response> {
+        GenericVec::collect_range_response(self, from, to)
+    }
+
+    #[inline]
+    fn path_vec(&self) -> PathBuf {
+        GenericVec::path_vec(self)
+    }
+
+    fn file_name(&self) -> String {
+        GenericVec::file_name(self)
+    }
+}