Struct Store 

pub struct Store<Id, C, M>
where
    C: Codec,
{ /* private fields */ }

In-memory event store that keeps streams in a hash map.

Uses a global sequence counter (Position = u64) to maintain chronological ordering across streams, enabling cross-aggregate projections that need to interleave events by time rather than by stream name.

Generic over:

• Id: Aggregate identifier type (must be hashable/equatable for map keys)
• C: Serialization codec
• M: Metadata type (use () when not needed)

Implementations

impl<Id, C, M> Store<Id, C, M>

where C: Codec,

pub fn new(codec: C) -> Self

Trait Implementations

impl<Id, C, M> EventStore for Store<Id, C, M>

where Id: Clone + Eq + Hash + Send + Sync + 'static, C: Codec + Clone + Send + Sync + 'static, M: Clone + Send + Sync + 'static,

type Codec = C

Serialization codec.

type Error = InMemoryError

Store-specific error type.

type Id = Id

Aggregate identifier type.

type Metadata = M

Metadata type for infrastructure concerns.

type Position = u64

Position type used for ordering events and version checking.

fn codec(&self) -> &Self::Codec

fn stream_version<'a>( &'a self, aggregate_kind: &'a str, aggregate_id: &'a Self::Id, ) -> impl Future<Output = Result<Option<u64>, Self::Error>> + Send + 'a

Get the current version (latest position) for an aggregate stream.

fn begin<Conc: ConcurrencyStrategy>( &mut self, aggregate_kind: &str, aggregate_id: Self::Id, expected_version: Option<Self::Position>, ) -> Transaction<'_, Self, Conc>

Begin a transaction for appending events to an aggregate.

fn append<'a>( &'a mut self, aggregate_kind: &'a str, aggregate_id: &'a Self::Id, expected_version: Option<u64>, events: Vec<PersistableEvent<Self::Metadata>>, ) -> impl Future<Output = Result<(), AppendError<u64, Self::Error>>> + Send + 'a

Append events with optional version checking.

fn append_expecting_new<'a>( &'a mut self, aggregate_kind: &'a str, aggregate_id: &'a Self::Id, events: Vec<PersistableEvent<Self::Metadata>>, ) -> impl Future<Output = Result<(), AppendError<u64, Self::Error>>> + Send + 'a

Append events expecting an empty stream.

fn load_events<'a>( &'a self, filters: &'a [EventFilter<Self::Id, Self::Position>], ) -> impl Future<Output = Result<Vec<StoredEvent<Id, u64, M>>, Self::Error>> + Send + 'a

Load events matching the specified filters.