Enum Entry

pub enum Entry<'a, S, K, V>
where
    S: MapStorage<K, V> + 'a,
{
    Occupied(S::Occupied<'a>),
    Vacant(S::Vacant<'a>),
}

A view into a single entry in a map, which may either be vacant or occupied.

This enum is constructed from the entry method on Map.

Variants

Occupied(S::Occupied<'a>)

An occupied entry.

Vacant(S::Vacant<'a>)

A vacant entry.

Implementations

impl<'a, S, K, V> Entry<'a, S, K, V>

where S: MapStorage<K, V> + 'a,

pub fn or_insert(self, default: V) -> &'a mut V

Ensures a value is in the entry by inserting the default if empty, and returns a mutable reference to the value in the entry.

Examples

use fixed_map::{Key, Map};

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

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

map.entry(MyKey::First).or_insert(3);
assert_eq!(map.get(MyKey::First), Some(&3));

*map.entry(MyKey::First).or_insert(10) *= 2;
assert_eq!(map.get(MyKey::First), Some(&6));

Using a composite key:

use fixed_map::{Key, Map};

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

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

map.entry(MyKey::First(false)).or_insert(3);
assert_eq!(map.get(MyKey::First(false)), Some(&3));

*map.entry(MyKey::First(false)).or_insert(10) *= 2;
assert_eq!(map.get(MyKey::First(false)), Some(&6));

pub fn or_insert_with<F>(self, default: F) -> &'a mut V

where F: FnOnce() -> V,

Ensures a value is in the entry by inserting the result of the default function if empty, and returns a mutable reference to the value in the entry.

Examples

use fixed_map::{Key, Map};

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

let mut map: Map<MyKey, String> = Map::new();

map.entry(MyKey::First).or_insert_with(|| format!("{}", 3));
assert_eq!(map.get(MyKey::First), Some(&"3".to_string()));

Using a composite key:

use fixed_map::{Key, Map};

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

let mut map: Map<MyKey, String> = Map::new();

map.entry(MyKey::First(false)).or_insert_with(|| format!("{}", 3));
assert_eq!(map.get(MyKey::First(false)), Some(&"3".to_string()));

pub fn or_insert_with_key<F>(self, default: F) -> &'a mut V

where F: FnOnce(K) -> V,

Ensures a value is in the entry by inserting, if empty, the result of the default function. This method allows for generating key-derived values for insertion by providing the default function a copy of the key that was passed to the .entry(key) method call.

Examples

use fixed_map::{Key, Map};

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

let mut map: Map<MyKey, String> = Map::new();

map.entry(MyKey::First).or_insert_with_key(|k| format!("{:?} = {}", k, 3));
assert_eq!(map.get(MyKey::First), Some(&"First = 3".to_string()));

Using a composite key:

use fixed_map::{Key, Map};

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

let mut map: Map<MyKey, String> = Map::new();

map.entry(MyKey::First(false)).or_insert_with_key(|k| format!("{:?} = {}", k, 3));
assert_eq!(map.get(MyKey::First(false)), Some(&"First(false) = 3".to_string()));

pub fn key(&self) -> K

Returns a copy of this entry’s key.

Examples

use fixed_map::{Key, Map};

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

let mut map: Map<MyKey, i32> = Map::new();
assert_eq!(map.entry(MyKey::First).key(), MyKey::First);

Using a composite key:

use fixed_map::{Key, Map};

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

let mut map: Map<MyKey, i32> = Map::new();
assert_eq!(map.entry(MyKey::First(false)).key(), MyKey::First(false));

pub fn and_modify<F>(self, f: F) -> Self

where F: FnOnce(&mut V),

Provides in-place mutable access to an occupied entry before any potential inserts into the map.

Examples

use fixed_map::{Key, Map};

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

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

map.entry(MyKey::First)
   .and_modify(|e| { *e += 1 })
   .or_insert(42);
assert_eq!(map.get(MyKey::First), Some(&42));

map.entry(MyKey::First)
   .and_modify(|e| { *e += 1 })
   .or_insert(42);
assert_eq!(map.get(MyKey::First), Some(&43));

Using a composite key:

use fixed_map::{Key, Map};

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

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

map.entry(MyKey::First(true))
   .and_modify(|e| { *e += 1 })
   .or_insert(42);
assert_eq!(map.get(MyKey::First(true)), Some(&42));

map.entry(MyKey::First(true))
   .and_modify(|e| { *e += 1 })
   .or_insert(42);
assert_eq!(map.get(MyKey::First(true)), Some(&43));

pub fn or_default(self) -> &'a mut V

where V: Default,

Ensures a value is in the entry by inserting the default value if empty, and returns a mutable reference to the value in the entry.

Examples

use fixed_map::{Key, Map};

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

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

map.entry(MyKey::First).or_default();
assert_eq!(map.get(MyKey::First), Some(&0));

Using a composite key:

use fixed_map::{Key, Map};

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

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

map.entry(MyKey::First(false)).or_default();
assert_eq!(map.get(MyKey::First(false)), Some(&0));