Struct Map 

pub struct Map<K: 'static + Label, V: AsHashTree + 'static> { /* private fields */ }

Implementations

impl<K: 'static + Label, V: AsHashTree + 'static> Map<K, V>

pub fn new() -> Self

pub fn is_empty(&self) -> bool

Returns true if the map does not contain any values.

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn clear(&mut self)

Clear the map.

pub fn insert(&mut self, key: K, value: V) -> Option<V>

Insert a key-value pair into the map. Returns None if the key did not exists in the map, otherwise the previous value associated with the provided key will be returned.

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

where K: Borrow<Q>, Q: Ord + ?Sized,

Remove the value associated with the given key from the map, returns the previous value associated with the key.

pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>

where K: Borrow<Q>, Q: Ord + ?Sized,

Remove an entry from the map and return the key and value.

pub fn entry(&mut self, key: K) -> Entry<'_, K, V>

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

where K: Borrow<Q>, Q: Ord + ?Sized,

Returns a mutable reference to the value corresponding to the key.

pub fn get<Q>(&self, key: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Ord + ?Sized,

Return the value associated with the given key.

pub fn iter(&self) -> RbTreeIterator<'_, K, V>

Return an iterator over the key-values in the map.

pub fn witness<Q>(&self, key: &Q) -> HashTree<'_>

where K: Borrow<Q>, Q: Ord + ?Sized,

Create a HashTree witness for the value associated with given key.

pub fn witness_keys(&self) -> HashTree<'_>

Returns a witness enumerating all the keys in this map. The resulting tree doesn’t include values, they are replaced with “Pruned” nodes.

pub fn witness_value_range<Q1, Q2>(&self, first: &K, last: &K) -> HashTree<'_>

where K: Borrow<Q1> + Borrow<Q2>, Q1: Ord + ?Sized, Q2: Ord + ?Sized,

Returns a witness for the key-value pairs in the specified range. The resulting tree contains both keys and values.

pub fn witness_key_range<Q1, Q2>(&self, first: &K, last: &K) -> HashTree<'_>

where K: Borrow<Q1> + Borrow<Q2>, Q1: Ord + ?Sized, Q2: Ord + ?Sized,

Returns a witness for the keys in the specified range. The resulting tree only contains the keys, and the values are replaced with “Pruned” nodes.

pub fn witness_keys_with_prefix<P>(&self, prefix: &P) -> HashTree<'_>

where K: Prefix<P>, P: Ord + ?Sized,

Returns a witness for the keys with the given prefix, this replaces the values with “Pruned” nodes.

pub fn as_tree(&self) -> &RbTree<K, V>

Return the underlying RbTree for this map.

impl<K: 'static + Label, V: AsHashTree> Map<K, Seq<V>>

pub fn append_deep(&mut self, key: K, value: V)

Perform a Seq::append on the seq associated with the give value, if the seq does not exists, creates an empty one and inserts it to the map.

pub fn len_deep<Q>(&mut self, key: &Q) -> usize

where K: Borrow<Q>, Q: Ord + ?Sized,

Trait Implementations

impl<K: 'static + Label, V: AsHashTree + 'static> AsHashTree for Map<K, V>

fn root_hash(&self) -> Hash

This method should return the root hash of this hash tree. Must be equivalent to as_hash_tree().reconstruct().

fn as_hash_tree(&self) -> HashTree<'_>

Constructs a hash tree corresponding to the data.

impl<K: 'static + Label, V: 'static + AsHashTree> AsRef<RbTree<K, V>> for Map<K, V>

fn as_ref(&self) -> &RbTree<K, V>

Converts this type into a shared reference of the (usually inferred) input type.

impl<K, V> CandidType for Map<K, V>

where K: CandidType + 'static + Label, V: CandidType + AsHashTree + 'static,

fn _ty() -> Type

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

where S: Serializer,

fn ty() -> Type

fn id() -> TypeId

impl<K, V> Debug for Map<K, V>

where K: Debug + 'static + Label, V: Debug + AsHashTree + 'static,

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

Formats the value using the given formatter.

impl<K: Default + 'static + Label, V: Default + AsHashTree + 'static> Default for Map<K, V>

fn default() -> Map<K, V>

Returns the “default value” for a type.

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

where K: Deserialize<'de> + 'static + Label, V: Deserialize<'de> + AsHashTree + 'static,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K: 'static + Label, V: AsHashTree + 'static> FromIterator<(K, V)> for Map<K, V>

fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self

Creates a value from an iterator.

impl<K, V> Serialize for Map<K, V>

where K: Serialize + 'static + Label, V: Serialize + AsHashTree + 'static,

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

where S: Serializer,

Serialize this value into the given Serde serializer.