Struct VecKeyBatch 

pub struct VecKeyBatch<K, T, R, O = usize>
where
    K: DataTrait + ?Sized,
    T: Timestamp,
    R: WeightTrait + ?Sized,
    O: OrdOffset,
{
    pub layer: VecKeyBatchLayer<K, T, R, O>,
    /* private fields */
}

An immutable collection of update tuples, from a contiguous interval of logical times.

Fields

layer: VecKeyBatchLayer<K, T, R, O>

Where all the dataz is.

Trait Implementations

impl<K, T, R, O> Archive for VecKeyBatch<K, T, R, O>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset,

type Archived = ()

The archived representation of this type.

type Resolver = ()

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, _pos: usize, _resolver: Self::Resolver, _out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl<K, T, R, O> Batch for VecKeyBatch<K, T, R, O>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset,

type Timed<T2: Timestamp> = VecKeyBatch<K, T2, R, O>

A batch type equivalent to Self, but with timestamp type T instead of Self::Time.

type Batcher = MergeBatcher<VecKeyBatch<K, T, R, O>>

A type used to assemble batches from disordered updates.

type Builder = VecKeyBuilder<K, T, R, O>

A type used to assemble batches from ordered update sequences.

fn file_reader(&self) -> Option<Arc<dyn FileReader>>

This functions returns the file that can be used to restore the batch’s contents.

fn dyn_from_tuples( factories: &Self::Factories, time: Self::Time, tuples: &mut Box<DynWeightedPairs<DynPair<Self::Key, Self::Val>, Self::R>>, ) -> Self

Assemble an unordered vector of weighted items into a batch.

fn from_batch<BI>( batch: &BI, timestamp: &Self::Time, factories: &Self::Factories, ) -> Self

where BI: BatchReader<Key = Self::Key, Val = Self::Val, Time = (), R = Self::R>,

Creates a new batch as a copy of batch, using timestamp for all of the new batch’s timestamps This is useful for adding a timestamp to a batch, or for converting between different batch implementations (e.g. writing an in-memory batch to disk).

fn from_arc_batch<BI>( batch: &Arc<BI>, timestamp: &Self::Time, factories: &Self::Factories, ) -> Arc<Self>

where BI: BatchReader<Key = Self::Key, Val = Self::Val, Time = (), R = Self::R>,

Like from_batch, but avoids cloning the batch if the output type is identical to the input type.

fn from_cursor<C>( cursor: C, timestamp: &Self::Time, factories: &Self::Factories, key_capacity: usize, value_capacity: usize, ) -> Self

where C: Cursor<Self::Key, Self::Val, (), Self::R>,

