Struct hashbrown::hash_map::RawEntryBuilderMut
source · pub struct RawEntryBuilderMut<'a, K, V, S, A: Allocator = Global> { /* private fields */ }
Expand description
A builder for computing where in a HashMap
a key-value pair would be stored.
See the HashMap::raw_entry_mut
docs for usage examples.
§Examples
use hashbrown::hash_map::{RawEntryBuilderMut, RawEntryMut::Vacant, RawEntryMut::Occupied};
use hashbrown::HashMap;
use core::hash::{BuildHasher, Hash};
let mut map = HashMap::new();
map.extend([(1, 11), (2, 12), (3, 13), (4, 14), (5, 15), (6, 16)]);
assert_eq!(map.len(), 6);
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 builder: RawEntryBuilderMut<_, _, _> = map.raw_entry_mut();
// Existing key
match builder.from_key(&6) {
Vacant(_) => unreachable!(),
Occupied(view) => assert_eq!(view.get(), &16),
}
for key in 0..12 {
let hash = compute_hash(map.hasher(), &key);
let value = map.get(&key).cloned();
let key_value = value.as_ref().map(|v| (&key, v));
println!("Key: {} and value: {:?}", key, value);
match map.raw_entry_mut().from_key(&key) {
Occupied(mut o) => assert_eq!(Some(o.get_key_value()), key_value),
Vacant(_) => assert_eq!(value, None),
}
match map.raw_entry_mut().from_key_hashed_nocheck(hash, &key) {
Occupied(mut o) => assert_eq!(Some(o.get_key_value()), key_value),
Vacant(_) => assert_eq!(value, None),
}
match map.raw_entry_mut().from_hash(hash, |q| *q == key) {
Occupied(mut o) => assert_eq!(Some(o.get_key_value()), key_value),
Vacant(_) => assert_eq!(value, None),
}
}
assert_eq!(map.len(), 6);
Implementations§
source§impl<'a, K, V, S, A: Allocator> RawEntryBuilderMut<'a, K, V, S, A>
impl<'a, K, V, S, A: Allocator> RawEntryBuilderMut<'a, K, V, S, A>
sourcepub fn from_key<Q>(self, k: &Q) -> RawEntryMut<'a, K, V, S, A>
pub fn from_key<Q>(self, k: &Q) -> RawEntryMut<'a, K, V, S, A>
Creates a RawEntryMut
from the given key.
§Examples
use hashbrown::hash_map::{HashMap, RawEntryMut};
let mut map: HashMap<&str, u32> = HashMap::new();
let key = "a";
let entry: RawEntryMut<&str, u32, _> = map.raw_entry_mut().from_key(&key);
entry.insert(key, 100);
assert_eq!(map[&"a"], 100);
sourcepub fn from_key_hashed_nocheck<Q>(
self,
hash: u64,
k: &Q,
) -> RawEntryMut<'a, K, V, S, A>where
Q: Equivalent<K> + ?Sized,
pub fn from_key_hashed_nocheck<Q>(
self,
hash: u64,
k: &Q,
) -> RawEntryMut<'a, K, V, S, A>where
Q: Equivalent<K> + ?Sized,
Creates a RawEntryMut
from the given key and its hash.
§Examples
use core::hash::{BuildHasher, Hash};
use hashbrown::hash_map::{HashMap, RawEntryMut};
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 mut map: HashMap<&str, u32> = HashMap::new();
let key = "a";
let hash = compute_hash(map.hasher(), &key);
let entry: RawEntryMut<&str, u32, _> = map.raw_entry_mut().from_key_hashed_nocheck(hash, &key);
entry.insert(key, 100);
assert_eq!(map[&"a"], 100);
source§impl<'a, K, V, S, A: Allocator> RawEntryBuilderMut<'a, K, V, S, A>
impl<'a, K, V, S, A: Allocator> RawEntryBuilderMut<'a, K, V, S, A>
sourcepub fn from_hash<F>(self, hash: u64, is_match: F) -> RawEntryMut<'a, K, V, S, A>
pub fn from_hash<F>(self, hash: u64, is_match: F) -> RawEntryMut<'a, K, V, S, A>
Creates a RawEntryMut
from the given hash and matching function.
§Examples
use core::hash::{BuildHasher, Hash};
use hashbrown::hash_map::{HashMap, RawEntryMut};
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 mut map: HashMap<&str, u32> = HashMap::new();
let key = "a";
let hash = compute_hash(map.hasher(), &key);
let entry: RawEntryMut<&str, u32, _> = map.raw_entry_mut().from_hash(hash, |k| k == &key);
entry.insert(key, 100);
assert_eq!(map[&"a"], 100);
Trait Implementations§
Auto Trait Implementations§
impl<'a, K, V, S, A> Freeze for RawEntryBuilderMut<'a, K, V, S, A>
impl<'a, K, V, S, A> RefUnwindSafe for RawEntryBuilderMut<'a, K, V, S, A>
impl<'a, K, V, S, A> Send for RawEntryBuilderMut<'a, K, V, S, A>
impl<'a, K, V, S, A> Sync for RawEntryBuilderMut<'a, K, V, S, A>
impl<'a, K, V, S, A> Unpin for RawEntryBuilderMut<'a, K, V, S, A>
impl<'a, K, V, S, A = Global> !UnwindSafe for RawEntryBuilderMut<'a, K, V, S, A>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Layout§
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 8 bytes