Struct OccupiedEntry 

pub struct OccupiedEntry<'a, T, S, A = Global>
where
    A: Allocator,
{
    inner: OccupiedEntry<'a, T, (), S, A>,
}

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

Fields

inner: OccupiedEntry<'a, T, (), S, A>

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

Trait Implementations

impl<T, S, A> Debug for OccupiedEntry<'_, T, S, A>

where T: Debug, A: Allocator,

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

Formats the value using the given formatter.