mio 0.1.0 

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
127
128
129

use buf::{Buf, MutBuf};
use os;
use error::MioResult;

#[deriving(Show)]
pub enum NonBlock<T> {
    Ready(T),
    WouldBlock
}

impl<T> NonBlock<T> {
    pub fn would_block(&self) -> bool {
        match *self {
            WouldBlock => true,
            _ => false
        }
    }

    pub fn unwrap(self) -> T {
        match self {
            Ready(v) => v,
            _ => panic!("would have blocked, no result to take")
        }
    }
}

pub trait IoHandle {
    fn desc(&self) -> &os::IoDesc;
}

pub trait IoReader {
    fn read(&mut self, buf: &mut MutBuf) -> MioResult<NonBlock<()>>;
}

pub trait IoWriter {
    fn write(&mut self, buf: &mut Buf) -> MioResult<NonBlock<()>>;
}

pub trait IoAcceptor<T> {
    fn accept(&mut self) -> MioResult<NonBlock<T>>;
}

pub fn pipe() -> MioResult<(PipeReader, PipeWriter)> {
    let (rd, wr) = try!(os::pipe());
    Ok((PipeReader { desc: rd }, PipeWriter { desc: wr }))
}

pub struct PipeReader {
    desc: os::IoDesc
}

impl IoHandle for PipeReader {
    fn desc(&self) -> &os::IoDesc {
        &self.desc
    }
}

pub struct PipeWriter {
    desc: os::IoDesc
}

impl IoHandle for PipeWriter {
    fn desc(&self) -> &os::IoDesc {
        &self.desc
    }
}

impl IoReader for PipeReader {
    fn read(&mut self, buf: &mut MutBuf) -> MioResult<NonBlock<()>> {
        read(self, buf)
    }
}

impl IoWriter for PipeWriter {
    fn write(&mut self, buf: &mut Buf) -> MioResult<NonBlock<()>> {
        write(self, buf)
    }
}

pub fn read<I: IoHandle>(io: &mut I, buf: &mut MutBuf) -> MioResult<NonBlock<()>> {
    let mut first_iter = true;

    while buf.has_remaining() {
        match os::read(io.desc(), buf.mut_bytes()) {
            // Successfully read some bytes, advance the cursor
            Ok(cnt) => {
                buf.advance(cnt);
                first_iter = false;
            }
            Err(e) => {
                if e.is_would_block() {
                    return Ok(WouldBlock);
                }

                // If the EOF is hit the first time around, then propagate
                if e.is_eof() {
                    if first_iter {
                        return Err(e);
                    }

                    return Ok(Ready(()));
                }

                // Indicate that the read was successful
                return Err(e);
            }
        }
    }

    Ok(Ready(()))
}

pub fn write<O: IoHandle>(io: &mut O, buf: &mut Buf) -> MioResult<NonBlock<()>> {
    while buf.has_remaining() {
        match os::write(io.desc(), buf.bytes()) {
            Ok(cnt) => buf.advance(cnt),
            Err(e) => {
                if e.is_would_block() {
                    return Ok(WouldBlock);
                }

                return Err(e);
            }
        }
    }

    Ok(Ready(()))
}