Struct fixed_map::map::Map

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

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]);

Implementations

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();

pub fn keys(&self) -> Keys<'_, 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]);

pub fn values(&self) -> Values<'_, 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]);

pub fn values_mut(&mut self) -> ValuesMut<'_, 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]);

pub fn iter(&self) -> Iter<'_, 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)]);

pub fn iter_mut(&mut self) -> IterMut<'_, 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> 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.

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

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for Map<K, V>where
    K: Key<K, V> + Deserialize<'de>,
    V: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 ==.

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

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