use core::future::Future;
use core::future::poll_fn;
use core::pin::pin;
use core::sync::atomic::AtomicBool;
use core::sync::atomic::Ordering;
use core::task::Poll;
use atomic_waker::AtomicWaker;
use spin::Mutex;
pub async fn with_timeout<F: Future>(
fut: F,
timeout: impl Future<Output = ()>,
) -> Option<F::Output> {
let mut fut = pin!(fut);
let mut timeout = pin!(timeout);
poll_fn(move |cx| {
if let Poll::Ready(value) = fut.as_mut().poll(cx) {
return Poll::Ready(Some(value));
}
match timeout.as_mut().poll(cx) {
Poll::Ready(()) => Poll::Ready(None),
Poll::Pending => Poll::Pending,
}
})
.await
}
pub async fn yield_now() {
let mut yielded = false;
poll_fn(|cx| {
if yielded {
return Poll::Ready(());
}
yielded = true;
cx.waker().wake_by_ref();
Poll::Pending
})
.await;
}
pub struct Signal<T> {
value: Mutex<Option<T>>,
waker: AtomicWaker,
}
impl<T> Default for Signal<T> {
fn default() -> Self {
Self::new()
}
}
impl<T> Signal<T> {
pub const fn new() -> Self {
Self {
value: Mutex::new(None),
waker: AtomicWaker::new(),
}
}
pub fn signal(&self, value: T) {
*self.value.lock() = Some(value);
self.waker.wake();
}
pub fn reset(&self) {
*self.value.lock() = None;
}
pub fn try_take(&self) -> Option<T> {
self.value.lock().take()
}
pub fn is_signaled(&self) -> bool {
self.value.lock().is_some()
}
pub async fn wait(&self) -> T {
poll_fn(|cx| {
if let Some(value) = self.try_take() {
return Poll::Ready(value);
}
self.waker.register(cx.waker());
match self.try_take() {
Some(value) => Poll::Ready(value),
None => Poll::Pending,
}
})
.await
}
}
#[derive(Default)]
pub struct Event {
set: AtomicBool,
waker: AtomicWaker,
}
impl Event {
pub const fn new() -> Self {
Self {
set: AtomicBool::new(false),
waker: AtomicWaker::new(),
}
}
pub fn signal(&self) {
self.set.store(true, Ordering::Release);
self.waker.wake();
}
pub fn reset(&self) {
self.set.store(false, Ordering::Release);
}
pub fn is_set(&self) -> bool {
self.set.load(Ordering::Acquire)
}
pub async fn wait(&self) {
poll_fn(|cx| {
if self.set.swap(false, Ordering::AcqRel) {
return Poll::Ready(());
}
self.waker.register(cx.waker());
if self.set.swap(false, Ordering::AcqRel) {
return Poll::Ready(());
}
Poll::Pending
})
.await;
}
pub async fn wait_set(&self) {
poll_fn(|cx| {
if self.set.load(Ordering::Acquire) {
return Poll::Ready(());
}
self.waker.register(cx.waker());
if self.set.load(Ordering::Acquire) {
return Poll::Ready(());
}
Poll::Pending
})
.await;
}
}
#[cfg(test)]
mod tests {
use core::future::Future;
use core::pin::pin;
use core::task::Context;
use core::task::Waker;
use super::*;
#[test]
fn wait_consumes_signal() {
let event = Event::new();
let mut cx = Context::from_waker(Waker::noop());
let mut wait = pin!(event.wait());
assert!(wait.as_mut().poll(&mut cx).is_pending());
event.signal();
assert!(wait.as_mut().poll(&mut cx).is_ready());
let mut wait = pin!(event.wait());
assert!(wait.as_mut().poll(&mut cx).is_pending());
}
#[test]
fn signal_delivers_value_once() {
let signal = Signal::<u8>::new();
let mut cx = Context::from_waker(Waker::noop());
let mut wait = pin!(signal.wait());
assert!(wait.as_mut().poll(&mut cx).is_pending());
signal.signal(0x42);
assert_eq!(wait.as_mut().poll(&mut cx), Poll::Ready(0x42));
assert!(!signal.is_signaled());
assert!(pin!(signal.wait()).poll(&mut cx).is_pending());
}
#[test]
fn wait_set_leaves_flag() {
let event = Event::new();
let mut cx = Context::from_waker(Waker::noop());
event.signal();
assert!(pin!(event.wait_set()).poll(&mut cx).is_ready());
assert!(pin!(event.wait_set()).poll(&mut cx).is_ready());
}
}