Struct EagerVec

pub struct EagerVec<I, T> { /* private fields */ }

Implementations

impl<I, T> EagerVec<I, T>

where I: StoredIndex, T: StoredType,

pub fn forced_import( path: &Path, version: Version, compressed: Compressed, ) -> Result<Self>

pub fn forced_push_at(&mut self, index: I, value: T, exit: &Exit) -> Result<()>

pub fn safe_flush(&mut self, exit: &Exit) -> Result<()>

pub fn path(&self) -> &Path

pub fn validate_computed_version_or_reset_file( &mut self, version: Version, ) -> Result<()>

pub fn compute_to<F>( &mut self, max_from: I, to: usize, version: Version, t: F, exit: &Exit, ) -> Result<()>

where F: FnMut(I) -> (I, T),

pub fn compute_range<A, F>( &mut self, max_from: I, other: &impl AnyIterableVec<I, A>, t: F, exit: &Exit, ) -> Result<()>

where A: StoredType, F: FnMut(I) -> (I, T),

pub fn compute_transform<A, B, F>( &mut self, max_from: A, other: &impl AnyIterableVec<A, B>, t: F, exit: &Exit, ) -> Result<()>

where A: StoredIndex, B: StoredType, F: FnMut((A, B, &Self)) -> (I, T),

pub fn compute_inverse_more_to_less( &mut self, max_from: T, other: &impl AnyIterableVec<T, I>, exit: &Exit, ) -> Result<()>

where I: StoredType + StoredIndex, T: StoredIndex,

pub fn compute_inverse_less_to_more( &mut self, max_from: T, first_indexes: &impl AnyIterableVec<T, I>, indexes_count: &impl AnyIterableVec<T, StoredUsize>, exit: &Exit, ) -> Result<()>

where I: StoredType, T: StoredIndex,

pub fn compute_count_from_indexes<T2, T3>( &mut self, max_from: I, first_indexes: &impl AnyIterableVec<I, T2>, other_to_else: &impl AnyIterableVec<T2, T3>, exit: &Exit, ) -> Result<()>

where T: From<T2>, T2: StoredType + StoredIndex + Copy + Add<usize, Output = T2> + CheckedSub<T2> + TryInto<T> + Default, <T2 as TryInto<T>>::Error: Error + 'static, T3: StoredType,

pub fn compute_filtered_count_from_indexes<T2, T3, F>( &mut self, max_from: I, first_indexes: &impl AnyIterableVec<I, T2>, other_to_else: &impl AnyIterableVec<T2, T3>, filter: F, exit: &Exit, ) -> Result<()>

where T: From<T2>, T2: StoredType + StoredIndex + Copy + Add<usize, Output = T2> + CheckedSub<T2> + TryInto<T> + Default, <T2 as TryInto<T>>::Error: Error + 'static, T3: StoredType, F: FnMut(T2) -> bool,

pub fn compute_is_first_ordered<A>( &mut self, max_from: I, self_to_other: &impl AnyIterableVec<I, A>, other_to_self: &impl AnyIterableVec<A, I>, exit: &Exit, ) -> Result<()>

where I: StoredType, T: From<bool>, A: StoredIndex + StoredType,

pub fn compute_sum_from_indexes<T2>( &mut self, max_from: I, first_indexes: &impl AnyIterableVec<I, T2>, indexes_count: &impl AnyIterableVec<I, StoredUsize>, source: &impl AnyIterableVec<T2, T>, exit: &Exit, ) -> Result<()>

where T: From<usize> + Add<T, Output = T>, T2: StoredIndex + StoredType,

impl<I> EagerVec<I, Bitcoin>

where I: StoredIndex,

pub fn compute_from_sats( &mut self, max_from: I, sats: &impl AnyIterableVec<I, Sats>, exit: &Exit, ) -> Result<()>

impl EagerVec<Height, Dollars>

pub fn compute_from_bitcoin( &mut self, max_from: Height, bitcoin: &impl AnyIterableVec<Height, Bitcoin>, price: &impl AnyIterableVec<Height, Close<Dollars>>, exit: &Exit, ) -> Result<()>

impl EagerVec<TxIndex, Dollars>

pub fn compute_from_bitcoin( &mut self, max_from: TxIndex, bitcoin: &impl AnyIterableVec<TxIndex, Bitcoin>, i_to_height: &impl AnyIterableVec<TxIndex, Height>, price: &impl AnyIterableVec<Height, Close<Dollars>>, exit: &Exit, ) -> Result<()>

Trait Implementations

impl<I, T> AnyCollectableVec for EagerVec<I, T>

where I: StoredIndex, T: StoredType,

fn collect_range_serde_json( &self, from: Option<i64>, to: Option<i64>, ) -> Result<Vec<Value>>

impl<I, T> AnyIterableVec<I, T> for EagerVec<I, T>

where I: StoredIndex, T: StoredType,

fn boxed_iter<'a>(&'a self) -> BoxedVecIterator<'a, I, T>

where I: StoredIndex, T: StoredType + 'a,

fn iter<'a>(&'a self) -> BoxedVecIterator<'a, I, T>

where I: StoredIndex, T: StoredType + 'a,

fn iter_at<'a>(&'a self, i: I) -> BoxedVecIterator<'a, I, T>

where I: StoredIndex, T: StoredType + 'a,

fn iter_at_<'a>(&'a self, i: usize) -> BoxedVecIterator<'a, I, T>

where I: StoredIndex, T: StoredType + 'a,

impl<I, T> AnyVec for EagerVec<I, T>

where I: StoredIndex, T: StoredType,

fn version(&self) -> Version

fn name(&self) -> String

fn len(&self) -> usize

fn modified_time(&self) -> Result<Duration>

fn index_type_to_string(&self) -> &str

fn is_empty(&self) -> bool

impl<I: Clone, T: Clone> Clone for EagerVec<I, T>

fn clone(&self) -> EagerVec<I, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug, T: Debug> Debug for EagerVec<I, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, I, T> IntoIterator for &'a EagerVec<I, T>

where I: StoredIndex, T: StoredType,

type Item = (I, Value<'a, T>)

The type of the elements being iterated over.

type IntoIter = StoredVecIterator<'a, I, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.