Trait MapStorage

pub trait MapStorage<K, V>: Sized {
    type Iter<'this>: Iterator<Item = (K, &'this V)>
       where Self: 'this,
             V: 'this;
    type Keys<'this>: Iterator<Item = K>
       where Self: 'this;
    type Values<'this>: Iterator<Item = &'this V>
       where Self: 'this,
             V: 'this;
    type IterMut<'this>: Iterator<Item = (K, &'this mut V)>
       where Self: 'this,
             V: 'this;
    type ValuesMut<'this>: Iterator<Item = &'this mut V>
       where Self: 'this,
             V: 'this;
    type IntoIter: Iterator<Item = (K, V)>;
    type Occupied<'this>: OccupiedEntry<'this, K, V>
       where Self: 'this;
    type Vacant<'this>: VacantEntry<'this, K, V>
       where Self: 'this;

    // Required methods
    fn empty() -> Self;
    fn len(&self) -> usize;
    fn is_empty(&self) -> bool;
    fn insert(&mut self, key: K, value: V) -> Option<V>;
    fn contains_key(&self, key: K) -> bool;
    fn get(&self, key: K) -> Option<&V>;
    fn get_mut(&mut self, key: K) -> Option<&mut V>;
    fn remove(&mut self, key: K) -> Option<V>;
    fn retain<F>(&mut self, f: F)
       where F: FnMut(K, &mut V) -> bool;
    fn clear(&mut self);
    fn iter(&self) -> Self::Iter<'_>;
    fn keys(&self) -> Self::Keys<'_>;
    fn values(&self) -> Self::Values<'_>;
    fn iter_mut(&mut self) -> Self::IterMut<'_>;
    fn values_mut(&mut self) -> Self::ValuesMut<'_>;
    fn into_iter(self) -> Self::IntoIter;
    fn entry(&mut self, key: K) -> Entry<'_, Self, K, V>;
}

The trait defining how storage works.

Type Arguments

• K is the key being stored.
• V is the value being stored.

Required Associated Types

type Iter<'this>: Iterator<Item = (K, &'this V)> where Self: 'this, V: 'this

Immutable iterator over storage.

type Keys<'this>: Iterator<Item = K> where Self: 'this

Immutable iterator over keys in storage.

type Values<'this>: Iterator<Item = &'this V> where Self: 'this, V: 'this

Immutable iterator over values in storage.

type IterMut<'this>: Iterator<Item = (K, &'this mut V)> where Self: 'this, V: 'this

Mutable iterator over storage.

type ValuesMut<'this>: Iterator<Item = &'this mut V> where Self: 'this, V: 'this

Mutable iterator over values in storage.

type IntoIter: Iterator<Item = (K, V)>

Consuming iterator.

type Occupied<'this>: OccupiedEntry<'this, K, V> where Self: 'this

An occupied entry.

type Vacant<'this>: VacantEntry<'this, K, V> where Self: 'this

A vacant entry.

Required Methods

fn empty() -> Self

Construct empty storage.

fn len(&self) -> usize

Get the length of storage.

fn is_empty(&self) -> bool

Check if storage is empty.

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

This is the storage abstraction for Map::insert.

fn contains_key(&self, key: K) -> bool

This is the storage abstraction for Map::contains_key.

fn get(&self, key: K) -> Option<&V>

This is the storage abstraction for Map::get.

fn get_mut(&mut self, key: K) -> Option<&mut V>

This is the storage abstraction for Map::get_mut.

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

This is the storage abstraction for Map::remove.

fn retain<F>(&mut self, f: F)

where F: FnMut(K, &mut V) -> bool,

This is the storage abstraction for Map::retain.

fn clear(&mut self)

This is the storage abstraction for Map::clear.

fn iter(&self) -> Self::Iter<'_>

This is the storage abstraction for Map::iter.

fn keys(&self) -> Self::Keys<'_>

This is the storage abstraction for Map::keys.

fn values(&self) -> Self::Values<'_>

This is the storage abstraction for Map::values.

fn iter_mut(&mut self) -> Self::IterMut<'_>

This is the storage abstraction for Map::iter_mut.

fn values_mut(&mut self) -> Self::ValuesMut<'_>

This is the storage abstraction for Map::values_mut.

fn into_iter(self) -> Self::IntoIter

This is the storage abstraction for Map::into_iter.

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

This is the storage abstraction for Map::entry.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors