Struct fixed_map::map::Map

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

A fixed map with a predetermined size.

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Part {
    One,
    Two,
}

#[derive(Clone, Copy, Key)]
enum Key {
    Simple,
    Composite(Part),
    String(&'static str),
    Number(u32),
    Singleton(()),
    Option(Option<Part>),
    Boolean(bool),
}

let mut map = Map::new();

map.insert(Key::Simple, 1);
map.insert(Key::Composite(Part::One), 2);
map.insert(Key::String("foo"), 3);
map.insert(Key::Number(1), 4);
map.insert(Key::Singleton(()), 5);
map.insert(Key::Option(None), 6);
map.insert(Key::Option(Some(Part::One)), 7);
map.insert(Key::Boolean(true), 8);

assert_eq!(map.get(Key::Simple), Some(&1));
assert_eq!(map.get(Key::Composite(Part::One)), Some(&2));
assert_eq!(map.get(Key::Composite(Part::Two)), None);
assert_eq!(map.get(Key::String("foo")), Some(&3));
assert_eq!(map.get(Key::String("bar")), None);
assert_eq!(map.get(Key::Number(1)), Some(&4));
assert_eq!(map.get(Key::Number(2)), None);
assert_eq!(map.get(Key::Singleton(())), Some(&5));
assert_eq!(map.get(Key::Option(None)), Some(&6));
assert_eq!(map.get(Key::Option(Some(Part::One))), Some(&7));
assert_eq!(map.get(Key::Option(Some(Part::Two))), None);
assert_eq!(map.get(Key::Boolean(true)), Some(&8));
assert_eq!(map.get(Key::Boolean(false)), None);

Storing references:

use fixed_map::{Key, Map};

#[derive(Debug, Clone, Copy, Key)]
enum Key {
    First,
    Second,
}

let mut map = Map::new();
let a = 42u32;

map.insert(Key::First, &a);

assert_eq!(map.values().cloned().collect::<Vec<_>>(), vec![&42u32]);

Methods

impl<K, V> Map<K, V> where     K: Key<K, V>,

A map implementation that uses fixed storage.

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut m = Map::new();
m.insert(Key::One, 1);

assert_eq!(m.get(Key::One), Some(&1));
assert_eq!(m.get(Key::Two), None);

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Part {
    A,
    B,
}

#[derive(Clone, Copy, Key)]
enum Key {
    Simple,
    Composite(Part),
}

let mut m = Map::new();
m.insert(Key::Simple, 1);
m.insert(Key::Composite(Part::A), 2);

assert_eq!(m.get(Key::Simple), Some(&1));
assert_eq!(m.get(Key::Composite(Part::A)), Some(&2));
assert_eq!(m.get(Key::Composite(Part::B)), None);

pub fn new() -> Map<K, V>

Creates an empty Map.

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut map: Map<Key, i32> = Map::new();

Important traits for Keys<'a, K, V>

impl<'a, K: 'a, V: 'a> Iterator for Keys<'a, K, V> where
    K: Key<K, V>,  type Item = K;

pub fn keys<'a>(&'a self) -> Keys<'a, K, V>

An iterator visiting all keys in arbitrary order. The iterator element type is K.

Examples

use fixed_map::{Key, Map};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Key)]
pub enum Key {
    One,
    Two,
    Three,
}

let mut map = Map::new();
map.insert(Key::One, 1);
map.insert(Key::Two, 2);

assert_eq!(map.keys().collect::<Vec<_>>(), vec![Key::One, Key::Two]);

Important traits for Values<'a, K, V>

impl<'a, K: 'a, V: 'a> Iterator for Values<'a, K, V> where
    K: Key<K, V>,  type Item = &'a V;

pub fn values<'a>(&'a self) -> Values<'a, K, V>

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

Examples

use fixed_map::{Key, Map};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Key)]
pub enum Key {
    One,
    Two,
    Three,
}

let mut map = Map::new();
map.insert(Key::One, 1);
map.insert(Key::Two, 2);

assert_eq!(map.values().map(|v| *v).collect::<Vec<_>>(), vec![1, 2]);

Important traits for ValuesMut<'a, K, V>

