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

// SPDX-License-Identifier: MIT
// Copyright 2023 IROX Contributors
//

use alloc::collections::VecDeque;
use core::cmp::min;
use core::ops::RangeBounds;
use std::io::{BufRead, BufReader, Read};

use crate::bits::Bits;

///
/// An effective, infinite cached buffer.  What [`BufRead`] and [`BufReader`]
/// would be if they weren't backed by a fixed buffer.
#[derive()]
pub struct Buffer<T> {
    reader: BufReader<T>,
    buffer: VecDeque<u8>,
}

impl<T: Read> Buffer<T> {
    ///
    pub fn new(reader: T) -> Self {
        Buffer {
            reader: BufReader::new(reader),
            buffer: VecDeque::new(),
        }
    }

    /// The associated iterator call 'next' fills the buffer and returns the
    /// individual byte-by-byte values.  This function returns and clears the
    /// buffer as a consecutive block, up to 'len' items.
    pub fn consume_read_buffer_up_to(&mut self, len: usize) -> Vec<u8> {
        let len = min(len, self.buffer.len());
        self.buffer.drain(0..len).collect()
    }

    /// The associated iterator call 'next' fills the buffer and returns the
    /// individual byte-by-byte values. This function returns the entire read buffer.
    pub fn consume_read_buffer(&mut self) -> VecDeque<u8> {
        core::mem::take(&mut self.buffer)
    }

    /// Removes the specified range and throws it away.
    pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) {
        self.buffer.drain(range);
    }
}

impl<T: Read> Read for Buffer<T> {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        if self.buffer.is_empty() {
            let mut buf: [u8; 4096] = [0; 4096];
            let read = self.reader.read(&mut buf)?;
            self.buffer.extend(buf.get(0..read).unwrap_or_default());
        }
        let read = self.buffer.read(buf)?;
        Ok(read)
    }
}

impl<T: Read> Iterator for Buffer<T> {
    type Item = u8;

    fn next(&mut self) -> Option<Self::Item> {
        if let Ok(Some(val)) = self.reader.next_u8() {
            self.buffer.push_back(val);
            return Some(val);
        };
        None
    }
}

impl<T: Read> BufRead for Buffer<T> {
    fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
        let buf = self.reader.fill_buf()?;
        self.buffer.extend(buf.iter());
        Ok(buf)
    }

    fn consume(&mut self, amt: usize) {
        self.reader.consume(amt);
        self.consume_read_buffer_up_to(amt);
    }
}