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
91
92
93
94
95
96
97
98
use crate::transport::Transport;
use futures::prelude::*;
use multiaddr::Multiaddr;
use std::io;
#[derive(Debug, Copy, Clone)]
pub struct MapErrDial<T, F> { transport: T, fun: F }
impl<T, F> MapErrDial<T, F> {
#[inline]
pub(crate) fn new(transport: T, fun: F) -> MapErrDial<T, F> {
MapErrDial { transport, fun }
}
}
impl<T, F> Transport for MapErrDial<T, F>
where
T: Transport,
F: FnOnce(io::Error, Multiaddr) -> io::Error
{
type Output = T::Output;
type Listener = T::Listener;
type ListenerUpgrade = T::ListenerUpgrade;
type Dial = MapErrFuture<T::Dial, F>;
fn listen_on(self, addr: Multiaddr) -> Result<(Self::Listener, Multiaddr), (Self, Multiaddr)> {
let fun = self.fun;
self.transport.listen_on(addr)
.map_err(move |(transport, addr)| (MapErrDial { transport, fun }, addr))
}
fn dial(self, addr: Multiaddr) -> Result<Self::Dial, (Self, Multiaddr)> {
match self.transport.dial(addr.clone()) {
Ok(future) => Ok(MapErrFuture {
inner: future,
args: Some((self.fun, addr))
}),
Err((transport, addr)) => Err((MapErrDial { transport, fun: self.fun }, addr))
}
}
#[inline]
fn nat_traversal(&self, server: &Multiaddr, observed: &Multiaddr) -> Option<Multiaddr> {
self.transport.nat_traversal(server, observed)
}
}
#[derive(Debug, Clone)]
pub struct MapErrFuture<T, F> {
inner: T,
args: Option<(F, Multiaddr)>,
}
impl<T, E, F, A> Future for MapErrFuture<T, F>
where
T: Future<Error = E>,
F: FnOnce(E, Multiaddr) -> A
{
type Item = T::Item;
type Error = A;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self.inner.poll() {
Ok(Async::NotReady) => Ok(Async::NotReady),
Ok(Async::Ready(x)) => Ok(Async::Ready(x)),
Err(e) => {
let (f, a) = self.args.take().expect("MapErrFuture has already finished.");
Err(f(e, a))
}
}
}
}