Struct HashMapCache 

pub struct HashMapCache<T, K = StdHashKey>
where
    K: CacheKey<T>,
    T: Clone,
{ /* private fields */ }

RewriteCache implemented with a HashMap, generic over a CacheKey hashing strategy.

Use HashMapCache<T> (defaults to StdHashKey) for standard Hash types, or HashMapCache<T, CachedHashKey> for types implementing CacheHashable.

Implementations

impl<T, K> HashMapCache<T, K>

where K: CacheKey<T>, T: Clone,

pub fn new() -> Self

Creates a new HashMapCache that can be used as a RewriteCache

Trait Implementations

impl<T, K> Default for HashMapCache<T, K>

where K: CacheKey<T>, T: Clone,

fn default() -> Self

Returns the “default value” for a type.

impl<T, K> RewriteCache<T> for HashMapCache<T, K>

where K: CacheKey<T>, T: Clone,

fn invalidate_node(&self, node: &T)

Invalidate any internally cached hash for the given node. This is called on ancestors when a subtree is replaced. The default implementation is a no-op for caches that don’t use node-level hash caching.

fn invalidate_subtree(&self, node: &T)

Invalidate cached hashes for the given node and all its descendants. Called on replacement subtrees after rule application.

fn get(&self, subtree: &T, level: usize) -> CacheResult<T>

Get the cached result

fn insert(&mut self, from: &T, to: Option<T>, level: usize)

Insert the results into the cache. Note: Any powerful side effects such as changing other parts of the tree or replacing the root should NOT be inserted into the cache.

fn push_ancestor(&mut self, node: &T)

Record the hash of an ancestor node before descending into a child. Called by the zipper on every successful go_down.

fn pop_ancestor(&mut self)

Discard the top ancestor hash after ascending back to a parent. Called by the zipper on every go_up during normal traversal.

fn pop_and_map_ancestor(&mut self, new_ancestor: &T, level: usize)

Pop the top ancestor hash and insert a mapping from the old ancestor to the new (rebuilt) ancestor at the given level. Called by mark_dirty_to_root as it walks up after a replacement.

fn is_active(&self) -> bool

Returns false if this cache never stores anything (e.g. NoCache). The engine uses this to skip clones that would only feed into a no-op insert.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 120 bytes