Struct AugDict 

pub struct AugDict<K, A, V> { /* private fields */ }

Typed augmented dictionary with fixed length keys.

TLB scheme

ahm_edge#_ {n:#} {V:Type} {A:Type} {l:#} {m:#}
  label:(HmLabel ~l n) {n = (~m) + l}
  node:(HashmapAugNode m V A) = HashmapAug n V A;

ahmn_leaf#_ {V:Type} {A:Type} extra:A value:V = HashmapAugNode 0 V A;
ahmn_fork#_ {n:#} {V:Type} {A:Type} left:^(HashmapAug n V A)
  right:^(HashmapAug n V A) extra:A = HashmapAugNode (n + 1) V A;

ahme_empty$0 {n:#} {V:Type} {A:Type} extra:A = HashmapAugE n V A;
ahme_root$1 {n:#} {V:Type} {A:Type} root:^(HashmapAug n V A) extra:A = HashmapAugE n V A;

Implementations

impl<K, A: Default, V> AugDict<K, A, V>

pub fn new() -> Self

Creates an empty dictionary

pub const fn from_parts(dict: Dict<K, (A, V)>, extra: A) -> Self

Manually constructs the dictionaty from parts.

pub fn into_parts(self) -> (Dict<K, (A, V)>, A)

Returns an underlying dictionary and the extra value.

pub fn cast_into<Q, T>(self) -> AugDict<Q, A, T>

where Q: EquivalentRepr<K>, (A, T): EquivalentRepr<(A, V)>,

Converts into a dictionary with an equivalent value type.

impl<K, A, V> AugDict<K, A, V>

where K: DictKey, for<'a> A: Default + Load<'a>,

pub fn update_root_extra(&mut self) -> Result<(), Error>

Recomputes the root extra value.

impl<K, A, V> AugDict<K, A, V>

pub const fn is_empty(&self) -> bool

Returns true if the dictionary contains no elements.

pub const fn dict(&self) -> &Dict<K, (A, V)>

Returns the underlying dictionary.

pub const fn root_extra(&self) -> &A

Returns the root augmented value.

impl<K, A, V> AugDict<K, A, V>

where K: Store + DictKey,

pub fn contains_key<Q>(&self, key: Q) -> Result<bool, Error>

where Q: Borrow<K>,

Returns true if the dictionary contains a value for the specified key.

impl<K, A, V> AugDict<K, A, V>

where K: Store + DictKey,

pub fn get<'a: 'b, 'b, Q>(&'a self, key: Q) -> Result<Option<(A, V)>, Error>

where Q: Borrow<K> + 'b, (A, V): Load<'a>,

Returns the value corresponding to the key.

impl<K, A, V> AugDict<K, A, V>

where K: DictKey,

pub fn find_by_extra<'a, S>( &'a self, flow: S, ) -> Result<Option<(K, A, V)>, Error>

where S: SearchByExtra<A>, A: Load<'a>, V: Load<'a>,

Searches for an item using a predicate on extra values.

Used as a secondary index.

impl<K, A, V> AugDict<K, A, V>

where K: Store + DictKey, for<'a> A: AugDictExtra + Store + Load<'a>, V: Store,

pub fn try_from_btree<Q, E, T>( sorted: &BTreeMap<Q, (E, T)>, ) -> Result<Self, Error>

where Q: Borrow<K>, E: Borrow<A>, T: Borrow<V>, K: Ord,

Builds a dictionary from a sorted collection.

pub fn try_from_sorted_slice<Q, E, T>( sorted: &[(Q, E, T)], ) -> Result<Self, Error>

where Q: Borrow<K>, E: Borrow<A>, T: Borrow<V>, K: Ord,

Builds a dictionary from a sorted slice.

pub fn set<Q, E, T>(&mut self, key: Q, aug: E, value: T) -> Result<bool, Error>

where Q: Borrow<K>, E: Borrow<A>, T: Borrow<V>,

Sets the augmented value associated with the key in the aug dictionary.

Use set_ext if you need to use a custom cell context.

pub fn set_ext<Q, E, T>( &mut self, key: Q, aug: E, value: T, context: &mut dyn CellContext, ) -> Result<bool, Error>

where Q: Borrow<K>, E: Borrow<A>, T: Borrow<V>,

Sets the value associated with the key in the dictionary.

pub fn replace<Q, E, T>( &mut self, key: Q, aug: E, value: T, ) -> Result<bool, Error>

where Q: Borrow<K>, E: Borrow<A>, T: Borrow<V>,

Sets the augmented value associated with the key in the aug dictionary only if the key was already present in it.

Use replace_ext if you need to use a custom cell context.

pub fn replace_ext<Q, E, T>( &mut self, key: Q, aug: E, value: T, context: &mut dyn CellContext, ) -> Result<bool, Error>

where Q: Borrow<K>, E: Borrow<A>, T: Borrow<V>,

Sets the value associated with the key in the dictionary only if the key was already present in it.

pub fn add<Q, E, T>(&mut self, key: Q, aug: E, value: T) -> Result<bool, Error>

where Q: Borrow<K>, E: Borrow<A>, T: Borrow<V>,

Sets the value associated with key in aug dictionary, but only if it is not already present.

