jbytes/
buffer.rs

1#[cfg(feature = "std")]
2use std::io::{self, Read, Write, Seek, SeekFrom};
3use core::{
4    ops::Deref,
5    cell::Cell,
6};
7use crate::std::*;
8use crate::{
9    BufRead, BufWrite,
10    bytes::{Bytes, ToBytes},
11    // errors::{JResult, make_error, ErrorKind},
12};
13
14
15/// This is a Buffer type based on the Vec<u8> implementation for storing byte stream data.
16/// 
17/// # Example
18/// 
19/// ```
20/// use jbytes::prelude::*;
21///
22///
23/// fn buffer_example(buffer: &mut Buffer) -> JResult<()>  {
24///     buffer.push_be_u16(1)?;
25///     buffer.push(b"\x01\x02\x03")?;
26///
27///     Ok(())
28/// }
29///
30///
31/// fn main() {
32///     let mut buffer = Buffer::new();
33///     if buffer_example(&mut buffer).is_ok() {
34///         assert_eq!(*buffer, b"\x00\x01\x01\x02\x03");
35///     }
36/// }
37/// ```
38#[derive(Debug, Clone, PartialEq, Eq)]
39pub struct Buffer {
40    data: Vec<u8>,
41    position: Cell<usize>,
42}
43
44
45impl Buffer {
46    /// Constructs a new Buffer.
47    #[inline]
48    pub fn new() -> Self {
49        Self {
50            position: Cell::new(0),
51            data: Vec::new(),
52        }
53    }
54}
55
56
57impl ToBytes for Buffer {
58    type Target = [u8];
59
60    fn to_bytes(&self) -> Bytes<&Self::Target> {
61        Bytes::new(&(*self.data)[..])
62    }
63}
64
65
66impl Default for Buffer {
67    fn default() -> Self {
68        Self::new()
69    }
70}
71
72
73impl From<Vec<u8>> for Buffer {
74    fn from(value: Vec<u8>) -> Self {
75        Self { data: value, position: Cell::new(0) }
76    }
77}
78
79
80impl Deref for Buffer {
81    type Target = Vec<u8>;
82
83    fn deref(&self) -> &Self::Target {
84        &self.data
85    }
86}
87
88
89impl AsRef<[u8]> for Buffer {
90    fn as_ref(&self) -> &[u8] {
91        &(*self.data)[..]
92    }
93}
94
95
96impl BufRead for Buffer {
97    #[inline]
98    fn get_position(&self) -> usize {
99        self.position.get()
100    }
101
102    #[inline]
103    fn get_data(&self) -> &'_ [u8] {
104        &self.data
105    }
106
107    #[inline]
108    fn set_position(&self, position: usize) {
109        self.position.set(position);
110    }
111
112    #[inline]
113    fn reset_position(&self) {
114        self.position.set(0)
115    }
116
117    #[inline]
118    fn advance(&self, nbytes: usize) {
119        self.position.set(self.position.get() + nbytes)
120    }
121}
122
123
124impl BufWrite for Buffer {
125    #[inline]
126    fn remaining_mut(&mut self) -> &'_ mut [u8] {
127        &mut self.data[self.position.get()..]
128    }
129
130    #[inline]
131    fn resize(&mut self, nbytes: usize) -> usize {
132        let nbytes = self.position.get() + nbytes;
133
134        self.data.resize(nbytes, 0);
135
136        nbytes
137    }
138}
139
140
141#[cfg(feature = "std")]
142impl Read for Buffer {
143    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
144        let data_len = self.data.len();
145        let position = self.position.get();
146
147        if position >= data_len {
148            return Ok(0);
149        }
150
151        let nbytes = std::cmp::min(buf.len(), data_len - position);
152        buf[..nbytes].copy_from_slice(&self.data[position..position + nbytes]);
153        self.position.set(position + nbytes);
154
155        Ok(nbytes)
156    }
157}
158
159
160#[cfg(feature = "std")]
161impl Write for Buffer {
162    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
163        let buf_len = buf.len();
164        let position = self.position.get();
165
166        if position + buf_len > self.data.len() {
167            self.data.resize(position + buf_len, 0);
168        }
169
170        self.data[position..position + buf_len].copy_from_slice(buf);
171        self.position.set(position + buf_len);
172
173        Ok(buf_len)
174    }
175
176    fn flush(&mut self) -> io::Result<()> {
177        Ok(())
178    }
179}
180
181
182#[cfg(feature = "std")]
183impl Seek for Buffer {
184    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
185        let position = self.position.get();
186
187        let new_position = match pos {
188            SeekFrom::Start(offset) => offset as isize,
189            SeekFrom::End(offset) => self.data.len() as isize + offset as isize,
190            SeekFrom::Current(offset) => position as isize + offset as isize,
191        };
192
193        if new_position < 0 {
194            return Err(io::Error::new(io::ErrorKind::InvalidInput, "Invalid seek to a negative position"));
195        }
196
197        self.position.set(new_position as usize);
198
199        Ok(position as u64)
200    }
201}
202
203
204#[cfg(test)]
205mod tests {
206    use super::*;
207
208    #[cfg(feature = "std")]
209    #[test]
210    fn test_buffer_read_write() {
211        let mut buffer = Buffer::from(b"Hello, world!".to_vec());
212
213        // Read Data
214        let mut read_buf = [0; 5];
215        buffer.read(&mut read_buf).unwrap();
216        assert_eq!(&read_buf, b"Hello");
217    
218        // Seek
219        buffer.seek(SeekFrom::Start(0)).unwrap();
220        assert_eq!(buffer.position.get(), 0);
221    
222        // Write Data
223        buffer.write(b"Rust").unwrap();
224        assert_eq!(&buffer.data, b"Rusto, world!");
225    
226        // Seek
227        buffer.seek(SeekFrom::End(-2)).unwrap();
228        assert_eq!(buffer.position.get(), buffer.data.len() - 2);
229    
230        // Write Data
231        buffer.write(b"!").unwrap();
232        assert_eq!(&buffer.data, b"Rusto, worl!!");
233    }
234
235    #[test]
236    fn test_buffer_set_position() {
237        let mut buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
238        assert_eq!(buffer.get_position(), 0);
239        buffer.advance(3);
240        assert_eq!(buffer.get_position(), 3);
241        assert_eq!(buffer.take_u16().unwrap(), 0x0405);
242        assert_eq!(buffer.get_position(), 5);
243        assert_eq!(buffer.take_u8().is_err(), true);
244
245        buffer.reset_position();
246        assert_eq!(buffer.get_position(), 0);
247        buffer.set_position(10);
248        assert_eq!(buffer.take_u8().is_err(), true);
249        buffer.push_u8(0x01).unwrap();
250        assert_eq!(buffer.get_position(), 11);
251        assert_eq!(buffer.data, vec![0x01, 0x02, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01]);
252    }
253
254    #[test]
255    fn test_buffer_take_u8() {
256        let buffer = Buffer::from(vec![0x01, 0x02, 0x03]);
257        assert_eq!(buffer.take_u8().unwrap(), 0x01);
258        assert_eq!(buffer.take_u8().unwrap(), 0x02);
259        assert_eq!(buffer.remaining(), [0x03]);
260        assert_eq!(buffer.take_u8().unwrap(), 0x03);
261        assert_eq!(buffer.take_u8().is_err(), true);
262        assert_eq!(buffer.get_position(), 3);
263    }
264
265    #[test]
266    fn test_buffer_take_u16() {
267        let buffer = Buffer::from(vec![0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x04]);
268        assert_eq!(buffer.take_u16().unwrap(), 0x0001);
269        assert_eq!(buffer.take_be_u16().unwrap(), 0x0002);
270        assert_eq!(buffer.take_le_u16().unwrap(), 0x0300);
271        assert_eq!(buffer.remaining(), [0x04]);
272        assert_eq!(buffer.take_u16().is_err(), true);
273        assert_eq!(buffer.take_u8().unwrap(), 0x04);
274        assert_eq!(buffer.get_position(), 7);
275    }
276
277    #[test]
278    fn test_buffer_take_u24() {
279        let buffer = Buffer::from(vec![
280            0x00, 0x00, 0x01,
281            0x00, 0x00, 0x02,
282            0x00, 0x00, 0x03,
283            0x04
284        ]);
285        assert_eq!(buffer.take_u24().unwrap(), 0x000001);
286        assert_eq!(buffer.take_be_u24().unwrap(), 0x000002);
287        assert_eq!(buffer.take_le_u24().unwrap(), 0x030000);
288        assert_eq!(buffer.remaining(), [0x04]);
289        assert_eq!(buffer.take_u24().is_err(), true);
290        assert_eq!(buffer.take_u8().unwrap(), 0x04);
291        assert_eq!(buffer.get_position(), 10);
292    }
293
294    #[test]
295    fn test_buffer_take_u32() {
296        let buffer = Buffer::from(vec![
297            0x00, 0x00, 0x00, 0x01,
298            0x00, 0x00, 0x00, 0x02,
299            0x00, 0x00, 0x00, 0x03,
300            0x04
301        ]);
302        assert_eq!(buffer.take_u32().unwrap(), 0x00000001);
303        assert_eq!(buffer.take_be_u32().unwrap(), 0x00000002);
304        assert_eq!(buffer.take_le_u32().unwrap(), 0x03000000);
305        assert_eq!(buffer.remaining(), [0x04]);
306        assert_eq!(buffer.take_u32().is_err(), true);
307        assert_eq!(buffer.take_u8().unwrap(), 0x04);
308        assert_eq!(buffer.get_position(), 13);
309    }
310
311    #[test]
312    fn test_buffer_take_u64() {
313        let buffer = Buffer::from(vec![
314            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
315            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
316            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
317            0x04
318        ]);
319        assert_eq!(buffer.take_u64().unwrap(), 0x0000000000000001);
320        assert_eq!(buffer.take_be_u64().unwrap(), 0x0000000000000002);
321        assert_eq!(buffer.take_le_u64().unwrap(), 0x0300000000000000);
322        assert_eq!(buffer.remaining(), [0x04]);
323        assert_eq!(buffer.take_u64().is_err(), true);
324        assert_eq!(buffer.take_u8().unwrap(), 0x04);
325        assert_eq!(buffer.get_position(), buffer.len());
326    }
327
328    #[test]
329    fn test_buffer_take_u128() {
330        let buffer = Buffer::from(vec![
331            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
332            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
333            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
334            0x04
335        ]);
336        assert_eq!(buffer.take_u128().unwrap(), 0x00000000000000000000000000000001);
337        assert_eq!(buffer.take_be_u128().unwrap(), 0x00000000000000000000000000000002);
338        assert_eq!(buffer.take_le_u128().unwrap(), 0x03000000000000000000000000000000);
339        assert_eq!(buffer.remaining(), [0x04]);
340        assert_eq!(buffer.take_u128().is_err(), true);
341        assert_eq!(buffer.take_u8().unwrap(), 0x04);
342        assert_eq!(buffer.get_position(), buffer.len());
343    }
344
345    #[test]
346    fn test_buffer_take_uint() {
347        let buffer = Buffer::from(vec![
348            0x00, 0x00, 0x00, 0x00, 0x01,
349            0x00, 0x00, 0x00, 0x00, 0x02,
350            0x00, 0x00, 0x00, 0x00, 0x03,
351            0x04
352        ]);
353        assert_eq!(buffer.take_uint(5).unwrap(), 0x0000000001);
354        assert_eq!(buffer.take_be_uint(5).unwrap(), 0x0000000002);
355        assert_eq!(buffer.take_le_uint(5).unwrap(), 0x0300000000);
356        assert_eq!(buffer.remaining(), [0x04]);
357        assert_eq!(buffer.take_uint(5).is_err(), true);
358        assert_eq!(buffer.take_u8().unwrap(), 0x04);
359        assert_eq!(buffer.get_position(), buffer.len());
360    }
361
362    #[test]
363    fn test_buffer_take_bytes() {
364        let buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
365        assert_eq!(buffer.take_bytes(2).unwrap(), &[0x01, 0x02]);
366        assert_eq!(buffer.take_bytes(2).unwrap(), &[0x03, 0x04]);
367        assert_eq!(buffer.remaining(), &[0x05]);
368        assert_eq!(buffer.take_bytes(2).is_err(), true);
369        assert_eq!(buffer.take_bytes(1).unwrap(), &[0x05]);
370        assert_eq!(buffer.position.get(), 5);
371    }
372
373    #[test]
374    fn test_buffer_take_array() {
375        let buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
376        assert_eq!(buffer.take_array::<2>().unwrap(), [0x01, 0x02]);
377        assert_eq!(buffer.take_array::<2>().unwrap(), [0x03, 0x04]);
378        assert_eq!(buffer.remaining(), &[0x05]);
379        assert_eq!(buffer.take_array::<2>().is_err(), true);
380        assert_eq!(buffer.take_array::<1>().unwrap(), [0x05]);
381        assert_eq!(buffer.position.get(), 5);
382    }
383
384    #[test]
385    fn test_buffer_push() {
386        let mut buffer = Buffer::new();
387        buffer.push_u8(0x02).unwrap();
388        buffer.push_u16(0x03).unwrap();
389        buffer.push_u24(0x04).unwrap();
390        buffer.push_u32(0x05).unwrap();
391        buffer.push_u64(0x06).unwrap();
392        buffer.push_u128(0x07).unwrap();
393        buffer.push_uint(1, 3).unwrap();
394        buffer.push_le_uint(1, 3).unwrap();
395        buffer.push_char('1').unwrap();
396        buffer.push("23").unwrap();
397        buffer.push("45".to_string()).unwrap();
398        buffer.push([4, 5]).unwrap();
399        buffer.push(vec![6, 7]).unwrap();
400        buffer.push(&[8, 9]).unwrap();
401
402        assert_eq!(*buffer, [
403            0x02,
404            0x00, 0x03,
405            0x00, 0x00, 0x04,
406            0x00, 0x00, 0x00, 0x05,
407            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
408            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
409            0x00, 0x00, 0x01,
410            0x01, 0x00, 0x00,
411            0x31,
412            0x32, 0x33,
413            0x34, 0x35,
414            0x04, 0x05,
415            0x06, 0x07,
416            0x08, 0x09,
417        ]);
418    }
419
420    #[test]
421    fn test_buffer_subsequence() {
422        let buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
423        assert_eq!(buffer.find_subsequence(&[0x03, 0x04]).unwrap(), &[0x01, 0x02]);
424        assert_eq!(buffer.remaining_len(), 1);
425
426        let buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
427        assert_eq!(buffer.find_subsequence_needle(&[0x03, 0x04], false).unwrap(), &[0x01, 0x02]);
428        assert_eq!(buffer.remaining_len(), 3);
429
430        let buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
431        assert_eq!(buffer.find_subsequence_needle(&[0x03, 0x04], true).unwrap(), &[0x01, 0x02, 0x03, 0x04]);
432        assert_eq!(buffer.remaining_len(), 1);
433    }
434
435    #[test]
436    fn test_buffer_subsequences() {
437        let buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
438        assert_eq!(buffer.find_subsequences(&[&[0x03, 0x04], &[0x04, 0x05]]).unwrap(), &[0x01, 0x02]);
439        assert_eq!(buffer.remaining_len(), 1);
440
441        let buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
442        assert_eq!(buffer.find_subsequences(&[&[0x04, 0x04], &[0x04, 0x05]]).unwrap(), &[0x01, 0x02, 0x03]);
443        assert_eq!(buffer.remaining_len(), 0);
444
445        let buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
446        assert_eq!(buffer.find_subsequences_needle(&[&[0x03, 0x04], &[0x04, 0x05]], false).unwrap(), &[0x01, 0x02]);
447        assert_eq!(buffer.remaining_len(), 3);
448
449        let buffer = Buffer::from(vec![0x01, 0x02, 0x03, 0x04, 0x05]);
450        assert_eq!(buffer.find_subsequences_needle(&[&[0x03, 0x04], &[0x04, 0x05]], true).unwrap(), &[0x01, 0x02, 0x03, 0x04]);
451        assert_eq!(buffer.remaining_len(), 1);
452    }
453}
jbytes/buffer.rs

jbytes/
buffer.rs
