Struct HashCache

pub struct HashCache<'f, I, O, S = RandomState>
where
    I: Eq + Hash,
    S: BuildHasher,
{ /* 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: impl Fn(&I) -> O + Send + 'f) -> Self

pub fn recursive( f: impl Fn(&mut RefCache<'_, HashMap<I, O>>, &I) -> O + Send + 'f, ) -> Self

impl<'f, I, O, S> HashCache<'f, I, O, S>

where I: Eq + Hash, S: BuildHasher,

pub fn with_hasher(hash_builder: S, f: impl Fn(&I) -> O + Send + 'f) -> Self

pub fn recursive_with_hasher( hash_builder: S, f: impl Fn(&mut RefCache<'_, HashMap<I, O, S>>, &I) -> O + Send + 'f, ) -> Self

Methods from Deref<Target = GenericCache<'f, HashMap<I, O, S>>>

pub fn cache(&self) -> &C

Get a reference to the underlying cache object, letting you use functions exclusive to the cache type (as long they only need &self of course).

pub fn len(&self) -> usize

Returns the number of elements in the cache.

pub fn clear(&mut self)

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

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: &C::Input) -> Option<C::Output>

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

Trait Implementations

impl<'f, I, O, S> Deref for HashCache<'f, I, O, S>

where I: Eq + Hash, S: BuildHasher,

type Target = GenericCache<'f, HashMap<I, O, S>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'f, I, O, S> DerefMut for HashCache<'f, I, O, S>

where I: Eq + Hash, S: BuildHasher,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'f, I, O, S> From<GenericCache<'f, HashMap<I, O, S>>> for HashCache<'f, I, O, S>

where I: Eq + Hash, S: BuildHasher,

fn from(value: GenericCache<'f, HashMap<I, O, S>>) -> Self

Converts to this type from the input type.