Struct FifoCache 

pub struct FifoCache<T, const N: usize>
where
    T: Clone + Debug + Eq + Hash,
{ /* private fields */ }

A bounded cache that maintains a set of IDs with O(1) lookups.

Uses an ArrayDeque for FIFO ordering and an AHashSet for fast membership checks. When capacity is exceeded, the oldest entry is automatically evicted.

Examples

use nautilus_common::cache::fifo::FifoCache;

let mut cache: FifoCache<u32, 3> = FifoCache::new();
cache.add(1);
cache.add(2);
cache.add(3);
assert!(cache.contains(&1));

// Adding beyond capacity evicts the oldest
cache.add(4);
assert!(!cache.contains(&1));
assert!(cache.contains(&4));

Zero capacity is a compile-time error:

use nautilus_common::cache::fifo::FifoCache;

// This fails to compile: capacity must be > 0
let cache: FifoCache<u32, 0> = FifoCache::new();

Default also enforces non-zero capacity:

use nautilus_common::cache::fifo::FifoCache;

// This also fails to compile
let cache: FifoCache<u32, 0> = FifoCache::default();

Implementations

impl<T, const N: usize> FifoCache<T, N>

where T: Clone + Debug + Eq + Hash,

pub fn new() -> Self

Creates a new empty FifoCache with capacity N.

Panics

Compile-time panic if N == 0.

pub const fn capacity(&self) -> usize

Returns the capacity of the cache.

pub fn len(&self) -> usize

Returns the number of IDs in the cache.

pub fn is_empty(&self) -> bool

Returns whether the cache is empty.

pub fn contains(&self, id: &T) -> bool

Returns whether the cache contains the given ID (O(1) lookup).

pub fn add(&mut self, id: T)

Adds an ID to the cache.

If the ID already exists, this is a no-op. If the cache is at capacity, the oldest entry is evicted.

pub fn remove(&mut self, id: &T)

Removes an ID from the cache.

pub fn clear(&mut self)

Clears all entries from the cache.

Trait Implementations

impl<T, const N: usize> Debug for FifoCache<T, N>

where T: Clone + Debug + Eq + Hash + Debug,

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for FifoCache<T, N>

where T: Clone + Debug + Eq + Hash,

fn default() -> Self

Returns the “default value” for a type.