Struct DialCache 

pub struct DialCache { /* private fields */ }

A cache instance: request, process-local and remote layers behind explicit enablement.

Instances are cheap to clone and share one state.

Implementations

impl DialCache

pub fn builder() -> DialCacheBuilder

Start configuring an instance with the defaults documented on DialCacheBuilder’s setters.

pub fn namespace(&self) -> &str

The instance namespace.

pub fn enable_guard(&self) -> ScopeGuard

Open the outermost enabled scope and hold it in a guard. The scope closes when the guard drops; retained Scope clones then pass through.

let request = cache.enable_guard();
let name = display_name.get(request.scope(), id).await?;

pub async fn enable<F, Fut, R>(&self, f: F) -> R

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

Open the outermost enabled scope for f. The scope closes when the returned future completes, is dropped before completion, or unwinds; retained clones then pass through.

pub async fn enable_in<F, Fut, R>(&self, parent: &Scope, f: F) -> R

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

Enable caching inside parent, reusing its live outer request memo. When parent has no live outer scope, this opens a new one.

pub async fn disable_in<F, Fut, R>(&self, parent: &Scope, f: F) -> R

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

Disable caching inside parent while preserving its outer request memo for nested re-enablement.

pub fn is_enabled(&self, scope: &Scope) -> bool

Whether calls made with scope on this instance use caching.

pub fn coalescing_state(&self) -> CoalescingState

Process-scoped single-flight state of this instance.

pub async fn invalidate( &self, key_type: &str, id: impl IntoKeyId, future_buffer_ms: u64, ) -> Result<(), Error>

Advance the invalidation watermark of every tracked variant of one entity, in this instance’s namespace. Call it after the source mutation commits. Requires a remote adapter; failures are returned. IDs use the same IntoKeyId conversion as crate::KeySpec::new.

pub async fn invalidate_identity( &self, identity: Identity, future_buffer_ms: u64, ) -> Result<(), Error>

Advance the watermark for the entity named by identity after its source mutation commits. An empty namespace inherits this instance’s; an explicit namespace is preserved, exactly as in get_or_load.

All use cases and argument variants share the entity’s watermark. tracked is ignored: this operation always invalidates tracked remote values. Local entries and already acquired snapshots retain their lifetimes. Requires a remote adapter; mutation failures are returned to the caller.

pub async fn get_or_load<T, F, Fut>( &self, scope: &Scope, operation: Operation<T>, load: F, ) -> Result<Arc<T>, Error>

where T: Send + Sync + 'static, F: Fn(Scope) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<T, BoxError>> + Send + 'static,

Execute one inline cached call.

load is the source of truth; it may be invoked again later by served-hit shadow validation, so it must be reusable. The returned value is shared by reference: treat it as immutable.

impl DialCache

pub fn use_case<Args, T>( &self, key_type: impl Into<String>, use_case: impl Into<String>, ) -> UseCaseBuilder<Args, T>

where Args: Clone + Send + Sync + 'static, T: Send + Sync + 'static,

Start registering a use case. key_type names the entity type and use_case the operation; the pair identifies cached values.

Trait Implementations

impl Clone for DialCache

fn clone(&self) -> DialCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DialCache

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

Formats the value using the given formatter.