rw_builder/
vec.rs

1use std::{cell::RefCell, cmp::min, rc::Rc};
2
3use anyhow::Result;
4
5use crate::RwBuilder;
6
7/// Type for building readers and writers on top of a `Vec` in memory.
8/// It is itself an `RwBuilder`, but can't be created through one.
9/// This is why we call it a source.
10#[derive(Debug, Default)]
11pub struct Builder {
12    /// The inner `Vec` which is used to write data to and read data from
13    /// It is shared between the reader and the writer
14    buffer: Rc<RefCell<Vec<u8>>>,
15}
16
17impl RwBuilder for Builder {
18    type Reader = Reader;
19    type Writer = Writer;
20
21    fn reader(&self) -> Result<Self::Reader> {
22        Ok(Reader { buffer: Rc::clone(&self.buffer), bytes_read: 0 })
23    }
24
25    fn writer(&self) -> Result<Self::Writer> {
26        Ok(Writer { buffer: Rc::clone(&self.buffer) })
27    }
28}
29
30/// Reading from a `Vec`
31#[derive(Debug)]
32pub struct Reader {
33    /// The buffer shared between the builder, reader and writer
34    buffer: Rc<RefCell<Vec<u8>>>,
35    /// The read position in the buffer
36    bytes_read: usize,
37}
38
39impl std::io::Read for Reader {
40    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
41        let borrowed = self.buffer.borrow();
42        let byte_count = min(borrowed.len() - self.bytes_read, buf.len());
43        buf[..byte_count].copy_from_slice(&borrowed[self.bytes_read..self.bytes_read + byte_count]);
44        self.bytes_read += byte_count;
45        Ok(byte_count)
46    }
47}
48
49impl std::io::Write for Writer {
50    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
51        let mut borrowed = self.buffer.borrow_mut();
52        let byte_count = buf.len();
53        borrowed.extend_from_slice(buf);
54        Ok(byte_count)
55    }
56
57    fn flush(&mut self) -> std::io::Result<()> {
58        Ok(())
59    }
60}
61
62/// Writing to a `Vec`
63#[derive(Debug)]
64pub struct Writer {
65    /// The buffer shared between the builder, reader and writer
66    buffer: Rc<RefCell<Vec<u8>>>,
67}