Struct hashbrown::map::RawOccupiedEntryMut

source ·
pub struct RawOccupiedEntryMut<'a, K, V, S, A: Allocator = Global> {
    elem: Bucket<(K, V)>,
    table: &'a mut RawTable<(K, V), A>,
    hash_builder: &'a S,
}
Expand description

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);

Fields§

§elem: Bucket<(K, V)>§table: &'a mut RawTable<(K, V), A>§hash_builder: &'a S

Implementations§

source§

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

source

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")
}
source

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);
source

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);
source

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),
}
source

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);
source

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);
source

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)),
}
source

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);
source

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);
source

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);
source

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);
source

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);
source

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);
source

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§

source§

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

source§

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

Formats the value using the given formatter. Read more
source§

impl<K, V, S, A> Send for RawOccupiedEntryMut<'_, K, V, S, A>
where K: Send, V: Send, S: Send, A: Send + Allocator,

source§

impl<K, V, S, A> Sync for RawOccupiedEntryMut<'_, K, V, S, A>
where K: Sync, V: Sync, S: Sync, A: Sync + Allocator,

Auto Trait Implementations§

§

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

§

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

§

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

§

impl<'a, K, V, S, A = Global> !UnwindSafe for RawOccupiedEntryMut<'a, K, V, S, A>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.