Struct LookupMap

pub struct LookupMap<K, V>
where
    K: BorshSerialize + Ord,
    V: BorshSerialize + BorshDeserialize,
{ /* private fields */ }

An implementation of a map that stores its content directly on the persistent storage.

All operations are cached. The cache is flushed in the following cases:

• Self::flush method is called
• drop method is called

Implementations

impl<K, V> LookupMap<K, V>

where K: BorshSerialize + Ord, V: BorshSerialize + BorshDeserialize,

pub fn new(prefix: Vec<u8>) -> Self

Creates a new map. Uses prefix as a unique prefix for keys.

pub fn get_prefix(&self) -> &Box<[u8]>

Returns the unique byte prefix used for key generation in the LookupSet.

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

Inserts or removes a key-value to the map.

• If value is None then the specified key is removed.
• If value is Some(v) then v is inserted by the specified key

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

where K: Borrow<Q>, Q: BorshSerialize + ToOwned<Owned = K> + ?Sized,

Returns a reference to the value corresponding to the key.

If the map doesn’t have the key present, returns None

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

where K: Borrow<Q>, Q: BorshSerialize + ToOwned<Owned = K> + ?Sized,

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

If the map doesn’t have the key present, returns None

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

where K: Clone,

Inserts a key-value pair into the map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned.

pub fn remove(&mut self, k: K) -> Option<V>

where K: Clone,

Removes a key from the map, returning the value at the key if the key was previously in the map.

pub fn contains_key<Q>(&self, k: &Q) -> bool

where K: Borrow<Q>, Q: BorshSerialize + ToOwned<Owned = K> + ?Sized,

Returns true if the map contains a value for the specified key.

pub fn flush(&mut self)

Writes the cached operations to the persistent storage.

Panic

Panics if serialization fails

Trait Implementations

impl<K, V> BorshDeserialize for LookupMap<K, V>

where K: BorshSerialize + Ord, V: BorshSerialize + BorshDeserialize, Box<[u8]>: BorshDeserialize,

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.

impl<K, V> BorshSerialize for LookupMap<K, V>

where K: BorshSerialize + Ord, V: BorshSerialize + BorshDeserialize, Box<[u8]>: BorshSerialize,

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

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

Serialize this instance into a vector of bytes.

impl<K, V> Drop for LookupMap<K, V>

where K: BorshSerialize + Ord, V: BorshSerialize + BorshDeserialize,

fn drop(&mut self)

Executes the destructor for this type.

impl<K, V> Extend<(K, V)> for LookupMap<K, V>

where K: BorshSerialize + Ord, V: BorshSerialize + BorshDeserialize,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = (K, V)>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<K, V, Q> Index<&Q> for LookupMap<K, V>

where K: BorshSerialize + Ord + Borrow<Q>, V: BorshSerialize + BorshDeserialize, Q: BorshSerialize + ToOwned<Owned = K> + ?Sized,

type Output = V

The returned type after indexing.

fn index(&self, index: &Q) -> &Self::Output

Performs the indexing (container[index]) operation.