1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use std::{
    cell::Cell,
    future::Future,
    pin::Pin,
    rc::Rc,
    task::{Context, Poll, Waker},
};

// https://users.rust-lang.org/t/how-to-receive-a-async-callback/40110/3
// https://users.rust-lang.org/t/can-you-turn-a-callback-into-a-future-into-async-await/49378/16
// https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=10cd4b012f678705c9d78fed5ca81857

#[derive(Default)]
pub struct CallbackFutureInner<T> {
    waker: Cell<Option<Waker>>,
    result: Cell<Option<T>>,
}

impl<T> CallbackFutureInner<T> {
    fn new() -> Rc<CallbackFutureInner<T>> {
        Rc::new(CallbackFutureInner {
            waker: Cell::new(None),
            result: Cell::new(None),
        })
    }
}

#[derive(Default, Clone)]
pub struct FutureBoxSend<T> {
    inner: Rc<CallbackFutureInner<T>>,
}

impl<T> FutureBoxSend<T> {
    fn new(inner: Rc<CallbackFutureInner<T>>) -> FutureBoxSend<T> {
        FutureBoxSend { inner }
    }

    pub fn publish(&self, result: T) {
        self.inner.result.set(Some(result));
        if let Some(w) = self.inner.waker.take() {
            w.wake()
        }
    }
}

#[derive(Default, Clone)]
pub struct FutureBox<T> {
    inner: Rc<CallbackFutureInner<T>>,
}

impl<T> FutureBox<T> {
    pub fn new() -> (FutureBoxSend<T>, FutureBox<T>) {
        let inner = CallbackFutureInner::new();
        let sender = FutureBoxSend::new(inner.clone());
        let future = FutureBox { inner };
        (sender, future)
    }
}

impl<T> Future for FutureBox<T> {
    type Output = T;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        match self.inner.result.take() {
            Some(x) => Poll::Ready(x),
            None => {
                self.inner.waker.set(Some(cx.waker().clone()));
                Poll::Pending
            }
        }
    }
}