Struct enum_collections::EnumMap

pub struct EnumMap<K, V>
where
    K: Enumerated,
{ /* private fields */ }

A key-value map optimized for Enums used as keys.

Abstracts away the need to handle Option on insert/remove operations. It is faster to initialize than EnumTable, because Default value needn’t be cloned for each field.

Examples

Using get and insert functions.

use enum_collections::{EnumMap, Enumerated};
#[derive(Enumerated)]
enum Letter {
    A,
    B,
}

let mut map: EnumMap<Letter, u8> = EnumMap::new();
map.insert(Letter::A, 42);
assert_eq!(Some(&42u8), map.get(Letter::A));
map.remove(Letter::A);
assert_eq!(None, map.get(Letter::A));

Using Index and IndexMut syntactic sugar.

use enum_collections::{EnumMap, Enumerated};
#[derive(Enumerated)]
enum Letter {
    A,
    B,
}

let mut map: EnumMap<Letter, u8> = EnumMap::new();
map[Letter::A] = Some(42);
assert_eq!(Some(42u8), map[Letter::A]);
assert_eq!(Some(&42u8), map[Letter::A].as_ref());

Implementations

impl<K, V> EnumMap<K, V>

where K: Enumerated,

pub fn new() -> Self

Creates a new EnumMap, with pre-allocated space for all keys of the enum K. With the underlying array righsized, no resizing is further required.

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

Attemps to obtain a value for given key, returning Some(V) if found, or None if no value has been inserted for given key yet.

Args

• key - Instance of K, used to look up the corresponding value.

pub fn insert(&mut self, key: K, value: V)

Stores given value under the provided key. Overrides any existing value previously set.

Args

• key - The instance of K the value inserted can be looked up for.
• values - Value to bind to K.

pub fn remove(&mut self, key: K)

Removes value stored under given key. Further get operations are going to return None.

Trait Implementations

impl<K, V> Debug for EnumMap<K, V>

where K: Enumerated + Debug, V: Default + Debug,

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

Formats the value using the given formatter.

impl<K, V> Default for EnumMap<K, V>

where K: Enumerated,

fn default() -> Self

Constructs a new instance, capable of holding all values of key K without further resizing.

impl<K, V> Index<K> for EnumMap<K, V>

where K: Enumerated, V: Default,

type Output = Option<V>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<K, V> IndexMut<K> for EnumMap<K, V>

where K: Enumerated, V: Default,

fn index_mut(&mut self, key: K) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<K, V> PartialEq for EnumMap<K, V>

where K: Enumerated, V: Default + PartialEq,

fn eq(&self, other: &Self) -> 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> Eq for EnumMap<K, V>

where K: Enumerated, V: Default + Eq,