Enum scc::hash_map::Entry

pub enum Entry<'h, K, V, H = RandomState>
where
    H: BuildHasher,
{
    Occupied(OccupiedEntry<'h, K, V, H>),
    Vacant(VacantEntry<'h, K, V, H>),
}

Entry represents a single entry in a HashMap.

Variants

Occupied(OccupiedEntry<'h, K, V, H>)

An occupied entry.

Vacant(VacantEntry<'h, K, V, H>)

A vacant entry.

Implementations

impl<'h, K, V, H> Entry<'h, K, V, H>

where K: Eq + Hash, H: BuildHasher,

pub fn or_insert(self, val: V) -> OccupiedEntry<'h, K, V, H>

Ensures a value is in the entry by inserting the supplied instance if empty.

Examples

use scc::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

hashmap.entry(3).or_insert(7);
assert_eq!(hashmap.read(&3, |_, v| *v), Some(7));

pub fn or_insert_with<F: FnOnce() -> V>( self, constructor: F ) -> OccupiedEntry<'h, K, V, H>

Ensures a value is in the entry by inserting the result of the supplied closure if empty.

Examples

use scc::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

hashmap.entry(19).or_insert_with(|| 5);
assert_eq!(hashmap.read(&19, |_, v| *v), Some(5));

pub fn or_insert_with_key<F: FnOnce(&K) -> V>( self, constructor: F ) -> OccupiedEntry<'h, K, V, H>

Ensures a value is in the entry by inserting the result of the supplied closure if empty.

The reference to the moved key is provided, therefore cloning or copying the key is unnecessary.

Examples

use scc::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

hashmap.entry(11).or_insert_with_key(|k| if *k == 11 { 7 } else { 3 });
assert_eq!(hashmap.read(&11, |_, v| *v), Some(7));

pub fn key(&self) -> &K

Returns a reference to the key of this entry.

Examples

use scc::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();
assert_eq!(hashmap.entry(31).key(), &31);

pub fn and_modify<F>(self, f: F) -> Self

where F: FnOnce(&mut V),

Provides in-place mutable access to an occupied entry.

Examples

use scc::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();

hashmap.entry(37).and_modify(|v| { *v += 1 }).or_insert(47);
assert_eq!(hashmap.read(&37, |_, v| *v), Some(47));

hashmap.entry(37).and_modify(|v| { *v += 1 }).or_insert(3);
assert_eq!(hashmap.read(&37, |_, v| *v), Some(48));

pub fn insert_entry(self, val: V) -> OccupiedEntry<'h, K, V, H>

Sets the value of the entry.

Examples

use scc::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();
let entry = hashmap.entry(11).insert_entry(17);
assert_eq!(entry.key(), &11);

impl<'h, K, V, H> Entry<'h, K, V, H>

where K: Eq + Hash, V: Default, H: BuildHasher,

pub fn or_default(self) -> OccupiedEntry<'h, K, V, H>

Ensures a value is in the entry by inserting the default value if empty.

Examples

use scc::HashMap;

let hashmap: HashMap<u64, u32> = HashMap::default();
hashmap.entry(11).or_default();
assert_eq!(hashmap.read(&11, |_, v| *v), Some(0));

Trait Implementations

impl<'h, K, V, H> Debug for Entry<'h, K, V, H>

where K: Debug + Eq + Hash, V: Debug, H: BuildHasher,

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

Formats the value using the given formatter.