Struct TypedBatch 

pub struct TypedBatch<K, V, R, B> { /* private fields */ }

A statically typed wrapper around a dynamically typed batch B with concrete key, value, and weight types K, V, and R respectively.

Implementations

impl<K, V, R, B> TypedBatch<K, V, R, B>

pub fn new(inner: B) -> Self

impl<K, V, R, B> TypedBatch<K, V, R, B>

where B: DynBatch, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

pub fn empty() -> Self

Create an empty batch.

pub fn from_tuples(time: B::Time, tuples: Vec<Tup2<Tup2<K, V>, R>>) -> Self

Build a batch out of tuples.

pub fn merge(&self, other: &Self) -> Self

Merge self with other.

pub fn merge_batches<I>(batches: I) -> Self

where I: IntoIterator<Item = Self>,

impl<K, V, R, B> TypedBatch<K, V, R, B>

pub fn into_inner(self) -> B

impl<K, R, B> TypedBatch<K, (), R, B>

where B: DynBatch, K: DBData + Erase<B::Key>, (): Erase<B::Val>, R: DBWeight + Erase<B::R>,

pub fn from_keys(time: B::Time, tuples: Vec<Tup2<K, R>>) -> Self

impl<K, V, R, B> TypedBatch<K, V, R, DynSpineSnapshot<B>>

where B: DynBatch, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

pub fn concat<'a, I>(snapshots: I) -> TypedBatch<K, V, R, DynSpineSnapshot<B>>

where I: IntoIterator<Item = &'a Self>,

Concatenate a list of snapshots into a single snapshot.

pub fn consolidate(&self) -> TypedBatch<K, V, R, B>

Consolidate the batches in the snapshot.

impl<K, V, R, B> TypedBatch<K, V, R, B>

where B: DynTrace, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

pub fn consolidate(self) -> TypedBatch<K, V, R, B::Batch>

Consolidate the batches in the trace.

impl<K, V, R, B> TypedBatch<K, V, R, DynSpine<B>>

where B: DynBatch, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

pub fn ro_snapshot(&self) -> TypedBatch<K, V, R, DynSpineSnapshot<B>>

Trait Implementations

impl<K, V, R, B> AddAssignByRef for TypedBatch<K, V, R, B>

where B: DynBatchReaderWithSnapshot + AddAssignByRef, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

fn add_assign_by_ref(&mut self, other: &Self)

impl<K, V, R, B> AddByRef for TypedBatch<K, V, R, B>

where B: DynBatchReaderWithSnapshot + AddByRef, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

fn add_by_ref(&self, other: &Self) -> Self

impl<K, V, R, B> BatchReader for TypedBatch<K, V, R, B>

where B: DynBatchReaderWithSnapshot, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

type Inner = B

type IntoBatch = <B as WithSnapshot>::Batch

Any batch reader can be decomposed into a list of batches. This type represents the type of the batches:

type Key = K

Concrete key type.

type Val = V

Concrete value type.

type R = R

Concrete weight typ.

type Time = <B as BatchReader>::Time

type DynK = <B as BatchReader>::Key

Dynamic key type (e.g., DynData).

type DynV = <B as BatchReader>::Val

Dynamic value typ, (e.g., DynData).

type DynR = <B as BatchReader>::R

Dynamic weight type (e.g., DynZWeight).

fn inner(&self) -> &Self::Inner

Extract the dynamically typed batch.

fn inner_mut(&mut self) -> &mut Self::Inner

fn into_inner(self) -> Self::Inner

Drop the statically typed wrapper and return the inner dynamic batch type.

fn from_inner(inner: Self::Inner) -> Self

Create a statically typed wrapper around inner.

fn stream_inner<C: Clone>(stream: &Stream<C, Self>) -> Stream<C, B>

Convert a stream of batches of statically typed batches of type Self into a stream of dynamically typed batches Self::Inner batches.

fn stream_from_inner<C: Clone>( stream: &Stream<C, Self::Inner>, ) -> Stream<C, Self>

Convert a stream of dynamically typed batches of type Self::Inner into a stream of statically typed batches of type Self.

fn into_dyn_batches(self) -> Vec<Arc<Self::IntoBatch>>

Consume self and returns the list of dynamically typed batches comprising it.

