Struct CacheEntry

Source

pub struct CacheEntry<R> {
    pub value: R,
    pub inserted_at: Instant,
    pub frequency: u64,
}

Expand description

Internal wrapper that tracks when a value was inserted into the cache. Used for TTL expiration support.

This structure is used internally to support TTL (Time To Live) expiration. Each cached value is wrapped in a CacheEntry which records the insertion timestamp using Instant::now().

§Type Parameters

R - The type of the cached value

§Fields

value - The actual cached value
inserted_at - The Instant when this entry was created
frequency - The number of times this entry has been accessed (for LFU policy)

§Examples

use cachelito_core::CacheEntry;

let entry = CacheEntry::new(42);
assert_eq!(entry.value, 42);
assert_eq!(entry.frequency, 0);

// Check if expired (TTL of 60 seconds)
assert!(!entry.is_expired(Some(60)));

Fields§

§value: R§inserted_at: Instant§frequency: u64

Implementations§

Source §

impl<R> CacheEntry<R>

Source

pub fn new(value: R) -> Self

Creates a new cache entry with the current timestamp.

§Arguments

value - The value to cache

§Returns

A new CacheEntry with inserted_at set to Instant::now() and frequency set to 0

Source

pub fn is_expired(&self, ttl: Option<u64>) -> bool

Returns true if the entry has expired based on the provided TTL.

§Arguments

ttl - Optional time-to-live in seconds. None means no expiration.

§Returns

true if the entry age exceeds the TTL
false if TTL is None or the entry is still valid

§Examples

use cachelito_core::CacheEntry;
use std::thread;
use std::time::Duration;

let entry = CacheEntry::new("data");

// Fresh entry is not expired
assert!(!entry.is_expired(Some(1)));

// Wait 2 seconds
thread::sleep(Duration::from_secs(2));

// Now it's expired (TTL was 1 second)
assert!(entry.is_expired(Some(1)));

// No TTL means never expires
assert!(!entry.is_expired(None));

Source

pub fn increment_frequency(&mut self)

Increments the access frequency counter.

This method is used by the LFU (Least Frequently Used) eviction policy to track how many times an entry has been accessed.

§Examples

use cachelito_core::CacheEntry;

let mut entry = CacheEntry::new(42);
assert_eq!(entry.frequency, 0);

entry.increment_frequency();
assert_eq!(entry.frequency, 1);

entry.increment_frequency();
assert_eq!(entry.frequency, 2);