Struct ValueCache 

pub struct ValueCache<V> { /* private fields */ }

Values by key, each with its own time to live, at most capacity of them (the oldest goes first when full, after anything expired). Cheap to clone; clones share the entries.

use std::time::Duration;
use rust_web_server::cache::ValueCache;

let cache: ValueCache<String> = ValueCache::new(1000);
let a = cache.fetch_or("greeting:en", Duration::from_secs(60), || "Hello".to_string());
let b = cache.fetch_or("greeting:en", Duration::from_secs(60), || unreachable!("cached"));
assert_eq!(a, b);

The value is computed outside the lock: two threads missing the same key at once both compute it (the last one stored wins). Errors from try_fetch_or aren’t cached.

Implementations

impl<V> ValueCache<V>

where V: Clone,

pub fn new(capacity: usize) -> ValueCache<V>

At most capacity entries (at least 1).

pub fn get(&self, key: &str) -> Option<V>

The value under key, unless it’s missing or expired.

pub fn put(&self, key: &str, value: V, ttl: Duration)

Store value under key for ttl.

pub fn fetch_or( &self, key: &str, ttl: Duration, compute: impl FnOnce() -> V, ) -> V

The cached value, or compute() stored for ttl and returned.

pub fn try_fetch_or<E>( &self, key: &str, ttl: Duration, compute: impl FnOnce() -> Result<V, E>, ) -> Result<V, E>

fetch_or for a computation that can fail: an Err is returned and nothing is stored.

pub async fn fetch_or_async<F, Fut>( &self, key: &str, ttl: Duration, compute: F, ) -> V

where F: FnOnce() -> Fut, Fut: Future<Output = V>,

fetch_or with an async computation (a query).

pub async fn try_fetch_or_async<E, F, Fut>( &self, key: &str, ttl: Duration, compute: F, ) -> Result<V, E>

where F: FnOnce() -> Fut, Fut: Future<Output = Result<V, E>>,

try_fetch_or with an async computation.

pub fn invalidate(&self, key: &str) -> bool

Remove key; whether it was there.

pub fn invalidate_prefix(&self, prefix: &str) -> usize

Remove every key starting with prefix ("user:42:"); how many.

pub fn clear(&self)

pub fn len(&self) -> usize

Entries held (expired ones until they’re noticed).

pub fn is_empty(&self) -> bool

pub fn stats(&self) -> (u64, u64)

(hits, misses) of get (and so of the fetch_ors).

Trait Implementations

impl<V> Clone for ValueCache<V>

fn clone(&self) -> ValueCache<V>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.