Enum scc::hash_index::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 HashIndex.

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: 'static + Clone + Eq + Hash, V: 'static + Clone, 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::HashIndex;

let hashindex: HashIndex<u64, u32> = HashIndex::default();

hashindex.entry(3).or_insert(7);
assert_eq!(hashindex.peek_with(&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::HashIndex;

let hashindex: HashIndex<u64, u32> = HashIndex::default();

hashindex.entry(19).or_insert_with(|| 5);
assert_eq!(hashindex.peek_with(&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::HashIndex;

let hashindex: HashIndex<u64, u32> = HashIndex::default();

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

pub fn key(&self) -> &K

Returns a reference to the key of this entry.

Examples

use scc::HashIndex;

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

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

where F: FnOnce(&mut V),

Provides in-place mutable access to an occupied entry.

Safety

The caller has to make sure that there are no readers of the entry, e.g., a reader keeping a reference to the entry via HashIndex::iter, HashIndex::peek, or HashIndex::peek_with, unless an instance of V can be safely read when there is a single writer, e.g., V = [u8; 32].

Examples

use scc::HashIndex;

let hashindex: HashIndex<u64, u32> = HashIndex::default();

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

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

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

where K: 'static + Clone + Eq + Hash, V: 'static + Clone + 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::HashIndex;

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

Trait Implementations

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

where K: 'static + Clone + Debug + Eq + Hash, V: 'static + Clone + Debug, H: BuildHasher,

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

Formats the value using the given formatter.