Trait frame_support::storage::StorageNMap

source · 
pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
    type Query;


Show 20 methods    // Required methods
    fn hashed_key_for<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(
        key: KArg,
    ) -> Vec<u8> ⓘ;
    fn contains_key<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(
        key: KArg,
    ) -> bool;
    fn get<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(
        key: KArg,
    ) -> Self::Query;
    fn try_get<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(
        key: KArg,
    ) -> Result<V, ()>;
    fn set<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(
        key: KArg,
        query: Self::Query,
    );
    fn swap<KOther, KArg1, KArg2>(key1: KArg1, key2: KArg2)
       where KOther: KeyGenerator,
             KArg1: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
             KArg2: EncodeLikeTuple<KOther::KArg> + TupleToEncodedIter;
    fn insert<KArg, VArg>(key: KArg, val: VArg)
       where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
             VArg: EncodeLike<V>;
    fn remove<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg);
    fn remove_prefix<KP>(
        partial_key: KP,
        limit: Option<u32>,
    ) -> KillStorageResult
       where K: HasKeyPrefix<KP>;
    fn clear_prefix<KP>(
        partial_key: KP,
        limit: u32,
        maybe_cursor: Option<&[u8]>,
    ) -> MultiRemovalResults
       where K: HasKeyPrefix<KP>;
    fn contains_prefix<KP>(partial_key: KP) -> bool
       where K: HasKeyPrefix<KP>;
    fn iter_prefix_values<KP>(partial_key: KP) -> PrefixIterator<V> ⓘ
       where K: HasKeyPrefix<KP>;
    fn mutate<KArg, R, F>(key: KArg, f: F) -> R
       where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
             F: FnOnce(&mut Self::Query) -> R;
    fn try_mutate<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
       where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
             F: FnOnce(&mut Self::Query) -> Result<R, E>;
    fn mutate_exists<KArg, R, F>(key: KArg, f: F) -> R
       where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
             F: FnOnce(&mut Option<V>) -> R;
    fn try_mutate_exists<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
       where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
             F: FnOnce(&mut Option<V>) -> Result<R, E>;
    fn take<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(
        key: KArg,
    ) -> Self::Query;
    fn append<Item, EncodeLikeItem, KArg>(key: KArg, item: EncodeLikeItem)
       where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
             Item: Encode,
             EncodeLikeItem: EncodeLike<Item>,
             V: StorageAppend<Item>;
    fn migrate_keys<KArg>(key: KArg, hash_fns: K::HArg) -> Option<V>
       where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter;

    // Provided method
    fn decode_len<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(
        key: KArg,
    ) -> Option<usize>
       where V: StorageDecodeLength { ... }

}
Expand description

An implementation of a map with an arbitrary number of keys.

Details of implementation can be found at [generator::StorageNMap].

Required Associated Types§

source

type Query

The type that get/take returns.

Required Methods§

source

fn hashed_key_for<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>( key: KArg, ) -> Vec<u8> ⓘ

Get the storage key used to fetch a value corresponding to a specific key.

source

fn contains_key<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>( key: KArg, ) -> bool

Does the value (explicitly) exist in storage?

source

fn get<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>( key: KArg, ) -> Self::Query

Load the value associated with the given key from the map.

source

fn try_get<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>( key: KArg, ) -> Result<V, ()>

Try to get the value for the given key from the map.

Returns Ok if it exists, Err if not.

source

fn set<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>( key: KArg, query: Self::Query, )

Store or remove the value to be associated with key so that get returns the query.

source

fn swap<KOther, KArg1, KArg2>(key1: KArg1, key2: KArg2)
where KOther: KeyGenerator, KArg1: EncodeLikeTuple<K::KArg> + TupleToEncodedIter, KArg2: EncodeLikeTuple<KOther::KArg> + TupleToEncodedIter,

Swap the values of two keys.

source

fn insert<KArg, VArg>(key: KArg, val: VArg)
where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter, VArg: EncodeLike<V>,

Store a value to be associated with the given key from the map.

source

fn remove<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg)

Remove the value under a key.

source

fn remove_prefix<KP>(partial_key: KP, limit: Option<u32>) -> KillStorageResult
where K: HasKeyPrefix<KP>,

👎Deprecated: Use clear_prefix instead

