Skip to main content

circular_buffer/
io.rs

1// Copyright © 2023-2026 Andrea Corbellini and contributors
2// SPDX-License-Identifier: BSD-3-Clause
3
4#![cfg(feature = "std")]
5
6use crate::CircularBuffer;
7use crate::FixedCircularBuffer;
8use crate::HeapCircularBuffer;
9use std::cmp;
10use std::io::BufRead;
11use std::io::Read;
12use std::io::Result;
13use std::io::Write;
14use std::ops::DerefMut;
15
16impl Write for CircularBuffer<u8> {
17    #[inline]
18    fn write(&mut self, src: &[u8]) -> Result<usize> {
19        self.extend_from_slice(src);
20        Ok(src.len())
21    }
22
23    #[inline]
24    fn flush(&mut self) -> Result<()> {
25        Ok(())
26    }
27}
28
29impl Read for CircularBuffer<u8> {
30    fn read(&mut self, dst: &mut [u8]) -> Result<usize> {
31        let (mut front, mut back) = self.as_slices();
32        let mut count = front.read(dst)?;
33        count += back.read(&mut dst[count..])?;
34        let truncate_to = self.len() - count;
35        self.truncate_front(truncate_to);
36        Ok(count)
37    }
38}
39
40impl BufRead for CircularBuffer<u8> {
41    fn fill_buf(&mut self) -> Result<&[u8]> {
42        let (front, back) = self.as_slices();
43        if !front.is_empty() {
44            Ok(front)
45        } else {
46            Ok(back)
47        }
48    }
49
50    fn consume(&mut self, amt: usize) {
51        let amt = cmp::min(amt, self.len());
52        self.drain(..amt);
53    }
54}
55
56impl<const N: usize> Write for FixedCircularBuffer<u8, N> {
57    #[inline]
58    fn write(&mut self, src: &[u8]) -> Result<usize> {
59        self.deref_mut().write(src)
60    }
61
62    #[inline]
63    fn flush(&mut self) -> Result<()> {
64        self.deref_mut().flush()
65    }
66}
67
68impl<const N: usize> Read for FixedCircularBuffer<u8, N> {
69    fn read(&mut self, dst: &mut [u8]) -> Result<usize> {
70        self.deref_mut().read(dst)
71    }
72}
73
74impl<const N: usize> BufRead for FixedCircularBuffer<u8, N> {
75    fn fill_buf(&mut self) -> Result<&[u8]> {
76        self.deref_mut().fill_buf()
77    }
78
79    fn consume(&mut self, amt: usize) {
80        self.deref_mut().consume(amt)
81    }
82}
83
84impl Write for HeapCircularBuffer<u8> {
85    #[inline]
86    fn write(&mut self, src: &[u8]) -> Result<usize> {
87        self.deref_mut().write(src)
88    }
89
90    #[inline]
91    fn flush(&mut self) -> Result<()> {
92        self.deref_mut().flush()
93    }
94}
95
96impl Read for HeapCircularBuffer<u8> {
97    fn read(&mut self, dst: &mut [u8]) -> Result<usize> {
98        self.deref_mut().read(dst)
99    }
100}
101
102impl BufRead for HeapCircularBuffer<u8> {
103    fn fill_buf(&mut self) -> Result<&[u8]> {
104        self.deref_mut().fill_buf()
105    }
106
107    fn consume(&mut self, amt: usize) {
108        self.deref_mut().consume(amt)
109    }
110}