Struct OccupiedEntry

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

Expand description

A view into an occupied entry in a HashSet. It is part of the Entry enum.

§Examples

use hashbrown::hash_set::{Entry, HashSet, OccupiedEntry};

let mut set = HashSet::new();
set.extend(["a", "b", "c"]);

let _entry_o: OccupiedEntry<_, _> = set.entry("a").insert();
assert_eq!(set.len(), 3);

// Existing key
match set.entry("a") {
    Entry::Vacant(_) => unreachable!(),
    Entry::Occupied(view) => {
        assert_eq!(view.get(), &"a");
    }
}

assert_eq!(set.len(), 3);

// Existing key (take)
match set.entry("c") {
    Entry::Vacant(_) => unreachable!(),
    Entry::Occupied(view) => {
        assert_eq!(view.remove(), "c");
    }
}
assert_eq!(set.get(&"c"), None);
assert_eq!(set.len(), 2);

Implementations§

§

impl<T, S, A> OccupiedEntry<'_, T, S, A>
where A: Allocator,

pub fn get(&self) -> &T

Gets a reference to the value in the entry.

§Examples

use hashbrown::hash_set::{Entry, HashSet};

let mut set: HashSet<&str> = HashSet::new();
set.entry("poneyland").or_insert();

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

pub fn remove(self) -> T

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

§Examples

use hashbrown::HashSet;
use hashbrown::hash_set::Entry;

let mut set: HashSet<&str> = HashSet::new();
// The set is empty
assert!(set.is_empty() && set.capacity() == 0);

set.entry("poneyland").or_insert();
let capacity_before_remove = set.capacity();

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

assert_eq!(set.contains("poneyland"), false);
// Now set hold none elements but capacity is equal to the old one
assert!(set.len() == 0 && set.capacity() == capacity_before_remove);

pub fn replace(self) -> T

Replaces the entry, returning the old value. The new value in the hash map will be the value used to create this entry.

§Panics

Will panic if this OccupiedEntry was created through Entry::insert.

§Examples

 use hashbrown::hash_set::{Entry, HashSet};
 use std::rc::Rc;

 let mut set: HashSet<Rc<String>> = HashSet::new();
 let key_one = Rc::new("Stringthing".to_string());
 let key_two = Rc::new("Stringthing".to_string());

 set.insert(key_one.clone());
 assert!(Rc::strong_count(&key_one) == 2 && Rc::strong_count(&key_two) == 1);

 match set.entry(key_two.clone()) {
     Entry::Occupied(entry) => {
         let old_key: Rc<String> = entry.replace();
         assert!(Rc::ptr_eq(&key_one, &old_key));
     }
     Entry::Vacant(_) => panic!(),
 }

 assert!(Rc::strong_count(&key_one) == 1 && Rc::strong_count(&key_two) == 2);
 assert!(set.contains(&"Stringthing".to_owned()));