Struct eventually_core::aggregate::AggregateRoot

pub struct AggregateRoot<T> where
    T: Aggregate + 'static,  { /* fields omitted */ }

An AggregateRoot represents an handler to the Aggregate it's managing, such as:

• Owning the current, local Aggregate State,
• Proxying Commands to the Aggregate using the current State,
• Keeping a list of Events to commit after Command execution.

Initialize

AggregateRoot can be initialized in two ways:

1. Using the From<Aggregate> method:

   let root = AggregateRoot::from(aggregate);
   

2. Using the AggregateExt extension trait to call root() on the Aggregate instance:

   // This will result in a Clone of the Aggregate instance.
   let root = aggregate.root();
   

Implementations

impl<T> AggregateRoot<T> where
    T: Aggregate, 

pub fn state(&self) -> &T::State

Returns a reference to the current Aggregate State.

impl<T> AggregateRoot<T> where
    T: Aggregate, 

pub fn new(aggregate: T, state: T::State) -> Self

Creates a new AggregateRoot instance wrapping the specified State.

impl<T> AggregateRoot<T> where
    T: AggregateExt,
    T::Event: Clone,
    T::State: Clone, 

pub async fn handle<'_, '_>(
    &'_ mut self,
    command: T::Command
) -> Result<&'_ mut Self, T::Error>

Handles the submitted Command using the Aggregate::handle method and updates the Aggregate State.

Returns a &mut self reference to allow for method chaining.

Trait Implementations

impl<T: Debug> Debug for AggregateRoot<T> where
    T: Aggregate + 'static,
    T::State: Debug,
    T::Event: Debug, 

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

Formats the value using the given formatter.

impl<T> From<T> for AggregateRoot<T> where
    T: Aggregate,
    T::State: Default, 

fn from(aggregate: T) -> Self

Performs the conversion.

impl<T> Identifiable for AggregateRoot<T> where
    T: Aggregate, 

type Id = AggregateId<T>

Type of the data id. An id must support total equality.

fn id(&self) -> Self::Id

Data structure id accessor.

impl<T> PartialEq<AggregateRoot<T>> for AggregateRoot<T> where
    T: Aggregate, 

fn eq(&self, other: &Self) -> bool

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.