Struct bevy_internal::utils::hashbrown::hash_table::VacantEntry

pub struct VacantEntry<'a, T, A = Global>
where
    A: Allocator,
{ /* private fields */ }

A view into a vacant entry in a HashTable. It is part of the Entry enum.

Examples

use ahash::AHasher;
use hashbrown::hash_table::{Entry, HashTable, VacantEntry};
use std::hash::{BuildHasher, BuildHasherDefault};

let mut table: HashTable<&str> = HashTable::new();
let hasher = BuildHasherDefault::<AHasher>::default();
let hasher = |val: &_| hasher.hash_one(val);

let entry_v: VacantEntry<_, _> = match table.entry(hasher(&"a"), |&x| x == "a", hasher) {
    Entry::Vacant(view) => view,
    Entry::Occupied(_) => unreachable!(),
};
entry_v.insert("a");
assert!(table.find(hasher(&"a"), |&x| x == "a").is_some() && table.len() == 1);

// Nonexistent key (insert)
match table.entry(hasher(&"b"), |&x| x == "b", hasher) {
    Entry::Vacant(view) => {
        view.insert("b");
    }
    Entry::Occupied(_) => unreachable!(),
}
assert!(table.find(hasher(&"b"), |&x| x == "b").is_some() && table.len() == 2);

Implementations

impl<'a, T, A> VacantEntry<'a, T, A>

where A: Allocator,

pub fn insert(self, value: T) -> OccupiedEntry<'a, T, A>

Inserts a new element into the table with the hash that was used to obtain the VacantEntry.

An OccupiedEntry is returned for the newly inserted element.

Examples

use ahash::AHasher;
use hashbrown::hash_table::Entry;
use hashbrown::HashTable;
use std::hash::{BuildHasher, BuildHasherDefault};

let mut table: HashTable<&str> = HashTable::new();
let hasher = BuildHasherDefault::<AHasher>::default();
let hasher = |val: &_| hasher.hash_one(val);

if let Entry::Vacant(o) = table.entry(hasher(&"poneyland"), |&x| x == "poneyland", hasher) {
    o.insert("poneyland");
}
assert_eq!(
    table.find(hasher(&"poneyland"), |&x| x == "poneyland"),
    Some(&"poneyland")
);

pub fn into_table(self) -> &'a mut HashTable<T, A>

Converts the VacantEntry into a mutable reference to the underlying table.

Trait Implementations

impl<T, A> Debug for VacantEntry<'_, T, A>

where T: Debug, A: Allocator,

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

Formats the value using the given formatter.