global: vec iter part 2

crates/brk_vec/src/lib.rs

@@ -56,6 +56,12 @@ where
     pub fn iter(&self) -> StoredVecIterator<'_, I, T> {
         self.into_iter()
     }
+
+    pub fn iter_at(&self, i: I) -> StoredVecIterator<'_, I, T> {
+        let mut iter = self.into_iter();
+        iter.set(i);
+        iter
+    }
 }
 
 impl<I, T> DynamicVec for StoredVec<I, T>
@@ -73,13 +79,6 @@ where
             StoredVec::Compressed(v) => v.get_stored_(index, guard),
         }
     }
-    #[inline]
-    fn cached_get_stored_(&mut self, index: usize, guard: &Mmap) -> Result<Option<T>> {
-        match self {
-            StoredVec::Raw(v) => v.cached_get_stored_(index, guard),
-            StoredVec::Compressed(v) => v.cached_get_stored_(index, guard),
-        }
-    }
 
     #[inline]
     fn mmap(&self) -> &ArcSwap<Mmap> {
@@ -244,7 +243,7 @@ where
     Compressed(CompressedVecIterator<'a, I, T>),
 }
 
-impl<'a, I, T> StoredVecIterator<'a, I, T>
+impl<I, T> StoredVecIterator<'_, I, T>
 where
     I: StoredIndex,
     T: StoredType,
@@ -255,33 +254,32 @@ where
     }
 
     #[inline]
-    pub fn get(&mut self, i: I) -> Option<(I, Value<'a, T>)> {
+    pub fn get_inner(&mut self, i: I) -> Option<T> {
+        self.get_(i.unwrap_to_usize()).map(|(_, v)| v.into_inner())
+    }
+
+    #[inline]
+    pub fn get(&mut self, i: I) -> Option<(I, Value<'_, T>)> {
         self.get_(i.unwrap_to_usize())
     }
 
     #[inline]
-    pub fn get_(&mut self, i: usize) -> Option<(I, Value<'a, T>)> {
+    pub fn get_(&mut self, i: usize) -> Option<(I, Value<'_, T>)> {
         match self {
-            Self::Compressed(iter) => {
-                iter.set(i);
-                iter.next()
-            }
-            Self::Raw(iter) => {
-                iter.set(i);
-                iter.next()
-            }
+            Self::Compressed(iter) => iter.get_(i),
+            Self::Raw(iter) => iter.get_(i),
         }
     }
 
     pub fn set(&mut self, i: I) {
         match self {
             Self::Compressed(iter) => {
-                iter.set(i.unwrap_to_usize());
+                iter.set(i);
             }
             Self::Raw(iter) => {
-                iter.set(i.unwrap_to_usize());
+                iter.set(i);
             }
-        }
+        };
     }
 }
 
@@ -297,6 +295,23 @@ where
             Self::Raw(i) => i.next(),
         }
     }
+
+    fn last(self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        match self {
+            Self::Compressed(i) => i.last(),
+            Self::Raw(i) => i.last(),
+        }
+    }
+
+    fn skip(self, _: usize) -> std::iter::Skip<Self>
+    where
+        Self: Sized,
+    {
+        todo!("")
+    }
 }
 
 impl<'a, I, T> IntoIterator for &'a StoredVec<I, T>

crates/brk_vec/src/traits/dynamic.rs

@@ -16,18 +16,6 @@ pub trait DynamicVec: Send + Sync {
         self.get_(index.to_usize()?)
     }
     #[inline]
