Struct everscale_types::RawDict

pub struct RawDict<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> RawDict<C, N>

pub const fn new() -> Self

Creates an empty dictionary.

pub const fn is_empty(&self) -> bool

Returns true if the dictionary contains no elements.

pub const fn root(&self) -> &Option<CellContainer<C>>

Returns the underlying root cell of the dictionary.

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

pub fn load_from_root_ext( slice: &mut CellSlice<'_, C>, finalizer: &mut dyn Finalizer<C> ) -> Option<Self>

Loads a non-empty dictionary from a root cell.

impl<C, const N: u16> RawDict<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) -> RawIter<'_, 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) -> RawKeys<'_, 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) -> RawValues<'_, 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> RawDict<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 RawDict<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> Debug for RawDict<C, N>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<C: CellFamily, const N: u16> From<Option<<C as CellFamily>::Container>> for RawDict<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 RawDict<C, N>

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

Tries to load itself from a cell slice.

impl<C: CellFamily, const N: u16> PartialEq<RawDict<C, N>> for RawDict<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 RawDict<C, N>

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

Tries to store itself into the cell builder.

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