Struct sov_state::AccessoryStateMap

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

A container that maps keys to values stored as “accessory” state, outside of the JMT.

Type parameters

AccessoryStateMap is generic over:

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

Implementations

impl<K, V> AccessoryStateMap<K, V>

pub fn new(prefix: Prefix) -> Self

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

impl<K, V, Codec> AccessoryStateMap<K, V, Codec>

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

Creates a new AccessoryStateMap with the given prefix and StateValueCodec.

pub fn prefix(&self) -> &Prefix

Returns the prefix used when this AccessoryStateMap was created.

impl<K, V, Codec> AccessoryStateMap<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 AccessoryWorkingSet<'_, S> )where Codec::KeyCodec: EncodeKeyLike<Q, K>, Q: ?Sized,

Inserts a key-value pair into the map.

Much like AccessoryStateMap::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 AccessoryWorkingSet<'_, S> ) -> Option<V>where Codec::KeyCodec: EncodeKeyLike<Q, K>, 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::{AccessoryStateMap, Storage, AccessoryWorkingSet};

fn foo<S>(map: AccessoryStateMap<Vec<u8>, u64>, key: &[u8], ws: &mut AccessoryWorkingSet<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::{AccessoryStateMap, Storage, AccessoryWorkingSet};

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

pub fn get_or_err<Q, S: Storage>( &self, key: &Q, working_set: &mut AccessoryWorkingSet<'_, S> ) -> Result<V, StateMapError>where Codec::KeyCodec: EncodeKeyLike<Q, K>, 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 AccessoryWorkingSet<'_, S> ) -> Option<V>where Codec::KeyCodec: EncodeKeyLike<Q, K>, 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 AccessoryWorkingSet<'_, S> ) -> Result<V, StateMapError>where Codec::KeyCodec: EncodeKeyLike<Q, K>, Q: ?Sized,

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

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

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

Deletes a key-value pair from the map.

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

Trait Implementations

impl<K, V, Codec> BorshDeserialize for AccessoryStateMap<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 AccessoryStateMap<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 AccessoryStateMap<K, V, Codec>

fn clone(&self) -> AccessoryStateMap<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 AccessoryStateMap<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 AccessoryStateMap<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<AccessoryStateMap<K, V, Codec>> for AccessoryStateMap<K, V, Codec>

fn eq(&self, other: &AccessoryStateMap<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 AccessoryStateMap<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 AccessoryStateMap<K, V, Codec>