Struct memo_map::MemoMap

pub struct MemoMap<K, V, S = RandomState> { /* private fields */ }

An insert only, thread safe hash map to memoize values.

Implementations

impl<K, V> MemoMap<K, V, RandomState>

pub fn new() -> MemoMap<K, V, RandomState>

Creates an empty MemoMap.

impl<K, V, S> MemoMap<K, V, S>

pub fn with_hasher(hash_builder: S) -> MemoMap<K, V, S>

Creates an empty MemoMap which will use the given hash builder to hash keys.

impl<K, V, S> MemoMap<K, V, S> where
    K: Eq + Hash,
    V: StableDeref,
    S: BuildHasher, 

pub fn insert(&self, key: K, value: V) -> bool

Inserts a value into the memo map.

This inserts a value for a specific key into the memo map. If the key already exists, this method does nothing and instead returns false. Otherwise the value is inserted and true is returned. It’s generally recommended to instead use get_or_insert or it’s sibling get_or_try_insert.

pub fn contains_key<Q>(&self, key: &Q) -> bool where
    Q: Hash + Eq + ?Sized,
    K: Borrow<Q>, 

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

pub fn get<Q>(&self, key: &Q) -> Option<&V> where
    Q: Hash + Eq + ?Sized,
    K: Borrow<Q>, 

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

pub fn get_or_try_insert<Q, F, E>(&self, key: &Q, creator: F) -> Result<&V, E> where
    Q: Hash + Eq + ToOwned<Owned = K> + ?Sized,
    K: Borrow<Q>,
    F: FnOnce() -> Result<V, E>, 

Returns a reference to the value corresponding to the key or inserts.

This is the preferred way to work with a memo map: if the value has not been in the map yet the creator function is invoked to create the value, otherwise the already stored value is returned. The creator function itself can be falliable and the error is passed through.

If the creator is infallible, get_or_insert can be used.

pub fn get_or_insert<Q, F>(&self, key: &Q, creator: F) -> &V where
    Q: Hash + Eq + ToOwned<Owned = K> + ?Sized,
    K: Borrow<Q>,
    F: FnOnce() -> V, 

Returns a reference to the value corresponding to the key or inserts.

This is the preferred way to work with a memo map: if the value has not been in the map yet the creator function is invoked to create the value, otherwise the already stored value is returned.

If the creator is fallible, get_or_try_insert can be used.

Example

let memo = MemoMap::new();

// first time inserts
let value = memo.get_or_insert("key", || "23");
assert_eq!(*value, "23");

// second time returns old value
let value = memo.get_or_insert("key", || "24");
assert_eq!(*value, "23");

pub fn len(&self) -> usize

Returns the number of items in the map.

Example

let memo = MemoMap::new();

assert_eq!(memo.len(), 0);
memo.insert(1, "a");
memo.insert(2, "b");
memo.insert(2, "not b");
assert_eq!(memo.len(), 2);

pub fn is_empty(&self) -> bool

Returns true if the memo map contains no items.

pub fn iter(&self) -> Iter<'_, K, V, S>

An iterator visiting all key-value pairs in arbitrary order. The iterator element type is (&'a K, &'a V).

Important note: during iteration the map is locked! This means that you must not perform modifications to the map or you will run into deadlocks.

pub fn keys(&self) -> Keys<'_, K, V, S>

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

Trait Implementations

impl<K: Clone, V: Clone, S: Clone> Clone for MemoMap<K, V, S>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K: Debug, V: Debug, S: Debug> Debug for MemoMap<K, V, S>

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

Formats the value using the given formatter.

impl<K, V, S: Default> Default for MemoMap<K, V, S>

fn default() -> Self

Returns the “default value” for a type.