Struct EventStream 

pub struct EventStream<P> { /* private fields */ }

The high level event stream that embeds event filtering.

Parsing SimpleX events may be costly, they are quite large deeply nested structs with a lot of String and std::collections::BTreeMap types. This stream provides filtering APIs allowing to parse and propagate events the application handles and drop all other events early without allocating any extra memory.

By default filters are disabled and no events are dropped. Use Self::set_filter to only receive events you’re interested in.

Use Self::into_dispatcher to handle events conveniently. Dispatchers are completely zerocost, manage filters internally, and provide a high-level easy to use API covering the absolute majority of use cases.

Implementations

impl<P> EventStream<P>

pub fn add_hook(&mut self, hook: Box<dyn Hook>)

pub fn set_filter<I: IntoIterator<Item = EventKind>>( &mut self, f: Filter<I>, ) -> &mut Self

pub fn accept(&mut self, kind: EventKind)

pub fn reject(&mut self, kind: EventKind)

pub fn accept_all(&mut self)

pub fn reject_all(&mut self)

impl<P: EventParser> EventStream<P>

pub fn into_dispatcher<C>(self, ctx: C) -> DispatchChain<P, C>

Turns stream into a DispatchChain builder with the provided ctx. The ctx is an arbitrary type that can be used within event handlers. Use dispatcher::Dispatcher::seq to add sequential handlers: AsyncFnMut(Arc<Ev>, &mut Ctx); or dispatcher::Dispatcher::on for concurrent ones: AsyncFn(Arc<Ev>, Ctx) where Ctx: 'static + Clone + Send.

pub async fn wait_for<Ev: EventData>( &mut self, ) -> Result<Option<Arc<Ev>>, P::Error>

Waits for a particular event Ev dropping other events in the process. This method is mostly useful in bot initialisation scenarios when the bot doesn’t have any active users. Misusing this method may result in not receiving user messages and other important events.

pub async fn wait_for_any( &mut self, kinds: impl IntoIterator<Item = EventKind>, ) -> Result<Option<Event>, P::Error>

Waits for one one of the events in the kinds list dropping other events in the process. Returns the first encountered event of the specified kind. This method is mostly useful in bot initialisation scenarios when the bot doesn’t have any active users. Misusing this method may result in not receiving user messages and other important events.

pub async fn stream_events<E, F>(self, f: F) -> Result<Self, E>

where F: AsyncFnMut(Event) -> Result<StreamEvents, E>, E: From<P::Error>,

pub async fn stream_events_with_ctx_mut<E, Ctx, F>( self, f: F, ctx: Ctx, ) -> Result<(Self, Ctx), E>

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

pub async fn stream_events_with_ctx_cloned<E, Ctx, F>( self, f: F, ctx: Ctx, ) -> Result<(Self, Ctx), E>

where Ctx: Clone, F: AsyncFn(Event, Ctx) -> Result<StreamEvents, E>, E: From<P::Error>,

Trait Implementations

impl<P> From<UnboundedReceiver<P>> for EventStream<P>

fn from(receiver: UnboundedReceiver<P>) -> Self

Converts to this type from the input type.

impl<P: EventParser> Stream for EventStream<P>

type Item = Result<Event, <P as EventParser>::Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.