Creates a new batch as a copy of the tuples accessible via cursor``, using timestamp` for all of the new batch’s timestamps.

fn dyn_empty(factories: &Self::Factories) -> Self

Creates an empty batch.

fn filter(&self, predicate: &dyn Fn(&Self::Key, &Self::Val) -> bool) -> Self

where Self::Time: PartialEq<()> + From<()>,

Returns elements from self that satisfy a predicate.

fn persisted(&self) -> Option<Self>

If this batch is not on storage, but supports writing itself to storage, this method writes it to storage and returns the stored version.

fn from_path( _factories: &Self::Factories, _path: &StoragePath, ) -> Result<Self, ReaderError>

impl<K, T, R, O> BatchReader for VecKeyBatch<K, T, R, O>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset,

type Key = K

Key by which updates are indexed.

type Val = dyn DataTyped<Type = ()>

Values associated with keys.

type Time = T

Timestamps associated with updates

type R = R

Associated update.

type Cursor<'s> = ValKeyCursor<'s, K, T, R, O> where O: 's

The type used to enumerate the batch’s contents.

type Factories = VecKeyBatchFactories<K, T, R>

fn factories(&self) -> Self::Factories

fn cursor(&self) -> Self::Cursor<'_>

Acquires a cursor to the batch’s contents.

fn key_count(&self) -> usize

The number of keys in the batch.

fn len(&self) -> usize

The number of updates in the batch.

fn approximate_byte_size(&self) -> usize

The memory or storage size of the batch in bytes.

fn filter_size(&self) -> usize

Number of bytes used as a Bloom filter for Cursor::seek_key_exact.

fn sample_keys<RG>( &self, rng: &mut RG, sample_size: usize, sample: &mut DynVec<Self::Key>, )

where Self::Time: PartialEq<()>, RG: Rng,

Returns a uniform random sample of distincts keys from the batch.

fn push_cursor( &self, ) -> Box<dyn PushCursor<Self::Key, Self::Val, Self::Time, Self::R> + Send + '_>

Acquires a PushCursor for the batch’s contents.

fn merge_cursor( &self, key_filter: Option<Filter<Self::Key>>, value_filter: Option<Filter<Self::Val>>, ) -> Box<dyn MergeCursor<Self::Key, Self::Val, Self::Time, Self::R> + Send + '_>

Acquires a MergeCursor for the batch’s contents.

fn consuming_cursor( &mut self, key_filter: Option<Filter<Self::Key>>, value_filter: Option<Filter<Self::Val>>, ) -> Box<dyn MergeCursor<Self::Key, Self::Val, Self::Time, Self::R> + Send + '_>

Acquires a merge cursor for the batch’s contents.

fn location(&self) -> BatchLocation

Where the batch’s data is stored.

fn cache_stats(&self) -> CacheStats

Storage cache access statistics for this batch only.

fn is_empty(&self) -> bool

True if the batch is empty.

fn maybe_contains_key(&self, _hash: u64) -> bool

A method that returns either true (possibly in the batch) or false (definitely not in the batch).

async fn fetch<B>( &self, keys: &B, ) -> Option<Box<dyn CursorFactory<Self::Key, Self::Val, Self::Time, Self::R>>>

where B: BatchReader<Key = Self::Key, Time = ()>,

Creates and returns a new batch that is a subset of this one, containing only the key-value pairs whose keys are in keys. May also return None, the default implementation, if the batch doesn’t want to implement this method. In particular, a batch for which access through a cursor is fast should return None to avoid the expense of copying data.

fn keys(&self) -> Option<&DynVec<Self::Key>>

impl<K, T, R, O> Builder<VecKeyBatch<K, T, R, O>> for VecKeyBuilder<K, T, R, O>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset,

fn with_capacity( factories: &VecKeyBatchFactories<K, T, R>, key_capacity: usize, value_capacity: usize, ) -> Self

Creates an empty builder with estimated capacities for keys and key-value pairs. Only tuple_capacity >= key_capacity makes sense but implementations must tolerate contradictory capacity requests.

fn reserve(&mut self, additional: usize)

Allocates room for additional keys.

fn push_key(&mut self, key: &K)

Adds key key.

fn push_key_mut(&mut self, key: &mut K)

Adds key key.

fn push_val(&mut self, _val: &DynUnit)

Adds value val.

fn push_time_diff(&mut self, time: &T, weight: &R)

Adds time-diff pair (time, weight).

fn push_time_diff_mut(&mut self, time: &mut T, weight: &mut R)

Adds time-diff pair (time, weight).

fn done(self) -> VecKeyBatch<K, T, R, O>

Completes building and returns the batch.

fn num_keys(&self) -> usize

fn num_tuples(&self) -> usize

fn new_builder(factories: &Output::Factories) -> Self

Creates a new builder with an initial capacity of 0.

fn for_merge<'a, B, I>( factories: &Output::Factories, batches: I, location: Option<BatchLocation>, ) -> Self

where B: BatchReader, I: IntoIterator<Item = &'a B> + Clone,

Creates an empty builder to hold the result of merging batches. Optionally, location can specify the preferred location for the result of the merge.

fn push_val_mut(&mut self, val: &mut Output::Val)

Adds value val.

fn push_diff(&mut self, weight: &Output::R)

where Output::Time: PartialEq<()>,

Adds time-diff pair (), weight.

fn push_diff_mut(&mut self, weight: &mut Output::R)

where Output::Time: PartialEq<()>,

Adds time-diff pair (), weight.

fn push_val_diff(&mut self, val: &Output::Val, weight: &Output::R)

where Output::Time: PartialEq<()>,

Adds time-diff pair (), weight and value val.

fn push_val_diff_mut(&mut self, val: &mut Output::Val, weight: &mut Output::R)

where Output::Time: PartialEq<()>,

Adds time-diff pair (), weight and value val.

impl<K, T, R, O> Clone for VecKeyBatch<K, T, R, O>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, T, R, O> Debug for VecKeyBatch<K, T, R, O>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized, T: Timestamp, O: OrdOffset,

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

Formats the value using the given formatter.

impl<K, T, R, O> Deserialize<VecKeyBatch<K, T, R, O>, SharedDeserializeMap> for ()

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset,

fn deserialize( &self, _deserializer: &mut Deserializer, ) -> Result<VecKeyBatch<K, T, R, O>, <Deserializer as Fallible>::Error>

Deserializes using the given deserializer

impl<K, T, R, O> Display for VecKeyBatch<K, T, R, O>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset,

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

Formats the value using the given formatter.

impl<K, T, R, O> NumEntries for VecKeyBatch<K, T, R, O>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset,

const CONST_NUM_ENTRIES: Option<usize> = VecKeyBatchLayer<K, T, R, O>::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, T, R, O> Serialize<CompositeSerializer<FBufSerializer<FBuf>, FallbackScratch<HeapScratch<65536>, AllocScratch>, SharedSerializeMap>> for VecKeyBatch<K, T, R, O>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset,

fn serialize( &self, _serializer: &mut Serializer, ) -> Result<Self::Resolver, <Serializer as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<K, T, R, O> SizeOf for VecKeyBatch<K, T, R, O>

where K: DataTrait + ?Sized, T: Timestamp, R: WeightTrait + ?Sized, O: OrdOffset, VecKeyBatchLayer<K, T, R, O>: 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