Struct Cache 

pub struct Cache { /* private fields */ }

The app’s cache (state.cache), in memory or the cache table (CACHE_STORE).

Implementations

impl Cache

pub async fn get<T: DeserializeOwned>(&self, key: &str) -> Result<Option<T>>

The cached value, if present and not expired. A value of another type than T is an error.

pub async fn has(&self, key: &str) -> Result<bool>

Whether key holds a value that hasn’t expired.

pub async fn put( &self, key: &str, value: &impl Serialize, ttl: Option<Duration>, ) -> Result

Stores value for ttl, or until forgotten when ttl is None. A zero ttl stores nothing (and forgets the key).

pub async fn add( &self, key: &str, value: &impl Serialize, ttl: Option<Duration>, ) -> Result<bool>

Stores value only if key has no live value; returns whether it did. Atomic, so of several callers exactly one gets true.

pub async fn pull<T: DeserializeOwned>(&self, key: &str) -> Result<Option<T>>

The cached value, removed from the cache in the same step (a one-time code, a flash of data between requests).

pub async fn increment(&self, key: &str, by: i64) -> Result<i64>

Adds by (negative to subtract) to the number at key and returns the new value; a missing or expired key counts as 0 and never expires. Atomic, so concurrent calls don’t lose counts. A live value that isn’t a whole number is an error.

pub async fn decrement(&self, key: &str, by: i64) -> Result<i64>

increment(key, -by).

pub fn lock(&self, name: &str, ttl: Duration) -> Lock

A lock named name, held for ttl (up to a second more, never less) once acquired unless released earlier, so a crashed holder doesn’t block others forever. With the database store it works across processes and servers; with the memory store, within this process.

pub async fn prune(&self) -> Result<u64>

Deletes expired entries; returns how many (the database store’s count; the memory store returns 0 after sweeping).

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

where T: Serialize + DeserializeOwned, F: FnOnce() -> Fut, Fut: Future<Output = Result<T>>,

Returns the cached value, or runs compute, caches its result for ttl and returns it. Errors are not cached. Concurrent calls for the same key in this process compute once; the others wait for it. A cached value of another type (e.g. after a deploy) is computed again.

pub async fn forget(&self, key: &str) -> Result

Removes key (nothing happens if it’s missing).

pub async fn flush(&self) -> Result

Removes everything the app cached (not the framework’s renox: rows).

Trait Implementations

impl Clone for Cache

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.