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 a VecDeque 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.