Enum hashbrown_tstd::hash_map::RustcEntry

pub enum RustcEntry<'a, K, V, A = Global>where
    A: Allocator + Clone,{
    Occupied(RustcOccupiedEntry<'a, K, V, A>),
    Vacant(RustcVacantEntry<'a, K, V, A>),
}

A view into a single entry in a map, which may either be vacant or occupied.

This enum is constructed from the entry method on HashMap.

Variants

Occupied(RustcOccupiedEntry<'a, K, V, A>)

An occupied entry.

Vacant(RustcVacantEntry<'a, K, V, A>)

A vacant entry.

Implementations

impl<'a, K, V, A: Allocator + Clone> RustcEntry<'a, K, V, A>

pub fn insert(self, value: V) -> RustcOccupiedEntry<'a, K, V, A>

Sets the value of the entry, and returns a RustcOccupiedEntry.

Examples

use hashbrown::HashMap;

let mut map: HashMap<&str, u32> = HashMap::new();
let entry = map.entry("horseyland").insert(37);

assert_eq!(entry.key(), &"horseyland");

pub fn or_insert(self, default: V) -> &'a mut Vwhere
    K: Hash,

Ensures a value is in the entry by inserting the default if empty, and returns a mutable reference to the value in the entry.

Examples

use hashbrown::HashMap;

let mut map: HashMap<&str, u32> = HashMap::new();

map.rustc_entry("poneyland").or_insert(3);
assert_eq!(map["poneyland"], 3);

*map.rustc_entry("poneyland").or_insert(10) *= 2;
assert_eq!(map["poneyland"], 6);

pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut Vwhere
    K: Hash,

Ensures a value is in the entry by inserting the result of the default function if empty, and returns a mutable reference to the value in the entry.

Examples

use hashbrown::HashMap;

let mut map: HashMap<&str, String> = HashMap::new();
let s = "hoho".to_string();

map.rustc_entry("poneyland").or_insert_with(|| s);

assert_eq!(map["poneyland"], "hoho".to_string());

pub fn key(&self) -> &K

Returns a reference to this entry’s key.

Examples

use hashbrown::HashMap;

let mut map: HashMap<&str, u32> = HashMap::new();
assert_eq!(map.rustc_entry("poneyland").key(), &"poneyland");

pub fn and_modify<F>(self, f: F) -> Selfwhere
    F: FnOnce(&mut V),

Provides in-place mutable access to an occupied entry before any potential inserts into the map.

Examples

use hashbrown::HashMap;

let mut map: HashMap<&str, u32> = HashMap::new();

map.rustc_entry("poneyland")
   .and_modify(|e| { *e += 1 })
   .or_insert(42);
assert_eq!(map["poneyland"], 42);

map.rustc_entry("poneyland")
   .and_modify(|e| { *e += 1 })
   .or_insert(42);
assert_eq!(map["poneyland"], 43);

impl<'a, K, V: Default, A: Allocator + Clone> RustcEntry<'a, K, V, A>

pub fn or_default(self) -> &'a mut Vwhere
    K: Hash,

Ensures a value is in the entry by inserting the default value if empty, and returns a mutable reference to the value in the entry.

Examples

use hashbrown::HashMap;

let mut map: HashMap<&str, Option<u32>> = HashMap::new();
map.rustc_entry("poneyland").or_default();

assert_eq!(map["poneyland"], None);

Trait Implementations

impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for RustcEntry<'_, K, V, A>

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

Formats the value using the given formatter.