pub struct OccupiedEntry<'a, T, S, A: Allocator + Clone = Global> { /* 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§
Source§impl<T, S, A: Allocator + Clone> OccupiedEntry<'_, T, S, A>
impl<T, S, A: Allocator + Clone> OccupiedEntry<'_, T, S, A>
Sourcepub fn get(&self) -> &T
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"),
}
Sourcepub fn remove(self) -> T
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);
Sourcepub fn replace(self) -> T
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§
Auto Trait Implementations§
impl<'a, T, S, A> Freeze for OccupiedEntry<'a, T, S, A>where
T: Freeze,
impl<'a, T, S, A> RefUnwindSafe for OccupiedEntry<'a, T, S, A>
impl<'a, T, S, A> Send for OccupiedEntry<'a, T, S, A>
impl<'a, T, S, A> Sync for OccupiedEntry<'a, T, S, A>
impl<'a, T, S, A> Unpin for OccupiedEntry<'a, T, S, A>where
T: Unpin,
impl<'a, T, S, A = Global> !UnwindSafe for OccupiedEntry<'a, T, 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