Enum scc::hash_cache::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 cache entry in a HashCache.

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_put(self, val: V) -> (EvictedEntry<K, V>, OccupiedEntry<'h, K, V, H>)

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

Examples

use scc::HashCache;

let hashcache: HashCache<u64, u32> = HashCache::default();

hashcache.entry(3).or_put(7);
assert_eq!(*hashcache.get(&3).unwrap().get(), 7);

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

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

Examples

use scc::HashCache;

let hashcache: HashCache<u64, u32> = HashCache::default();

hashcache.entry(19).or_put_with(|| 5);
assert_eq!(*hashcache.get(&19).unwrap().get(), 5);

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

Ensures a value is in the entry by putting 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::HashCache;

let hashcache: HashCache<u64, u32> = HashCache::default();

hashcache.entry(11).or_put_with_key(|k| if *k == 11 { 7 } else { 3 });
assert_eq!(*hashcache.get(&11).unwrap().get(), 7);

pub fn key(&self) -> &K

Returns a reference to the key of this entry.

Examples

use scc::HashCache;

let hashcache: HashCache<u64, u32> = HashCache::default();
assert_eq!(hashcache.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::HashCache;

let hashcache: HashCache<u64, u32> = HashCache::default();

hashcache.entry(37).and_modify(|v| { *v += 1 }).or_put(47);
assert_eq!(*hashcache.get(&37).unwrap().get(), 47);

hashcache.entry(37).and_modify(|v| { *v += 1 }).or_put(3);
assert_eq!(*hashcache.get(&37).unwrap().get(), 48);

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

Sets the value of the entry.

Examples

use scc::HashCache;

let hashcache: HashCache<u64, u32> = HashCache::default();
let entry = hashcache.entry(11).put_entry(17).1;
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) -> (EvictedEntry<K, V>, OccupiedEntry<'h, K, V, H>)

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

Examples

use scc::HashCache;

let hashcache: HashCache<u64, u32> = HashCache::default();
hashcache.entry(11).or_default();
assert_eq!(*hashcache.get(&11).unwrap().get(), 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.