#blocking #park #condvar #wake #reduce-boilerplate #envcount

no-std event-listener-strategy

Block or poll on event_listener easily

8 releases (4 breaking)

0.5.3 Nov 30, 2024
0.5.2 Apr 27, 2024
0.5.1 Mar 30, 2024
0.5.0 Feb 7, 2024
0.1.0 Sep 11, 2023

#976 in Asynchronous

Download history 1037034/week @ 2024-11-19 837192/week @ 2024-11-26 1053728/week @ 2024-12-03 1204081/week @ 2024-12-10 966560/week @ 2024-12-17 434335/week @ 2024-12-24 663913/week @ 2024-12-31 1182224/week @ 2025-01-07 1162291/week @ 2025-01-14 1169831/week @ 2025-01-21 1249085/week @ 2025-01-28 1376628/week @ 2025-02-04 1414291/week @ 2025-02-11 1404196/week @ 2025-02-18 1449646/week @ 2025-02-25 1577894/week @ 2025-03-04

6,080,820 downloads per month
Used in 6,169 crates (8 directly)

Apache-2.0 OR MIT

22KB
302 lines

event-listener-strategy

Build License Cargo Documentation

A strategy for using the event-listener crate in both blocking and non-blocking contexts.

One of the stand-out features of the event-listener crate is the ability to use it in both asynchronous and synchronous contexts. However, sometimes using it like this causes a lot of boilerplate to be duplicated. This crate aims to reduce that boilerplate by providing an EventListenerFuture trait that implements both blocking and non-blocking functionality.

Examples

use event_listener::{Event, EventListener};
use event_listener_strategy::{EventListenerFuture, FutureWrapper, Strategy};

use std::pin::Pin;
use std::task::Poll;
use std::thread;
use std::sync::Arc;

// A future that waits three seconds for an event to be fired.
fn wait_three_seconds() -> WaitThreeSeconds {
    let event = Event::new();
    let listener = event.listen();

    thread::spawn(move || {
        thread::sleep(std::time::Duration::from_secs(3));
        event.notify(1);
    });

    WaitThreeSeconds { listener }
}

struct WaitThreeSeconds {
    listener: Pin<Box<EventListener>>,
}

impl EventListenerFuture for WaitThreeSeconds {
    type Output = ();

    fn poll_with_strategy<'a, S: Strategy<'a>>(
        mut self: Pin<&'a mut Self>,
        strategy: &mut S,
        context: &mut S::Context,
    ) -> Poll<Self::Output> {
        strategy.poll(self.listener.as_mut(), context)
    }
}

// Use the future in a blocking context.
let future = wait_three_seconds();
future.wait();

// Use the future in a non-blocking context.
futures_lite::future::block_on(async {
    let future = FutureWrapper::new(wait_three_seconds());
    future.await;
});

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Dependencies

~0.3–23MB
~300K SLoC