Struct hashbrown::hash_set::VacantEntry  
source · [−]pub struct VacantEntry<'a, T, S, A: Allocator + Clone = Global> { /* private fields */ }Expand description
A view into a vacant entry in a HashSet.
It is part of the Entry enum.
Examples
use hashbrown::hash_set::{Entry, HashSet, VacantEntry};
let mut set = HashSet::<&str>::new();
let entry_v: VacantEntry<_, _> = match set.entry("a") {
    Entry::Vacant(view) => view,
    Entry::Occupied(_) => unreachable!(),
};
entry_v.insert();
assert!(set.contains("a") && set.len() == 1);
// Nonexistent key (insert)
match set.entry("b") {
    Entry::Vacant(view) => view.insert(),
    Entry::Occupied(_) => unreachable!(),
}
assert!(set.contains("b") && set.len() == 2);Implementations
sourceimpl<'a, T, S, A: Allocator + Clone> VacantEntry<'a, T, S, A>
 
impl<'a, T, S, A: Allocator + Clone> VacantEntry<'a, T, S, A>
sourcepub fn get(&self) -> &T
 
pub fn get(&self) -> &T
Gets a reference to the value that would be used when inserting
through the VacantEntry.
Examples
use hashbrown::HashSet;
let mut set: HashSet<&str> = HashSet::new();
assert_eq!(set.entry("poneyland").get(), &"poneyland");sourcepub fn into_value(self) -> T
 
pub fn into_value(self) -> T
Take ownership of the value.
Examples
use hashbrown::hash_set::{Entry, HashSet};
let mut set: HashSet<&str> = HashSet::new();
match set.entry("poneyland") {
    Entry::Occupied(_) => panic!(),
    Entry::Vacant(v) => assert_eq!(v.into_value(), "poneyland"),
}sourcepub fn insert(self) where
    T: Hash,
    S: BuildHasher, 
 
pub fn insert(self) where
    T: Hash,
    S: BuildHasher, 
Sets the value of the entry with the VacantEntry’s value.
Examples
use hashbrown::HashSet;
use hashbrown::hash_set::Entry;
let mut set: HashSet<&str> = HashSet::new();
if let Entry::Vacant(o) = set.entry("poneyland") {
    o.insert();
}
assert!(set.contains("poneyland"));Trait Implementations
Auto Trait Implementations
impl<'a, T, S, A> RefUnwindSafe for VacantEntry<'a, T, S, A> where
    A: RefUnwindSafe,
    S: RefUnwindSafe,
    T: RefUnwindSafe, 
impl<'a, T, S, A> Send for VacantEntry<'a, T, S, A> where
    A: Send,
    S: Send,
    T: Send, 
impl<'a, T, S, A> Sync for VacantEntry<'a, T, S, A> where
    A: Sync,
    S: Sync,
    T: Sync, 
impl<'a, T, S, A> Unpin for VacantEntry<'a, T, S, A> where
    T: Unpin, 
impl<'a, T, S, A = Global> !UnwindSafe for VacantEntry<'a, T, S, A>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
    T: ?Sized, 
 
impl<T> BorrowMut<T> for T where
    T: ?Sized, 
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more