Struct everscale_types::dict::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

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.

Key is serialized using the default finalizer.

impl<K, A, V> AugDict<K, A, V>where K: DictKey,

pub fn iter<'a>(&'a self) -> AugIter<'_, 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 get_ext<'a: 'b, 'b, Q>( &'a self, key: Q, finalizer: &mut dyn Finalizer ) -> Result<Option<(A, V)>, Error>where Q: Borrow<K> + 'b, A: Load<'a>, V: Load<'a>,

Returns the augmented value corresponding to the key.

Key is serialized using the provided finalizer.

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

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

Tries to store itself into the cell builder.

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