Struct CacheEntry 

pub struct CacheEntry<T> {
    pub value: T,
    pub created_at: SystemTime,
    pub last_accessed: SystemTime,
    pub access_count: u64,
    pub ttl: Option<Duration>,
    pub stale_while_revalidate: Option<Duration>,
    pub tags: Vec<String>,
    pub dependencies: Vec<String>,
    pub cost: u64,
    pub size: usize,
    pub etag: Option<String>,
    pub version: u64,
}

A cached entry with full metadata

Fields

value: T

The cached value

created_at: SystemTime

When the entry was created

last_accessed: SystemTime

When the entry was last accessed

access_count: u64

Number of times accessed

ttl: Option<Duration>

Time-to-live

stale_while_revalidate: Option<Duration>

Stale-while-revalidate duration

tags: Vec<String>

Associated tags

dependencies: Vec<String>

Dependency keys

cost: u64

Computation cost

size: usize

Size in bytes

etag: Option<String>

ETag for HTTP caching

version: u64

Version for optimistic concurrency

Implementations

impl<T> CacheEntry<T>

pub fn new(value: T, size: usize) -> CacheEntry<T>

Create a new cache entry

pub fn with_ttl(value: T, size: usize, ttl: Duration) -> CacheEntry<T>

Create entry with TTL

pub fn is_expired(&self) -> bool

Check if entry has expired

pub fn is_stale(&self) -> bool

Check if entry is stale but still usable

pub fn ttl_remaining(&self) -> Option<Duration>

Get remaining TTL

pub fn age(&self) -> Duration

Get age of the entry

Trait Implementations

impl<T> Clone for CacheEntry<T>

where T: Clone,

fn clone(&self) -> CacheEntry<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for CacheEntry<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for CacheEntry<T>

where T: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<CacheEntry<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for CacheEntry<T>

where T: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.