Use add_ext if you need to use a custom cell context.

pub fn add_ext<Q, E, T>( &mut self, key: Q, aug: E, value: T, context: &mut dyn CellContext, ) -> Result<bool, Error>

where Q: Borrow<K>, E: Borrow<A>, T: Borrow<V>,

Sets the value associated with key in dictionary, but only if it is not already present.

pub fn remove<Q>(&mut self, key: Q) -> Result<Option<(A, V)>, Error>

where Q: Borrow<K>, for<'a> A: Load<'a> + 'static, for<'a> V: Load<'a> + 'static,

Removes the value associated with key in aug dictionary. Returns an optional removed value as cell slice parts.

pub fn remove_raw_ext<Q>( &mut self, key: Q, context: &mut dyn CellContext, ) -> Result<Option<CellSliceParts>, Error>

where Q: Borrow<K>,

Removes the value associated with key in dictionary. Returns an optional removed value as cell slice parts.

pub fn split(&self) -> Result<(Self, Self), Error>

Split dictionary into 2 dictionaries by the first key bit.

pub fn split_ext( &self, context: &mut dyn CellContext, ) -> Result<(Self, Self), Error>

Split dictionary into 2 dictionaries by the first key bit.

pub fn split_by_prefix( &self, key_prefix: &CellSlice<'_>, ) -> Result<(Self, Self), Error>

Split dictionary into 2 dictionaries at the prefix.

pub fn split_by_prefix_ext( &self, key_prefix: &CellSlice<'_>, context: &mut dyn CellContext, ) -> Result<(Self, Self), Error>

Split dictionary into 2 dictionaries at the prefix.

impl<K, A, V> AugDict<K, A, V>

where K: DictKey,

pub fn iter<'a>(&'a self) -> AugIter<'a, K, A, V>

where V: Load<'a>,

Gets an iterator over the entries of the dictionary, sorted by key. The iterator element type is Result<(K, A, V)>.

If the dictionary is invalid, finishes after the first invalid element, returning an error.

Performance

In the current implementation, iterating over dictionary builds a key for each element. Use values or raw_values if you don’t need keys from an iterator.

pub fn keys(&self) -> Keys<'_, K>

Gets an iterator over the keys of the dictionary, in sorted order. The iterator element type is Result<K>.

If the dictionary is invalid, finishes after the first invalid element, returning an error.

Performance

In the current implementation, iterating over dictionary builds a key for each element. Use values if you don’t need keys from an iterator.

impl<K, A, V> AugDict<K, A, V>

where K: DictKey,

pub fn values<'a>(&'a self) -> Values<'a, (A, V)>

where V: Load<'a>,

Gets an iterator over the augmented values of the dictionary, in order by key. The iterator element type is Result<V>.

If the dictionary is invalid, finishes after the first invalid element, returning an error.

impl<K, A, V> AugDict<K, A, V>

where K: Store + DictKey,

pub fn raw_iter(&self) -> RawIter<'_>

Gets an iterator over the raw entries of the dictionary, sorted by key. The iterator element type is Result<(CellBuilder, CellSlice)>.

If the dictionary is invalid, finishes after the first invalid element, returning an error.

Performance

In the current implementation, iterating over dictionary builds a key for each element. Use values or raw_values if you don’t need keys from an iterator.

pub fn raw_keys(&self) -> RawKeys<'_>

Gets an iterator over the raw keys of the dictionary, in sorted order. The iterator element type is Result<CellBuilder>.

If the dictionary is invalid, finishes after the first invalid element, returning an error.

Performance

In the current implementation, iterating over dictionary builds a key for each element. Use values or raw_values if you don’t need keys from an iterator.

impl<K, A, V> AugDict<K, A, V>

where K: DictKey,

pub fn raw_values(&self) -> RawValues<'_>

Gets an iterator over the raw values of the dictionary, in order by key. The iterator element type is Result<CellSlice>.

If the dictionary is invalid, finishes after the first invalid element, returning an error.

Trait Implementations

impl<K, A: Clone, V> Clone for AugDict<K, A, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, A: Debug, V> Debug for AugDict<K, A, V>

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

Formats the value using the given formatter.

impl<K, A: Default, V> Default for AugDict<K, A, V>

fn default() -> Self

Returns the “default value” for a type.

impl<K, A: ExactSize, V> ExactSize for AugDict<K, A, V>

fn exact_size(&self) -> Size

Exact size of the value when it is stored in a slice.

impl<'a, K, A: Load<'a>, V> Load<'a> for AugDict<K, A, V>

fn load_from(slice: &mut CellSlice<'a>) -> Result<Self, Error>

Tries to load itself from a cell slice.

impl<K, A: PartialEq, V> PartialEq for AugDict<K, A, V>

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<K, A, V> Serialize for AugDict<K, A, V>

where K: Serialize + Store + DictKey, for<'a> A: Serialize + Store + Load<'a>, for<'a> V: Serialize + Load<'a>,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, A: Store, V> Store for AugDict<K, A, V>

fn store_into( &self, builder: &mut CellBuilder, context: &mut dyn CellContext, ) -> Result<(), Error>

Tries to store itself into the cell builder.

impl<K, A: Eq, V> Eq for AugDict<K, A, V>