Struct everscale_types::dict::Dict

pub struct Dict<C: CellFamily, const N: u16>(_);

Dictionary with fixed length keys (where N is a number of bits in each key).

TLB scheme

// ordinary Hashmap / HashmapE, with fixed length keys

hm_edge#_ {n:#} {X:Type} {l:#} {m:#} label:(HmLabel ~l n)
          {n = (~m) + l} node:(HashmapNode m X) = Hashmap n X;

hmn_leaf#_ {X:Type} value:X = HashmapNode 0 X;
hmn_fork#_ {n:#} {X:Type} left:^(Hashmap n X)
           right:^(Hashmap n X) = HashmapNode (n + 1) X;

hml_short$0 {m:#} {n:#} len:(Unary ~n) {n <= m} s:(n * Bit) = HmLabel ~n m;
hml_long$10 {m:#} n:(#<= m) s:(n * Bit) = HmLabel ~n m;
hml_same$11 {m:#} v:Bit n:(#<= m) = HmLabel ~n m;

hme_empty$0 {n:#} {X:Type} = HashmapE n X;
hme_root$1 {n:#} {X:Type} root:^(Hashmap n X) = HashmapE n X;

unary_zero$0 = Unary ~0;
unary_succ$1 {n:#} x:(Unary ~n) = Unary ~(n + 1);

bit$_ (## 1) = Bit;

Implementations

impl<C: CellFamily, const N: u16> Dict<C, N>

pub fn new() -> Self

Creates an empty dictionary.

pub fn is_empty(&self) -> bool

Returns true if the dictionary contains no elements.

impl<C, const N: u16> Dict<C, N>where
    for<'c> C: CellFamily + 'c,

pub fn get<'a: 'b, 'b>(
    &'a self,
    key: CellSlice<'b, C>
) -> Result<Option<CellSlice<'a, C>>, Error>

Returns a CellSlice of the value corresponding to the key.

pub fn contains_key(&self, key: CellSlice<'_, C>) -> Result<bool, Error>

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

pub fn set_ext(
    &mut self,
    key: CellSlice<'_, C>,
    value: CellSlice<'_, C>,
    finalizer: &mut dyn Finalizer<C>
) -> Result<(), Error>

Sets the value associated with the key in the dictionary.

pub fn replace_ext(
    &mut self,
    key: CellSlice<'_, C>,
    value: CellSlice<'_, C>,
    finalizer: &mut dyn Finalizer<C>
) -> Result<(), Error>

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

pub fn add_ext(
    &mut self,
    key: CellSlice<'_, C>,
    value: CellSlice<'_, C>,
    finalizer: &mut dyn Finalizer<C>
) -> Result<(), Error>

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

pub fn iter(&self) -> Iter<'_, C>

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

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.

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

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

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.

pub fn values(&self) -> Values<'_, C>

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

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

impl<C, const N: u16> Dict<C, N>where
    for<'c> C: DefaultFinalizer + 'c,

pub fn set(
    &mut self,
    key: CellSlice<'_, C>,
    value: CellSlice<'_, C>
) -> Result<(), Error>

Sets the value associated with the key in the dictionary.

Use set_ext if you need to use a custom finalizer.

pub fn replace(
    &mut self,
    key: CellSlice<'_, C>,
    value: CellSlice<'_, C>
) -> Result<(), Error>

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

Use replace_ext if you need to use a custom finalizer.

pub fn add(
    &mut self,
    key: CellSlice<'_, C>,
    value: CellSlice<'_, C>
) -> Result<(), Error>

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

Use add_ext if you need to use a custom finalizer.

Trait Implementations

impl<C: CellFamily, const N: u16> Clone for Dict<C, N>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: CellFamily, const N: u16> Default for Dict<C, N>

fn default() -> Self

Returns the “default value” for a type.

impl<C: CellFamily, const N: u16> From<Option<<C as CellFamily>::Container<dyn Cell<C> + 'static>>> for Dict<C, N>

fn from(value: Option<CellContainer<C>>) -> Self

Converts to this type from the input type.

impl<'a, C: CellFamily, const N: u16> Load<'a, C> for Dict<C, N>

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

impl<C: CellFamily, const N: u16> PartialEq<Dict<C, N>> for Dict<C, N>

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<C: CellFamily, const N: u16> Store<C> for Dict<C, N>

fn store_into(&self, b: &mut CellBuilder<C>) -> bool

impl<C: CellFamily, const N: u16> Eq for Dict<C, N>