Struct aldrin::Events

pub struct Events { /* private fields */ }

Manages subscriptions to service events.

This type is created by Handle::events. Events can be subscribed and unsubscribed. After subscribing to events, this type should be polled through its implementation of Stream.

Subscriptions can be removed implicitly, e.g. when a Service has been destroyed. When there are no subscriptions left (or when none have been made in the first place) Stream::poll_next will return None.

When the Client shuts down, all subscriptions are removed and Stream::poll_next will return None as well.

Events holds an internal Handle and will thus prevent the Client from shutting down automatically. The Handle is only released when Events is dropped.

This is low-level type. You should generally use the auto-generated event streams instead, which do not require knowledge of event ids and provide better ergonomics for event arguments.

Examples

use aldrin::Event;

let mut events = handle.events();

events.subscribe(service_id, 1).await?;
events.subscribe(service_id, 2).await?;

while let Some(event) = events.next_event().await {
    match event {
        Event { id: 1, value, .. } => {
            let value: u32 = value.deserialize()?;
            println!("Event 1 with u32 value {value}.");
        }

        Event { id: 2, value, .. } => {
            let value: String = value.deserialize()?;
            println!("Event 2 with string value {value}.");
        }

        _ => unreachable!(),
    }
}

Implementations

impl Events

pub async fn subscribe( &mut self, service_id: ServiceId, id: u32 ) -> Result<bool, Error>

Subscribes to an event.

This function returns true, if the event id of service service_id was not already subscribed to. Otherwise false is returned.

pub fn unsubscribe( &mut self, service_id: ServiceId, id: u32 ) -> Result<bool, Error>

Unsubscribe from an event.

This function returns true, if the event id of service service_id was subscribed to before the call to this function and is now unsubscribed from. Otherwise false is returned.

pub fn poll_next_event(&mut self, cx: &mut Context<'_>) -> Poll<Option<Event>>

Polls for the next event.

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

Returns the next event.

Trait Implementations

impl Debug for Events

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FusedStream for Events

fn is_terminated(&self) -> bool

Returns true if the stream should no longer be polled.

impl Stream for Events

type Item = Event

Values yielded by the stream.

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

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.