variable_len_reader/util/
read_buf.rs

1macro_rules! impl_read_buf {
2    () => {
3        #[inline]
4        fn len(&self) -> usize {
5            self.buf.as_ref().len()
6        }
7
8        #[inline]
9        pub fn buf(&self) -> &[u8] {
10            self.buf.as_ref()
11        }
12
13        #[inline]
14        pub fn buf_mut(&mut self) -> &mut [u8] {
15            self.buf.as_mut()
16        }
17
18        #[inline]
19        pub fn position(&self) -> usize {
20            self.position
21        }
22
23        #[inline]
24        pub fn advance(&mut self, cnt: usize) {
25            let new = self.position.checked_add(cnt).expect("advance overflow");
26            assert!(
27                self.len() >= new,
28                "position ({}) must not become larger than buf.len ({})",
29                new, self.len()
30            );
31            self.position = new;
32        }
33
34        #[inline]
35        pub fn left(&self) -> usize {
36            self.len() - self.position
37        }
38
39        #[inline]
40        pub fn reset(&mut self) {
41            self.position = 0;
42        }
43
44        #[inline]
45        pub fn set_position(&mut self, position: usize) {
46            assert!(
47                self.len() >= position,
48                "position ({}) must not become larger than buf.len ({})",
49                position, self.len()
50            );
51            self.position = position;
52        }
53
54
55        #[inline]
56        pub fn set(&mut self, val: u8) {
57            self.buf.as_mut()[self.position] = val;
58        }
59
60        #[inline]
61        pub fn put(&mut self, val: u8) {
62            assert!(
63                self.left() >= 1,
64                "no more writable bytes in buffer"
65            );
66            self.set(val);
67            self.position += 1;
68        }
69
70        #[inline]
71        pub fn set_slice(&mut self, slice: &[u8]) {
72            assert!(
73                self.left() >= slice.len(),
74                "not enough writable bytes in buffer"
75            );
76            self.buf.as_mut()[self.position..self.position + slice.len()].copy_from_slice(slice);
77        }
78
79        #[inline]
80        pub fn put_slice(&mut self, slice: &[u8]) {
81            self.set_slice(slice);
82            self.position += slice.len();
83        }
84    };
85}
86#[cfg(feature = "bytes")]
87macro_rules! impl_bytes_buf {
88    () => {
89        #[inline]
90        fn remaining_mut(&self) -> usize {
91            self.left()
92        }
93
94        #[inline]
95        unsafe fn advance_mut(&mut self, cnt: usize) {
96            self.advance(cnt)
97        }
98
99        #[inline]
100        fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {
101            bytes::buf::UninitSlice::new(self.buf_mut())
102        }
103    };
104}
105
106#[derive(Debug)]
107pub struct ReadBuf<'a> {
108    buf: &'a mut [u8],
109    position: usize,
110}
111
112impl<'a> ReadBuf<'a> {
113    pub fn new(buf: &'a mut [u8]) -> Self {
114        Self {
115            buf,
116            position: 0,
117        }
118    }
119
120    impl_read_buf!();
121}
122
123#[cfg(feature = "bytes")]
124#[cfg_attr(docsrs, doc(cfg(feature = "bytes")))]
125unsafe impl<'a> bytes::BufMut for ReadBuf<'a> {
126    impl_bytes_buf!();
127}
128
129#[cfg(feature = "tokio")]
130#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
131impl<'a, 'b> From<&'b mut ReadBuf<'a>> for tokio::io::ReadBuf<'b> {
132    #[inline]
133    fn from(value: &'b mut ReadBuf<'a>) -> Self {
134        let mut buf = Self::new(value.buf);
135        buf.set_filled(value.position);
136        buf
137    }
138}
139
140
141/// The type parameter `B` should be `[u8, $n]`.
142#[derive(Debug, Clone)]
143pub struct OwnedReadBuf<B: AsRef<[u8]> + AsMut<[u8]>> {
144    buf: B,
145    position: usize
146}
147
148impl<B: AsRef<[u8]> + AsMut<[u8]>> OwnedReadBuf<B> {
149    pub fn new(buf: B) -> Self {
150        Self {
151            buf,
152            position: 0,
153        }
154    }
155
156    pub fn into_inner(self) -> B {
157        self.buf
158    }
159
160    impl_read_buf!();
161}
162
163#[cfg(feature = "bytes")]
164#[cfg_attr(docsrs, doc(cfg(feature = "bytes")))]
165unsafe impl<B: AsRef<[u8]> + AsMut<[u8]>> bytes::BufMut for OwnedReadBuf<B> {
166    impl_bytes_buf!();
167}
168
169impl<'a, B: AsRef<[u8]> + AsMut<[u8]>> From<&'a mut OwnedReadBuf<B>> for ReadBuf<'a> {
170    #[inline]
171    fn from(value: &'a mut OwnedReadBuf<B>) -> Self {
172        let mut buf = Self::new(value.buf.as_mut());
173        buf.set_position(value.position);
174        buf
175    }
176}
177
178#[cfg(feature = "tokio")]
179#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
180impl<'a, B: AsRef<[u8]> + AsMut<[u8]>> From<&'a mut OwnedReadBuf<B>> for tokio::io::ReadBuf<'a> {
181    #[inline]
182    fn from(value: &'a mut OwnedReadBuf<B>) -> Self {
183        let mut buf = Self::new(value.buf.as_mut());
184        buf.set_filled(value.position);
185        buf
186    }
187}
188
189
190#[cfg(test)]
191fn __owned_read_buf_u8_array() {
192    let _ = OwnedReadBuf::<[u8; 16]>::new([0; 16]);
193}
194#[cfg(all(test, feature = "alloc"))]
195fn __owned_read_buf_u8_vec() {
196    let _ = OwnedReadBuf::<alloc::vec::Vec<u8>>::new(alloc::vec::Vec::new());
197}
variable_len_reader/util/read_buf.rs

variable_len_reader/util/
read_buf.rs
