Struct BoundedIdempotenceCache 

pub struct BoundedIdempotenceCache {
    order: VecDeque<Uuid>,
    set: HashSet<Uuid>,
    capacity: usize,
}

A bounded FIFO cache for idempotency checking.

Uses a ring buffer (VecDeque) for eviction order and HashSet for fast membership checks. When capacity is reached, the oldest entries are evicted to make room for new ones.

Fields

order: VecDeque<Uuid>

Ring buffer storing request_ids in insertion order (oldest at front)

set: HashSet<Uuid>

Fast O(1) membership lookup

capacity: usize

Maximum capacity

Implementations

impl BoundedIdempotenceCache

pub fn with_capacity(capacity: usize) -> Self

Create a new cache with the specified capacity.

pub fn new() -> Self

Create a new cache with the default capacity (100,000 entries).

pub fn insert(&mut self, request_id: Uuid)

Insert a request_id into the cache.

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

pub fn contains(&self, request_id: &Uuid) -> bool

Check if a request_id is in the cache.

pub fn len(&self) -> usize

Return the number of entries in the cache.

pub fn is_empty(&self) -> bool

Check if the cache is empty.

pub fn capacity(&self) -> usize

Return the capacity of the cache.

pub fn extend<I: IntoIterator<Item = Uuid>>(&mut self, iter: I)

Extend the cache from an iterator of request_ids.

This is useful for bulk loading (e.g., from database at startup). Items are inserted in order, so the last items in the iterator will be the most recent (least likely to be evicted).

Trait Implementations

impl Default for BoundedIdempotenceCache

fn default() -> Self

Returns the “default value” for a type.