impl<'a, K, V, S, A: Allocator> OccupiedEntry<'a, K, V, S, A>

fn key(&self) -> &K

Gets a reference to the key in the entry.

Examples

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

let mut map: HashMap<&str, u32> = HashMap::new();
map.entry("poneyland").or_insert(12);

match map.entry("poneyland") {
    Entry::Vacant(_) => panic!(),
    Entry::Occupied(entry) => assert_eq!(entry.key(), &"poneyland"),
}

fn replace_key(&mut self, key: K) -> K
where
    K: Equivalent<K>,

Replaces the key in the entry with a new one.

Panics

This method panics if key is not equivalent to the key in the entry.

Examples

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

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

let old_key = "poneyland";
let new_key = Box::leak(old_key.to_owned().into_boxed_str());
map.entry(old_key).or_insert(12);
 match map.entry("poneyland") {
    Entry::Vacant(_) => panic!(),
    Entry::Occupied(mut entry) => {
        let replaced = entry.replace_key(new_key);
        assert!(std::ptr::eq(replaced, old_key));
        assert!(std::ptr::eq(*entry.key(), new_key));
    },
}

# // appease miri; no memory leaks here!
# drop(map);
# unsafe {
#     Box::from_raw(new_key);
# }

unsafe fn replace_key_unchecked(&mut self, key: K) -> K

Replaces the key in the entry with a new one, without checking the equivalence of the key.

Safety

This operation is safe if you replace the key with an equivalent one.

Additionally, this operation (and following operations) are guaranteed to not violate memory safety.

However this operation is still unsafe because the resulting HashMap may be passed to unsafe code which does expect the map to behave correctly. If the map has keys at unexpected positions inside it, future operations may panic, loop forever, or return unexpected results, potentially violating memory safety.

Examples

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

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

let old_key = "poneyland";
let new_key = Box::leak(old_key.to_owned().into_boxed_str());
map.entry(old_key).or_insert(12);
 match map.entry("poneyland") {
    Entry::Vacant(_) => panic!(),
    Entry::Occupied(mut entry) => {
        let replaced = unsafe { entry.replace_key_unchecked(new_key) };
        assert!(std::ptr::eq(replaced, old_key));
        assert!(std::ptr::eq(*entry.key(), new_key));
    },
}

# // appease miri; no memory leaks here!
# drop(map);
# unsafe {
#     Box::from_raw(new_key);
# }

fn remove_entry(self) -> (K, V)

Take the ownership of the key and value from the map. Keeps the allocated memory for reuse.

Examples

use hashbrown::HashMap;
use hashbrown::hash_map::Entry;

let mut map: HashMap<&str, u32> = HashMap::new();
// The map is empty
assert!(map.is_empty() && map.capacity() == 0);

map.entry("poneyland").or_insert(12);

if let Entry::Occupied(o) = map.entry("poneyland") {
    // We delete the entry from the map.
    assert_eq!(o.remove_entry(), ("poneyland", 12));
}

assert_eq!(map.contains_key("poneyland"), false);
// Now map hold none elements
assert!(map.is_empty());

fn get(&self) -> &V

Gets a reference to the value in the entry.

Examples

use hashbrown::HashMap;
use hashbrown::hash_map::Entry;

let mut map: HashMap<&str, u32> = HashMap::new();
map.entry("poneyland").or_insert(12);

match map.entry("poneyland") {
    Entry::Vacant(_) => panic!(),
    Entry::Occupied(entry) => assert_eq!(entry.get(), &12),
}

fn get_mut(&mut self) -> &mut V

Gets a mutable reference to the value in the entry.

If you need a reference to the OccupiedEntry which may outlive the destruction of the Entry value, see into_mut.

Examples

use hashbrown::HashMap;
use hashbrown::hash_map::Entry;

let mut map: HashMap<&str, u32> = HashMap::new();
map.entry("poneyland").or_insert(12);

assert_eq!(map["poneyland"], 12);
if let Entry::Occupied(mut o) = map.entry("poneyland") {
    *o.get_mut() += 10;
    assert_eq!(*o.get(), 22);

    // We can use the same Entry multiple times.
    *o.get_mut() += 2;
}

