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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
use super::RW;
use super::evented::{Evented, EventedImpl, MioAdapter};
use std::io;
use std::path::Path;
use std::os::unix::io::RawFd;
use mio_orig;
pub type PipeReader = MioAdapter<mio_orig::unix::PipeReader>;
pub type PipeWriter = MioAdapter<mio_orig::unix::PipeWriter>;
pub type UnixListener = MioAdapter<mio_orig::unix::UnixListener>;
impl UnixListener {
pub fn bind<P: AsRef<Path> + ?Sized>(addr: &P) -> io::Result<Self> {
mio_orig::unix::UnixListener::bind(addr).map(MioAdapter::new)
}
pub fn try_clone(&self) -> io::Result<Self> {
self.shared().io_ref().try_clone().map(MioAdapter::new)
}
}
pub type UnixSocket = MioAdapter<mio_orig::unix::UnixSocket>;
impl UnixSocket {
pub fn stream() -> io::Result<UnixSocket> {
mio_orig::unix::UnixSocket::stream().map(MioAdapter::new)
}
pub fn connect<P: AsRef<Path> + ?Sized>(self, addr: &P) -> io::Result<(UnixStream, bool)> {
self.shared()
.io_ref()
.try_clone()
.and_then(|t| mio_orig::unix::UnixSocket::connect(t, addr))
.map(|(t, b)| (MioAdapter::new(t), b))
}
pub fn bind<P: AsRef<Path> + ?Sized>(&self, addr: &P) -> io::Result<()> {
self.shared().io_ref().bind(addr)
}
pub fn try_clone(&self) -> io::Result<Self> {
self.shared().io_ref().try_clone().map(MioAdapter::new)
}
}
pub type UnixStream = MioAdapter<mio_orig::unix::UnixStream>;
impl UnixStream {
pub fn connect<P: AsRef<Path> + ?Sized>(path: &P) -> io::Result<UnixStream> {
mio_orig::unix::UnixStream::connect(path).map(MioAdapter::new)
}
pub fn try_clone(&self) -> io::Result<Self> {
self.shared().io_ref().try_clone().map(MioAdapter::new)
}
pub fn try_read_recv_fd(&mut self,
buf: &mut [u8])
-> io::Result<Option<(usize, Option<RawFd>)>> {
self.shared().io_mut().try_read_recv_fd(buf)
}
pub fn read_recv_fd(&mut self, buf: &mut [u8]) -> io::Result<(usize, Option<RawFd>)> {
loop {
let res = self.try_read_recv_fd(buf);
match res {
Ok(None) => self.block_on(RW::read()),
Ok(Some(r)) => {
return Ok(r);
}
Err(e) => return Err(e),
}
}
}
pub fn try_write_send_fd(&self, buf: &[u8], fd: RawFd) -> io::Result<Option<usize>> {
self.shared().io_mut().try_write_send_fd(buf, fd)
}
pub fn write_send_fd(&mut self, buf: &[u8], fd: RawFd) -> io::Result<usize> {
loop {
let res = self.try_write_send_fd(buf, fd);
match res {
Ok(None) => self.block_on(RW::write()),
Ok(Some(r)) => {
return Ok(r);
}
Err(e) => return Err(e),
}
}
}
}
pub fn pipe() -> io::Result<(PipeReader, PipeWriter)> {
let (raw_reader, raw_writer) = try!(mio_orig::unix::pipe());
Ok((MioAdapter::new(raw_reader), MioAdapter::new(raw_writer)))
}