use std::future::Future;
use std::pin::pin;
use std::sync::{Arc, OnceLock};
use std::task::{Context, Poll, Waker};
use std::thread;
use std::thread::Thread;
use std::time::Instant;
pub(crate) enum Either2<A, B> {
First(A),
Second(B),
}
pub(crate) fn drive_either<A, B>(
a: A,
b: B,
deadline: Option<Instant>,
waker: &Waker,
) -> Option<Either2<A::Output, B::Output>>
where
A: Future,
B: Future,
{
let mut a = pin!(a);
let mut b = pin!(b);
let mut cx = Context::from_waker(waker);
loop {
if let Poll::Ready(v) = a.as_mut().poll(&mut cx) {
return Some(Either2::First(v));
}
if let Poll::Ready(v) = b.as_mut().poll(&mut cx) {
return Some(Either2::Second(v));
}
match deadline {
None => thread::park(),
Some(deadline) => {
let now = Instant::now();
if now >= deadline {
return None;
}
thread::park_timeout(deadline - now);
}
}
}
}
pub(crate) fn drive_until<F: Future>(
fut: F,
deadline: Option<Instant>,
waker: &Waker,
) -> Option<F::Output> {
use std::convert::Infallible;
match drive_either(fut, std::future::pending::<Infallible>(), deadline, waker) {
Some(Either2::First(v)) => Some(v),
Some(Either2::Second(never)) => match never {}, None => None,
}
}
#[derive(Clone, Default, Debug)]
pub(crate) struct SharedWaker {
inner: Arc<WakerInner>,
}
#[derive(Default, Debug)]
struct WakerInner {
thread: OnceLock<Thread>,
}
impl SharedWaker {
pub(crate) fn attach_current(&self) {
let _ = self.inner.thread.set(std::thread::current());
}
pub(crate) fn wake(&self) {
if let Some(t) = self.inner.thread.get() {
t.unpark();
}
}
pub(crate) fn waker(&self) -> Waker {
Waker::from(Arc::new(WakeRef(self.clone())))
}
}
struct WakeRef(SharedWaker);
impl std::task::Wake for WakeRef {
fn wake(self: Arc<Self>) {
self.0.wake();
}
fn wake_by_ref(self: &Arc<Self>) {
self.0.wake();
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::future::pending;
use std::time::Duration;
#[test]
fn drive_until_times_out() {
let w = SharedWaker::default().waker();
let out = drive_until(
pending::<()>(),
Some(Instant::now() + Duration::from_millis(20)),
&w,
);
assert!(out.is_none());
}
#[test]
fn shared_waker_unparks_thread() {
let w = SharedWaker::default();
let w2 = w.clone();
let h = std::thread::spawn(move || {
w2.attach_current();
thread::park();
true
});
std::thread::sleep(Duration::from_millis(10));
w.wake();
assert!(h.join().unwrap());
}
}