computer: lazy part 1

crates/brk_vec/src/lib.rs

@@ -218,45 +218,30 @@ where
     Compressed(CompressedVecIterator<'a, I, T>),
 }
 
-impl<I, T> StoredVecIterator<'_, I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    #[inline]
-    pub fn unwrap_get_inner(&mut self, i: I) -> T {
-        self.get_(i.unwrap_to_usize()).unwrap().into_inner()
-    }
+// impl<I, T> StoredVecIterator<'_, I, T>
+// impl<'a, I, T> VecIterator<'a> for StoredVecIterator<'a, I, T>
+// where
+//     I: StoredIndex,
+//     T: StoredType,
+// {
+//     type I = I;
+//     type T = T;
 
-    #[inline]
-    pub fn get_inner(&mut self, i: I) -> Option<T> {
-        self.get_(i.unwrap_to_usize()).map(|v| v.into_inner())
-    }
+//     #[inline]
+//     fn mut_index(&mut self) -> &mut usize {
+//         match self {
+//             Self::Compressed(iter) => iter.mut_index(),
+//             Self::Raw(iter) => iter.mut_index(),
+//         }
+//     }
 
-    #[inline]
-    pub fn get(&mut self, i: I) -> Option<Value<'_, T>> {
-        self.get_(i.unwrap_to_usize())
-    }
-
-    #[inline]
-    pub fn get_(&mut self, i: usize) -> Option<Value<'_, T>> {
-        match self {
-            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);
-            }
-            Self::Raw(iter) => {
-                iter.set(i);
-            }
-        };
-    }
-}
+//     fn len(&self) -> usize {
+//         match self {
+//             Self::Compressed(i) => i.len(),
+//             Self::Raw(i) => i.len(),
+//         }
+//     }
+// }
 
 impl<'a, I, T> Iterator for StoredVecIterator<'a, I, T>
 where
@@ -270,23 +255,6 @@ 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/iterator.rs

@@ -0,0 +1,129 @@
+use crate::Value;
+
+use super::{StoredIndex, StoredType};
+
+// pub trait BaseVecIterator: Iterator {
+//     fn mut_index(&mut self) -> &mut usize;
+
+//     fn len(&self) -> usize;
+
+//     fn is_empty(&self) -> bool {
+//         self.len() == 0
+//     }
+
+//     #[inline]
+//     fn set_(&mut self, i: usize) -> &mut Self {
+//         *self.mut_index() = i;
+//         self
+//     }
+
+//     fn skip(self, _: usize) -> std::iter::Skip<Self>
+//     where
+//         Self: Sized,
+//     {
+//         todo!("")
+//     }
+// }
+
+pub trait VecIterator<'a>: Iterator<Item = (Self::I, Value<'a, Self::T>)> + 'a {
+    type I: StoredIndex;
+    type T: StoredType;
+
+    fn mut_index(&mut self) -> &mut usize;
+
+    fn len(&self) -> usize;
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    #[inline]
+    fn set_(&mut self, i: usize) -> &mut Self {
+        *self.mut_index() = i;
+        self
+    }
+
+    fn skip(self, _: usize) -> std::iter::Skip<Self>
+    where
+        Self: Sized,
+    {
+        todo!("")
+    }
+
+    //     fn set(&mut self, i: Self::I) -> &mut Self;
+
+    //     fn get_(&mut self, i: usize) -> Option<Value<'a, Self::T>>;
+
+    //     fn get(&mut self, i: Self::I) -> Option<Value<'a, Self::T>>;
+
+    //     fn unwrap_get_inner(&mut self, i: Self::I) -> Self::T;
+
+    //     fn get_inner(&mut self, i: Self::I) -> Option<Self::T>;
+
+    //     fn last(self) -> Option<Self::Item>;
+    // }
+
+    // impl<'a, I, T, Iter> VecIterator<'a, I, T> for Iter
+    // where
+    //     I: StoredIndex,
+    //     T: StoredType + 'a,
+    //     Iter: Iterator<Item = (I, Value<'a, T>)> + BaseVecIterator,
+    // {
+    #[inline]
+    fn set(&mut self, i: Self::I) -> &mut Self {
+        self.set_(i.unwrap_to_usize())
+    }
+
+    #[inline]
+    fn get_(&mut self, i: usize) -> Option<Value<'a, Self::T>> {
+        self.set_(i);
+        self.next().map(|(_, v)| v)
+    }
+
+    #[inline]
+    fn get(&mut self, i: Self::I) -> Option<Value<'a, Self::T>> {
+        self.get_(i.unwrap_to_usize())
+    }
+
+    #[inline]
+    fn unwrap_get_inner(&mut self, i: Self::I) -> Self::T {
+        self.get_(i.unwrap_to_usize()).unwrap().into_inner()
+    }
+
+    #[inline]
+    fn get_inner(&mut self, i: Self::I) -> Option<Self::T> {
+        self.get_(i.unwrap_to_usize()).map(|v| v.into_inner())
+    }
+
+    fn last(mut self) -> Option<Self::Item>
+    where
+        Self: Sized,
+    {
+        let len = self.len();
+        if len == 0 {
+            return None;
+        }
+        let i = len - 1;
+        self.set_(i);
+        self.next().map(|(i, v)| (i, Value::Owned(v.into_inner())))
+    }
+}
+
+impl<'a, I, T, Iter> VecIterator<'a> for Iter
+where
+    Iter: Iterator<Item = (I, Value<'a, T>)> + 'a,
+    I: StoredIndex,
+    T: StoredType + 'a,
+{
+    type I = I;
+    type T = T;
+
+    fn len(&self) -> usize {
+        todo!()
+    }
+
+    fn mut_index(&mut self) -> &mut usize {
+        todo!()
+    }
+}
+// pub trait VecIterator<'a>: Iterator<Item = (Self::I, Value<'a, Self::T>)> + 'a {

crates/brk_vec/src/traits/mod.rs

@@ -1,9 +1,11 @@
 mod dynamic;
 mod generic;
+mod iterator;
 mod stored_index;
 mod stored_type;
 
 pub use dynamic::*;
 pub use generic::*;
+pub use iterator::*;
 pub use stored_index::*;
 pub use stored_type::*;

crates/brk_vec/src/variants/compressed.rs

@@ -12,7 +12,7 @@ use zstd::DEFAULT_COMPRESSION_LEVEL;
 
 use crate::{
     CompressedPageMetadata, CompressedPagesMetadata, DynamicVec, Error, GenericVec, RawVec, Result,
-    StoredIndex, StoredType, UnsafeSlice, Value, Version,
+    StoredIndex, StoredType, UnsafeSlice, Value, VecIterator, Version,
 };
 
 const ONE_KIB: usize = 1024;
@@ -390,36 +390,34 @@ where
 {
     const SIZE_OF_T: usize = size_of::<T>();
     const PER_PAGE: usize = MAX_PAGE_SIZE / Self::SIZE_OF_T;
-
-    #[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<Value<'_, T>> {
-        self.set(i).next().map(|(_, v)| v)
-    }
-
-    #[inline]
-    pub fn get_(&mut self, i: usize) -> Option<Value<'_, T>> {
-        self.set_(i);
-        self.next().map(|(_, v)| v)
-    }
 }
 
