Struct sov_state::StateMap

pub struct StateMap<K, V, Codec = BorshCodec> { /* private fields */ }

A container that maps keys to values.

Type parameters

StateMap is generic over:

• a key type K;
• a value type V;
• a StateValueCodec Codec.

Implementations

impl<K, V> StateMap<K, V>

pub fn new(prefix: Prefix) -> Self

Creates a new StateMap with the given prefix and the default StateValueCodec (i.e. BorshCodec).

impl<K, V, Codec> StateMap<K, V, Codec>

pub fn with_codec(prefix: Prefix, codec: Codec) -> Self

Creates a new StateMap with the given prefix and StateValueCodec.

pub fn codec(&self) -> &Codec

pub fn prefix(&self) -> &Prefix

Returns the prefix used when this StateMap was created.

impl<K, V, Codec> StateMap<K, V, Codec>where Codec: StateCodec, Codec::KeyCodec: StateKeyCodec<K>, Codec::ValueCodec: StateValueCodec<V>,

pub fn set<Q, S: Storage>( &self, key: &Q, value: &V, working_set: &mut WorkingSet<S> )where Codec::KeyCodec: EncodeKeyLike<Q, K>, Q: ?Sized,

Inserts a key-value pair into the map.

Much like StateMap::get, the key may be any borrowed form of the map’s key type.

pub fn get<Q, S: Storage>( &self, key: &Q, working_set: &mut WorkingSet<S> ) -> Option<V>where Codec: StateCodec, Codec::KeyCodec: EncodeKeyLike<Q, K>, Codec::ValueCodec: StateValueCodec<V>, Q: ?Sized,

Returns the value corresponding to the key, or None if the map doesn’t contain the key.

Examples

The key may be any item that implements EncodeKeyLike the map’s key type using your chosen codec.

use sov_state::{StateMap, Storage, WorkingSet};

fn foo<S>(map: StateMap<Vec<u8>, u64>, key: &[u8], ws: &mut WorkingSet<S>) -> Option<u64>
where
    S: Storage,
{
    // We perform the `get` with a slice, and not the `Vec`. it is so because `Vec` borrows
    // `[T]`.
    map.get(key, ws)
}

If the map’s key type does not implement EncodeKeyLike for your desired target type, you’ll have to convert the key to something else. An example of this would be “slicing” an array to use in Vec-keyed maps:

use sov_state::{StateMap, Storage, WorkingSet};

fn foo<S>(map: StateMap<Vec<u8>, u64>, key: [u8; 32], ws: &mut WorkingSet<S>) -> Option<u64>
where
    S: Storage,
{
    map.get(&key[..], ws)
}

pub fn get_or_err<Q, S: Storage>( &self, key: &Q, working_set: &mut WorkingSet<S> ) -> Result<V, StateMapError>where Codec: StateCodec, Codec::KeyCodec: EncodeKeyLike<Q, K>, Codec::ValueCodec: StateValueCodec<V>, Q: ?Sized,

Returns the value corresponding to the key or StateMapError if key is absent in the map.

pub fn remove<Q, S: Storage>( &self, key: &Q, working_set: &mut WorkingSet<S> ) -> Option<V>where Codec: StateCodec, Codec::KeyCodec: EncodeKeyLike<Q, K>, Codec::ValueCodec: StateValueCodec<V>, Q: ?Sized,

Removes a key from the map, returning the corresponding value (or None if the key is absent).

pub fn remove_or_err<Q, S: Storage>( &self, key: &Q, working_set: &mut WorkingSet<S> ) -> Result<V, StateMapError>where Codec: StateCodec, Codec::KeyCodec: EncodeKeyLike<Q, K>, Codec::ValueCodec: StateValueCodec<V>, Q: ?Sized,

Removes a key from the map, returning the corresponding value (or StateMapError if the key is absent).

Use StateMap::remove if you want an Option instead of a Result.

pub fn delete<Q, S: Storage>(&self, key: &Q, working_set: &mut WorkingSet<S>)where Codec: StateCodec, Codec::KeyCodec: EncodeKeyLike<Q, K>, Q: ?Sized,

Deletes a key-value pair from the map.

This is equivalent to StateMap::remove, but doesn’t deserialize and return the value beforing deletion.

Trait Implementations

impl<K, V, Codec> BorshDeserialize for StateMap<K, V, Codec>where (PhantomData<K>, PhantomData<V>): BorshDeserialize, Codec: BorshDeserialize, Prefix: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>where R: Read,

impl<K, V, Codec> BorshSerialize for StateMap<K, V, Codec>where (PhantomData<K>, PhantomData<V>): BorshSerialize, Codec: BorshSerialize, Prefix: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

impl<K: Clone, V: Clone, Codec: Clone> Clone for StateMap<K, V, Codec>

fn clone(&self) -> StateMap<K, V, Codec>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K: Debug, V: Debug, Codec: Debug> Debug for StateMap<K, V, Codec>

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

Formats the value using the given formatter.

impl<'de, K, V, Codec> Deserialize<'de> for StateMap<K, V, Codec>where Codec: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K: PartialEq, V: PartialEq, Codec: PartialEq> PartialEq<StateMap<K, V, Codec>> for StateMap<K, V, Codec>

fn eq(&self, other: &StateMap<K, V, Codec>) -> 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<K, V, Codec> Serialize for StateMap<K, V, Codec>where Codec: Serialize,

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, Codec> StructuralPartialEq for StateMap<K, V, Codec>