Trait MapStorage 

pub trait MapStorage {
    type Key;
    type Value;

    // Required methods
    fn contains_key(key: &Self::Key) -> bool;
    fn get(key: &Self::Key) -> Option<Self::Value>;
    fn insert(key: Self::Key, value: Self::Value);
    fn mutate<R, F: FnOnce(&mut Option<Self::Value>) -> R>(
        key: Self::Key,
        f: F,
    ) -> R;
    fn mutate_values<F: FnMut(Self::Value) -> Self::Value>(f: F);
    fn remove(key: Self::Key);
    fn clear();
    fn take(key: Self::Key) -> Option<Self::Value>;

    // Provided method
    fn mutate_exists<R, F: FnOnce(&mut Self::Value) -> R>(
        key: Self::Key,
        f: F,
    ) -> Option<R> { ... }
}

Represents logic of managing globally stored single-key map for more complicated logic.

In fact, represents custom implementation/wrapper around of Substrate’s StorageMap with OptionQuery.

Required Associated Types

type Key

Map’s key type.

type Value

Map’s stored value type.

Required Methods

fn contains_key(key: &Self::Key) -> bool

Returns bool, defining does map contain value under given key.

fn get(key: &Self::Key) -> Option<Self::Value>

Gets value stored under given key, if present.

fn insert(key: Self::Key, value: Self::Value)

Inserts value with given key.

fn mutate<R, F: FnOnce(&mut Option<Self::Value>) -> R>( key: Self::Key, f: F, ) -> R

Mutates value by Option reference, which stored (or not in None case) under given key with given function.

May return generic type value.

fn mutate_values<F: FnMut(Self::Value) -> Self::Value>(f: F)

Mutates all stored values with given convert function.

fn remove(key: Self::Key)

Removes value stored under the given key.

fn clear()

Removes all values.

fn take(key: Self::Key) -> Option<Self::Value>

Gets value stored under given key, if present, and removes it from storage.

Provided Methods

fn mutate_exists<R, F: FnOnce(&mut Self::Value) -> R>( key: Self::Key, f: F, ) -> Option<R>

Works the same as Self::mutate, but triggers if value present.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<GNStorage, GNProvider> MapStorage for GasNodesWrap<GNStorage, GNProvider>

where GNStorage: GasNodesStorage<GNProvider> + 'static, GNProvider: GasNodesProvider + 'static,

Available on crate feature std only.

type Key = GasNodeId<PlainNodeId, ReservationNodeId>

type Value = GasNode<ExternalOrigin, GasNodeId<PlainNodeId, ReservationNodeId>, u64, u128>

impl<T: AuxiliaryStorageWrap> MapStorage for T

Available on crate feature std only.

type Key = <T as AuxiliaryStorageWrap>::Key

type Value = <T as AuxiliaryStorageWrap>::Value