1
use std::io::{BufReader, BufWriter};
2

            
3
use anyhow::Result;
4

            
5
use crate::RwBuilder;
6

            
7
/// Type returned by the `buffered` function on the `RwBuilder` trait.
8
/// It is itself an `RwBuilder` so can be chained further.
9
#[derive(Debug)]
10
pub struct Builder<B>
11
where
12
    B: RwBuilder,
13
{
14
    /// The inner builder it wraps
15
    builder: B,
16
}
17

            
18
impl<B> Builder<B>
19
where
20
    B: RwBuilder,
21
{
22
    /// Factory function to wrap an inner builder
23
    #[must_use]
24
1
    pub const fn new(builder: B) -> Self {
25
1
        Self { builder }
26
1
    }
27
}
28

            
29
impl<B> RwBuilder for Builder<B>
30
where
31
    B: RwBuilder,
32
    B::Reader: std::io::Read,
33
    B::Writer: std::io::Write,
34
{
35
    type Reader = BufReader<B::Reader>;
36
    type Writer = BufWriter<B::Writer>;
37

            
38
1
    fn reader(&self) -> Result<Self::Reader> {
39
1
        Ok(BufReader::new(self.builder.reader()?))
40
1
    }
41

            
42
1
    fn writer(&self) -> Result<Self::Writer> {
43
1
        Ok(BufWriter::new(self.builder.writer()?))
44
1
    }
45
}