Struct EventStore 

pub struct EventStore { /* private fields */ }

Event Store - Centralized storage for memory events

The EventStore is the single source of truth for all memory events in the system. It uses a lock-free SegQueue for recording operations and a RwLock-protected Vec for efficient snapshots.

Key properties:

• Lock-free recording: Uses SegQueue for O(1) append without blocking
• Thread-safe: All operations are safe for concurrent use
• Efficient snapshots: Uses RwLock for fast read access
• Clear-safe: Uses atomic flag to prevent event loss during clear operations

Implementations

impl EventStore

pub fn new() -> Self

Create a new EventStore

pub fn record(&self, event: MemoryEvent)

Record a memory event

This method is lock-free and can be called from any thread without blocking other recording operations.

Arguments

• event - The memory event to record

Note

If a clear operation is in progress, this method will skip recording the event to prevent data loss. This ensures consistency between the event queue and the count.

pub fn snapshot(&self) -> Vec<MemoryEvent>

Get all events as a snapshot

Returns a snapshot of all events currently in the store. This method flushes any pending events from the lock-free queue to the cache before returning.

Returns

A vector containing all events in the store

pub fn len(&self) -> usize

Get the number of events in the store

Note: This returns an approximate count that may be slightly higher than the actual count due to concurrent operations.

pub fn is_empty(&self) -> bool

Check if the store is empty

pub fn clear(&self)

Clear all events from the store

This method removes all events from both the queue and cache. Uses write lock to ensure atomicity with concurrent record operations. Sets a clearing flag to prevent record() operations during clear.

Trait Implementations

impl Debug for EventStore

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

Formats the value using the given formatter.

impl Default for EventStore

fn default() -> Self

Returns the “default value” for a type.