Struct DispatchChain 

pub struct DispatchChain<P, Ctx> { /* private fields */ }

Dispatcher builder. Obtained from EventStream::into_dispatcher.

Implementations

impl<P, Ctx> DispatchChain<P, Ctx>

where P: EventParser,

pub fn with_ctx(events: EventStream<P>, ctx: Ctx) -> Self

pub fn seq_fallback<E, F>(self, f: F) -> Dispatcher<P, Ctx, Fallback<F>>

where F: AsyncFnMut(Event, &mut Ctx) -> Result<StreamEvents, E>,

The sequential version of Self::fallback

pub fn fallback<E, F, Fut>(self, f: F) -> Dispatcher<P, Ctx, Fallback<F>>

where Ctx: 'static + Send, E: 'static + Send + From<P::Error>, F: Fn(Event, Ctx) -> Fut, Fut: 'static + Send + Future<Output = Result<StreamEvents, E>>,

Accepts all events (crate::Event) unhandled by regular handlers. It is mostly useful for debug logging. Prefer to remove this call in production because it forces full parsing of all event types when by default only the events with set up handlers get parsed.

pub fn seq<Ev, E, F>(self, f: F) -> Dispatcher<P, Ctx, Match<Ev, F>>

where Ev: EventData, F: AsyncFnMut(Arc<Ev>, &mut Ctx) -> Result<StreamEvents, E>,

Register the sequential handler. This call determines the Dispatcher type. You won’t be able to mix seq with on, after calling this all handlers must be seq. See Dispatcher::seq for full docs.

pub fn on<Ev, E, F, Fut>(self, f: F) -> Dispatcher<P, Ctx, Match<Ev, F>>

where Ctx: 'static + Send, E: 'static + Send, Ev: 'static + EventData, F: Fn(Arc<Ev>, Ctx) -> Fut, Fut: 'static + Send + Future<Output = Result<StreamEvents, E>>,

Register the concurrent handler. This call determines the Dispatcher type. You won’t be able to mix seq with on, after calling this all handlers must be on. See Dispatcher::on for full docs. Concurrent handlers require Ctx: 'static + Send + Clone. Ctx is getting cloned into each handler, ensure that impl Clone for Ctx is cheap. If you need to mutate the Ctx you will have to use Arc<Mutex> or similar.