Struct NotifyAggregator

pub struct NotifyAggregator { /* private fields */ }

This struct is used to aggregate multiple Notify instances into effectively a single Notify instance.

Calling NotifyAggregator::notified will wait for a notification on any of the registered Notify instances.

Implementations

impl NotifyAggregator

pub fn new() -> Self

Constructs a new NotifyAggregator.

Examples

use tokio_notify_aggregator::NotifyAggregator;

let aggregator = NotifyAggregator::new();

pub fn from_vec(vec: &Vec<Arc<Notify>>) -> Self

Constructs a new NotifyAggregator with the Arc<Notify> instances from vec.

Examples

use std::sync::Arc;
use tokio::sync::Notify;
use tokio_notify_aggregator::NotifyAggregator;

let notifiers = vec![Arc::new(Notify::new()), Arc::new(Notify::new())];
let aggregator = NotifyAggregator::from_vec(&notifiers);

pub fn add_notifier(&self, notifier: Arc<Notify>) -> &Self

Registers a new Notify instance to be tracked.

Examples

Simple usage:

use std::sync::Arc;
use tokio::sync::Notify;
use tokio_notify_aggregator::NotifyAggregator;

let aggregator = NotifyAggregator::new();
let notifier = Arc::new(Notify::new());
aggregator.add_notifier(notifier.clone());

Chained addition:

use std::sync::Arc;
use tokio::sync::Notify;
use tokio_notify_aggregator::NotifyAggregator;

let notifier1 = Arc::new(Notify::new());
let notifier2 = Arc::new(Notify::new());

let aggregator = NotifyAggregator::new()
    .add_notifier(notifier1.clone())
    .add_notifier(notifier2.clone());

pub fn notified(&self) -> Notified<'_>

Wait for a notification on any of the registered Notify instances.

Examples

use std::sync::Arc;
use tokio::sync::Notify;

use tokio_notify_aggregator::NotifyAggregator;

#[tokio::main]
async fn main() {
let aggregator = NotifyAggregator::new();

let notifier1 = Arc::new(Notify::new());
let notifier2 = Arc::new(Notify::new());

aggregator.add_notifier(notifier1.clone());
aggregator.add_notifier(notifier2.clone());

tokio::spawn(async move {
    loop {
        aggregator.notified().await;
        println!("Notified!");
    }
});

notifier1.notify_waiters();
notifier2.notify_waiters();
notifier1.notify_waiters();
notifier2.notify_waiters();
}

Trait Implementations

impl Clone for NotifyAggregator

fn clone(&self) -> NotifyAggregator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NotifyAggregator

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

Formats the value using the given formatter.

impl Default for NotifyAggregator

fn default() -> NotifyAggregator

Returns the “default value” for a type.

impl Drop for NotifyAggregator

fn drop(&mut self)

Handles the cleanup logic for the NotifyAggregator, by signaling all spawned tasks (one per registered Notify) to stop.

impl<'a> From<&'a Vec<Arc<Notify>>> for NotifyAggregator

fn from(vec: &'a Vec<Arc<Notify>>) -> Self

Constructs a new NotifyAggregator with the Arc<Notify> instances from vec.

Examples

use std::sync::Arc;
use tokio::sync::Notify;
use tokio_notify_aggregator::NotifyAggregator;

let notifiers = vec![Arc::new(Notify::new()), Arc::new(Notify::new())];
let aggregator = NotifyAggregator::from(&notifiers);

impl From<Vec<Arc<Notify>>> for NotifyAggregator

fn from(vec: Vec<Arc<Notify>>) -> Self

Constructs a new NotifyAggregator with the Arc<Notify> instances from vec.

Examples

use std::sync::Arc;
use tokio::sync::Notify;
use tokio_notify_aggregator::NotifyAggregator;

let notifiers = vec![Arc::new(Notify::new()), Arc::new(Notify::new())];
let aggregator = NotifyAggregator::from(notifiers);

impl FromIterator<Arc<Notify>> for NotifyAggregator

fn from_iter<T: IntoIterator<Item = Arc<Notify>>>(iter: T) -> Self

Constructs a new NotifyAggregator with the Arc<Notify> instances from iter.

Examples

use std::sync::Arc;
use tokio::sync::Notify;
use tokio_notify_aggregator::NotifyAggregator;

let notifiers = vec![Arc::new(Notify::new()), Arc::new(Notify::new())];
let aggregator = NotifyAggregator::from_iter(notifiers.into_iter());