Struct fn_cache::HashCache

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

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)

Implementations

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

pub fn new<F>(f: F) -> Selfwhere
    F: Fn(&I) -> O + 'f + Send + Sync,

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

pub fn recursive<F>(f: F) -> Selfwhere
    F: Fn(&mut Self, &I) -> O + 'f + Send + Sync,

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

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

pub fn with_hasher<F>(hash_builder: S, f: F) -> Selfwhere
    F: Fn(&I) -> O + 'f + Send + Sync,

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

See the documentation on HashMap::with_hasher for more details.

pub fn recursive_with_hasher<F>(hash_builder: S, f: F) -> Selfwhere
    F: Fn(&mut Self, &I) -> O + 'f + Send + Sync,

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

See the documentation on HashMap::with_hasher 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<'f, I, O, S> FnCache<I, O> for HashCache<'f, 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.