Struct EventStream 

pub struct EventStream { /* private fields */ }

Asynchronous iterator over the incoming Events destined for this node.

This struct implements the Stream trait, so you can use methods of the StreamExt trait on this struct. A common pattern is while let Some(event) = event_stream.next().await.

Nodes should iterate over this event stream and react to events that they are interested in. Typically, the most important event type is Event::Input. You don’t need to handle all events, it’s fine to ignore events that are not relevant to your node.

The event stream will close itself after a Event::Stop was received. A manual break on Event::Stop is typically not needed. (You probably do need to use a manual break on stop events when using the StreamExt::merge implementation on EventStream to combine the stream with an external one.)

Once the event stream finished, nodes should exit. Note that Dora kills nodes that don’t exit quickly after a Event::Stop of type StopCause::Manual was received.

Implementations

impl EventStream

pub fn recv(&mut self) -> Option<Event>

Synchronously waits for the next event.

Blocks the thread until the next event arrives. Returns None once the event stream is closed.

For an asynchronous variant of this method see recv_async.

Event Reordering

This method uses an EventScheduler internally to reorder events. This means that the events might be returned in a different order than they occurred. For details, check the documentation of the EventScheduler struct.

If you want to receive the events in their original chronological order, use the asynchronous StreamExt::next method instead (EventStream implements the Stream trait).

pub fn recv_timeout(&mut self, dur: Duration) -> Option<Event>

Receives the next incoming Event synchronously with a timeout.

Blocks the thread until the next event arrives or the timeout is reached. Returns a Event::Error if no event was received within the given duration.

Returns None once the event stream is closed.

For an asynchronous variant of this method see recv_async_timeout.

Event Reordering

This method uses an EventScheduler internally to reorder events. This means that the events might be returned in a different order than they occurred. For details, check the documentation of the EventScheduler struct.

If you want to receive the events in their original chronological order, use the asynchronous StreamExt::next method instead (EventStream implements the Stream trait).

pub async fn recv_async(&mut self) -> Option<Event>

Receives the next incoming Event asynchronously, using an EventScheduler for fairness.

Returns None once the event stream is closed.

Event Reordering

This method uses an EventScheduler internally to reorder events. This means that the events might be returned in a different order than they occurred. For details, check the documentation of the EventScheduler struct.

If you want to receive the events in their original chronological order, use the StreamExt::next method with a custom timeout future instead (EventStream implements the Stream trait).

pub async fn recv_async_timeout(&mut self, dur: Duration) -> Option<Event>

Receives the next incoming Event asynchronously with a timeout.

Returns a Event::Error if no event was received within the given duration.

Returns None once the event stream is closed.

Event Reordering

This method uses an EventScheduler internally to reorder events. This means that the events might be returned in a different order than they occurred. For details, check the documentation of the EventScheduler struct.

If you want to receive the events in their original chronological order, use the StreamExt::next method with a custom timeout future instead (EventStream implements the Stream trait).

Trait Implementations

impl Drop for EventStream

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, E> MergeExternal<'a, E> for EventStream

where E: 'static,

type Item = MergedEvent<E>

The item type yielded from the merged stream.

fn merge_external( self, external_events: impl Stream<Item = E> + Unpin + 'a, ) -> Box<dyn Stream<Item = Self::Item> + Unpin + 'a>

Merge the given stream into an existing event stream.

impl<'a, E> MergeExternalSend<'a, E> for EventStream

where E: 'static,

type Item = MergedEvent<E>

The item type yielded from the merged stream.

fn merge_external_send( self, external_events: impl Stream<Item = E> + Unpin + Send + Sync + 'a, ) -> Box<dyn Stream<Item = Self::Item> + Unpin + Send + Sync + 'a>

Merge the given stream into an existing event stream.

impl Stream for EventStream

type Item = Event

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.