Struct akka_persistence_rs::effect::Then

pub struct Then<B, F, R> { /* private fields */ }

The return type of then.

Trait Implementations

impl<B, F, R> Effect<B> for Then<B, F, R>where B: EventSourcedBehavior + Send + Sync + 'static, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = Result> + Send,

fn process<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 mut self, behavior: &'life1 B, _handler: &'life2 mut (dyn Handler<B::Event> + Send), entities: &'life3 mut (dyn EntityOps<B> + Send + Sync), entity_id: &'life4 EntityId, _last_seq_nr: &'life5 mut u64, prev_result: Result ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Consume the effect asynchronously. This operation may be performed multiple times, but only the first time is expected to perform the effect.

impl<B, F, R> EffectExt<B> for Then<B, F, R>where B: EventSourcedBehavior + Send + Sync + 'static, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = Result> + Send,

fn and<R>(self, r: R) -> And<B, Self, R>where Self: Sized, R: Effect<B>,

Perform the provided effect after this current one.

fn and_then<F, R>(self, f: F) -> And<B, Self, Then<B, F, R>>where Self: Sized, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = Result>,

Perform a side effect to run a function asynchronously after this current one. The associated behavior is available so that communication channels, for example, can be accessed by the side-effect. Additionally, the latest state given any previous effect having persisted an event, or else the state at the outset of the effects being applied, is also available.

fn then_persist_event<F>( self, f: F ) -> And<B, Self, ThenPersistEvent<B, Box<dyn FnOnce(&B, Option<&B::State>, Result) -> Ready<StdResult<Option<B::Event>, Error>> + Send>, Ready<StdResult<Option<B::Event>, Error>>>>where Self: Sized, B::State: Send + Sync, F: FnOnce(Option<&B::State>) -> Option<B::Event> + Send + 'static,

An effect to persist an event. The latest state given any previous effect having persisted an event, or else the state at the outset of the effects being applied, is also available.

fn then_reply<F, T>( self, f: F ) -> And<B, Self, ThenReply<B, Box<dyn FnOnce(&B, Option<&B::State>, Result) -> Ready<ReplyResult<T>> + Send>, Ready<ReplyResult<T>>, T>>where Self: Sized, B::State: Send + Sync, F: FnOnce(Option<&B::State>) -> Option<ReplyTo<T>> + Send + 'static, T: Send,

An effect to reply an envelope. The latest state given any previous effect having persisted an event, or else the state at the outset of the effects being applied, is also available.

fn boxed(self) -> Box<dyn Effect<B>>where Self: Sized + 'static,

Box the effect for the purposes of returning it.