linebuf 0.0.2

The library provides a interface to read a line through a fixed size of buffer
Documentation 
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
130
131
132
133
134
135

extern crate memchr;

use std::io::{Read, Result};
use std::cmp::min;
use memchr::memchr;

static DEFAULT_BUF_SIZE: usize = 8 * 1024;

#[derive(Debug, Eq, PartialEq, PartialOrd)]
pub enum Line {
    Return(usize),
    More(usize),
}

impl Line {
    pub fn amount(&self) -> usize {
        match *self {
            Line::Return(n) => n,
            Line::More(n) => n,
        }
    }
}

pub struct LineReader<R> {
    inner: R,
    buf: Box<[u8]>,
    pos: usize,
    cap: usize,
}

impl<R: Read> LineReader<R> {
    pub fn new(inner: R) -> LineReader<R> {
        LineReader::with_capacity(DEFAULT_BUF_SIZE, inner)
    }

    pub fn with_capacity(capacity: usize, inner: R) -> LineReader<R> {
        unsafe {
            let mut buf = Vec::with_capacity(capacity);
            buf.set_len(capacity);
            LineReader {
                inner,
                buf: buf.into_boxed_slice(),
                pos: 0,
                cap: 0,
            }
        }
    }

    fn fill_buf(&mut self) -> Result<&[u8]> {
        if self.pos >= self.cap {
            self.cap = self.inner.read(&mut self.buf)?;
            self.pos = 0;
        }
        Ok(&mut self.buf[self.pos..self.cap])
    }

    fn read_buf(&mut self, buf: &mut [u8]) -> Result<Line> {
        let line = {
            self.fill_buf()?;
            if self.pos == self.cap {
                return Ok(Line::Return(0));
            }

            let mut rem = self.fill_buf()?;

            if buf.len() < rem.len() {
                rem = &rem[..buf.len()];
            }

            match memchr(b'\n', rem) {
                Some(n) => Line::Return((&rem[..n + 1]).read(buf)?),
                None => Line::More(rem.read(buf)?),
            }
        };

        self.consume(line.amount());
        Ok(line)
    }

    pub fn try_read_line(&mut self, buf: &mut [u8]) -> Result<Line> {
        let mut amt: usize = 0;
        let cap = buf.len();

        while amt < cap {
            match self.read_buf(&mut buf[amt..])? {
                Line::Return(n) => {
                    return Ok(Line::Return(amt + n));
                }
                Line::More(n) => {
                    amt += n;
                }
            }
        }
        Ok(Line::More(amt))
    }

    fn consume(&mut self, n: usize) {
        self.pos = min(self.pos + n, self.cap);
    }
}



#[cfg(test)]
mod tests {
    use Line;
    use LineReader;
    use std::io::Cursor;

    #[test]
    fn try_read_line() {
        let cur = Cursor::new(b"12\n345");
        let mut reader = LineReader::new(cur.clone());
        let mut buf = vec![0; 1];
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::More(1)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::More(1)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::Return(1)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::More(1)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::More(1)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::More(1)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::Return(0)));

        let mut reader = LineReader::new(cur.clone());
        let mut buf = vec![0; 2];
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::More(2)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::Return(1)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::More(2)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::Return(1)));

        let mut reader = LineReader::new(cur.clone());
        let mut buf = vec![0; 4];
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::Return(3)));
        assert_eq!(reader.try_read_line(&mut buf).ok(), Some(Line::Return(3)));
    }
}