Enum ComputedVec

pub enum ComputedVec<I, T, S1I, S1T, S2I, S2T, S3I, S3T>
where
    S1T: Clone,
    S2T: Clone,
    S3T: Clone,
{
    Eager {
        vec: EagerVec<I, T>,
        deps: Dependencies<I, T, S1I, S1T, S2I, S2T, S3I, S3T>,
    },
    LazyFrom1(LazyVecFrom1<I, T, S1I, S1T>),
    LazyFrom2(LazyVecFrom2<I, T, S1I, S1T, S2I, S2T>),
    LazyFrom3(LazyVecFrom3<I, T, S1I, S1T, S2I, S2T, S3I, S3T>),
}

Variants

Eager

Fields

vec: EagerVec<I, T>

deps: Dependencies<I, T, S1I, S1T, S2I, S2T, S3I, S3T>

LazyFrom1(LazyVecFrom1<I, T, S1I, S1T>)

LazyFrom2(LazyVecFrom2<I, T, S1I, S1T, S2I, S2T>)

LazyFrom3(LazyVecFrom3<I, T, S1I, S1T, S2I, S2T, S3I, S3T>)

Implementations

impl<I, T, S1I, S1T, S2I, S2T, S3I, S3T> ComputedVec<I, T, S1I, S1T, S2I, S2T, S3I, S3T>

where I: StoredIndex, T: StoredCompressed, S1I: StoredIndex, S1T: StoredRaw, S2I: StoredIndex, S2T: StoredRaw, S3I: StoredIndex, S3T: StoredRaw,

pub fn forced_import_or_init_from_1( db: &Database, name: &str, version: Version, computation: Computation, format: Format, source: AnyBoxedIterableVec<S1I, S1T>, compute: for<'a> fn(I, &mut dyn BaseVecIterator<Item = (S1I, Cow<'a, S1T>)>) -> Option<T>, ) -> Result<Self>

pub fn forced_import_or_init_from_1_with( options: ImportOptions<'_>, computation: Computation, format: Format, source: AnyBoxedIterableVec<S1I, S1T>, compute: for<'a> fn(I, &mut dyn BaseVecIterator<Item = (S1I, Cow<'a, S1T>)>) -> Option<T>, ) -> Result<Self>

pub fn forced_import_or_init_from_2( db: &Database, name: &str, version: Version, computation: Computation, format: Format, source1: AnyBoxedIterableVec<S1I, S1T>, source2: AnyBoxedIterableVec<S2I, S2T>, compute: for<'a> fn(I, &mut dyn BaseVecIterator<Item = (S1I, Cow<'a, S1T>)>, &mut dyn BaseVecIterator<Item = (S2I, Cow<'a, S2T>)>) -> Option<T>, ) -> Result<Self>

pub fn forced_import_or_init_from_2_with( options: ImportOptions<'_>, computation: Computation, format: Format, source1: AnyBoxedIterableVec<S1I, S1T>, source2: AnyBoxedIterableVec<S2I, S2T>, compute: for<'a> fn(I, &mut dyn BaseVecIterator<Item = (S1I, Cow<'a, S1T>)>, &mut dyn BaseVecIterator<Item = (S2I, Cow<'a, S2T>)>) -> Option<T>, ) -> Result<Self>

pub fn forced_import_or_init_from_3( db: &Database, name: &str, version: Version, computation: Computation, format: Format, source1: AnyBoxedIterableVec<S1I, S1T>, source2: AnyBoxedIterableVec<S2I, S2T>, source3: AnyBoxedIterableVec<S3I, S3T>, compute: for<'a> fn(I, &mut dyn BaseVecIterator<Item = (S1I, Cow<'a, S1T>)>, &mut dyn BaseVecIterator<Item = (S2I, Cow<'a, S2T>)>, &mut dyn BaseVecIterator<Item = (S3I, Cow<'a, S3T>)>) -> Option<T>, ) -> Result<Self>

pub fn forced_import_or_init_from_3_with( options: ImportOptions<'_>, computation: Computation, format: Format, source1: AnyBoxedIterableVec<S1I, S1T>, source2: AnyBoxedIterableVec<S2I, S2T>, source3: AnyBoxedIterableVec<S3I, S3T>, compute: for<'a> fn(I, &mut dyn BaseVecIterator<Item = (S1I, Cow<'a, S1T>)>, &mut dyn BaseVecIterator<Item = (S2I, Cow<'a, S2T>)>, &mut dyn BaseVecIterator<Item = (S3I, Cow<'a, S3T>)>) -> Option<T>, ) -> Result<Self>

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

Trait Implementations

impl<I, T, S1I, S1T, S2I, S2T, S3I, S3T> AnyCollectableVec for ComputedVec<I, T, S1I, S1T, S2I, S2T, S3I, S3T>

where I: StoredIndex, T: StoredCompressed, S1I: StoredIndex, S1T: StoredRaw, S2I: StoredIndex, S2T: StoredRaw, S3I: StoredIndex, S3T: StoredRaw,

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

fn range_count(&self, from: Option<i64>, to: Option<i64>) -> usize

fn range_weight(&self, from: Option<i64>, to: Option<i64>) -> usize

impl<I, T, S1I, S1T, S2I, S2T, S3I, S3T> AnyIterableVec<I, T> for ComputedVec<I, T, S1I, S1T, S2I, S2T, S3I, S3T>

where I: StoredIndex, T: StoredCompressed, S1I: StoredIndex, S1T: StoredRaw, S2I: StoredIndex, S2T: StoredRaw, S3I: StoredIndex, S3T: StoredRaw,

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

where T: 'a,

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

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

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

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

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

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

impl<I, T, S1I, S1T, S2I, S2T, S3I, S3T> AnyVec for ComputedVec<I, T, S1I, S1T, S2I, S2T, S3I, S3T>

where I: StoredIndex, T: StoredCompressed, S1I: StoredIndex, S1T: StoredRaw, S2I: StoredIndex, S2T: StoredRaw, S3I: StoredIndex, S3T: StoredRaw,

fn version(&self) -> Version

fn name(&self) -> &str

fn index_type_to_string(&self) -> &'static str

fn len(&self) -> usize

fn value_type_to_size_of(&self) -> usize

fn is_empty(&self) -> bool

fn etag(&self, stamp: Stamp, to: Option<i64>) -> String

fn i64_to_usize(&self, i: i64) -> usize

impl<I: Clone, T: Clone, S1I: Clone, S1T, S2I: Clone, S2T, S3I: Clone, S3T> Clone for ComputedVec<I, T, S1I, S1T, S2I, S2T, S3I, S3T>

where S1T: Clone + Clone, S2T: Clone + Clone, S3T: Clone + Clone,

fn clone(&self) -> ComputedVec<I, T, S1I, S1T, S2I, S2T, S3I, S3T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, I, T, S1I, S1T, S2I, S2T, S3I, S3T> IntoIterator for &'a ComputedVec<I, T, S1I, S1T, S2I, S2T, S3I, S3T>

where I: StoredIndex, T: StoredCompressed, S1I: StoredIndex, S1T: StoredRaw, S2I: StoredIndex, S2T: StoredRaw, S3I: StoredIndex, S3T: StoredRaw,

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

The type of the elements being iterated over.

type IntoIter = ComputedVecIterator<'a, I, T, S1I, S1T, S2I, S2T, S3I, S3T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.