Struct InMemoryStore 

pub struct InMemoryStore<K, V>
where
    K: Eq + Hash + Clone + Send + Sync,
    V: Clone + Send + Sync,
{ /* private fields */ }

Generic thread-safe in-memory store

Uses DashMap for lock-free concurrent access with sharded hash maps. Arc wrapper enables cheap cloning for shared ownership across async tasks.

Iteration Consistency

This store uses DashMap which provides weakly consistent iteration:

• Individual items are always consistent (no torn reads)
• Items added during iteration may or may not be included
• Items removed during iteration may or may not be included
• Overall result represents a “fuzzy” snapshot of the store

For operations requiring strong consistency:

• Use single-key lookups (get, contains_key)
• Accept eventual consistency for bulk queries

This trade-off enables lock-free concurrent access without the overhead of MVCC or snapshot isolation.

Implementations

impl<K, V> InMemoryStore<K, V>

where K: Eq + Hash + Clone + Send + Sync, V: Clone + Send + Sync,

pub fn new() -> Self

Create empty store

pub fn count(&self) -> usize

Get number of entries

pub fn clear(&self)

Remove all entries

pub fn all_keys(&self) -> Vec<K>

Get all keys

Consistency

Returns a weakly consistent snapshot. Keys added or removed during iteration may or may not be included.

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

Get value by key

Consistency

Single-key lookups are always consistent and provide the most recent committed value for the key.

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

Insert or update value

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

Remove entry by key

pub fn filter<P>(&self, predicate: P) -> Vec<V>

where P: Fn(&V) -> bool,

Filter values by predicate

Consistency

Results are weakly consistent. Items added or removed during iteration may or may not be included. For authoritative checks, use single-key lookups (get, contains_key).

pub fn filter_limited<P>( &self, predicate: P, result_limit: usize, scan_limit: usize, ) -> (Vec<V>, bool)

where P: Fn(&V) -> bool,

Filter with bounded results and scan limit

Returns at most result_limit items matching predicate. Stops iteration after scanning scan_limit items.

Consistency

Results are weakly consistent. Items added or removed during iteration may or may not be included. For authoritative checks, use single-key lookups (get, contains_key).

Returns

A tuple of (results, limit_reached) where:

• results: Vec of matching items (at most result_limit items)
• limit_reached: true if either scan_limit or result_limit was hit, meaning the query stopped before examining all items. Results are still valid but potentially incomplete.

Example

use super::limits::{MAX_SCAN_LIMIT, MAX_RESULTS_LIMIT};

let (results, truncated) = store.filter_limited(
    |v| v.is_active(),
    MAX_RESULTS_LIMIT,
    MAX_SCAN_LIMIT,
);

if truncated {
    // Results may be incomplete
}

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

Check if key exists

Consistency

Single-key lookups are always consistent and provide the most recent committed state.

pub fn is_empty(&self) -> bool

Check if store is empty

pub fn update_with<F, R>(&self, key: &K, f: F) -> Option<R>

where F: FnOnce(&mut V) -> R,

Atomic read-modify-write operation

Applies function to mutable value reference if key exists. Returns the result of the function or None if key not found.

Consistency

This operation is atomic with respect to the specific key. The function is executed while holding the shard lock for that key, ensuring no concurrent modifications to the same key.

Example

store.update_with(&stream_id, |stream| {
    stream.complete()
});

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

Iterate over all entries

Returns an iterator that yields references to each entry. Useful for manual iteration with early abort.

Consistency

Iteration is weakly consistent. Items added or removed during iteration may or may not be included. This is a fundamental property of DashMap that enables lock-free concurrent access.

Trait Implementations

impl<K, V> Clone for InMemoryStore<K, V>

where K: Eq + Hash + Clone + Send + Sync, V: Clone + Send + Sync,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for InMemoryStore<K, V>

where K: Eq + Hash + Clone + Send + Sync + Debug, V: Clone + Send + Sync + Debug,

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

Formats the value using the given formatter.

impl<K, V> Default for InMemoryStore<K, V>

where K: Eq + Hash + Clone + Send + Sync, V: Clone + Send + Sync,

fn default() -> Self

Returns the “default value” for a type.