Struct Dict 

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

Typed dictionary with fixed length keys.

Implementations

impl<K, V> Dict<K, V>

pub const fn new() -> Self

Creates an empty dictionary

pub const fn from_raw(dict: Option<Cell>) -> Self

Creates a dictionary from a raw cell.

pub const fn is_empty(&self) -> bool

Returns true if the dictionary contains no elements.

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

Returns the underlying root cell of the dictionary.

pub fn into_root(self) -> Option<Cell>

Returns the underlying root cell of the dictionary.

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

where Q: EquivalentRepr<K>, T: EquivalentRepr<V>,

Converts into a dictionary with an equivalent value type.

pub fn cast_ref<Q, T>(&self) -> &Dict<Q, T>

where Q: EquivalentRepr<K>, T: EquivalentRepr<V>,

Casts itself into a lazy loaded for an equivalent type.

impl<K: DictKey, V> Dict<K, V>

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

Loads a non-empty dictionary from a root cell.

impl<K, V> Dict<K, V>

where K: StoreDictKey,

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, V> Dict<K, V>

where K: StoreDictKey,

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

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

Returns the value corresponding to the key.

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

where Q: Borrow<K> + 'b,

Returns the raw value corresponding to the key.

pub fn get_raw_owned<Q>(&self, key: Q) -> Result<Option<CellSliceParts>, Error>

where Q: Borrow<K>,

Returns cell slice parts of the value corresponding to the key.

NOTE: Uses the default cell context.

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

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

Removes the value associated with key in dictionary. Returns an optional removed value.

The dict is rebuilt using an empty cell context.

pub fn remove_raw<Q>(&mut self, key: Q) -> 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.

The dict is rebuilt using an empty cell context.

pub fn remove_min_raw( &mut self, signed: bool, ) -> Result<Option<(K, CellSliceParts)>, Error>

where K: LoadDictKey,

Removes the lowest key from the dict. Returns an optional removed key and value as cell slice parts.

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

pub fn remove_max_raw( &mut self, signed: bool, ) -> Result<Option<(K, CellSliceParts)>, Error>

where K: LoadDictKey,

Removes the largest key from the dict. Returns an optional removed key and value as cell slice parts.

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

pub fn remove_bound_raw( &mut self, bound: DictBound, signed: bool, ) -> Result<Option<(K, CellSliceParts)>, Error>

where K: LoadDictKey,

Removes the specified dict bound. Returns an optional removed key and value as cell slice parts.

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

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

Split dictionary into 2 dictionaries by the first key bit.

pub fn split_ext( &self, context: &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: &dyn CellContext, ) -> Result<(Self, Self), Error>

Split dictionary into 2 dictionaries at the prefix.

pub fn merge_with_right_sibling( &self, right: &Dict<K, V>, ) -> Result<Self, Error>

where for<'a> V: Load<'a> + 'static,

Merge dictionary with its right sibling.

pub fn merge_with_right_sibling_ext( &self, right: &Dict<K, V>, context: &dyn CellContext, ) -> Result<Self, Error>

Merge dictionary with its right sibling.

impl<K, V> Dict<K, V>

where K: StoreDictKey, V: Store,

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

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

Builds a dictionary from a sorted collection.

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

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

Builds a dictionary from a sorted slice.

pub fn modify_with_sorted_iter<I>(&mut self, entries: I) -> Result<bool, Error>

where I: IntoIterator<Item = (K, Option<V>)>, K: Clone + Ord,

Applies a sorted list of inserts/removes to the dictionary. Use this when you have a large set of known changes.

Uses custom extracts for values.

pub fn modify_with_sorted_iter_ext<T, I, FK, FV>( &mut self, entries: I, extract_key: FK, extract_value: FV, context: &dyn CellContext, ) -> Result<bool, Error>

where I: IntoIterator<Item = T>, K: Ord, for<'a> FK: FnMut(&'a T) -> K, FV: FnMut(T) -> Result<Option<V>, Error>,

Applies a sorted list of inserts/removes to the dictionary. Use this when you have a large set of known changes.

Uses custom extracts for values.

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

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

Sets the value associated with the key in the dictionary.

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

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

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

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 cell context.

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

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

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 cell context.

impl<K, V> Dict<K, V>

where K: DictKey,

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

where V: Load<'a>,