Remove all values starting with partial_key in the overlay and up to limit in the backend.

All values in the client overlay will be deleted, if there is some limit then up to limit values are deleted from the client backend, if limit is none then all values in the client backend are deleted.

§Note

Calling this multiple times per block with a limit set leads always to the same keys being removed and the same result being returned. This happens because the keys to delete in the overlay are not taken into account when deleting keys in the backend.

source

fn clear_prefix<KP>( partial_key: KP, limit: u32, maybe_cursor: Option<&[u8]>, ) -> MultiRemovalResults
where K: HasKeyPrefix<KP>,

Attempt to remove items from the map matching a partial_key prefix.

Returns MultiRemovalResults to inform about the result. Once the resultant maybe_cursor field is None, then no further items remain to be deleted.

NOTE: After the initial call for any given map, it is important that no further items are inserted into the map which match the partial key. If so, then the map may not be empty when the resultant maybe_cursor is None.

§Limit

A limit must be provided in order to cap the maximum amount of deletions done in a single call. This is one fewer than the maximum number of backend iterations which may be done by this operation and as such represents the maximum number of backend deletions which may happen. A limit of zero implies that no keys will be deleted, though there may be a single iteration done.

§Cursor

A cursor may be passed in to this operation with maybe_cursor. None should only be passed once (in the initial call) for any given storage map and partial_key. Subsequent calls operating on the same map/partial_key should always pass Some, and this should be equal to the previous call result’s maybe_cursor field.

source

fn contains_prefix<KP>(partial_key: KP) -> bool
where K: HasKeyPrefix<KP>,

Does any value under a partial_key prefix (explicitly) exist in storage? Might have unexpected behaviour with empty keys, e.g. [].

source

fn iter_prefix_values<KP>(partial_key: KP) -> PrefixIterator<V> ⓘ
where K: HasKeyPrefix<KP>,

Iterate over values that share the partial prefix key.

source

fn mutate<KArg, R, F>(key: KArg, f: F) -> R
where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter, F: FnOnce(&mut Self::Query) -> R,

Mutate the value under a key.

source

fn try_mutate<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter, F: FnOnce(&mut Self::Query) -> Result<R, E>,

Mutate the item, only if an Ok value is returned.

source

fn mutate_exists<KArg, R, F>(key: KArg, f: F) -> R
where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter, F: FnOnce(&mut Option<V>) -> R,

Mutate the value under a key.

Deletes the item if mutated to a None.

source

fn try_mutate_exists<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter, F: FnOnce(&mut Option<V>) -> Result<R, E>,

Mutate the item, only if an Ok value is returned. Deletes the item if mutated to a None. f will always be called with an option representing if the storage item exists (Some<V>) or if the storage item does not exist (None), independent of the QueryType.

source

fn take<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>( key: KArg, ) -> Self::Query

Take the value under a key.

source

fn append<Item, EncodeLikeItem, KArg>(key: KArg, item: EncodeLikeItem)
where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter, Item: Encode, EncodeLikeItem: EncodeLike<Item>, V: StorageAppend<Item>,

Append the given items to the value in the storage.

V is required to implement codec::EncodeAppend.

§Warning

If the storage item is not encoded properly, the storage will be overwritten and set to [item]. Any default value set for the storage item will be ignored on overwrite.

source

fn migrate_keys<KArg>(key: KArg, hash_fns: K::HArg) -> Option<V>
where KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,

Migrate an item with the given key from defunct hash_fns to the current hashers.

If the key doesn’t exist, then it’s a no-op. If it does, then it returns its value.

Provided Methods§

source

fn decode_len<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>( key: KArg, ) -> Option<usize>
where V: StorageDecodeLength,

Read the length of the storage value without decoding the entire value under the given key.

V is required to implement StorageDecodeLength.

If the value does not exists or it fails to decode the length, None is returned. Otherwise Some(len) is returned.

§Warning

None does not mean that get() does not return a value. The default value is completely ignored by this function.

Object Safety§

This trait is not object safe.

Implementors§

source§

impl<K, V, G> StorageNMap<K, V> for G
where K: KeyGenerator, V: FullCodec, G: StorageNMap<K, V>,

§

type Query = <G as StorageNMap<K, V>>::Query