assert_eq!(map["poneyland"], 24);

fn into_mut(self) -> &'a mut V

Converts the OccupiedEntry into a mutable reference to the value in the entry with a lifetime bound to the map itself.

If you need multiple references to the OccupiedEntry, see get_mut.

Examples

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

let mut map: HashMap<&str, u32> = HashMap::new();
map.entry("poneyland").or_insert(12);

assert_eq!(map["poneyland"], 12);

let value: &mut u32;
match map.entry("poneyland") {
    Entry::Occupied(entry) => value = entry.into_mut(),
    Entry::Vacant(_) => panic!(),
}
*value += 10;

assert_eq!(map["poneyland"], 22);

fn into_entry(self) -> (&'a K, &'a mut V)

Converts the OccupiedEntry into a reference to the key and a mutable reference to the value in the entry with a lifetime bound to the map itself.

If you need multiple references to the OccupiedEntry, see key and get_mut.

Examples

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

let mut map: HashMap<&str, u32> = HashMap::new();
map.entry("poneyland").or_insert(12);

assert_eq!(map["poneyland"], 12);

let key_val: (&&str, &mut u32);
match map.entry("poneyland") {
    Entry::Occupied(entry) => key_val = entry.into_entry(),
    Entry::Vacant(_) => panic!(),
}
*key_val.1 += 10;

assert_eq!(key_val, (&"poneyland", &mut 22));
assert_eq!(map["poneyland"], 22);

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

Sets the value of the entry, and returns the entry's old value.

Examples

use hashbrown::HashMap;
use hashbrown::hash_map::Entry;

let mut map: HashMap<&str, u32> = HashMap::new();
map.entry("poneyland").or_insert(12);

if let Entry::Occupied(mut o) = map.entry("poneyland") {
    assert_eq!(o.insert(15), 12);
}

assert_eq!(map["poneyland"], 15);

fn remove(self) -> V

Takes the value out of the entry, and returns it. Keeps the allocated memory for reuse.

Examples

use hashbrown::HashMap;
use hashbrown::hash_map::Entry;

let mut map: HashMap<&str, u32> = HashMap::new();
// The map is empty
assert!(map.is_empty() && map.capacity() == 0);

map.entry("poneyland").or_insert(12);

if let Entry::Occupied(o) = map.entry("poneyland") {
    assert_eq!(o.remove(), 12);
}

assert_eq!(map.contains_key("poneyland"), false);
// Now map hold none elements
assert!(map.is_empty());

fn replace_entry_with<F>(self, f: F) -> Entry<'a, K, V, S, A>
where
    F: FnOnce(&K, V) -> Option<V>,

Provides shared access to the key and owned access to the value of the entry and allows to replace or remove it based on the value of the returned option.

Examples

use hashbrown::HashMap;
use hashbrown::hash_map::Entry;

let mut map: HashMap<&str, u32> = HashMap::new();
map.insert("poneyland", 42);

let entry = match map.entry("poneyland") {
    Entry::Occupied(e) => {
        e.replace_entry_with(|k, v| {
            assert_eq!(k, &"poneyland");
            assert_eq!(v, 42);
            Some(v + 1)
        })
    }
    Entry::Vacant(_) => panic!(),
};

match entry {
    Entry::Occupied(e) => {
        assert_eq!(e.key(), &"poneyland");
        assert_eq!(e.get(), &43);
    }
    Entry::Vacant(_) => panic!(),
}

assert_eq!(map["poneyland"], 43);

let entry = match map.entry("poneyland") {
    Entry::Occupied(e) => e.replace_entry_with(|_k, _v| None),
    Entry::Vacant(_) => panic!(),
};

match entry {
    Entry::Vacant(e) => {
        assert_eq!(e.key(), &"poneyland");
    }
    Entry::Occupied(_) => panic!(),
}

assert!(!map.contains_key("poneyland"));

fn into_map(self) -> &'a mut HashMap<K, V, S, A>

Converts the OccupiedEntry into a mutable reference to the underlying map.