-    fn cached_get(&mut self, index: Self::I) -> Result<Option<Value<Self::T>>> {
-        self.cached_get_(index.to_usize()?)
-    }
-    #[inline]
-    fn unwrap_cached_get(&mut self, index: Self::I) -> Option<Self::T> {
-        self.cached_get(index).unwrap().map(Value::into_inner)
-    }
-    #[inline]
-    fn double_unwrap_cached_get(&mut self, index: Self::I) -> Self::T {
-        self.unwrap_cached_get(index).unwrap()
-    }
-    #[inline]
     fn get_(&self, index: usize) -> Result<Option<Value<Self::T>>> {
         match self.index_to_pushed_index(index) {
             Ok(index) => {
@@ -45,40 +33,13 @@ pub trait DynamicVec: Send + Sync {
             .map(Value::Owned))
     }
     fn get_stored_(&self, index: usize, mmap: &Mmap) -> Result<Option<Self::T>>;
-    fn last(&self) -> Result<Option<Value<Self::T>>> {
-        let len = self.len();
-        if len == 0 {
-            return Ok(None);
-        }
-        self.get_(len - 1)
-    }
-    #[inline]
-    fn cached_get_(&mut self, index: usize) -> Result<Option<Value<Self::T>>> {
-        match self.index_to_pushed_index(index) {
-            Ok(index) => {
-                if let Some(index) = index {
-                    return Ok(self.pushed().get(index).map(Value::Ref));
-                }
-            }
-            Err(Error::IndexTooHigh) => return Ok(None),
-            Err(Error::IndexTooLow) => {}
-            Err(error) => return Err(error),
-        }
-
-        let mmap = Arc::clone(self.guard().as_ref().unwrap());
-
-        Ok(self
-            .cached_get_stored_(index.to_usize()?, &mmap)?
-            .map(Value::Owned))
-    }
-    fn cached_get_stored_(&mut self, index: usize, mmap: &Mmap) -> Result<Option<Self::T>>;
-    fn cached_get_last(&mut self) -> Result<Option<Value<Self::T>>> {
-        let len = self.len();
-        if len == 0 {
-            return Ok(None);
-        }
-        self.cached_get_(len - 1)
-    }
+    // fn last(&self) -> Result<Option<Value<Self::T>>> {
+    //     let len = self.len();
+    //     if len == 0 {
+    //         return Ok(None);
+    //     }
+    //     self.get_(len - 1)
+    // }
 
     #[inline]
     fn len(&self) -> usize {

crates/brk_vec/src/traits/stored_index.rs

@@ -21,6 +21,7 @@ where
     fn unwrap_to_usize(self) -> usize;
     fn to_usize(self) -> Result<usize>;
     fn to_string<'a>() -> &'a str;
+    fn decremented(self) -> Option<Self>;
 }
 impl<I> StoredIndex for I
 where
@@ -52,4 +53,9 @@ where
     fn to_string<'a>() -> &'a str {
         std::any::type_name::<I>()
     }
+
+    #[inline]
+    fn decremented(self) -> Option<Self> {
+        self.unwrap_to_usize().checked_sub(1).map(Self::from)
+    }
 }

crates/brk_vec/src/variants/compressed.rs

@@ -23,12 +23,8 @@ pub const MAX_PAGE_SIZE: usize = 16 * ONE_KIB;
 #[derive(Debug)]
 pub struct CompressedVec<I, T> {
     inner: RawVec<I, T>,
-    decoded_page: Option<(usize, Vec<T>)>,
     decoded_pages: Option<Vec<OnceLock<Vec<T>>>>,
     pages_meta: Arc<ArcSwap<CompressedPagesMetadata>>,
-    // pages: Option<Vec<OnceLock<Values<T>>>>,
-    // page: Option<(usize, Values<T>)>,
-    // length: Length
 }
 
 impl<I, T> CompressedVec<I, T>
@@ -71,7 +67,6 @@ where
 
         Ok(Self {
             inner: RawVec::import(path, version)?,
-            decoded_page: None,
             decoded_pages: None,
             pages_meta: Arc::new(ArcSwap::new(Arc::new(CompressedPagesMetadata::read(path)?))),
         })
@@ -175,12 +170,7 @@ where
         self.decoded_pages.as_ref().map_or(0, |v| v.len())
     }
 
-    fn reset_small_cache(&mut self) {
-        self.decoded_page.take();
-    }
-
     fn reset_caches(&mut self) {
-        self.reset_small_cache();
         self.reset_large_cache();
     }
 
@@ -202,9 +192,22 @@ where
         }
     }
 
+    #[inline]
     pub fn iter(&self) -> CompressedVecIterator<'_, I, T> {
         self.into_iter()
     }
+
+    #[inline]
+    pub fn iter_at(&self, i: I) -> CompressedVecIterator<'_, I, T> {
+        self.iter_at_(i.unwrap_to_usize())
+    }
+
+    #[inline]
+    pub fn iter_at_(&self, i: usize) -> CompressedVecIterator<'_, I, T> {
+        let mut iter = self.into_iter();
+        iter.set_(i);
+        iter
+    }
 }
 
 impl<I, T> DynamicVec for CompressedVec<I, T>
@@ -248,16 +251,6 @@ where
             .get(decoded_index)
             .cloned())
     }
-    #[inline]
-    fn cached_get_stored_(&mut self, index: usize, mmap: &Mmap) -> Result<Option<T>> {
-        Self::cached_get_stored__(
-            index,
-            mmap,
-            self.stored_len(),
-            &mut self.decoded_page,
-            &self.pages_meta.load(),
-        )
-    }
 
     #[inline]
     fn mmap(&self) -> &ArcSwap<Mmap> {
@@ -307,8 +300,7 @@ where
         }
 
         Ok(self
-            .into_iter()
-            .skip(from)
+            .iter_at_(from)
             .take(to - from)
             .map(|(_, v)| v.into_inner())
             .collect::<Vec<_>>())
