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

use futures::{Future, Poll};
use http;

/// HTTP response future trait
///
/// A trait "alias" for `Future` where the yielded item is an `http::Response`.
///
/// Using `HttpFuture` in where bounds is easier than trying to use `Future`
/// directly.
pub trait HttpFuture: sealed::Sealed {
    /// The HTTP response body
    type Body;

    /// Attempt to resolve the future to a final value, registering the current
    /// task for wakeup if the value is not yet available.
    fn poll_http(&mut self) -> Poll<http::Response<Self::Body>, ::Error>;

    /// Wraps `self` with `LiftFuture`. This provides an implementation of
    /// `Future` for `Self`.
    fn lift(self) -> LiftFuture<Self>
    where Self: Sized,
    {
        LiftFuture { inner: self }
    }
}

/// Contains an `HttpFuture` providing an implementation of `Future`.
#[derive(Debug)]
pub struct LiftFuture<T> {
    inner: T,
}

impl<T, B> HttpFuture for T
where T: Future<Item = http::Response<B>, Error = ::Error>
{
    type Body = B;

    fn poll_http(&mut self) -> Poll<http::Response<Self::Body>, ::Error> {
        Future::poll(self)
    }
}

impl<T, B> sealed::Sealed for T
where T: Future<Item = http::Response<B>, Error = ::Error>
{
}

impl<T: HttpFuture> Future for LiftFuture<T> {
    type Item = http::Response<T::Body>;
    type Error = ::Error;

    fn poll(&mut self) -> Poll<Self::Item, ::Error> {
        self.inner.poll_http()
    }
}

/// Must be made crate public for `Either{N}` implementations.
pub(crate) mod sealed {
    pub trait Sealed {}
}