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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

#![allow(missing_docs)]

//! Definition of `Either`s

use std::fmt::{self, Display};
use std::error::Error;
use futures::{Async, Future, Poll};
use response::{Responder, Response};

macro_rules! define_either {
    ($name:ident <$( $variant:ident ),*>) => {
        #[derive(Debug)]
        pub enum $name<$( $variant ),*> {
            $(
                $variant($variant),
            )*
        }

        impl<$( $variant ),*> Display for $name<$( $variant ),*>
        where
        $( $variant: Display ),*
        {
            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                match *self {
                    $(
                        $name :: $variant (ref e) =>
                            write!(f,
                                   concat!(stringify!($name), "::", stringify!($variant),
                                   "({})"),
                                   e),
                    )*
                }
            }
        }

        impl<$( $variant ),*> Error for $name<$( $variant ),*>
        where
        $( $variant: Error ),*
        {
            fn description(&self) -> &str {
                match *self {
                    $(
                        $name :: $variant (ref e) => e.description(),
                    )*
                }
            }
        }

        impl<$( $variant ),*> Future for $name<$( $variant ),*>
        where
        $( $variant: Future ),*
        {
            type Item = $name <$( $variant :: Item ),*>;
            type Error = $name <$( $variant :: Error ),*>;

            fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
                match *self {
                    $(
                        $name :: $variant(ref mut e) => {
                            let item = try_ready!(e.poll().map_err($name :: $variant));
                            Ok(Async::Ready($name :: $variant (item)))
                        },
                    )*
                }
            }
        }

        impl<$( $variant ),*> Responder for $name<$( $variant ),*>
        where
        $( $variant: Responder ),*
        {
            type Error = $name <$( $variant :: Error ),*>;

            fn respond(self) -> Result<Response, Self::Error> {
                match self {
                    $(
                        $name :: $variant (e) => e.respond().map_err($name :: $variant),
                    )*
                }
            }
        }
    }
}

define_either!(Either2<E1, E2>);
define_either!(Either3<E1, E2, E3>);
define_either!(Either4<E1, E2, E3, E4>);
define_either!(Either5<E1, E2, E3, E4, E5>);
define_either!(Either6<E1, E2, E3, E4, E5, E6>);
define_either!(Either7<E1, E2, E3, E4, E5, E6, E7>);