global: snapshot

crates/brk_computer/src/grouped/builder_eager.rs

@@ -2,7 +2,7 @@ use brk_error::{Error, Result};
 use brk_traversable::Traversable;
 use brk_types::{CheckedSub, StoredU64, Version};
 use vecdb::{
-    AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format, GenericStoredVec,
+    AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format, GenericStoredVec, IterableVec,
     StoredIndex, StoredRaw,
 };
 
@@ -204,7 +204,7 @@ where
     pub fn extend(
         &mut self,
         max_from: I,
-        source: &impl AnyIterableVec<I, T>,
+        source: &impl IterableVec<I, T>,
         exit: &Exit,
     ) -> Result<()> {
         if self.cumulative.is_none() {
@@ -238,9 +238,9 @@ where
     pub fn compute<I2>(
         &mut self,
         max_from: I,
-        source: &impl AnyIterableVec<I2, T>,
-        first_indexes: &impl AnyIterableVec<I, I2>,
-        count_indexes: &impl AnyIterableVec<I, StoredU64>,
+        source: &impl IterableVec<I2, T>,
+        first_indexes: &impl IterableVec<I, I2>,
+        count_indexes: &impl IterableVec<I, StoredU64>,
         exit: &Exit,
     ) -> Result<()>
     where
@@ -398,8 +398,8 @@ where
         &mut self,
         max_from: I,
         source: &EagerVecsBuilder<I2, T>,
-        first_indexes: &impl AnyIterableVec<I, I2>,
-        count_indexes: &impl AnyIterableVec<I, StoredU64>,
+        first_indexes: &impl IterableVec<I, I2>,
+        count_indexes: &impl IterableVec<I, StoredU64>,
         exit: &Exit,
     ) -> Result<()>
     where

crates/brk_computer/src/grouped/builder_lazy.rs

@@ -1,8 +1,6 @@
 use brk_traversable::Traversable;
 use brk_types::Version;
-use vecdb::{
-    AnyBoxedIterableVec, AnyCloneableIterableVec, FromCoarserIndex, LazyVecFrom2, StoredIndex,
-};
+use vecdb::{FromCoarserIndex, IterableBoxedVec, IterableCloneableVec, LazyVecFrom2, StoredIndex};
 
 use crate::grouped::{EagerVecsBuilder, VecBuilderOptions};
 
@@ -39,9 +37,9 @@ where
     pub fn forced_import(
         name: &str,
         version: Version,
-        source: Option<AnyBoxedIterableVec<S1I, T>>,
+        source: Option<IterableBoxedVec<S1I, T>>,
         source_extra: &EagerVecsBuilder<S1I, T>,
-        len_source: AnyBoxedIterableVec<I, S2T>,
+        len_source: IterableBoxedVec<I, S2T>,
         options: LazyVecBuilderOptions,
     ) -> Self {
         let only_one_active = options.is_only_one_active();

crates/brk_computer/src/grouped/from_dateindex.rs

@@ -4,7 +4,7 @@ use brk_traversable::Traversable;
 use brk_types::{
     DateIndex, DecadeIndex, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex,
 };
-use vecdb::{AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit};
+use vecdb::{AnyCollectableVec, Database, EagerVec, Exit, IterableCloneableVec, IterableVec};
 
 use crate::{Indexes, grouped::LazyVecsBuilder, indexes};
 
@@ -128,7 +128,7 @@ where
         &mut self,
         starting_indexes: &Indexes,
         exit: &Exit,
-        dateindex: Option<&impl AnyIterableVec<DateIndex, T>>,
+        dateindex: Option<&impl IterableVec<DateIndex, T>>,
     ) -> Result<()> {
         if let Some(dateindex) = dateindex {
             self.dateindex_extra
@@ -178,8 +178,8 @@ where
         .unwrap()
     }
 
-    fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn vecdb::AnyCollectableVec> {
-        let mut regular_iter: Box<dyn Iterator<Item = &dyn vecdb::AnyCollectableVec>> =
+    fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut regular_iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
             Box::new(self.dateindex_extra.iter_any_collectable());
         regular_iter = Box::new(regular_iter.chain(self.weekindex.iter_any_collectable()));
         regular_iter = Box::new(regular_iter.chain(self.monthindex.iter_any_collectable()));

crates/brk_computer/src/grouped/from_height.rs

@@ -5,7 +5,7 @@ use brk_types::{
     DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, SemesterIndex,
     Version, WeekIndex, YearIndex,
 };
-use vecdb::{AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit};
+use vecdb::{AnyCollectableVec, Database, EagerVec, Exit, IterableCloneableVec, IterableVec};
 
 use crate::{
     Indexes,
@@ -152,7 +152,7 @@ where
         indexes: &indexes::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
-        height_vec: Option<&impl AnyIterableVec<Height, T>>,
+        height_vec: Option<&impl IterableVec<Height, T>>,
     ) -> Result<()> {
         if let Some(height) = height_vec {
             self.height_extra
@@ -239,8 +239,8 @@ where
         .unwrap()
     }
 
-    fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn vecdb::AnyCollectableVec> {
-        let mut regular_iter: Box<dyn Iterator<Item = &dyn vecdb::AnyCollectableVec>> =
+    fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut regular_iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
             Box::new(self.height_extra.iter_any_collectable());
         regular_iter = Box::new(regular_iter.chain(self.dateindex.iter_any_collectable()));
         regular_iter = Box::new(regular_iter.chain(self.weekindex.iter_any_collectable()));

crates/brk_computer/src/grouped/from_height_strict.rs

@@ -2,7 +2,7 @@ use brk_error::Result;
 
 use brk_traversable::Traversable;
 use brk_types::{DifficultyEpoch, Height, Version};
-use vecdb::{Database, EagerVec, Exit};
+use vecdb::{AnyCollectableVec, Database, EagerVec, Exit};
 
 use crate::{Indexes, indexes};
 
@@ -110,8 +110,8 @@ where
         .merge_branches()
         .unwrap()
     }
-    fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn vecdb::AnyCollectableVec> {
-        let mut regular_iter: Box<dyn Iterator<Item = &dyn vecdb::AnyCollectableVec>> =
+    fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut regular_iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
             Box::new(self.height.iter_any_collectable());
         regular_iter = Box::new(regular_iter.chain(self.height_extra.iter_any_collectable()));
         regular_iter = Box::new(regular_iter.chain(self.difficultyepoch.iter_any_collectable()));

crates/brk_computer/src/grouped/from_txindex.rs

@@ -6,8 +6,8 @@ use brk_types::{
     Sats, SemesterIndex, TxIndex, Version, WeekIndex, YearIndex,
 };
 use vecdb::{
-    AnyCloneableIterableVec, AnyVec, CollectableVec, Database, EagerVec, Exit, GenericStoredVec,
-    StoredIndex, VecIteratorExtended,
+    AnyCollectableVec, AnyVec, CollectableVec, Database, EagerVec, Exit, GenericStoredVec,
+    IterableCloneableVec, StoredIndex, TypedVecIterator,
 };
 
 use crate::{
@@ -521,8 +521,8 @@ where
         .unwrap()
     }
 
-    fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn vecdb::AnyCollectableVec> {
-        let mut regular_iter: Box<dyn Iterator<Item = &dyn vecdb::AnyCollectableVec>> =
+    fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
+        let mut regular_iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
             Box::new(self.height.iter_any_collectable());
         regular_iter = Box::new(regular_iter.chain(self.dateindex.iter_any_collectable()));
         regular_iter = Box::new(regular_iter.chain(self.weekindex.iter_any_collectable()));

crates/brk_computer/src/grouped/ratio_from_dateindex.rs

@@ -2,8 +2,8 @@ use brk_error::Result;
 use brk_traversable::Traversable;
 use brk_types::{Date, DateIndex, Dollars, StoredF32, Version};
 use vecdb::{
-    AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
-    GenericStoredVec, StoredIndex, VecIteratorExtended,
+    AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, Exit, GenericStoredVec, IterableVec,
+    StoredIndex, TypedVecIterator,
 };
 
 use crate::{
@@ -306,7 +306,7 @@ impl ComputedRatioVecsFromDateIndex {
         price: &price::Vecs,
         starting_indexes: &Indexes,
         exit: &Exit,
-        price_opt: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
+        price_opt: Option<&impl IterableVec<DateIndex, Dollars>>,
     ) -> Result<()> {
         let closes = price.timeindexes_to_price_close.dateindex.as_ref().unwrap();
 

crates/brk_computer/src/grouped/sd_from_dateindex.rs

@@ -2,8 +2,8 @@ use brk_error::Result;
 use brk_traversable::Traversable;
 use brk_types::{Date, DateIndex, Dollars, StoredF32, Version};
 use vecdb::{
-    AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec, Database, EagerVec,
-    Exit, GenericStoredVec, StoredIndex,
+    AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec, Database, EagerVec, Exit,
+    GenericStoredVec, IterableVec, StoredIndex,
 };
 
 use crate::{Indexes, grouped::source::Source, indexes};
@@ -422,7 +422,7 @@ impl ComputedStandardDeviationVecsFromDateIndex {
         starting_indexes: &Indexes,
         exit: &Exit,
         source: &impl CollectableVec<DateIndex, StoredF32>,
-        price_opt: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
+        price_opt: Option<&impl IterableVec<DateIndex, Dollars>>,
     ) -> Result<()> {
         let min_date = DateIndex::try_from(Date::MIN_RATIO).unwrap();
 
@@ -449,9 +449,9 @@ impl ComputedStandardDeviationVecsFromDateIndex {
         &mut self,
         starting_indexes: &Indexes,
         exit: &Exit,
-        sma_opt: Option<&impl AnyIterableVec<DateIndex, StoredF32>>,
+        sma_opt: Option<&impl IterableVec<DateIndex, StoredF32>>,
         source: &impl CollectableVec<DateIndex, StoredF32>,
-        price_opt: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
+        price_opt: Option<&impl IterableVec<DateIndex, Dollars>>,
     ) -> Result<()> {
         let sma = sma_opt.unwrap_or_else(|| unsafe {
             std::mem::transmute(&self.sma.as_ref().unwrap().dateindex)

crates/brk_computer/src/grouped/source.rs

@@ -1,10 +1,10 @@
-use vecdb::AnyBoxedIterableVec;
+use vecdb::IterableBoxedVec;
 
 #[derive(Clone)]
 pub enum Source<I, T> {
     Compute,
     None,
-    Vec(AnyBoxedIterableVec<I, T>),
+    Vec(IterableBoxedVec<I, T>),
 }
 
 impl<I, T> Source<I, T> {
@@ -20,7 +20,7 @@ impl<I, T> Source<I, T> {
         matches!(self, Self::Vec(_))
     }
 
-    pub fn vec(self) -> Option<AnyBoxedIterableVec<I, T>> {
+    pub fn vec(self) -> Option<IterableBoxedVec<I, T>> {
         match self {
             Self::Vec(v) => Some(v),
             _ => None,
@@ -35,16 +35,16 @@ impl<I, T> From<bool> for Source<I, T> {
     }
 }
 
-impl<I, T> From<AnyBoxedIterableVec<I, T>> for Source<I, T> {
+impl<I, T> From<IterableBoxedVec<I, T>> for Source<I, T> {
     #[inline]
-    fn from(value: AnyBoxedIterableVec<I, T>) -> Self {
+    fn from(value: IterableBoxedVec<I, T>) -> Self {
         Self::Vec(value)
     }
 }
 
-impl<I, T> From<Option<AnyBoxedIterableVec<I, T>>> for Source<I, T> {
+impl<I, T> From<Option<IterableBoxedVec<I, T>>> for Source<I, T> {
     #[inline]
-    fn from(value: Option<AnyBoxedIterableVec<I, T>>) -> Self {
+    fn from(value: Option<IterableBoxedVec<I, T>>) -> Self {
         if let Some(v) = value {
             Self::Vec(v)
         } else {

crates/brk_computer/src/grouped/value_from_txindex.rs

@@ -3,8 +3,8 @@ use brk_indexer::Indexer;
 use brk_traversable::Traversable;
 use brk_types::{Bitcoin, Close, Dollars, Height, Sats, TxIndex, Version};
 use vecdb::{
-    AnyCloneableIterableVec, CollectableVec, Database, Exit, LazyVecFrom1, LazyVecFrom3,
-    StoredIndex, StoredVec,
+    CollectableVec, Database, Exit, IterableCloneableVec, LazyVecFrom1, LazyVecFrom3, StoredIndex,
+    StoredVec,
 };
 
 use crate::{Indexes, grouped::Source, indexes, price};