Struct event_listener::EventListener

source ·

pub struct EventListener<T = ()> { /* private fields */ }

Expand description

A guard waiting for a notification from an Event.

There are two ways for a listener to wait for a notification:

In an asynchronous manner using .await.
In a blocking manner by calling EventListener::wait() on it.

If a notified listener is dropped without receiving a notification, dropping will notify another active listener. Whether one additional listener will be notified depends on what kind of notification was delivered.

Implementations§

source §

impl<T> EventListener<T>

source

pub fn new(event: &Event<T>) -> Self

Create a new EventListener that will wait for a notification from the given Event.

source

pub fn listen(self: Pin<&mut Self>)

Register this listener into the given Event.

This method can only be called after the listener has been pinned, and must be called before the listener is polled.

source

pub fn is_listening(&self) -> bool

Tell if this EventListener is currently listening for a notification.

Examples

use event_listener::{Event, EventListener};

let event = Event::new();
let mut listener = Box::pin(EventListener::new(&event));

// The listener starts off not listening.
assert!(!listener.is_listening());

// After listen() is called, the listener is listening.
listener.as_mut().listen();
assert!(listener.is_listening());

// Once the future is notified, the listener is no longer listening.
event.notify(1);
listener.as_mut().wait();
assert!(!listener.is_listening());

source

pub fn wait(self: Pin<&mut Self>) -> T

Blocks until a notification is received.

Examples

use event_listener::Event;

let event = Event::new();
let mut listener = event.listen();

// Notify `listener`.
event.notify(1);

// Receive the notification.
listener.as_mut().wait();

source

pub fn wait_timeout(self: Pin<&mut Self>, timeout: Duration) -> Option<T>

Blocks until a notification is received or a timeout is reached.

Returns true if a notification was received.

Examples

use std::time::Duration;
use event_listener::Event;

let event = Event::new();
let mut listener = event.listen();

// There are no notification so this times out.
assert!(listener.as_mut().wait_timeout(Duration::from_secs(1)).is_none());

source

pub fn wait_deadline(self: Pin<&mut Self>, deadline: Instant) -> Option<T>

Blocks until a notification is received or a deadline is reached.

Returns true if a notification was received.

Examples

use std::time::{Duration, Instant};
use event_listener::Event;

let event = Event::new();
let mut listener = event.listen();

// There are no notification so this times out.
assert!(listener.as_mut().wait_deadline(Instant::now() + Duration::from_secs(1)).is_none());

source

pub fn discard(self: Pin<&mut Self>) -> bool

Drops this listener and discards its notification (if any) without notifying another active listener.

Returns true if a notification was discarded.

Examples

use event_listener::Event;

let event = Event::new();
let mut listener1 = event.listen();
let mut listener2 = event.listen();

event.notify(1);

assert!(listener1.as_mut().discard());
assert!(!listener2.as_mut().discard());

source

pub fn listens_to(&self, event: &Event<T>) -> bool

Returns true if this listener listens to the given Event.

Examples

use event_listener::Event;

let event = Event::new();
let listener = event.listen();

assert!(listener.listens_to(&event));

source

pub fn same_event(&self, other: &EventListener<T>) -> bool

Returns true if both listeners listen to the same Event.

Examples

use event_listener::Event;

let event = Event::new();
let listener1 = event.listen();
let listener2 = event.listen();

assert!(listener1.same_event(&listener2));