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.

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

fn get_many<const N: usize>(&mut self, inputs: [I; N]) -> [&O; N]

Retrieve multiple values stored in the cache. If any of the values do not yet exist, the function is called, and the result is added to the cache before returning them.