vec: rework part 4

crates/brk_vec/src/traits/generic.rs

@@ -5,7 +5,6 @@ use std::{
     sync::Arc,
 };
 
-use arc_swap::{ArcSwap, Guard};
 use axum::{
     Json,
     response::{IntoResponse, Response},
@@ -38,9 +37,13 @@ where
 
     fn file_set_len(&mut self, len: u64) -> Result<()> {
         let mut file = self.open_file()?;
+        Self::file_set_len_(&mut file, len)?;
+        self.update_mmap(file)
+    }
+    fn file_set_len_(file: &mut File, len: u64) -> Result<()> {
         file.set_len(len)?;
         file.seek(SeekFrom::End(0))?;
-        self.update_mmap(file)
+        Ok(())
     }
 
     fn file_write_all(&mut self, buf: &[u8]) -> Result<()> {
@@ -49,34 +52,31 @@ where
         self.update_mmap(file)
     }
 
+    fn file_truncate_and_write_all(&mut self, len: u64, buf: &[u8]) -> Result<()> {
+        let mut file = self.open_file()?;
+        Self::file_set_len_(&mut file, len)?;
+        file.write_all(buf)?;
+        self.update_mmap(file)
+    }
+
     #[inline]
     fn reset(&mut self) -> Result<()> {
         self.file_write_all(&[])?;
         Ok(())
     }
 
-    fn mmap(&self) -> &ArcSwap<Mmap>;
-
-    #[inline]
-    fn new_guard(&self) -> Guard<Arc<Mmap>> {
-        self.mmap().load()
-    }
-    fn guard(&self) -> &Option<Guard<Arc<Mmap>>>;
-    fn mut_guard(&mut self) -> &mut Option<Guard<Arc<Mmap>>>;
-
     fn new_mmap(file: File) -> Result<Arc<Mmap>> {
         Ok(Arc::new(unsafe { Mmap::map(&file)? }))
     }
 
     fn update_mmap(&mut self, file: File) -> Result<()> {
-        file.sync_all()?;
         let mmap = Self::new_mmap(file)?;
         self.mmap().store(mmap);
         if self.guard().is_some() {
             let guard = self.new_guard();
             self.mut_guard().replace(guard);
         } else {
-            unreachable!()
+            unreachable!("This function shouldn't be called in a cloned instance")
         }
         Ok(())
     }
@@ -86,22 +86,6 @@ where
         self.pushed_len() == 0
     }
 
-    #[inline]
-    fn index_to_pushed_index(&self, index: usize) -> Result<Option<usize>> {
-        let stored_len = self.stored_len();
-
-        if index >= stored_len {
-            let index = index - stored_len;
-            if index >= self.pushed_len() {
-                Err(Error::IndexTooHigh)
-            } else {
-                Ok(Some(index))
-            }
-        } else {
-            Err(Error::IndexTooLow)
-        }
-    }
-
     #[inline]
     fn has(&self, index: Self::I) -> Result<bool> {
         Ok(self.has_(index.to_usize()?))
@@ -140,27 +124,33 @@ where
             ),
         ) -> Result<()>;
 
-    fn fix_i64(i: i64, len: usize, from: bool) -> usize {
+    fn flush(&mut self) -> Result<()>;
+
+    fn truncate_if_needed(&mut self, index: Self::I) -> Result<()>;
+
+    fn collect_range(&self, from: Option<usize>, to: Option<usize>) -> Result<Vec<Self::T>>;
+
+    #[inline]
+    fn collect_inclusive_range(&self, from: I, to: I) -> Result<Vec<Self::T>> {
+        self.collect_range(Some(from.to_usize()?), Some(to.to_usize()? + 1))
+    }
+
+    #[inline]
+    fn i64_to_usize(i: i64, len: usize) -> usize {
         if i >= 0 {
-            let v = i as usize;
-            if v < len {
-                v
-            } else if from {
-                len - 1
-            } else {
-                len
-            }
+            i as usize
         } else {
             let v = len as i64 + i;
             if v < 0 { 0 } else { v as usize }
         }
     }
 
-    fn flush(&mut self) -> Result<()>;
-
-    fn truncate_if_needed(&mut self, index: Self::I) -> Result<()>;
-
-    fn collect_range(&self, from: Option<i64>, to: Option<i64>) -> Result<Vec<Self::T>>;
+    fn collect_signed_range(&self, from: Option<i64>, to: Option<i64>) -> Result<Vec<Self::T>> {
+        let len = self.len();
+        let from = from.map(|i| Self::i64_to_usize(i, len));
+        let to = to.map(|i| Self::i64_to_usize(i, len));
+        self.collect_range(from, to)
+    }
 
     #[inline]
     fn collect_range_axum_json(
@@ -168,12 +158,12 @@ where
         from: Option<i64>,
         to: Option<i64>,
     ) -> Result<Json<Vec<Self::T>>> {
-        Ok(Json(self.collect_range(from, to)?))
+        Ok(Json(self.collect_signed_range(from, to)?))
     }
 
     #[inline]
     fn collect_range_serde_json(&self, from: Option<i64>, to: Option<i64>) -> Result<Vec<Value>> {
-        self.collect_range(from, to)?
+        self.collect_signed_range(from, to)?
             .into_iter()
             .map(|v| serde_json::to_value(v).map_err(Error::from))
             .collect::<Result<Vec<_>>>()
@@ -200,6 +190,11 @@ where
         path.join("version")
     }
 
+    #[inline]
+    fn path_compressed_(path: &Path) -> PathBuf {
+        path.join("compressed")
+    }
+
     #[inline]
     fn file_name(&self) -> String {
         self.path()