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

use extract::{ExtractFuture, Error};

use futures::{Poll};

/// Implements `ExtractFuture` such that the result is immediately available.
///
/// This type is useful when implementing `Extract` for types that do not
/// require any asynchronous processing. For example, extracting an HTTP header
/// value from an HTTP request can complete immediately as all the information
/// is present.
#[derive(Debug)]
pub struct Immediate<T> {
    inner: Result<T, Option<Error>>,
}

impl<T> Immediate<T> {
    fn new(result: Result<T, Error>) -> Immediate<T> {
        Immediate {
            inner: result.map_err(Some),
        }
    }

    /// Create a new `Immediate` instance that is in the success state.
    ///
    /// When polling the returned `Immediate` instance, it will yield `value`.
    pub fn ok(value: T) -> Immediate<T> {
        Immediate::new(Ok(value))
    }

    /// Create a new `Immediate` instance that is in the error state.
    ///
    /// When polling the returned `Immediate` instance, it will yield `error`.
    pub fn err(error: Error) -> Immediate<T> {
        Immediate::new(Err(error))
    }
}

impl<T> ExtractFuture for Immediate<T> {
    type Item = T;

    fn poll(&mut self) -> Poll<(), Error> {
        match self.inner {
            Ok(_) => Ok(().into()),
            Err(ref mut err) => {
                Err(err.take().unwrap())
            }
        }
    }

    fn extract(self) -> T {
        self.inner.unwrap()
    }
}

impl<T, E> From<Result<T, E>> for Immediate<T>
where E: Into<Error>,
{
    fn from(src: Result<T, E>) -> Self {
        let inner = src.map_err(|e| Some(e.into()));
        Immediate { inner }
    }
}