@@ -342,12 +334,6 @@ where
                 .and_then(|v| v.last_mut().and_then(|lock| lock.take()))
             {
                 values
-            } else if self
-                .decoded_page
-                .as_ref()
-                .is_some_and(|(page_index, _)| *page_index == last_page_index)
-            {
-                self.decoded_page.take().unwrap().1
             } else {
                 Self::decode_page_(
                     stored_len,
@@ -485,7 +471,6 @@ where
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
-            decoded_page: None,
             decoded_pages: None,
             pages_meta: self.pages_meta.clone(),
         }
@@ -503,9 +488,31 @@ pub struct CompressedVecIterator<'a, I, T> {
     index: usize,
 }
 
-impl<I, T> CompressedVecIterator<'_, I, T> {
-    pub fn set(&mut self, i: usize) {
-        self.index = i
+impl<I, T> CompressedVecIterator<'_, I, T>
+where
+    I: StoredIndex,
+    T: StoredType,
+{
+    #[inline]
+    pub fn set(&mut self, i: I) -> &mut Self {
+        self.index = i.unwrap_to_usize();
+        self
+    }
+
+    #[inline]
+    pub fn set_(&mut self, i: usize) {
+        self.index = i;
+    }
+
+    #[inline]
+    pub fn get(&mut self, i: I) -> Option<(I, Value<'_, T>)> {
+        self.set(i).next()
+    }
+
+    #[inline]
+    pub fn get_(&mut self, i: usize) -> Option<(I, Value<'_, T>)> {
+        self.set_(i);
+        self.next()
     }
 }
 

crates/brk_vec/src/variants/raw.rs

@@ -63,9 +63,22 @@ where
         })
     }
 
+    #[inline]
     pub fn iter(&self) -> RawVecIterator<'_, I, T> {
         self.into_iter()
     }
+
+    #[inline]
+    pub fn iter_at(&self, i: I) -> RawVecIterator<'_, I, T> {
+        self.iter_at_(i.unwrap_to_usize())
+    }
+
+    #[inline]
+    pub fn iter_at_(&self, i: usize) -> RawVecIterator<'_, I, T> {
+        let mut iter = self.into_iter();
+        iter.set_(i);
+        iter
+    }
 }
 
 impl<I, T> DynamicVec for RawVec<I, T>
@@ -84,10 +97,6 @@ where
             .map(|v| Some(v))
             .map_err(Error::from)
     }
-    #[inline]
-    fn cached_get_stored_(&mut self, index: usize, mmap: &Mmap) -> Result<Option<T>> {
-        self.get_stored_(index, mmap)
-    }
 
     #[inline]
     fn mmap(&self) -> &ArcSwap<Mmap> {
@@ -142,8 +151,7 @@ where
         }
 
         Ok(self
-            .into_iter()
-            .skip(from)
+            .iter_at_(from)
             .take(to - from)
             .map(|(_, v)| v.into_inner())
             .collect::<Vec<_>>())
@@ -226,11 +234,33 @@ pub struct RawVecIterator<'a, I, T> {
     index: usize,
 }
 
-impl<I, T> RawVecIterator<'_, I, T> {
+impl<I, T> RawVecIterator<'_, I, T>
+where
+    I: StoredIndex,
+    T: StoredType,
+{
     const SIZE_OF_T: usize = size_of::<T>();
 
-    pub fn set(&mut self, i: usize) {
-        self.index = i
+    #[inline]
+    pub fn set(&mut self, i: I) -> &mut Self {
+        self.index = i.unwrap_to_usize();
+        self
+    }
+
+    #[inline]
+    pub fn set_(&mut self, i: usize) {
+        self.index = i;
+    }
+
+    #[inline]
+    pub fn get(&mut self, i: I) -> Option<(I, Value<'_, T>)> {
+        self.set(i).next()
+    }
+
+    #[inline]
+    pub fn get_(&mut self, i: usize) -> Option<(I, Value<'_, T>)> {
+        self.set_(i);
+        self.next()
     }
 }
 
@@ -262,6 +292,18 @@ where
         self.index += 1;
         result
     }
+
+    fn last(mut self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        let len = self.vec.len();
+        if len == 0 {
+            return None;
+        }
+        self.get_(len - 1)
+            .map(|(i, v)| (i, Value::Owned(v.into_inner())))
+    }
 }
 
 impl<'a, I, T> IntoIterator for &'a RawVec<I, T>