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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use core::{cmp, fmt};
use std::io;
use std::io::{BufRead, Error, ErrorKind, Read};
use std::thread::JoinHandle;

use crossbeam_channel::Receiver;

use crate::util::buf::constants::BUF_SIZE;
use crate::util::buf::producer::{spawn_producer, ProducerResult};

pub struct ChopperBufReader {
    pos: usize,
    pub(in crate::util::buf) buf: Vec<u8>,
    receiver: Receiver<Vec<u8>>,
    producer: Option<JoinHandle<ProducerResult<()>>>,
}

impl ChopperBufReader {
    pub fn new<R: 'static + Read + Send>(inner: R) -> ChopperBufReader {
        let (producer, receiver) = spawn_producer(inner);

        ChopperBufReader {
            pos: 0,
            buf: Vec::new(),
            receiver,
            producer: Some(producer),
        }
    }
}

impl ChopperBufReader {
    pub(in crate::util::buf) fn inner_fill_buf(&mut self) -> io::Result<()> {
        if self.producer.is_none() {
            return Ok(());
        }

        if self.pos != self.buf.len() {
            return Err(Error::new(
                ErrorKind::Other,
                "asked to fill buffer when existing one was not empty",
            ));
        }

        self.buf = match self.receiver.recv() {
            Ok(buf) => buf,
            Err(e) => return Err(Error::new(ErrorKind::Other, e)),
        };
        self.pos = 0;

        if self.buf.len() < BUF_SIZE {
            self.producer
                .take()
                .unwrap() // we know it's not None
                .join()
                .unwrap() // if this fails something is seriously wrong
                .map_err(|e| Error::new(ErrorKind::Other, e))?;
        }

        Ok(())
    }
}

impl Read for ChopperBufReader {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        let bytes_read = {
            let mut rem = self.fill_buf()?;
            rem.read(buf)?
        };
        self.consume(bytes_read);
        Ok(bytes_read)
    }
}

impl BufRead for ChopperBufReader {
    fn fill_buf(&mut self) -> io::Result<&[u8]> {
        // Branch using `>=` instead of the more correct `==`
        // to tell the compiler that the pos..cap slice is always valid.
        if self.pos >= self.buf.len() {
            self.inner_fill_buf()?;
        }
        Ok(&self.buf[self.pos..])
    }

    fn consume(&mut self, amt: usize) {
        self.pos = cmp::min(self.pos + amt, self.buf.len());
    }
}

impl fmt::Debug for ChopperBufReader {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_struct("ChopperBufReader")
            .field(
                "buf",
                &format_args!("{}/{}", self.buf.len() - self.pos, self.buf.len()),
            )
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use std::io::{BufRead, BufReader, Cursor};

    use crate::util::buf::constants::BUF_SIZE;
    use crate::util::buf::reader::ChopperBufReader;

    const TEST_BYTES: &[u8] = "aaaaa\nbbbbb\nccccc".as_bytes();

    fn test_one(full_buf_count: usize, last_buf_size: usize) {
        let buf = vec![0; BUF_SIZE * full_buf_count + last_buf_size];
        let mut reader = ChopperBufReader::new(Cursor::new(buf));
        for _ in 0..full_buf_count {
            let result = reader.inner_fill_buf();
            assert!(result.is_ok());
            assert_eq!(reader.buf.len(), BUF_SIZE);
            assert!(reader.producer.is_some());
            reader.pos = reader.buf.len();
        }
        let result = reader.inner_fill_buf();
        assert!(result.is_ok());
        assert_eq!(reader.buf.len(), last_buf_size);
        assert!(reader.producer.is_none());
    }

    #[test]
    fn test() {
        test_one(0, 0);
        test_one(0, 1);
        test_one(0, BUF_SIZE - 1);
        test_one(1, 0);
        test_one(1, 1);
        test_one(1, BUF_SIZE - 1);
        test_one(2, 0);
        test_one(2, 1);
        test_one(2, BUF_SIZE - 1);
    }

    #[test]
    fn test_lines() {
        let inner = BufReader::new(TEST_BYTES);
        let mut reader = ChopperBufReader::new(inner);

        check_line(&mut reader, 6, "aaaaa\n");
        check_line(&mut reader, 6, "bbbbb\n");
        check_line(&mut reader, 5, "ccccc");
        check_line(&mut reader, 0, "");

        assert!(reader.producer.is_none());
    }

    fn check_line(reader: &mut ChopperBufReader, expect_result: usize, expect_line: &str) {
        let mut line = String::new();
        let result = reader.read_line(&mut line);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), expect_result);
        assert_eq!(line, expect_line);
    }
}