Enum Entry 

pub enum Entry<'a, K, V, S, A = Global>
where
    A: Allocator,
{
    Occupied(OccupiedEntry<'a, K, V, S, A>),
    Vacant(VacantEntry<'a, K, V, S, 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 HashMap.

Examples

use rune::alloc::prelude::*;
use rune::alloc::hash_map::{Entry, HashMap, OccupiedEntry};

let mut map = HashMap::new();
map.try_extend([("a", 10), ("b", 20), ("c", 30)])?;
assert_eq!(map.len(), 3);

// Existing key (try_insert)
let entry: Entry<_, _, _> = map.entry("a");
let _raw_o: OccupiedEntry<_, _, _> = entry.try_insert(1)?;
assert_eq!(map.len(), 3);
// Nonexistent key (try_insert)
map.entry("d").try_insert(4)?;

// Existing key (or_try_insert)
let v = map.entry("b").or_try_insert(2)?;
assert_eq!(std::mem::replace(v, 2), 20);
// Nonexistent key (or_try_insert)
map.entry("e").or_try_insert(5)?;

// Existing key (or_try_insert_with)
let v = map.entry("c").or_try_insert_with(|| 3)?;
assert_eq!(std::mem::replace(v, 3), 30);
// Nonexistent key (or_try_insert_with)
map.entry("f").or_try_insert_with(|| 6)?;

println!("Our HashMap: {:?}", map);

let mut vec: Vec<_> = map.iter().map(|(&k, &v)| (k, v)).try_collect()?;
// The `Iter` iterator produces items in arbitrary order, so the
// items must be sorted to test them against a sorted array.
vec.sort_unstable();
assert_eq!(vec, [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5), ("f", 6)]);

Variants

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

An occupied entry.

Examples

use rune::alloc::hash_map::{Entry, HashMap};
let mut map: HashMap<_, _> = [("a", 100), ("b", 200)].try_into()?;

match map.entry("a") {
    Entry::Vacant(_) => unreachable!(),
    Entry::Occupied(_) => { }
}

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

A vacant entry.

Examples

use rune::alloc::hash_map::{Entry, HashMap};
let mut map: HashMap<&str, i32> = HashMap::new();

match map.entry("a") {
    Entry::Occupied(_) => unreachable!(),
    Entry::Vacant(_) => { }
}