Struct Cache 

pub struct Cache<K, V>
where
    K: Hash + Eq + Clone,
{ /* private fields */ }

Provides a reliable cache for HashMap<Key, Value> where value can be derived from key, but could be expensive to generate. The cache is thread safe and can be used in multi-threaded environment. The cache is not async, so it is not suitable for async environment. For async cache, use CasheAsync instead.

use anycache::Cache;
use anycache::CacheAsync;
 
fn my_gen(x:&String) -> String {
  println!("Generating {}", x);
  let mut y = x.clone();
  y.push_str("@");
  y
}
 
// For async cache, use CacheAsync
fn test_sync_cache() {
  let c = Cache::new(my_gen);
 
  for j in 0..2 {
    for i in 0..10 {
      let key = format!("key{}", i);
      let v = c.get(&key);
      println!("{}:{}: {}", j, i, *v);
    }
  }
}
 
// For sync cache, use Cache
async fn test_cache_async() {
  // Cache is only generated once above. Similarly, for Async.
 
  let c = CacheAsync::new(my_gen);
 
  for j in 0..2 {
    for i in 0..10 {
      let key = format!("key{}", i);
      let v = c.get(&key).await;
      println!("{}:{}: {}", j, i, *v);
    }
  }
}
 

Create a Cache with K, V type. Similar to Map. However, the value is generated from key on-demand using generate function

Implementations

impl<K, V> Cache<K, V>

where K: Hash + Eq + Clone,

pub fn new(generator: impl Fn(&K) -> V + 'static + Sync) -> Self

where K: Hash + Eq,

Create a new cache using the given generator function

pub fn get_if(&self, key: &K) -> Option<Arc<V>>

Get from the cache. If the key is missing, do not generate it and return None

pub fn drop(&self, key: &K)

Drop the key from the cache if it exists Does nothing if the key is not there

pub fn get(&self, key: &K) -> Arc<V>

Get the key from cache. If not found, generate one.