Struct oasis_std::collections::map::Map

pub struct Map<K, V> { /* fields omitted */ }

Map is a data structure with a HashMap-like API but based on a Vec. It's primarily useful when you care about constant factors or prefer determinism to speed. Please refer to the docs for HashMap for details and examples of the Map API.

Example

use oasis_std::collections::Map;
let mut map = Map::new();
map.insert("hello".to_string(), "world".to_string());
map.entry("hello".to_string())
    .and_modify(|mut v| v.push_str("!"));
assert_eq!(map.get("hello").map(String::as_str), Some("world!"))

Methods

impl<K: Eq, V> Map<K, V>

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn capacity(&self) -> usize

pub fn clear(&mut self)

pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool where
    K: Borrow<Q>,
    Q: Eq, 

pub fn drain(&mut self) -> Drain<(K, V)>

pub fn entry(&mut self, key: K) -> Entry<K, V>

pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V> where
    K: Borrow<Q>,
    Q: Eq, 

pub fn get_key_value<Q: ?Sized>(&self, key: &Q) -> Option<(&K, &V)> where
    K: Borrow<Q>,
    Q: Eq, 

pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V> where
    K: Borrow<Q>,
    Q: Eq, 

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

pub fn is_empty(&self) -> bool

pub fn iter(
    &self
) -> impl Iterator<Item = (&K, &V)> + DoubleEndedIterator + ExactSizeIterator

pub fn iter_mut(
    &mut self
) -> impl Iterator<Item = (&mut K, &mut V)> + DoubleEndedIterator + ExactSizeIterator

pub fn keys(
    &self
) -> impl Iterator<Item = &K> + DoubleEndedIterator + ExactSizeIterator

pub fn len(&self) -> usize

pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where
    K: Borrow<Q>,
    Q: Eq, 

pub fn remove_entry<Q: ?Sized>(&mut self, key: &Q) -> Option<(K, V)> where
    K: Borrow<Q>,
    Q: Eq, 

pub fn reserve(&mut self, additional: usize)

pub fn retain(&mut self, f: impl FnMut(&K, &mut V) -> bool)

pub fn shrink_to(&mut self, min_capacity: usize)

pub fn shrink_to_fit(&mut self)

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

pub fn values(
    &self
) -> impl Iterator<Item = &V> + DoubleEndedIterator + ExactSizeIterator

pub fn values_mut(
    &mut self
) -> impl Iterator<Item = &mut V> + DoubleEndedIterator + ExactSizeIterator

Trait Implementations

impl<K, V> BorshDeserialize for Map<K, V> where
    K: BorshDeserialize + Eq,
    V: BorshDeserialize, 

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

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

Deserialize this instance from a slice of bytes.

impl<K, V> BorshSerialize for Map<K, V> where
    K: BorshSerialize + PartialOrd,
    V: 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: Clone, V: Clone> Clone for Map<K, V>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for Map<K, V>

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

Formats the value using the given formatter.

impl<K: Default, V: Default> Default for Map<K, V>

fn default() -> Map<K, V>

Returns the "default value" for a type.

impl<K: Eq, V: Eq> Eq for Map<K, V>

impl<'a, K: 'a + Copy + Eq, V: 'a + Copy> Extend<(&'a K, &'a V)> for Map<K, V>

fn extend<T: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

impl<K: Eq, V> Extend<(K, V)> for Map<K, V>

fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

impl<K: Eq, V> FromIterator<(K, V)> for Map<K, V>

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<'_, Q: Eq + ?Sized, K: Eq + Borrow<Q>, V> Index<&'_ Q> for Map<K, V>

type Output = V

The returned type after indexing.

fn index(&self, key: &Q) -> &V

Performs the indexing (container[index]) operation.

impl<'a, K, V> IntoIterator for &'a Map<K, V>

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Map<Iter<'a, (K, V)>, fn(_: &'a (K, V)) -> (&'a K, &'a V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a mut Map<K, V>

type Item = (&'a mut K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = Map<IterMut<'a, (K, V)>, fn(_: &'a mut (K, V)) -> (&'a mut K, &'a mut V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> IntoIterator for Map<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<(K, V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: PartialEq, V: PartialEq> PartialEq<Map<K, V>> for Map<K, V>

fn eq(&self, other: &Map<K, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Map<K, V>) -> bool

This method tests for !=.

impl<K, V> StructuralEq for Map<K, V>

impl<K, V> StructuralPartialEq for Map<K, V>