Enum hash_arr_map::map::Entry

pub enum Entry<'a, K, V> {
    Occupied(OccupiedEntry<'a, K, V>),
    Vacant(VacantEntry<'a, K, V>),
}

An view into an entry in a Ham

Variants

Occupied(OccupiedEntry<'a, K, V>)

Vacant(VacantEntry<'a, K, V>)

Implementations

impl<'a, K: IntoIndex + FromIndex + Hash + Eq, V> Entry<'a, K, V>

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.

Examples

use hash_arr_map::Ham;

let mut map = Ham::new();

map.entry(1).or_insert(5);
assert_eq!(map[&1], 5);

*map.entry(1).or_insert(10) += 1;
assert_eq!(map[&1], 6);

pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut 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.

Examples

use hash_arr_map::Ham;

let mut map: Ham<u8, String> = Ham::new();

map.entry(6).or_insert_with(|| "pick up sticks".to_string());

assert_eq!(map[&6], "pick up sticks");

pub fn or_insert_with_key<F: FnOnce(&K) -> V>(self, default: F) -> &'a mut 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. The default function is given a reference to the key, so you can have key-derived values inserted without having to clone the key.

Examples

use hash_arr_map::Ham;

let mut repeats: Ham<usize, String> = Ham::new();

repeats.entry(6).or_insert_with_key(|&n| "x".repeat(n));

assert_eq!(repeats[&6], "xxxxxx");

impl<'a, K: IntoIndex + FromIndex + Hash + Eq, V: Default> Entry<'a, K, V>

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

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

pub const fn key(&self) -> &K

Returns a reference to this entry’s key.

Examples

use hash_arr_map::Ham;

let mut map: Ham<String, ()> = Ham::new();
assert_eq!(map.entry("rust".into()).key(), "rust");

pub fn and_modify<F: FnOnce(&mut V)>(self, f: F) -> Self

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

Examples

use hash_arr_map::Ham;

let mut map: Ham<u32, String> = Ham::new();

map.entry(1)
    .and_modify(|e| e.push_str(" again"))
    .or_insert_with(|| "Hello".to_string());
assert_eq!(map[&1], "Hello");

map.entry(1)
    .and_modify(|e| e.push_str(" again"))
    .or_insert_with(|| "Hello".to_string());
assert_eq!(map[&1], "Hello again");

Trait Implementations

impl<K: Debug, V: Debug> Debug for Entry<'_, K, V>

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

Formats the value using the given formatter.