Struct hashbrown::hash_set::OccupiedEntry

source ·
pub struct OccupiedEntry<'a, T, S, A: Allocator = 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> OccupiedEntry<'_, T, S, A>

source

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"),
}
source

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

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§

source§

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

source§

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

Formats the value using the given formatter. Read more

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>
where T: Send, S: Send, A: Send,

§

impl<'a, T, S, A> Sync for OccupiedEntry<'a, T, S, A>
where T: Sync, S: Sync, A: Sync,

§

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> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.