Enum hashbrown::hash_table::Entry
source · pub enum Entry<'a, T, A = Global>where
A: Allocator,{
Occupied(OccupiedEntry<'a, T, A>),
Vacant(VacantEntry<'a, T, A>),
}
Expand description
A view into a single entry in a table, which may either be vacant or occupied.
This enum
is constructed from the entry
method on HashTable
.
§Examples
use hashbrown::hash_table::{Entry, OccupiedEntry};
use hashbrown::{HashTable, DefaultHashBuilder};
use std::hash::BuildHasher;
let mut table = HashTable::new();
let hasher = DefaultHashBuilder::default();
let hasher = |val: &_| hasher.hash_one(val);
for x in ["a", "b", "c"] {
table.insert_unique(hasher(&x), x, hasher);
}
assert_eq!(table.len(), 3);
// Existing value (insert)
let entry: Entry<_> = table.entry(hasher(&"a"), |&x| x == "a", hasher);
let _raw_o: OccupiedEntry<_, _> = entry.insert("a");
assert_eq!(table.len(), 3);
// Nonexistent value (insert)
table.entry(hasher(&"d"), |&x| x == "d", hasher).insert("d");
// Existing value (or_insert)
table
.entry(hasher(&"b"), |&x| x == "b", hasher)
.or_insert("b");
// Nonexistent value (or_insert)
table
.entry(hasher(&"e"), |&x| x == "e", hasher)
.or_insert("e");
println!("Our HashTable: {:?}", table);
let mut vec: Vec<_> = table.iter().copied().collect();
// The `Iter` iterator produces items in arbitrary order, so the
// items must be sorted to test them against a sorted array.
vec.sort_unstable();
assert_eq!(vec, ["a", "b", "c", "d", "e"]);
Variants§
Occupied(OccupiedEntry<'a, T, A>)
An occupied entry.
§Examples
use hashbrown::hash_table::{Entry, OccupiedEntry};
use hashbrown::{HashTable, DefaultHashBuilder};
use std::hash::BuildHasher;
let mut table = HashTable::new();
let hasher = DefaultHashBuilder::default();
let hasher = |val: &_| hasher.hash_one(val);
for x in ["a", "b"] {
table.insert_unique(hasher(&x), x, hasher);
}
match table.entry(hasher(&"a"), |&x| x == "a", hasher) {
Entry::Vacant(_) => unreachable!(),
Entry::Occupied(_) => {}
}
Vacant(VacantEntry<'a, T, A>)
A vacant entry.
§Examples
use hashbrown::hash_table::{Entry, OccupiedEntry};
use hashbrown::{HashTable, DefaultHashBuilder};
use std::hash::BuildHasher;
let mut table = HashTable::<&str>::new();
let hasher = DefaultHashBuilder::default();
let hasher = |val: &_| hasher.hash_one(val);
match table.entry(hasher(&"a"), |&x| x == "a", hasher) {
Entry::Vacant(_) => {}
Entry::Occupied(_) => unreachable!(),
}
Implementations§
source§impl<'a, T, A> Entry<'a, T, A>where
A: Allocator,
impl<'a, T, A> Entry<'a, T, A>where
A: Allocator,
sourcepub fn insert(self, value: T) -> OccupiedEntry<'a, T, A>
pub fn insert(self, value: T) -> OccupiedEntry<'a, T, A>
Sets the value of the entry, replacing any existing value if there is
one, and returns an OccupiedEntry
.
§Examples
use hashbrown::{HashTable, DefaultHashBuilder};
use std::hash::BuildHasher;
let mut table: HashTable<&str> = HashTable::new();
let hasher = DefaultHashBuilder::default();
let hasher = |val: &_| hasher.hash_one(val);
let entry = table
.entry(hasher(&"horseyland"), |&x| x == "horseyland", hasher)
.insert("horseyland");
assert_eq!(entry.get(), &"horseyland");
sourcepub fn or_insert(self, default: T) -> OccupiedEntry<'a, T, A>
pub fn or_insert(self, default: T) -> OccupiedEntry<'a, T, A>
Ensures a value is in the entry by inserting if it was vacant.
Returns an OccupiedEntry
pointing to the now-occupied entry.
§Examples
use hashbrown::{HashTable, DefaultHashBuilder};
use std::hash::BuildHasher;
let mut table: HashTable<&str> = HashTable::new();
let hasher = DefaultHashBuilder::default();
let hasher = |val: &_| hasher.hash_one(val);
// nonexistent key
table
.entry(hasher(&"poneyland"), |&x| x == "poneyland", hasher)
.or_insert("poneyland");
assert!(table
.find(hasher(&"poneyland"), |&x| x == "poneyland")
.is_some());
// existing key
table
.entry(hasher(&"poneyland"), |&x| x == "poneyland", hasher)
.or_insert("poneyland");
assert!(table
.find(hasher(&"poneyland"), |&x| x == "poneyland")
.is_some());
assert_eq!(table.len(), 1);
sourcepub fn or_insert_with(
self,
default: impl FnOnce() -> T
) -> OccupiedEntry<'a, T, A>
pub fn or_insert_with( self, default: impl FnOnce() -> T ) -> OccupiedEntry<'a, T, A>
Ensures a value is in the entry by inserting the result of the default function if empty..
Returns an OccupiedEntry
pointing to the now-occupied entry.
§Examples
use hashbrown::{HashTable, DefaultHashBuilder};
use std::hash::BuildHasher;
let mut table: HashTable<String> = HashTable::new();
let hasher = DefaultHashBuilder::default();
let hasher = |val: &_| hasher.hash_one(val);
table
.entry(hasher("poneyland"), |x| x == "poneyland", |val| hasher(val))
.or_insert_with(|| "poneyland".to_string());
assert!(table
.find(hasher(&"poneyland"), |x| x == "poneyland")
.is_some());
sourcepub fn and_modify(self, f: impl FnOnce(&mut T)) -> Self
pub fn and_modify(self, f: impl FnOnce(&mut T)) -> Self
Provides in-place mutable access to an occupied entry before any potential inserts into the table.
§Examples
use hashbrown::{HashTable, DefaultHashBuilder};
use std::hash::BuildHasher;
let mut table: HashTable<(&str, u32)> = HashTable::new();
let hasher = DefaultHashBuilder::default();
let hasher = |val: &_| hasher.hash_one(val);
table
.entry(
hasher(&"poneyland"),
|&(x, _)| x == "poneyland",
|(k, _)| hasher(&k),
)
.and_modify(|(_, v)| *v += 1)
.or_insert(("poneyland", 42));
assert_eq!(
table.find(hasher(&"poneyland"), |&(k, _)| k == "poneyland"),
Some(&("poneyland", 42))
);
table
.entry(
hasher(&"poneyland"),
|&(x, _)| x == "poneyland",
|(k, _)| hasher(&k),
)
.and_modify(|(_, v)| *v += 1)
.or_insert(("poneyland", 42));
assert_eq!(
table.find(hasher(&"poneyland"), |&(k, _)| k == "poneyland"),
Some(&("poneyland", 43))
);
Trait Implementations§
Auto Trait Implementations§
impl<'a, T, A> Freeze for Entry<'a, T, A>
impl<'a, T, A> RefUnwindSafe for Entry<'a, T, A>where
T: RefUnwindSafe,
A: RefUnwindSafe,
impl<'a, T, A> Send for Entry<'a, T, A>
impl<'a, T, A> Sync for Entry<'a, T, A>
impl<'a, T, A> Unpin for Entry<'a, T, A>
impl<'a, T, A = Global> !UnwindSafe for Entry<'a, T, 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