embytes_buffer/
read.rs

1use core::{cell::Cell, ops::Deref};
2
3use crate::Buffer;
4
5pub trait BufferReader: Deref<Target = [u8]> {
6    fn add_bytes_read(&self, n: usize);
7}
8
9pub struct Reader <'a, T: AsMut<[u8]> + AsRef<[u8]>> {
10    buffer: &'a mut Buffer<T>,
11    bytes_read: Cell<usize>,
12    max_bytes: Option<usize>
13}
14
15impl <'a, T: AsMut<[u8]> + AsRef<[u8]>> Reader<'a, T> {
16
17    pub(crate) fn new(buf: &'a mut Buffer<T>) -> Self {
18        Self {
19            buffer: buf,
20            bytes_read: Cell::new(0),
21            max_bytes: None
22        }
23    }
24
25    pub(crate) fn new_with_max(buf: &'a mut Buffer<T>, max_bytes: usize) -> Self {
26        Self {
27            buffer: buf,
28            bytes_read: Cell::new(0),
29            max_bytes: Some(max_bytes)
30        }
31    }
32
33    #[cfg(test)]
34    pub(crate) fn get_bytes_read(&self) -> usize {
35        self.bytes_read.get()
36    }
37}
38
39impl <'a, T: AsMut<[u8]> + AsRef<[u8]>> BufferReader for Reader<'a, T> {
40    fn add_bytes_read(&self, n: usize) {
41        self.bytes_read.set(
42            self.bytes_read.get() + n
43        );
44    }
45}
46
47impl <'a, T: AsMut<[u8]> + AsRef<[u8]>> Drop for Reader<'a, T> {
48    fn drop(&mut self) {
49        let bytes_read = self.bytes_read.get();
50        self.buffer.skip(bytes_read)
51            .expect("Reader: bytes_read must not be grater than the bytes skippable");
52    }
53}
54
55impl <'a, T: AsMut<[u8]> + AsRef<[u8]>> Deref for Reader<'a, T> {
56    type Target = [u8];
57
58    fn deref(&self) -> &Self::Target {
59        let src = self.buffer.data();
60        match self.max_bytes {
61            Some(max) => &src[..max],
62            None => src,
63        }
64    }
65}
66
67#[cfg(test)]
68mod tests {
69    use crate::{Buffer, BufferReader};
70    use super::Reader;
71
72
73    #[test]
74    fn test_read_skip() {
75        let mut b = [0u8; 8];
76        let mut buf = Buffer::new(&mut b);
77
78        let n = buf.write_base(&[1, 2, 3, 4]).unwrap();
79        assert_eq!(n, 4);
80
81        let reader = Reader::new(&mut buf);
82        assert_eq!(&reader[..], &[1, 2, 3, 4]);
83
84        reader.add_bytes_read(3);
85        assert_eq!(reader.get_bytes_read(), 3);
86        drop(reader);
87
88        assert_eq!(buf.read_position, 3);
89        assert_eq!(buf.write_position, 4);
90    }
91
92}