Struct LayerBuilder 

pub struct LayerBuilder<K, L, O = usize>
where
    K: DataTrait + ?Sized,
    L: Builder,
{
    pub keys: Box<DynVec<K>>,
    pub offs: Vec<O>,
    pub vals: L,
    /* private fields */
}

Assembles a layer of this

Fields

keys: Box<DynVec<K>>

Keys

offs: Vec<O>

Offsets

vals: L

The next layer down

Implementations

impl<K, L, O> LayerBuilder<K, L, O>

where K: DataTrait + ?Sized, L: Builder,

pub fn merge_step( &mut self, (trie1, lower1, upper1): (&Layer<K, L::Trie, O>, &mut usize, usize), (trie2, lower2, upper2): (&Layer<K, L::Trie, O>, &mut usize, usize), map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, )

where L: MergeBuilder, O: OrdOffset,

Performs one step of merging.

pub fn merge_step_retain_keys<F>( &mut self, (trie1, lower1, upper1): (&<Self as Builder>::Trie, &mut usize, usize), (trie2, lower2, upper2): (&<Self as Builder>::Trie, &mut usize, usize), filter: &F, map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, )

where L: MergeBuilder, O: OrdOffset, F: Fn(&K) -> bool,

impl<K, L, O> LayerBuilder<K, L, O>

where K: DataTrait + ?Sized, L: MergeBuilder, O: OrdOffset,

pub fn push_merge_fueled( &mut self, (source1, lower1, upper1): (&<Self as Builder>::Trie, &mut usize, usize), (source2, lower2, upper2): (&<Self as Builder>::Trie, &mut usize, usize), map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, fuel: &mut isize, )

Like push_merge, but uses fuel to bound the amount of work.

Builds at most fuel values plus values for one extra key. If fuel > 0 when the method returns, this means that the merge is complete.

pub fn push_merge_retain_keys_fueled<F>( &mut self, (source1, lower1, upper1): (&<Self as Builder>::Trie, &mut usize, usize), (source2, lower2, upper2): (&<Self as Builder>::Trie, &mut usize, usize), filter: &F, map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, fuel: &mut isize, )

where F: Fn(&K) -> bool,

pub fn copy_range_fueled( &mut self, other: &<Self as Builder>::Trie, lower: usize, upper: usize, map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, fuel: usize, ) -> usize

Like copy_range, but uses fuel to bound the amount of work.

Invariants:

• Copies at most fuel values plus values for one extra key.
• If fuel is greater than or equal to the number of values, in the lower..upper key range, copies the entire range.

impl<K, V, L, O> LayerBuilder<K, L, O>

where K: DataTrait + ?Sized, V: DataTrait + ?Sized, O: OrdOffset, L: MergeBuilder, <L as Builder>::Trie: 'static, for<'a, 'b> <<L as Builder>::Trie as Trie>::Cursor<'a>: Cursor<'a, Key = V>,

pub fn push_merge_retain_values_fueled<KF, VF>( &mut self, (source1, lower1, upper1): (&<Self as Builder>::Trie, &mut usize, usize), (source2, lower2, upper2): (&<Self as Builder>::Trie, &mut usize, usize), key_filter: &KF, value_filter: &VF, map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, fuel: &mut isize, )

where KF: Fn(&K) -> bool, VF: Fn(&V) -> bool,

Like push_merge_fueled, but also removes values that don’t pass filter in both inputs.

Trait Implementations

impl<K, L, O> Builder for LayerBuilder<K, L, O>

where K: DataTrait + ?Sized, L: Builder, O: OrdOffset,

type Trie = Layer<K, <L as Builder>::Trie, O>

The type of collection produced.

fn boundary(&mut self) -> usize

Requests a commitment to the offset of the current-most sub-collection.

fn done(self) -> Self::Trie

Finalizes the building process and returns the collection.

impl<K, L, O: Clone> Clone for LayerBuilder<K, L, O>

where K: DataTrait + ?Sized + Clone, L: Builder + Clone, L::Trie: Clone,

fn clone(&self) -> LayerBuilder<K, L, O>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, L, O> Debug for LayerBuilder<K, L, O>

where K: DataTrait + ?Sized, L: Builder + Debug, O: 'static + Debug,

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

Formats the value using the given formatter.

impl<K, L, O> MergeBuilder for LayerBuilder<K, L, O>

where K: DataTrait + ?Sized, L: MergeBuilder, O: OrdOffset,

fn with_capacity(other1: &Self::Trie, other2: &Self::Trie) -> Self

Allocates an instance of the builder with sufficient capacity to contain the merged data.

fn reserve(&mut self, additional: usize)

fn keys(&self) -> usize

The number of keys pushed to the builder so far.

fn copy_range( &mut self, other: &Self::Trie, lower: usize, upper: usize, map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, )

Copy a range of other into this collection.

fn copy_range_retain_keys<'a, F>( &mut self, other: &'a Self::Trie, lower: usize, upper: usize, filter: &F, map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, )

where F: Fn(&<<Self::Trie as Trie>::Cursor<'a> as Cursor<'a>>::Key) -> bool,

Copy a range of other into this collection, only retaining entries whose keys satisfy the filter condition.

fn push_merge<'a>( &'a mut self, cursor1: <Self::Trie as Trie>::Cursor<'a>, cursor2: <Self::Trie as Trie>::Cursor<'a>, map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, )

Merges two sub-collections into one sub-collection.

fn push_merge_retain_keys<'a, F>( &'a mut self, cursor1: <Self::Trie as Trie>::Cursor<'a>, cursor2: <Self::Trie as Trie>::Cursor<'a>, filter: &F, map_func: Option<&dyn Fn(&mut <<Self as Builder>::Trie as Trie>::LeafKey)>, )

where F: Fn(&<<Self::Trie as Trie>::Cursor<'a> as Cursor<'a>>::Key) -> bool,

Merges two sub-collections into one sub-collection, only retaining entries whose keys satisfy the filter condition.

impl<K, L, O> SizeOf for LayerBuilder<K, L, O>

where K: DataTrait + ?Sized, L: Builder + SizeOf, Box<DynVec<K>>: SizeOf, Vec<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

impl<K, L, O> TupleBuilder for LayerBuilder<K, L, O>

where K: DataTrait + ?Sized, L: TupleBuilder, O: OrdOffset,

fn new(factories: &<Self::Trie as Trie>::Factories) -> Self

Allocates a new builder.

fn with_capacity( factories: &<Self::Trie as Trie>::Factories, cap: usize, ) -> Self

Allocates a new builder with capacity for at least cap tuples.

fn reserve_tuples(&mut self, additional: usize)

Reserve space for additional new tuples to be added to the current builder

fn tuples(&self) -> usize

fn push_tuple<'a>(&mut self, (key, val): (&mut K, <L::Trie as Trie>::Item<'_>))

Inserts a new tuple into the current builder

fn push_refs<'a>(&mut self, (key, val): (&K, <L::Trie as Trie>::ItemRef<'_>))

fn extend_tuples<'a, I>(&'a mut self, tuples: I)

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

Inserts all of the given tuples into the current builder