Struct eventually::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 its State, Id and version,
• Proxying Commands to the Aggregate using the current State,
• Keeping a list of Events to commit after Command execution.

Initialize

An AggregateRoot can only be initialized using the AggregateRootBuilder.

Check AggregateRootBuilder::build for more information.

Implementations

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

pub fn id(&self) -> &<T as Aggregate>::Id

Returns a reference to the Aggregate Id that represents the entity wrapped by this AggregateRoot instance.

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

Returns a reference to the current Aggregate State.

impl<T> AggregateRoot<T> where
    T: Aggregate,
    <T as Aggregate>::Event: Clone,
    <T as Aggregate>::State: Clone,
    <T as Aggregate>::Command: Debug, 

pub async fn handle(
    &'_ mut self,
    command: <T as Aggregate>::Command
) -> Result<&'_ mut AggregateRoot<T>, <T as Aggregate>::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 for AggregateRoot<T> where
    T: Debug + Aggregate + 'static,
    <T as Aggregate>::Id: Debug,
    <T as Aggregate>::State: Debug,
    <T as Aggregate>::Event: Debug, 

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

Formats the value using the given formatter.

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

type Target = <T as Aggregate>::State

The resulting type after dereferencing.

fn deref(&self) -> &<AggregateRoot<T> as Deref>::Target

Dereferences the value.

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

fn eq(&self, other: &AggregateRoot<T>) -> 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 !=.

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

fn version(&self) -> u32

Current version of the data.