Struct FallbackWSet 

pub struct FallbackWSet<K, R>
where
    K: DataTrait + ?Sized,
    R: WeightTrait + ?Sized,
{ /* private fields */ }

Implementations

impl<K, R> FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

pub fn is_empty(&self) -> bool

Trait Implementations

impl<K, R> AddAssignByRef for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

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

impl<K, R> AddByRef for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

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

impl<K, R> Archive for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

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, R> Batch for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

type Timed<T: Timestamp> = FallbackKeyBatch<K, T, R>

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

type Batcher = MergeBatcher<FallbackWSet<K, R>>

A type used to assemble batches from disordered updates.

type Builder = FallbackWSetBuilder<K, R>

A type used to assemble batches from ordered update sequences.

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 file_reader(&self) -> Option<Arc<dyn FileReader>>

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

fn from_path( factories: &Self::Factories, path: &StoragePath, ) -> Result<Self, ReaderError>

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.

impl<K, R> BatchReader for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

type Factories = FileWSetFactories<K, R>

type Key = K

Key by which updates are indexed.

type Val = dyn DataTyped<Type = ()>

Values associated with keys.

type Time = ()

Timestamps associated with updates

type R = R

Associated update.

type Cursor<'s> = DelegatingCursor<'s, K, dyn DataTyped<Type = ()>, (), R>

The type used to enumerate the batch’s contents.

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

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

Acquires a cursor to the batch’s contents.

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<GroupFilter<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<GroupFilter<Self::Val>>, ) -> Box<dyn MergeCursor<Self::Key, Self::Val, Self::Time, Self::R> + Send + '_>

Acquires a merge cursor for 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_stats(&self) -> BloomFilterStats

Statistics of the Bloom filter used by Cursor::seek_key_exact. The Bloom filter (kept in memory) is used there to quickly check whether a key might be present in the batch, before doing a binary tree lookup within the batch to be exactly sure. The statistics include for example the size in bytes and the hit rate. Only some kinds of batches use a filter; others should return BloomFilterStats::default().

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 sample_keys<RG>( &self, rng: &mut RG, sample_size: usize, sample: &mut DynVec<Self::Key>, )

where RG: Rng,

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

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>>

fn merge_cursor_with_snapshot<'a, S>( &'a self, key_filter: Option<Filter<Self::Key>>, value_filter: Option<GroupFilter<Self::Val>>, snapshot: &'a Option<Arc<S>>, ) -> Box<dyn MergeCursor<Self::Key, Self::Val, Self::Time, Self::R> + Send + 'a>

where S: BatchReader<Key = Self::Key, Val = Self::Val, Time = Self::Time, R = Self::R>,

Similar to merge_cursor, but invoked in the context of a spine merger. Takes the current spine snapshot as an extra argument and uses it to evaluate value_filter precisely.

fn is_empty(&self) -> bool

True if the batch is empty.

fn partition_keys(&self, num_partitions: usize, bounds: &mut DynVec<Self::Key>)

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

Returns num_partitions-1 keys from the batch that partition the batch into num_partitions approximately equal size ranges 0..key1, key1..key2, … , key_num_partitions-1..last_key_in_the_batch.

impl<K, R> Builder<FallbackWSet<K, R>> for FallbackWSetBuilder<K, R>

where Self: SizeOf, K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

fn with_capacity( factories: &FallbackWSetFactories<K, 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 for_merge<'a, B, I>( factories: &FallbackWSetFactories<K, R>, 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_time_diff(&mut self, time: &(), weight: &R)

Adds time-diff pair (time, weight).

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

Adds value val.

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

Adds key key.

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

Adds time-diff pair (time, weight).

fn push_val_mut(&mut self, val: &mut DynUnit)

Adds value val.

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

Adds key key.

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

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

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

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

fn reserve(&mut self, additional: usize)

Allocates room for additional keys.

fn done(self) -> FallbackWSet<K, R>

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 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.

impl<K, R> Checkpoint for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

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

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

impl<K, R> Clone for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, R> Debug for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

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

Formats the value using the given formatter.

impl<K, R, D> Deserialize<FallbackWSet<K, R>, D> for Archived<FallbackWSet<K, R>>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized, D: Fallible,

fn deserialize( &self, _deserializer: &mut D, ) -> Result<FallbackWSet<K, R>, D::Error>

Deserializes using the given deserializer

impl<K, R> DynFilterMap for OrdWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

type DynItemRef<'a> = &'a K

A borrowed version of the record type, e.g., (&K, &V) for a stream of (key, value, weight) tuples or &K if the value type is ().

fn item_ref<'a>(key: &'a Self::Key, _val: &'a Self::Val) -> Self::DynItemRef<'a>

fn item_ref_keyval(item_ref: Self::DynItemRef<'_>) -> (&Self::Key, &Self::Val)

fn dyn_filter<C: Circuit>( stream: &Stream<C, Self>, filter_func: Box<dyn Fn(Self::DynItemRef<'_>) -> bool>, ) -> Stream<C, Self>

fn dyn_map_generic<C: Circuit, O>( stream: &Stream<C, Self>, output_factories: &O::Factories, map_func: Box<dyn Fn(Self::DynItemRef<'_>, &mut DynPair<O::Key, O::Val>)>, ) -> Stream<C, O>

where O: Batch<Time = (), R = Self::R>,

fn dyn_flat_map_generic<C: Circuit, O>( stream: &Stream<C, Self>, output_factories: &O::Factories, func: Box<dyn FnMut(Self::DynItemRef<'_>, &mut dyn FnMut(&mut O::Key, &mut O::Val))>, ) -> Stream<C, O>

where O: Batch<Time = (), R = Self::R>,

impl<K, R> Neg for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTraitTyped + ?Sized, R::Type: DBWeight + ZRingValue + NegByRef + Erase<R>,

type Output = FallbackWSet<K, R>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<K, R> NegByRef for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTraitTyped + ?Sized, R::Type: DBWeight + ZRingValue + NegByRef + Erase<R>,

fn neg_by_ref(&self) -> Self

impl<K, R> NumEntries for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,

const CONST_NUM_ENTRIES: Option<usize> = None

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<Other, K, R> PartialEq<Other> for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized, Other: BatchReader<Key = K, Val = DynUnit, R = R, Time = ()>,

fn eq(&self, other: &Other) -> 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, R, S> Serialize<S> for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized, S: Serializer + ?Sized,

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

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

impl<K, R> SizeOf for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized, Inner<K, 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<K, R> Eq for FallbackWSet<K, R>

where K: DataTrait + ?Sized, R: WeightTrait + ?Sized,