Struct CacheEntry 

pub struct CacheEntry<V> { /* private fields */ }

A cached value with associated metadata.

CacheEntry wraps a value with optional TTL and timestamp information. The cache system uses this metadata for expiration tracking and telemetry.

Examples

use std::time::Duration;

use cachet_tier::CacheEntry;

// Simple entry with just a value (no expiration)
let entry = CacheEntry::new(42);
assert_eq!(*entry.value(), 42);

// CacheEntry<V> implements Deref<Target = V>, so you can call
// methods on the inner value directly:
let entry = CacheEntry::new("hello world".to_string());
assert_eq!(entry.len(), 11); // calls String::len() via Deref
assert!(entry.starts_with("hello")); // calls str::starts_with() via Deref

// Entry that expires after a duration from insert time
let entry = CacheEntry::expires_after("data".to_string(), Duration::from_secs(60));
assert_eq!(entry.ttl(), Some(Duration::from_secs(60)));

Implementations

impl<V> CacheEntry<V>

pub fn new(value: V) -> CacheEntry<V>

Creates a new cache entry with the given value.

The entry will not expire unless a tier-level TTL is configured.

pub fn expires_after(value: V, ttl: Duration) -> CacheEntry<V>

Creates a cache entry that expires after the given duration from insert time.

The timestamp will be set by the cache when the entry is inserted. The per-entry TTL takes precedence over any tier-level TTL.

pub fn expires_at( value: V, ttl: Duration, cached_at: SystemTime, ) -> CacheEntry<V>

Creates a cache entry that expires at cached_at + ttl.

This is primarily useful for testing expiration logic with controlled timestamps, or if you need to construct entries with pre-determined expiration times.

pub fn cached_at(&self) -> Option<SystemTime>

Returns the timestamp when this entry was cached.

Returns None if the entry hasn’t been inserted into a cache yet, or was created without expires_at.

pub fn ensure_cached_at(&mut self, cached_at: SystemTime)

Sets the cache timestamp if not already set.

Called automatically by the cache during insertion. If the entry was created with expires_at, the existing timestamp is preserved.

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

Returns the per-entry TTL override.

When set, this takes precedence over any tier-level TTL configured on the cache.

pub fn set_ttl(&mut self, ttl: Duration)

Sets a per-entry TTL that overrides the tier-level TTL.

pub fn into_value(self) -> V

Consumes the entry and returns the inner value.

pub fn value(&self) -> &V

Returns a reference to the cached value.

pub fn try_map_value<U, F>(self, f: F) -> Result<CacheEntry<U>, Error>

where F: FnOnce(V) -> Result<U, Error>,

Transforms the value while preserving metadata (cached_at, ttl).

Errors

Forwards the error returned by the input encoding function

Trait Implementations

impl<V> Clone for CacheEntry<V>

where V: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V> Debug for CacheEntry<V>

where V: Debug,

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

Formats the value using the given formatter.

impl<V> Deref for CacheEntry<V>

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &<CacheEntry<V> as Deref>::Target

Dereferences the value.

impl<V> Eq for CacheEntry<V>

where V: Eq,

impl<V> From<V> for CacheEntry<V>

fn from(value: V) -> CacheEntry<V>

Converts to this type from the input type.

impl<V> PartialEq for CacheEntry<V>

where V: PartialEq,

fn eq(&self, other: &CacheEntry<V>) -> 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<V> StructuralPartialEq for CacheEntry<V>