+// impl<'a, I, T> VecIterator<'a> for CompressedVecIterator<'a, I, T>
+// where
+//     I: StoredIndex,
+//     T: StoredType,
+// {
+//     type I = I;
+//     type T = T;
+
+//     #[inline]
+//     fn mut_index(&mut self) -> &mut usize {
+//         &mut self.index
+//     }
+
+//     #[inline]
+//     fn len(&self) -> usize {
+//         self.vec.len()
+//     }
+// }
+
 impl<'a, I, T> Iterator for CompressedVecIterator<'a, I, T>
 where
     I: StoredIndex,
     T: StoredType,
 {
     type Item = (I, Value<'a, T>);
+
     fn next(&mut self) -> Option<Self::Item> {
         let mmap = &self.guard;
         let i = self.index;
@@ -460,20 +458,6 @@ where
 
         result
     }
-
-    #[inline]
-    fn last(mut self) -> Option<Self::Item>
-    where
-        Self: Sized,
-    {
-        let len = self.vec.len();
-        if len == 0 {
-            return None;
-        }
-        let i = len - 1;
-        self.get_(i)
-            .map(|v| (I::from(i), Value::Owned(v.into_inner())))
-    }
 }
 
 impl<'a, I, T> IntoIterator for &'a CompressedVec<I, T>

crates/brk_vec/src/variants/raw.rs

@@ -11,7 +11,8 @@ use memmap2::Mmap;
 use rayon::prelude::*;
 
 use crate::{
-    DynamicVec, Error, GenericVec, Result, StoredIndex, StoredType, UnsafeSlice, Value, Version,
+    DynamicVec, Error, GenericVec, Result, StoredIndex, StoredType, UnsafeSlice, Value,
+    VecIterator, Version,
 };
 
 #[derive(Debug)]
@@ -216,33 +217,24 @@ pub struct RawVecIterator<'a, I, T> {
     index: usize,
 }
 
-impl<I, T> RawVecIterator<'_, I, T>
-where
-    I: StoredIndex,
-    T: StoredType,
-{
-    #[inline]
-    pub fn set(&mut self, i: I) -> &mut Self {
-        self.index = i.unwrap_to_usize();
-        self
-    }
+// impl<'a, I, T> VecIterator<'a> for RawVecIterator<'a, I, T>
+// where
+//     I: StoredIndex,
+//     T: StoredType,
+// {
+//     type I = I;
+//     type T = T;
 
-    #[inline]
-    pub fn set_(&mut self, i: usize) {
-        self.index = i;
-    }
+//     #[inline]
+//     fn mut_index(&mut self) -> &mut usize {
+//         &mut self.index
+//     }
 
-    #[inline]
-    pub fn get(&mut self, i: I) -> Option<Value<'_, T>> {
-        self.set(i).next().map(|(_, v)| v)
-    }
-
-    #[inline]
-    pub fn get_(&mut self, i: usize) -> Option<Value<'_, T>> {
-        self.set_(i);
-        self.next().map(|(_, v)| v)
-    }
-}
+//     #[inline]
+//     fn len(&self) -> usize {
+//         self.vec.len()
+//     }
+// }
 
 impl<'a, I, T> Iterator for RawVecIterator<'a, I, T>
 where
@@ -250,6 +242,7 @@ where
     T: StoredType,
 {
     type Item = (I, Value<'a, T>);
+
     fn next(&mut self) -> Option<Self::Item> {
         let mmap = &self.guard;
         let index = self.index;
@@ -266,19 +259,6 @@ where
 
         opt
     }
-
-    fn last(mut self) -> Option<Self::Item>
-    where
-        Self: Sized,
-    {
-        let len = self.vec.len();
-        if len == 0 {
-            return None;
-        }
-        let i = len - 1;
-        self.get_(i)
-            .map(|v| (I::from(i), Value::Owned(v.into_inner())))
-    }
 }
 
 impl<'a, I, T> IntoIterator for &'a RawVec<I, T>