Struct TypedLifecycle 

pub struct TypedLifecycle<K, F>
where
    F: Fn(K) + Send + Sync,
{ /* private fields */ }

Helper for creating typed lifecycle implementations.

This wrapper provides convenient typed access to lifecycle events when you only use a single key type in your cache.

Example

use priority_lfu::{TypedLifecycle, CacheBuilder, CacheKey, DeepSizeOf};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

#[derive(Hash, Eq, PartialEq, Clone)]
struct MyKey(u64);

#[derive(Clone, DeepSizeOf)]
struct MyValue(String);

impl CacheKey for MyKey {
    type Value = MyValue;
}

let evict_count = Arc::new(AtomicUsize::new(0));
let counter = evict_count.clone();

let lifecycle = TypedLifecycle::<MyKey, _>::new(move |_key| {
    counter.fetch_add(1, Ordering::Relaxed);
});

let cache = CacheBuilder::new(1024)
    .lifecycle(lifecycle)
    .build();

Implementations

impl<K, F> TypedLifecycle<K, F>

where F: Fn(K) + Send + Sync,

pub fn new(callback: F) -> Self

Create a new typed lifecycle with the given eviction callback.

Trait Implementations

impl<K, F> Lifecycle for TypedLifecycle<K, F>

where K: Clone + Send + Sync + 'static, F: Fn(K) + Send + Sync,

fn on_evict(&self, key: &dyn Any)

Called when an item is evicted from the cache due to capacity pressure.

fn on_remove(&self, key: &dyn Any)

Called when an item is explicitly removed via cache.remove().

fn on_clear(&self, key: &dyn Any)

Called when the cache is cleared via cache.clear().