Struct akka_persistence_rs::effect::ThenEmitEvent

pub struct ThenEmitEvent<B, F, R>where
    B: EventSourcedBehavior,{ /* private fields */ }

The return type of EffectExt::and_then_emit_event and EffectExt::and_then_emit_deletion_event.

Trait Implementations

impl<B, F, R> Effect<B> for ThenEmitEvent<B, F, R>where B: EventSourcedBehavior + Send + Sync + 'static, B::State: Send + Sync, B::Event: Send, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = Result<Option<B::Event>, Error>> + 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 ThenEmitEvent<B, F, R>where B: EventSourcedBehavior + Send + Sync + 'static, B::State: Send + Sync, B::Event: Send, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = Result<Option<B::Event>, Error>> + 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 emitted an event, or else the state at the outset of the effects being applied, is also available.

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

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

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

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

fn and_then_reply<F, R, T>(self, f: F) -> And<B, Self, ThenReply<B, F, R, T>>where Self: Sized, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = StdResult<Option<(Sender<T>, T)>, Error>> + Send, T: Send,

An effect to reply an envelope. The latest state given any previous effect having emitted 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.