Struct Layer 

pub struct Layer<K, L, O = usize>
where
    K: DataTrait + ?Sized,
    O: 'static,
    L: Trie,
{ /* private fields */ }

A level of the trie, with keys and offsets into a lower layer.

In this representation, the values for keys[i] are found at vals[offs[i] .. offs[i+1]].

Implementations

impl<K: DataTrait + ?Sized, L, O: 'static> Layer<K, L, O>

where L: Trie,

pub fn from_parts( factories: &LayerFactories<K, <L as Trie>::Factories>, keys: Box<DynVec<K>>, offs: Vec<O>, vals: L, ) -> Self

where O: OrdOffset,

Create a new OrderedLayer from its component parts

pub fn sample_keys<RG>( &self, rng: &mut RG, sample_size: usize, output: &mut DynVec<K>, )

where RG: Rng,

Compute a random sample of size sample_size of keys in self.keys.

Pushes the random sample of keys to the output vector in ascending order.

Trait Implementations

impl<K, L, O> AddAssignByRef for Layer<K, L, O>

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

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

impl<K, L, O> AddByRef for Layer<K, L, O>

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

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

impl<K, L, O> Archive for Layer<K, L, O>

where K: DataTrait + ?Sized, O: 'static, L: Trie + Archive, LayerFactories<K, <L as Trie>::Factories>: Archive, Box<DynVec<K>>: Archive, Vec<O>: Archive,

type Archived = ArchivedLayer<K, L, O>

The archived representation of this type.

type Resolver = LayerResolver<K, L, O>

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, L, O> Clone for Layer<K, L, O>

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

impl<K, L, O> Display for Layer<K, L, O>

where K: DataTrait + ?Sized, L: Trie, for<'a> L::Cursor<'a>: Clone + Display, O: OrdOffset,

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

Formats the value using the given formatter.

impl<K, L, O> Neg for Layer<K, L, O>

where K: DataTrait + ?Sized, L: Trie + Neg<Output = L>, O: OrdOffset,

type Output = Layer<K, L, O>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<K, L, O> NegByRef for Layer<K, L, O>

where K: DataTrait + ?Sized, L: Trie + NegByRef, O: OrdOffset,

fn neg_by_ref(&self) -> Self

impl<K, L, O> NumEntries for Layer<K, L, O>

where K: DataTrait + ?Sized, L: Trie + NumEntries, O: OrdOffset,

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<K, L, O> PartialEq for Layer<K, L, O>

where K: DataTrait + ?Sized, O: OrdOffset, L: Trie + PartialEq,

fn eq(&self, other: &Self) -> 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<__S: Fallible + ?Sized, K, L, O> Serialize<__S> for Layer<K, L, O>

where K: DataTrait + ?Sized, O: 'static, L: Trie + Serialize<__S>, LayerFactories<K, <L as Trie>::Factories>: Serialize<__S>, Box<DynVec<K>>: Serialize<__S>, Vec<O>: Serialize<__S>,

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, L, O> SizeOf for Layer<K, L, O>

where K: DataTrait + ?Sized, O: 'static, L: Trie + 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> Trie for Layer<K, L, O>

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

type Item<'a> = (&'a mut K, <L as Trie>::Item<'a>)

The type of item from which the type is constructed.

type ItemRef<'a> = (&'a K, <L as Trie>::ItemRef<'a>)

type Factories = LayerFactories<K, <L as Trie>::Factories>

type Cursor<'s> = LayerCursor<'s, K, L, O> where K: 's, O: 's, L: 's

The type of cursor used to navigate the type.

type MergeBuilder = LayerBuilder<K, <L as Trie>::MergeBuilder, O>

The type used to merge instances of the type together.

type TupleBuilder = LayerBuilder<K, <L as Trie>::TupleBuilder, O>

The type used to assemble instances of the type from its Items.

type LeafKey = <L as Trie>::LeafKey

The key type of the leaf sub-trie of this trie.

fn keys(&self) -> usize

The number of distinct keys, as distinct from the total number of tuples.

fn tuples(&self) -> usize

The total number of tuples in the collection.

fn cursor_from(&self, lower: usize, upper: usize) -> Self::Cursor<'_>

Returns a cursor over a range of data, commonly used by others to restrict navigation to sub-collections.

fn approximate_byte_size(&self) -> usize

Compute an approximate byte size of the collection.

fn is_empty(&self) -> bool

True if self.keys() is zero.

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

Returns a cursor capable of navigating the collection.

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

Merges two collections into a third.

impl<K, L, O> Eq for Layer<K, L, O>

where K: DataTrait + ?Sized, O: OrdOffset, L: Trie + Eq,