fn into_dyn_snapshot(self) -> DynSpineSnapshot<Self::IntoBatch>

Convert self into a spine snapshot.

fn into_batches( self, ) -> Vec<Arc<TypedBatch<Self::Key, Self::Val, Self::R, Self::IntoBatch>>>

Consume self and returns the list of statically typed batches comprising it.

fn dyn_batches(&self) -> Vec<Arc<Self::IntoBatch>>

Returns the list of dynamically typed batches comprising self.

fn batches( &self, ) -> Vec<Arc<TypedBatch<Self::Key, Self::Val, Self::R, Self::IntoBatch>>>

Returns the list of statically typed batches comprising self.

fn dyn_snapshot(&self) -> DynSpineSnapshot<Self::IntoBatch>

Assemble batches from self into a spine snapshot.

fn factories() -> <Self::Inner as DynBatchReader>::Factories

Factories for Self::Inner.

fn into_batch_factories() -> <Self::IntoBatch as DynBatchReader>::Factories

impl<K, V, R, B> Checkpoint for TypedBatch<K, V, R, B>

where B: Checkpoint, K: DBData, V: DBData, R: DBWeight,

fn checkpoint(&self) -> Result<Vec<u8>, Error>

fn restore(&mut self, data: &[u8]) -> Result<(), Error>

impl<K: Clone, V: Clone, R: Clone, B: Clone> Clone for TypedBatch<K, V, R, B>

fn clone(&self) -> TypedBatch<K, V, R, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, R, B> Debug for TypedBatch<K, V, R, B>

where B: Debug,

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

Formats the value using the given formatter.

impl<K, V, R, B> Default for TypedBatch<K, V, R, B>

where B: DynBatch, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, R, B> Deref for TypedBatch<K, V, R, B>

type Target = B

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<K, V, R, B> DerefMut for TypedBatch<K, V, R, B>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<K: Eq, V: Eq, R: Eq, B: Eq> Eq for TypedBatch<K, V, R, B>

impl<K, V, R, B> HasZero for TypedBatch<K, V, R, B>

where B: DynBatch<Time = ()>, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

fn zero() -> Self

fn is_zero(&self) -> bool

impl<K, V, R, B> Neg for TypedBatch<K, V, R, B>

where B: DynBatchReader + Neg<Output = B>, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

type Output = TypedBatch<K, V, R, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<K, V, R, B> NegByRef for TypedBatch<K, V, R, B>

where B: DynBatchReaderWithSnapshot + NegByRef, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

fn neg_by_ref(&self) -> Self

impl<K, V, R, B> NumEntries for TypedBatch<K, V, R, B>

where B: DynBatchReader, K: DBData + Erase<B::Key>, V: DBData + Erase<B::Val>, R: DBWeight + Erase<B::R>,

const CONST_NUM_ENTRIES: Option<usize> = B::CONST_NUM_ENTRIES

Returns Some(n) if Self has constant size or None otherwise.

fn num_entries_shallow(&self) -> usize

Returns the number of entries in self.

fn num_entries_deep(&self) -> usize

Recursively computes the number of entries in a container by calling this method on each entry in self.

impl<K, V, R, B, B2> PartialEq<TypedBatch<K, V, R, B2>> for TypedBatch<K, V, R, B>

where B: PartialEq<B2>,

fn eq(&self, other: &TypedBatch<K, V, R, B2>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, V, R, B> SizeOf for TypedBatch<K, V, R, B>

where B: SizeOf, PhantomData<fn(&K, &V, &R)>: SizeOf,

fn size_of_children(&self, context: &mut Context)

Gets the size of all “children” owned by this value, not including the size of the value itself.

fn size_of(&self) -> TotalSize

Gets the total size of the current value

fn size_of_with_context(&self, context: &mut Context)

Adds the size of the current value to the given Context, including both the size of the value itself and all of its children

impl<R, T> SourceOperator<TypedBatch<T, (), i64, FallbackWSet<dyn Data, dyn WeightTyped<Type = i64>>>> for CsvSource<R, T>

where T: DBData + for<'de> Deserialize<'de> + 'static, R: Read + 'static,

async fn eval(&mut self) -> OrdZSet<T>

Yield the next value.