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, value_name: &str, version: Version, format: Format, ) -> 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 get_or_read(&self, index: I, mmap: &Mmap) -> Result<Option<Value<'_, T>>>

pub fn mmap(&self) -> &ArcSwap<Mmap>

pub fn inner_version(&self) -> Version

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_from_index<T2>( &mut self, max_from: I, other: &impl AnyIterableVec<I, T2>, exit: &Exit, ) -> Result<()>

where T: From<I>, T2: StoredType,

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_add( &mut self, max_from: I, added: &impl AnyIterableVec<I, T>, adder: &impl AnyIterableVec<I, T>, exit: &Exit, ) -> Result<()>

where T: Add<Output = T>,

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

where T: CheckedSub,

pub fn compute_max<T2>( &mut self, max_from: I, source: &impl AnyIterableVec<I, T2>, exit: &Exit, ) -> Result<()>

where T: From<T2> + Ord, T2: StoredType,

pub fn compute_multiply<T2, T3, T4>( &mut self, max_from: I, multiplied: &impl AnyIterableVec<I, T2>, multiplier: &impl AnyIterableVec<I, T3>, exit: &Exit, ) -> Result<()>

where T2: StoredType + Mul<T3, Output = T4>, T3: StoredType, T4: StoredType, T: From<T4>,

pub fn compute_divide<T2, T3, T4, T5>( &mut self, max_from: I, divided: &impl AnyIterableVec<I, T2>, divider: &impl AnyIterableVec<I, T3>, exit: &Exit, ) -> Result<()>

where T2: StoredType + Mul<usize, Output = T4>, T3: StoredType, T4: Div<T3, Output = T5> + From<T2>, T5: CheckedSub<usize>, T: From<T5>,

pub fn compute_percentage<T2, T3, T4, T5>( &mut self, max_from: I, divided: &impl AnyIterableVec<I, T2>, divider: &impl AnyIterableVec<I, T3>, exit: &Exit, ) -> Result<()>

where T2: StoredType + Mul<usize, Output = T4>, T3: StoredType, T4: Div<T3, Output = T5> + From<T2>, T5: CheckedSub<usize>, T: From<T5>,

pub fn compute_percentage_difference<T2, T3, T4, T5>( &mut self, max_from: I, divided: &impl AnyIterableVec<I, T2>, divider: &impl AnyIterableVec<I, T3>, exit: &Exit, ) -> Result<()>

where T2: StoredType + Mul<usize, Output = T4>, T3: StoredType, T4: Div<T3, Output = T5> + From<T2>, T5: CheckedSub<usize>, T: From<T5>,

pub fn compute_divide_<T2, T3, T4, T5>( &mut self, max_from: I, divided: &impl AnyIterableVec<I, T2>, divider: &impl AnyIterableVec<I, T3>, exit: &Exit, as_percentage: bool, as_difference: bool, ) -> Result<()>

where T2: StoredType + Mul<usize, Output = T4>, T3: StoredType, T4: Div<T3, Output = T5> + From<T2>, T5: CheckedSub<usize>, T: From<T5>,

pub fn compute_drawdown( &mut self, max_from: I, close: &impl AnyIterableVec<I, Close<Dollars>>, ath: &impl AnyIterableVec<I, Dollars>, exit: &Exit, ) -> Result<()>

where T: From<StoredF32>,

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,

pub fn compute_sum_of_others( &mut self, max_from: I, others: &[&impl AnyIterableVec<I, T>], exit: &Exit, ) -> Result<()>

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

pub fn compute_min_of_others( &mut self, max_from: I, others: &[&impl AnyIterableVec<I, T>], exit: &Exit, ) -> Result<()>

where T: From<usize> + Add<T, Output = T> + Ord,

pub fn compute_max_of_others( &mut self, max_from: I, others: &[&impl AnyIterableVec<I, T>], exit: &Exit, ) -> Result<()>

where T: From<usize> + Add<T, Output = T> + Ord,

pub fn compute_sma<T2>( &mut self, max_from: I, source: &impl AnyIterableVec<I, T2>, sma: usize, exit: &Exit, ) -> Result<()>

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

pub fn compute_sma_<T2>( &mut self, max_from: I, source: &impl AnyIterableVec<I, T2>, sma: usize, exit: &Exit, min_i: Option<I>, ) -> Result<()>

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

pub fn compute_previous_value<T2>( &mut self, max_from: I, source: &impl AnyIterableVec<I, T2>, len: usize, exit: &Exit, ) -> Result<()>

where I: CheckedSub, T2: StoredType + Default, f32: From<T2>, T: From<f32>,

pub fn compute_change( &mut self, max_from: I, source: &impl AnyIterableVec<I, T>, len: usize, exit: &Exit, ) -> Result<()>

where I: CheckedSub, T: CheckedSub + Default,

pub fn compute_percentage_change<T2>( &mut self, max_from: I, source: &impl AnyIterableVec<I, T2>, len: usize, exit: &Exit, ) -> Result<()>

where I: CheckedSub, T2: StoredType + Default, f32: From<T2>, T: From<f32>,

pub fn compute_cagr<T2>( &mut self, max_from: I, percentage_returns: &impl AnyIterableVec<I, T2>, days: usize, exit: &Exit, ) -> Result<()>

where I: CheckedSub, T2: StoredType + Default, f32: From<T2>, T: From<f32>,

impl EagerVec<DateIndex, Sats>

pub fn compute_dca_stack_via_len( &mut self, max_from: DateIndex, closes: &impl AnyIterableVec<DateIndex, Close<Dollars>>, len: usize, exit: &Exit, ) -> Result<()>

pub fn compute_dca_stack_via_from( &mut self, max_from: DateIndex, closes: &impl AnyIterableVec<DateIndex, Close<Dollars>>, from: DateIndex, exit: &Exit, ) -> Result<()>

impl EagerVec<DateIndex, Dollars>

pub fn compute_dca_avg_price_via_len( &mut self, max_from: DateIndex, stacks: &impl AnyIterableVec<DateIndex, Sats>, len: usize, exit: &Exit, ) -> Result<()>

pub fn compute_dca_avg_price_via_from( &mut self, max_from: DateIndex, stacks: &impl AnyIterableVec<DateIndex, Sats>, from: DateIndex, exit: &Exit, ) -> Result<()>

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<I> EagerVec<I, Dollars>

where I: StoredIndex,

pub fn compute_from_bitcoin( &mut self, max_from: I, bitcoin: &impl AnyIterableVec<I, Bitcoin>, price: &impl AnyIterableVec<I, 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) -> String

fn value_type_to_size_of(&self) -> usize

fn is_empty(&self) -> bool

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

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

Returns a duplicate 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.