impl<'a, K: 'a, V: 'a> Iterator for ValuesMut<'a, K, V> where
    K: Key<K, V>,  type Item = &'a mut V;

pub fn values_mut<'a>(&'a mut self) -> ValuesMut<'a, K, V>

An iterator visiting all values mutably in arbitrary order. The iterator element type is &'a mut V.

Examples

use fixed_map::{Key, Map};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Key)]
pub enum Key {
    One,
    Two,
    Three,
}

let mut map = Map::new();
map.insert(Key::One, 1);
map.insert(Key::Two, 2);

for val in map.values_mut() {
    *val += 10;
}

assert_eq!(map.values().map(|v| *v).collect::<Vec<_>>(), vec![11, 12]);

Important traits for Iter<'a, K, V>

impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> where
    K: Key<K, V>,  type Item = (K, &'a V);

pub fn iter<'a>(&'a self) -> Iter<'a, K, V>

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (K, &'a V).

Examples

use fixed_map::{Key, Map};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Key)]
enum Key {
    One,
    Two,
    Three,
}

let mut map = Map::new();
map.insert(Key::One, 1);
map.insert(Key::Two, 2);

assert_eq!(map.iter().collect::<Vec<_>>(), vec![(Key::One, &1), (Key::Two, &2)]);

Important traits for IterMut<'a, K, V>

impl<'a, K, V: 'a> Iterator for IterMut<'a, K, V> where
    K: Key<K, V>,  type Item = (K, &'a mut V);

pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, K, V>

An iterator visiting all key-value pairs in arbitrary order, with mutable references to the values. The iterator element type is (K, &'a mut V).

Examples

use fixed_map::{Key, Map};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Key)]
enum Key {
    One,
    Two,
    Three,
}

let mut map = Map::new();
map.insert(Key::One, 1);
map.insert(Key::Two, 2);

// Update all values
for (_, val) in map.iter_mut() {
    *val *= 2;
}

assert_eq!(map.iter().collect::<Vec<_>>(), vec![(Key::One, &2), (Key::Two, &4)]);

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

Returns a reference to the value corresponding to the key.

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut map = Map::new();
map.insert(Key::One, "a");
assert_eq!(map.get(Key::One), Some(&"a"));
assert_eq!(map.get(Key::Two), None);

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

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

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut map = Map::new();
map.insert(Key::One, "a");
if let Some(x) = map.get_mut(Key::One) {
    *x = "b";
}
assert_eq!(map.get(Key::One), Some(&"b"));

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

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.

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut map = Map::new();
assert_eq!(map.insert(Key::One, "a"), None);
assert_eq!(map.is_empty(), false);

map.insert(Key::Two, "b");
assert_eq!(map.insert(Key::Two, "c"), Some("b"));
assert_eq!(map.get(Key::Two), Some(&"c"));

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

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

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut map = Map::new();
map.insert(Key::One, "a");
assert_eq!(map.remove(Key::One), Some("a"));
assert_eq!(map.remove(Key::One), None);

pub fn clear(&mut self)

Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut map = Map::new();
map.insert(Key::One, "a");
map.clear();
assert!(map.is_empty());

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut map = Map::new();
assert!(map.is_empty());
map.insert(Key::One, "a");
assert!(!map.is_empty());

pub fn len(&self) -> usize

Returns the number of elements in the map.

Examples

use fixed_map::{Key, Map};

#[derive(Clone, Copy, Key)]
enum Key {
    One,
    Two,
}

let mut map = Map::new();
assert_eq!(map.len(), 0);
map.insert(Key::One, "a");
assert_eq!(map.len(), 1);

Trait Implementations

impl<K, V> Eq for Map<K, V> where     K: Key<K, V>,     K::Storage: Eq,

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

fn default() -> Self

Returns the "default value" for a type.

impl<K, V> PartialEq<Map<K, V>> for Map<K, V> where     K: Key<K, V>,     K::Storage: PartialEq,

fn eq(&self, other: &Self) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<K, V> Clone for Map<K, V> where     K: Key<K, V>,     K::Storage: Clone,

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, V> Debug for Map<K, V> where     K: Key<K, V> + Debug,     V: Debug,

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

Formats the value using the given formatter.