ratmom 0.1.0

Sensible, async, curl-based HTTP client
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

//! Tiny module containing utilities for working with futures.

use super::MaybeOwned;
use crossbeam_utils::sync::Parker;
use futures_lite::pin;
use std::{
    cell::RefCell,
    future::Future,
    task::{Context, Poll, Waker},
};
use waker_fn::waker_fn;

pub(crate) trait FutureExt: Future {
    /// Block the current thread until this future completes.
    fn wait(self) -> <Self as Future>::Output
    where
        Self: Sized,
    {
        fn create_parker() -> (Parker, Waker) {
            let parker = Parker::new();
            let unparker = parker.unparker().clone();
            let waker = waker_fn(move || unparker.unpark());

            (parker, waker)
        }

        thread_local! {
            static PARKER: RefCell<(Parker, Waker)> = RefCell::new(create_parker());
        }

        PARKER.with(|cell| {
            let future = self;
            pin!(future);

            let (ref parker, ref waker) = *cell
                .try_borrow_mut()
                .map(MaybeOwned::Borrowed)
                .unwrap_or_else(|_| MaybeOwned::Owned(create_parker()));
            let mut cx = Context::from_waker(waker);

            loop {
                match future.as_mut().poll(&mut cx) {
                    Poll::Ready(result) => break result,
                    Poll::Pending => parker.park(),
                }
            }
        })
    }
}

impl<F: Future> FutureExt for F {}