Gets an iterator over the entries of the dictionary, sorted by key. The iterator element type is Result<(K, 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 iter_union<'a>(&'a self, other: &'a Self) -> UnionIter<'a, K, V>

where V: Load<'a>,

Gets an iterator over the entries of two dictionaries, sorted by key. The iterator element type is Result<(K, Option<V>, Option<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.

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.

pub fn get_next<Q>(&self, key: Q, signed: bool) -> Result<Option<(K, V)>, Error>

where Q: Borrow<K>, K: StoreDictKey + LoadDictKey, for<'a> V: Load<'a>,

Computes the minimal key in dictionary that is lexicographically greater than key, and returns it along with associated value as cell slice parts.

pub fn get_prev<Q>(&self, key: Q, signed: bool) -> Result<Option<(K, V)>, Error>

where Q: Borrow<K>, K: StoreDictKey + LoadDictKey, for<'a> V: Load<'a>,

Computes the maximal key in dictionary that is lexicographically smaller than key, and returns it along with associated value as cell slice parts.

pub fn get_or_next<Q>( &self, key: Q, signed: bool, ) -> Result<Option<(K, V)>, Error>

where Q: Borrow<K>, K: StoreDictKey + LoadDictKey, for<'a> V: Load<'a>,

Computes the minimal key in dictionary that is lexicographically greater than key, and returns it along with associated value as cell slice parts.

pub fn get_or_prev<Q>( &self, key: Q, signed: bool, ) -> Result<Option<(K, V)>, Error>

where Q: Borrow<K>, K: StoreDictKey + LoadDictKey, for<'a> V: Load<'a>,

Computes the maximal key in dictionary that is lexicographically smaller than key, and returns it along with associated value as cell slice parts.

impl<K, V> Dict<K, V>

where K: DictKey,

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

where V: Load<'a>,

Gets an iterator over the 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.

pub fn get_min<'a>(&'a self, signed: bool) -> Result<Option<(K, V)>, Error>

where K: LoadDictKey, V: Load<'a>,

Returns the lowest key and a value corresponding to the key.

pub fn get_max<'a>(&'a self, signed: bool) -> Result<Option<(K, V)>, Error>

where K: LoadDictKey, V: Load<'a>,

Returns the lowest key and a value corresponding to the key.

pub fn get_bound_raw( &self, bound: DictBound, signed: bool, ) -> Result<Option<(K, CellSlice<'_>)>, Error>

where K: LoadDictKey,

Finds the specified dict bound and returns a key and a raw value corresponding to the key.

pub fn remove_bound_raw_ext( &mut self, bound: DictBound, signed: bool, context: &dyn CellContext, ) -> Result<Option<(K, CellSliceParts)>, Error>

where K: LoadDictKey,

Removes the specified dict bound. Returns an optional removed key and value as cell slice parts.

Key and dict are serialized using the provided cell context.

impl<K, V> Dict<K, V>

where K: StoreDictKey,

pub fn remove_raw_ext<Q>( &mut self, key: Q, context: &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.

Dict is rebuild using the provided cell context.

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_iter_union<'a>(&'a self, other: &'a Self) -> UnionRawIter<'a>

Gets an iterator over the raw entries of two dictionaries, sorted by key. The iterator element type is Result<(CellBuilder, Option<CellSlice>, Option<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.

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, V> Dict<K, 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.

impl<K, V> Dict<K, V>

where K: StoreDictKey, V: Store,

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

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

Sets the value associated with the key in the dictionary.

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

where Q: Borrow<K>, 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_ext<Q, T>( &mut self, key: Q, value: T, context: &dyn CellContext, ) -> Result<bool, Error>

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

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

Trait Implementations

impl BlockSignatureExt for Dict<u16, BlockSignature>

fn check_signatures<'a, I>(&self, list: I, data: &[u8]) -> Result<u64, Error>

where I: IntoIterator<Item = &'a ValidatorDescription, IntoIter: ExactSizeIterator>,

Verifies signatures for the specified data and the provided list of nodes.

impl<K, V> Clone for Dict<K, 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, V> Debug for Dict<K, V>

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

Formats the value using the given formatter.

impl<K, V> Default for Dict<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for Dict<K, V>

where K: Deserialize<'de> + Hash + Eq + StoreDictKey, V: Deserialize<'de> + Store,

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V> ExactSize for Dict<K, V>

fn exact_size(&self) -> Size

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

impl From<Dict<u32, VarUint248>> for ExtraCurrencyCollection

fn from(value: Dict<u32, VarUint248>) -> Self

Converts to this type from the input type.

impl From<ExtraCurrencyCollection> for Dict<u32, VarUint248>

fn from(value: ExtraCurrencyCollection) -> Self

Converts to this type from the input type.

impl<K, V> From<Option<Cell>> for Dict<K, V>

fn from(dict: Option<Cell>) -> Self

Converts to this type from the input type.

impl<'a, K, V> Load<'a> for Dict<K, V>

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

Tries to load itself from a cell slice.

impl<K, V> PartialEq for Dict<K, 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, V> Serialize for Dict<K, V>

where K: Serialize + LoadDictKey, for<'a> V: Serialize + Load<'a>,

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V> Store for Dict<K, V>

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

Tries to store itself into the cell builder.

impl<K, V, Q, T> TryFrom<&BTreeMap<Q, T>> for Dict<K, V>

where Q: Borrow<K>, T: Borrow<V>, K: StoreDictKey + Ord, V: Store,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &BTreeMap<Q, T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<K, V, Q, T> TryFrom<BTreeMap<Q, T>> for Dict<K, V>

where Q: Borrow<K>, T: Borrow<V>, K: StoreDictKey + Ord, V: Store,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: BTreeMap<Q, T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<K, V> Eq for Dict<K, V>