Struct BoundedHashMap 

pub struct BoundedHashMap<K, V, S = DefaultHasher> { /* private fields */ }

A fixed-capacity hash map that evicts the oldest entries when full.

When the map is at capacity, each insert pushes out the oldest entry (FIFO eviction order). This is used to track recently-seen message IDs for deduplication, preventing unbounded memory growth in long-running nodes.

Example

// Module is crate-private; use from within beam.
use beam::utils::BoundedHashMap;
let mut map = BoundedHashMap::new(2);
map.insert("a", 1);
map.insert("b", 2);

Implementations

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

pub fn new(max_entries: usize) -> Self

Creates a new BoundedHashMap with the given maximum capacity.

Uses the default FxHash hasher for non-cryptographic hashing.

Panics

Does not panic; a capacity of 0 will simply evict on every insert.

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

Inserts a key-value pair, evicting the oldest entry if at capacity.

If the key already exists, the value is updated in place and the eviction queue is not modified (the key’s position is preserved). If capacity is 0, the insert is silently dropped.

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

Returns a mutable reference to the value for the given key, or None.

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

Returns a reference to the value for the given key, or None.

pub fn len(&self) -> usize

Returns the number of entries currently stored.

pub fn is_empty(&self) -> bool

Returns true if the map contains no entries.

pub fn capacity(&self) -> usize

Returns the maximum number of entries before eviction begins.

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

Removes and returns the value for the given key, or None.

Also removes the key from the eviction queue to prevent it from being re-inserted as a stale entry on the next FIFO eviction. If you re-insert the same key later, it goes to the front of the queue (most-recently-used).

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

Iterator over all (key, value) pairs.

Used by periodic cleanup tasks (e.g., the quorum reaper) that need to scan all entries for expiration. Order is unspecified — typically the HashMap’s random iteration order. For FIFO-scoped iteration, callers should combine with take() to evict expired entries.

Examples

for (key, value) in map.iter() {
    if should_evict(&value) {
        map.take(&key);
    }
}

Trait Implementations

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

fn default() -> Self

Returns the “default value” for a type.