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 error::ErrorKind;
use util::BufStream;

use futures::{Future, Poll};

/// Map an arbitrary error type to [`Error`]
///
/// The conversion is done by treating all errors as "internal server errors".
///
/// [`Error`]: struct.Error.html
#[derive(Debug)]
pub struct Map<T> {
    inner: State<T>,
}

#[derive(Debug)]
enum State<T> {
    Inner(T),
    Immediate(Option<::Error>),
}

impl<T> Map<T> {
    /// Create a new `Map` instance backed by `inner`.
    ///
    /// The returned value will map all errors generated by `inner` into
    /// [`Error`] by treating them as "internal server errors".
    ///
    /// [`Error`]: struct.Error.html
    pub fn new(inner: T) -> Map<T> {
        Map {
            inner: State::Inner(inner),
        }
    }

    /// Create a neew `Map` instance that is in the error state.
    ///
    /// The instance will yield `error` immediately when it is used.
    pub fn immediate(error: ::Error) -> Map<T> {
        Map {
            inner: State::Immediate(Some(error)),
        }
    }
}

impl<T: Future> Future for Map<T> {
    type Item = T::Item;
    type Error = ::Error;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        use self::State::*;

        match self.inner {
            Inner(ref mut f) => f.poll().map_err(|_| ErrorKind::internal().into()),
            Immediate(ref mut e) => Err(e.take().unwrap()),
        }
    }
}

impl<T: BufStream> BufStream for Map<T> {
    type Item = T::Item;
    type Error = ::Error;

    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
        use self::State::*;

        match self.inner {
            Inner(ref mut f) => f.poll().map_err(|_| ErrorKind::internal().into()),
            Immediate(ref mut e) => Err(e.take().unwrap()),
        }
    }
}