Struct SecondChanceLru 

pub struct SecondChanceLru<K, V> { /* private fields */ }

LRU cache with second-chance eviction algorithm.

Access marking is lock-free (atomic bool), reducing contention on the hot read path. Only eviction requires exclusive access.

Example

use grafeo_core::cache::SecondChanceLru;

let mut cache = SecondChanceLru::new(3);
cache.insert("a", 1);
cache.insert("b", 2);
cache.insert("c", 3);

// Access "a" to give it a second chance
let _ = cache.get(&"a");

// Insert "d" - should evict "b" (not accessed), not "a"
cache.insert("d", 4);

assert!(cache.get(&"a").is_some());
assert!(cache.get(&"b").is_none()); // evicted

Implementations

impl<K: Hash + Eq + Clone, V> SecondChanceLru<K, V>

pub fn new(capacity: usize) -> Self

Creates a new cache with the given capacity.

The cache will hold at most capacity entries. When full, the second-chance algorithm determines which entry to evict.

pub fn get(&self, key: &K) -> Option<&V>

Gets a value, marking it as accessed (lock-free flag set).

Returns None if the key is not in the cache.

pub fn get_mut(&mut self, key: &K) -> Option<&mut V>

Gets a mutable reference to a value, marking it as accessed.

Returns None if the key is not in the cache.

pub fn contains_key(&self, key: &K) -> bool

Checks if the cache contains the given key.

This does NOT mark the entry as accessed.

pub fn insert(&mut self, key: K, value: V)

Inserts a value, evicting if at capacity.

If the key already exists, the value is updated and marked as accessed. If the cache is at capacity and this is a new key, one entry is evicted using the second-chance algorithm.

pub fn remove(&mut self, key: &K) -> Option<V>

Removes a specific key from the cache.

Returns the value if it was present.

pub fn len(&self) -> usize

Returns the number of entries in the cache.

pub fn is_empty(&self) -> bool

Returns true if the cache is empty.

pub fn clear(&mut self)

Clears all entries from the cache.

pub fn capacity(&self) -> usize

Returns the maximum capacity of the cache.

pub fn keys(&self) -> impl Iterator<Item = &K>

Returns an iterator over the keys in the cache.

The order is unspecified and does not reflect access patterns.

pub fn values(&self) -> impl Iterator<Item = &V>

Returns an iterator over the values in the cache.

The order is unspecified. Values are not marked as accessed.

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)>

Returns an iterator over key-value pairs in the cache.

The order is unspecified. Values are not marked as accessed.

Trait Implementations

impl<K: Hash + Eq + Clone, V: Clone> Clone for SecondChanceLru<K, V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Hash + Eq + Clone, V> Default for SecondChanceLru<K, V>

fn default() -> Self

Returns the “default value” for a type.