Struct fn_cache::HashCache

pub struct HashCache<'a, I, O, S = RandomState> where
    I: Eq + Hash,  { /* fields omitted */ }

A cache for a function which uses a HashMap.

The cache takes ownership of all inputs, but only passes a reference to the function, allowing it to store the input in the cache without any copies or clones.

The requirements for a HashMap must be met, specifically the keys must implement Eq and Hash, and the following propery must hold:

k1 == k2 -> hash(k1) == hash(k2)

Methods

impl<'a, I, O> HashCache<'a, I, O, RandomState> where
    I: Eq + Hash, 

pub fn new<F>(f: F) -> Self where
    F: Fn(&mut Self, &I) -> O + 'a, 

Create a cache for the provided function. If the function stores references, the cache can only live as long as those references.

impl<'a, I, O, S> HashCache<'a, I, O, S> where
    I: Eq + Hash,
    S: BuildHasher, 

pub fn with_hasher<F>(hash_builder: S, f: F) -> Self where
    F: Fn(&mut Self, &I) -> O + 'a, 

Create a HashCache which will use the given hash builder to hash keys.

See the documentation on HashMap for more details.

pub fn clear(&mut self)

Clears the cache, removing all key-value pairs. Keeps the allocated memory for reuse.

pub fn len(&self) -> usize

Returns the number of elements in the cache.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the cache. The collection may reserve more space to avoid frequent reallocations.

pub fn remove(&mut self, input: &I) -> Option<O>

Removes the input from the cache, returning any value if the input was previously in the cache.

Trait Implementations

impl<'a, I, O, S> FnCache<I, O> for HashCache<'a, I, O, S> where
    I: Eq + Hash,
    S: BuildHasher, 

fn get(&mut self, input: I) -> &O

Retrieve a value stored in the cache. If the value does not yet exist in the cache, the function is called, and the result is added to the cache before returning it.