Struct cqrs::CompositeEntityStore

pub struct CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>,  { /* fields omitted */ }

Combines an EntitySource and an EntitySink into a single type so that they can be jointly used as an EntityStore.

Methods

impl<A, E, M, ES, SS> CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

pub fn with_entity_source<NewES>(
    self,
    entity_source: NewES
) -> CompositeEntityStore<A, E, M, NewES, SS> where
    NewES: EntitySource<A, E>, 

Attaches a specific entity source.

pub fn with_entity_sink<NewSS>(
    self,
    entity_sink: NewSS
) -> CompositeEntityStore<A, E, M, ES, NewSS> where
    NewSS: EntitySink<A, E, M>, 

Attaches a specific entity sink.

Trait Implementations

impl<A: Clone, E: Clone, M: Clone, ES: Clone, SS: Clone> Clone for CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

fn clone(&self) -> CompositeEntityStore<A, E, M, ES, SS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, E, M> Default for CompositeEntityStore<A, E, M, CompositeEntitySource<'static, 'static, A, E, NullEventStore<A, E>, NullSnapshotStore<A>>, CompositeEntitySink<'static, 'static, A, E, M, NullEventStore<A, E>, NullSnapshotStore<A>>> where
    A: Aggregate,
    E: AggregateEvent<A>, 

fn default() -> Self

Returns the "default value" for a type.

impl<A: PartialEq, E: PartialEq, M: PartialEq, ES: PartialEq, SS: PartialEq> PartialEq<CompositeEntityStore<A, E, M, ES, SS>> for CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

fn eq(&self, other: &CompositeEntityStore<A, E, M, ES, SS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &CompositeEntityStore<A, E, M, ES, SS>) -> bool

This method tests for !=.

impl<A: Copy, E: Copy, M: Copy, ES: Copy, SS: Copy> Copy for CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

impl<A: Eq, E: Eq, M: Eq, ES: Eq, SS: Eq> Eq for CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

impl<A: Debug, E: Debug, M: Debug, ES: Debug, SS: Debug> Debug for CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

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

Formats the value using the given formatter.

impl<A, E, M, ES, SS> EventSource<A, E> for CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

type Error = <ES as EventSource<A, E>>::Error

The error type.

type Events = <ES as EventSource<A, E>>::Events

Represents the sequence of events read from the event source.

fn read_events<I>(
    &self,
    id: &I,
    since: Since,
    max_count: Option<u64>
) -> Result<Option<Self::Events>, Self::Error> where
    I: AggregateId<A>, 

Reads events from the event source for a given identifier.

impl<A, E, M, ES, SS> EventSink<A, E, M> for CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

type Error = <SS as EventSink<A, E, M>>::Error

The error type.

fn append_events<I>(
    &self,
    id: &I,
    events: &[E],
    precondition: Option<Precondition>,
    metadata: M
) -> Result<EventNumber, Self::Error> where
    I: AggregateId<A>, 

Appends events to a given source, with an optional precondition, and associated metadata.

impl<A, E, M, ES, SS> SnapshotSource<A> for CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

type Error = <ES as SnapshotSource<A>>::Error

The error type.

fn get_snapshot<I>(
    &self,
    id: &I
) -> Result<Option<VersionedAggregate<A>>, Self::Error> where
    I: AggregateId<A>, 

Loads a versioned aggregate from the snapshot source.

impl<A, E, M, ES, SS> SnapshotSink<A> for CompositeEntityStore<A, E, M, ES, SS> where
    A: Aggregate,
    E: AggregateEvent<A>,
    ES: EntitySource<A, E>,
    SS: EntitySink<A, E, M>, 

type Error = <SS as SnapshotSink<A>>::Error

The error type.

fn persist_snapshot<I>(
    &self,
    id: &I,
    aggregate: &A,
    version: Version,
    last_snapshot_version: Option<Version>
) -> Result<Version, Self::Error> where
    I: AggregateId<A>, 

Writes an aggregate with its version to the sink. Returns the version number of the latest snapshot.