Struct Cache 

pub struct Cache { /* private fields */ }

The cache handle. Cheap to clone: every clone is the same cache.

Implementations

impl Cache

pub fn new( values: impl ValueStore + 'static, signals: impl Signals + 'static, ) -> Self

A cache over the given stores.

pub fn local() -> Self

A cache for one process: values in memory, generations and locks in memory too, nothing shared. For tests, tools and an application assembled without the bootstrap.

pub fn store(&self) -> &'static str

The configured value store’s name.

pub fn allow(&self, namespace: impl Into<String>)

Registers a namespace, so values may depend on it and writes bump it. Registering one twice is nothing.

pub fn is_allowed(&self, namespace: &str) -> bool

Whether the namespace is registered or in the record family.

pub fn namespaces(&self) -> Vec<String>

The registered namespaces, sorted.

pub async fn get(&self, key: &str) -> Option<Vec<u8>>

The value under key while every namespace it depends on is at the generation it was stored at. A store failure reads as a miss and is logged.

pub async fn put( &self, key: &str, bytes: Vec<u8>, deps: &[&str], ttl: Duration, ) -> CoreResult<()>

Stores bytes under key for ttl, built from deps. An unregistered namespace in deps is refused; a store failure is logged and the value is simply not kept.

pub async fn add( &self, key: &str, bytes: Vec<u8>, deps: &[&str], ttl: Duration, ) -> CoreResult<bool>

Like Cache::put, only when nothing is under key; true when this call stored it.

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

Drops the value under key; true when one was there.

pub async fn flush(&self)

Drops every value this process’s store holds. Other processes keep theirs; Cache::bump_all reaches them.

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

The JSON value under key, decoded as T.

pub async fn put_json<T: Serialize + ?Sized>( &self, key: &str, value: &T, deps: &[&str], ttl: Duration, ) -> CoreResult<()>

Stores value as JSON under key.

pub async fn remember<T, F, Fut>( &self, key: &str, ttl: Duration, deps: &[&str], load: F, ) -> CoreResult<T>

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

The value under key, or what load returns, stored for ttl and built from deps. Concurrent callers for one key share one load.

pub fn current(&self, namespace: &str) -> Option<u64>

The namespace’s generation as this process last saw it, or None before it was ever read here.

pub async fn generation(&self, namespace: &str) -> CoreResult<u64>

The namespace’s generation, seeded when new.

pub async fn bump(&self, namespace: &str) -> CoreResult<u64>

Moves the namespace on: every value built from it misses from now. Returns the new generation. A failure is logged as well as returned, since the write it follows already stands.

pub async fn bump_all(&self) -> CoreResult<usize>

Bumps every namespace the shared store knows and drops this process’s values. Returns how many namespaces moved.

pub async fn known(&self) -> CoreResult<Vec<(String, u64)>>

Every namespace the shared store knows, with its generation.

pub async fn refresh(&self) -> CoreResult<()>

Brings in the other processes’ bumps.

pub fn start_polling(&self, every: Duration) -> JoinHandle<()>

Refreshes every every, for the life of the process.

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

Takes the named lock for ttl, or None while another holder has it. Release it with Lock::release; it lapses on its own after ttl.

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.

impl Debug for Cache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.