Struct cqrs_es::mem_store::MemStore

pub struct MemStore<A: Aggregate + Send + Sync> { /* private fields */ }

Simple memory store useful for application development and testing purposes.

Creation and use in a constructing a CqrsFramework:

use cqrs_es::CqrsFramework;
use cqrs_es::mem_store::MemStore;

let store = MemStore::<MyAggregate>::default();
let cqrs = CqrsFramework::new(store, vec![], MyService);

Implementations

impl<A: Aggregate> MemStore<A>

pub fn get_events(&self) -> Arc<RwLock<HashMap<String, Vec<EventEnvelope<A>>>>>

👎Deprecated since 0.4.9: clone the MemStore instead

Get a shared copy of the events stored within the event store.

This can be used to verify the state of events that have been committed. Example of reading and displaying stored events:

let store = MemStore::<MyAggregate>::default();
//...
let all_locked_events = store.get_events();
let unlocked_events = all_locked_events.read().unwrap();
if let Some(events) = unlocked_events.get("test-aggregate-id-C450D1A") {
    for event in events {
        println!("{:?}", event);
    }
};

Trait Implementations

impl<A: Clone + Aggregate + Send + Sync> Clone for MemStore<A>

fn clone(&self) -> MemStore<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Aggregate + Send + Sync> Debug for MemStore<A>

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

Formats the value using the given formatter.

impl<A: Aggregate> Default for MemStore<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A: Aggregate> EventStore<A> for MemStore<A>

type AC = MemStoreAggregateContext<A>

Provides the current state of an aggregate along with surrounding context. This is used by the CqrsFramework when loading an aggregate in order to handle incoming commands.

fn load_events<'life0, 'life1, 'async_trait>( &'life0 self, aggregate_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<EventEnvelope<A>>, AggregateError<A::Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load all events for a particular aggregate_id

fn load_aggregate<'life0, 'life1, 'async_trait>( &'life0 self, aggregate_id: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<MemStoreAggregateContext<A>, AggregateError<A::Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load aggregate at current state

fn commit<'life0, 'async_trait>( &'life0 self, events: Vec<A::Event>, context: MemStoreAggregateContext<A>, metadata: HashMap<String, String> ) -> Pin<Box<dyn Future<Output = Result<Vec<EventEnvelope<A>>, AggregateError<A::Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Commit new events