Struct bevy::utils::hashbrown::hash_map::RawOccupiedEntryMut

pub struct RawOccupiedEntryMut<'a, K, V, S, A = Global>
where
    A: Allocator,
{ /* private fields */ }

A view into an occupied entry in a HashMap. It is part of the RawEntryMut enum.

Examples

use core::hash::{BuildHasher, Hash};
use hashbrown::hash_map::{HashMap, RawEntryMut, RawOccupiedEntryMut};

let mut map = HashMap::new();
map.extend([("a", 10), ("b", 20), ("c", 30)]);

fn compute_hash<K: Hash + ?Sized, S: BuildHasher>(hash_builder: &S, key: &K) -> u64 {
    use core::hash::Hasher;
    let mut state = hash_builder.build_hasher();
    key.hash(&mut state);
    state.finish()
}

let _raw_o: RawOccupiedEntryMut<_, _, _> = map.raw_entry_mut().from_key(&"a").insert("a", 100);
assert_eq!(map.len(), 3);

// Existing key (insert and update)
match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => unreachable!(),
    RawEntryMut::Occupied(mut view) => {
        assert_eq!(view.get(), &100);
        let v = view.get_mut();
        let new_v = (*v) * 10;
        *v = new_v;
        assert_eq!(view.insert(1111), 1000);
    }
}

assert_eq!(map[&"a"], 1111);
assert_eq!(map.len(), 3);

// Existing key (take)
let hash = compute_hash(map.hasher(), &"c");
match map.raw_entry_mut().from_key_hashed_nocheck(hash, &"c") {
    RawEntryMut::Vacant(_) => unreachable!(),
    RawEntryMut::Occupied(view) => {
        assert_eq!(view.remove_entry(), ("c", 30));
    }
}
assert_eq!(map.raw_entry().from_key(&"c"), None);
assert_eq!(map.len(), 2);

let hash = compute_hash(map.hasher(), &"b");
match map.raw_entry_mut().from_hash(hash, |q| *q == "b") {
    RawEntryMut::Vacant(_) => unreachable!(),
    RawEntryMut::Occupied(view) => {
        assert_eq!(view.remove_entry(), ("b", 20));
    }
}
assert_eq!(map.get(&"b"), None);
assert_eq!(map.len(), 1);

Implementations

impl<'a, K, V, S, A> RawOccupiedEntryMut<'a, K, V, S, A>

where A: Allocator,

pub fn key(&self) -> &K

Gets a reference to the key in the entry.

Examples

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

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.key(), &"a")
}

pub fn key_mut(&mut self) -> &mut K

Gets a mutable reference to the key in the entry.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => {
        *o.key_mut() = key_two.clone();
    }
}
assert_eq!(map[&key_two], 10);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

pub fn into_key(self) -> &'a mut K

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

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

let inside_key: &mut Rc<&str>;

match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => inside_key = o.into_key(),
}
*inside_key = key_two.clone();

assert_eq!(map[&key_two], 10);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

pub fn get(&self) -> &V

Gets a reference to the value in the entry.

Examples

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

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.get(), &100),
}

pub 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.

Examples

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

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

let value: &mut u32;

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => value = o.into_mut(),
}
*value += 900;

assert_eq!(map[&"a"], 1000);

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

Gets a mutable reference to the value in the entry.

Examples

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

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => *o.get_mut() += 900,
}

assert_eq!(map[&"a"], 1000);

pub fn get_key_value(&self) -> (&K, &V)

Gets a reference to the key and value in the entry.

Examples

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

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.get_key_value(), (&"a", &100)),
}

pub fn get_key_value_mut(&mut self) -> (&mut K, &mut V)

Gets a mutable reference to the key and value in the entry.

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => {
        let (inside_key, inside_value) = o.get_key_value_mut();
        *inside_key = key_two.clone();
        *inside_value = 100;
    }
}
assert_eq!(map[&key_two], 100);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

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

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

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

let inside_key: &mut Rc<&str>;
let inside_value: &mut u32;
match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => {
        let tuple = o.into_key_value();
        inside_key = tuple.0;
        inside_value = tuple.1;
    }
}
*inside_key = key_two.clone();
*inside_value = 100;
assert_eq!(map[&key_two], 100);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

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

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

Examples

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

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => assert_eq!(o.insert(1000), 100),
}

assert_eq!(map[&"a"], 1000);

pub fn insert_key(&mut self, key: K) -> K

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

Examples

use hashbrown::hash_map::{HashMap, RawEntryMut};
use std::rc::Rc;

let key_one = Rc::new("a");
let key_two = Rc::new("a");

let mut map: HashMap<Rc<&str>, u32> = HashMap::new();
map.insert(key_one.clone(), 10);

assert_eq!(map[&key_one], 10);
assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

match map.raw_entry_mut().from_key(&key_one) {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(mut o) => {
        let old_key = o.insert_key(key_two.clone());
        assert!(Rc::ptr_eq(&old_key, &key_one));
    }
}
assert_eq!(map[&key_two], 10);
assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);

pub fn remove(self) -> V

Takes the value out of the entry, and returns it.

Examples

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

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.remove(), 100),
}
assert_eq!(map.get(&"a"), None);

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

Take the ownership of the key and value from the map.

Examples

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

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => assert_eq!(o.remove_entry(), ("a", 100)),
}
assert_eq!(map.get(&"a"), None);

pub fn replace_entry_with<F>(self, f: F) -> RawEntryMut<'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::hash_map::{HashMap, RawEntryMut};

let mut map: HashMap<&str, u32> = [("a", 100), ("b", 200)].into();

let raw_entry = match map.raw_entry_mut().from_key(&"a") {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => o.replace_entry_with(|k, v| {
        assert_eq!(k, &"a");
        assert_eq!(v, 100);
        Some(v + 900)
    }),
};
let raw_entry = match raw_entry {
    RawEntryMut::Vacant(_) => panic!(),
    RawEntryMut::Occupied(o) => o.replace_entry_with(|k, v| {
        assert_eq!(k, &"a");
        assert_eq!(v, 1000);
        None
    }),
};
match raw_entry {
    RawEntryMut::Vacant(_) => { },
    RawEntryMut::Occupied(_) => panic!(),
};
assert_eq!(map.get(&"a"), None);

Trait Implementations

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

where K: Debug, V: Debug, A: Allocator,

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

Formats the value using the given formatter.

impl<K, V, S, A> Send for RawOccupiedEntryMut<'_, K, V, S, A>

where K: Send, V: Send, S: Send, A: Send + Allocator,

impl<K, V, S, A> Sync for RawOccupiedEntryMut<'_, K, V, S, A>

where K: Sync, V: Sync, S: Sync, A: Sync + Allocator,