Enum CacheEventKind 

pub enum CacheEventKind {
    Hit,
    Miss,
    SingleFlightJoined,
    LoadStarted,
    LoadCompleted,
    LoadFailed,
    Stored,
    Removed,
    KeyInvalidated,
    TagInvalidated,
    Flushed,
    StaleLoadDiscarded,
    Expired,
    Evicted,
}

Kind of cache event emitted by a HydraCache runtime.

Access and loader events are intentionally separate from mutation events so applications can keep high-volume hit/miss reporting disabled until needed.

Variants

Hit

A lookup returned a cached value.

Miss

A lookup did not find a usable cached value.

SingleFlightJoined

A caller joined an already running single-flight load.

LoadStarted

The cache owner started a loader for a missing key.

LoadCompleted

A loader completed and its result was accepted into the cache.

LoadFailed

A loader returned an error or failed to encode the loaded value.

Stored

A value was stored.

Removed

A key was explicitly removed.

KeyInvalidated

A key was explicitly invalidated.

TagInvalidated

A tag was invalidated.

Flushed

The cache was flushed.

StaleLoadDiscarded

A loader result was discarded because an invalidation made it stale.

Expired

An entry expired and was removed during cache access.

Evicted

An entry was evicted by the backend.

Implementations

impl CacheEventKind

pub fn is_access(self) -> bool

Return whether this event belongs to the high-volume access/load group.

pub fn is_mutation(self) -> bool

Return whether this event describes a cache mutation or invalidation.

Trait Implementations

impl Clone for CacheEventKind

fn clone(&self) -> CacheEventKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CacheEventKind

impl Debug for CacheEventKind

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

Formats the value using the given formatter.

impl Eq for CacheEventKind

impl Hash for CacheEventKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CacheEventKind

fn eq(&self, other: &CacheEventKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CacheEventKind