Struct gstd::prelude::collections::hash_map::VacantEntryRef

pub struct VacantEntryRef<'a, 'b, K, Q, V, S, A = Global>
where
    A: Allocator,
    Q: ?Sized,
{ /* private fields */ }

A view into a vacant entry in a HashMap. It is part of the EntryRef enum.

Examples

use hashbrown::hash_map::{EntryRef, HashMap, VacantEntryRef};

let mut map = HashMap::<String, i32>::new();

let entry_v: VacantEntryRef<_, _, _, _> = match map.entry_ref("a") {
    EntryRef::Vacant(view) => view,
    EntryRef::Occupied(_) => unreachable!(),
};
entry_v.insert(10);
assert!(map["a"] == 10 && map.len() == 1);

// Nonexistent key (insert and update)
match map.entry_ref("b") {
    EntryRef::Occupied(_) => unreachable!(),
    EntryRef::Vacant(view) => {
        let value = view.insert(2);
        assert_eq!(*value, 2);
        *value = 20;
    }
}
assert!(map["b"] == 20 && map.len() == 2);

Implementations

impl<'a, 'b, K, Q, V, S, A> VacantEntryRef<'a, 'b, K, Q, V, S, A>

where A: Allocator, Q: ?Sized,

pub fn key(&self) -> &Q

where K: Borrow<Q>,

Gets a reference to the key that would be used when inserting a value through the VacantEntryRef.

Examples

use hashbrown::HashMap;

let mut map: HashMap<String, u32> = HashMap::new();
let key: &str = "poneyland";
assert_eq!(map.entry_ref(key).key(), "poneyland");

pub fn into_key(self) -> K

where K: From<&'b Q>,

Take ownership of the key.

Examples

use hashbrown::hash_map::{EntryRef, HashMap};

let mut map: HashMap<String, u32> = HashMap::new();
let key: &str = "poneyland";

match map.entry_ref(key) {
    EntryRef::Occupied(_) => panic!(),
    EntryRef::Vacant(v) => assert_eq!(v.into_key(), "poneyland".to_owned()),
}

pub fn insert(self, value: V) -> &'a mut V

where K: Hash + From<&'b Q>, S: BuildHasher,

Sets the value of the entry with the VacantEntryRef’s key, and returns a mutable reference to it.

Examples

use hashbrown::HashMap;
use hashbrown::hash_map::EntryRef;

let mut map: HashMap<String, u32> = HashMap::new();
let key: &str = "poneyland";

if let EntryRef::Vacant(o) = map.entry_ref(key) {
    o.insert(37);
}
assert_eq!(map["poneyland"], 37);

Trait Implementations

impl<K, Q, V, S, A> Debug for VacantEntryRef<'_, '_, K, Q, V, S, A>

where K: Borrow<Q>, Q: Debug + ?Sized, A: Allocator,

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

Formats the value using the given formatter.