Struct scc::hash_map::OccupiedEntry

source ·

pub struct OccupiedEntry<'h, K, V, H = RandomState>where
    H: BuildHasher,
{ /* private fields */ }

Expand description

OccupiedEntry is a view into an occupied entry in a HashMap.

Implementations§

source §

impl<'h, K, V, H> OccupiedEntry<'h, K, V, H>
where K: Eq + Hash, H: BuildHasher,

source

pub fn key(&self) -> &K

Gets a reference to the key in the entry.

§Examples

use scc::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

assert_eq!(hashmap.entry(29).or_default().key(), &29);

source

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

Takes ownership of the key and value from the HashMap.

§Examples

use scc::HashMap;
use scc::hash_map::Entry;

let hashmap: HashMap<u64, u32> = HashMap::default();

hashmap.entry(11).or_insert(17);

if let Entry::Occupied(o) = hashmap.entry(11) {
    assert_eq!(o.remove_entry(), (11, 17));
};

source

pub fn get(&self) -> &V

Gets a reference to the value in the entry.

§Examples

use scc::HashMap;
use scc::hash_map::Entry;

let hashmap: HashMap<u64, u32> = HashMap::default();

hashmap.entry(19).or_insert(11);

if let Entry::Occupied(o) = hashmap.entry(19) {
    assert_eq!(o.get(), &11);
};

source

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

Gets a mutable reference to the value in the entry.

§Examples

use scc::HashMap;
use scc::hash_map::Entry;

let hashmap: HashMap<u64, u32> = HashMap::default();

hashmap.entry(37).or_insert(11);

if let Entry::Occupied(mut o) = hashmap.entry(37) {
    *o.get_mut() += 18;
    assert_eq!(*o.get(), 29);
}

assert_eq!(hashmap.read(&37, |_, v| *v), Some(29));

source

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

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

§Examples

use scc::HashMap;
use scc::hash_map::Entry;

let hashmap: HashMap<u64, u32> = HashMap::default();

hashmap.entry(37).or_insert(11);

if let Entry::Occupied(mut o) = hashmap.entry(37) {
    assert_eq!(o.insert(17), 11);
}

assert_eq!(hashmap.read(&37, |_, v| *v), Some(17));

source

pub fn remove(self) -> V

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

§Examples

use scc::HashMap;
use scc::hash_map::Entry;

let hashmap: HashMap<u64, u32> = HashMap::default();

hashmap.entry(11).or_insert(17);

if let Entry::Occupied(o) = hashmap.entry(11) {
    assert_eq!(o.remove(), 17);
};

source

pub fn next(self) -> Option<Self>

Gets the next closest occupied entry.

HashMap::first_entry, HashMap::first_entry_async, and this method together enables the OccupiedEntry to effectively act as a mutable iterator over entries. The method never acquires more than one lock even when it searches other buckets for the next closest occupied entry.

§Examples

use scc::HashMap;
use scc::hash_map::Entry;

let hashmap: HashMap<u64, u32> = HashMap::default();

assert!(hashmap.insert(1, 0).is_ok());
assert!(hashmap.insert(2, 0).is_ok());

let first_entry = hashmap.first_entry().unwrap();
let first_key = *first_entry.key();
let second_entry = first_entry.next().unwrap();
let second_key = *second_entry.key();

assert!(second_entry.next().is_none());
assert_eq!(first_key + second_key, 3);

source

pub async fn next_async(self) -> Option<OccupiedEntry<'h, K, V, H>>

Gets the next closest occupied entry.

HashMap::first_entry, HashMap::first_entry_async, and this method together enables the OccupiedEntry to effectively act as a mutable iterator over entries. The method never acquires more than one lock even when it searches other buckets for the next closest occupied entry.

It is an asynchronous method returning an impl Future for the caller to await.

§Examples

use scc::HashMap;
use scc::hash_map::Entry;

let hashmap: HashMap<u64, u32> = HashMap::default();

assert!(hashmap.insert(1, 0).is_ok());
assert!(hashmap.insert(2, 0).is_ok());

let second_entry_future = hashmap.first_entry().unwrap().next_async();