buf_view/
buf_view_mut.rs

1use crate::macros::{buf_get_do, buf_read_do};
2use std::io::{self, Write};
3
4/// Wrap a &mut \[u8\] buffer as read and write.
5///
6/// BufViewMut support many methods to read/write primitive types from a byte buffer easily,
7/// it support to read/write primitive types as big endian or little endian. BufViewMut wrap
8/// the original buffer with reader_index and writer_index as fllowing structure.
9/// When read data from it, the reader_index will advance the data length, and the
10/// read must between the reader_index and writer_index. When write data to it,
11/// the writer_index will advance the data length, too.
12///
13/// Any more, it support get method, too. It make random get data from the BufViewMut, and
14/// support set method, too, which make random put data to the BufViewMut.
15///
16/// BufViewMut structure
17/// ```text
18/// -----------------------------------------------------
19/// |       |                         |                 |
20/// -----------------------------------------------------
21///         ^                         ^                 ^
22///         |                         |                 |
23///   reader_index              writer_index        buf.len()
24/// ```
25/// Example
26/// ```
27/// use buf_view::BufViewMut;
28///
29/// let mut buf = [0u8;7];
30/// let mut buf_view = BufViewMut::wrap(&mut buf);
31///
32/// buf_view.write_u8(0);
33/// buf_view.write_u16(0x0102);
34/// buf_view.write_u32(0x03040506);
35///
36/// assert_eq!(buf_view.read_u8(), 0);
37/// assert_eq!(buf_view.read_u16(), 0x0102);
38/// assert_eq!(buf_view.read_u32(), 0x03040506);
39/// assert_eq!(buf_view.get_u16(1), 0x0102);
40/// ```
41///
42#[derive(Debug)]
43pub struct BufViewMut<'a> {
44    buf: &'a mut [u8],
45    reader_index: usize,
46    writer_index: usize,
47}
48
49impl<'a> BufViewMut<'a> {
50    /// Wrap the `buf` as BufViewMut, set the reader_index=0 and writer_index=0,
51    /// this make the whole `buf` can write by default.
52    pub fn wrap(buf: &'a mut [u8]) -> Self {
53        BufViewMut::wrap_with(buf, 0, 0)
54    }
55
56    /// Wrap the `buf` as BufViewMut, and specify the reader_index and writer_index.
57    /// ```
58    /// use buf_view::BufViewMut;
59    ///
60    /// let mut buf = [0, 1, 2, 3, 4, 5, 6, 7];
61    /// let mut buf = BufViewMut::wrap_with(&mut buf, 1, 3);
62    ///
63    /// buf.write_u32(0x01020304);
64    ///
65    /// assert_eq!(buf.read_u16(), 0x0102);
66    /// assert_eq!(buf.read_u32(), 0x01020304);
67    /// ```
68    pub fn wrap_with(buf: &'a mut [u8], reader_index: usize, writer_index: usize) -> Self {
69        assert!(reader_index <= writer_index && buf.len() >= writer_index);
70        BufViewMut {
71            buf,
72            reader_index,
73            writer_index,
74        }
75    }
76
77    pub fn read_u8(&mut self) -> u8 {
78        assert!(self.remaining() >= 1);
79        let val = self.buf[self.reader_index];
80        self.reader_index += 1;
81        val
82    }
83
84    pub fn read_i8(&mut self) -> i8 {
85        self.read_u8() as i8
86    }
87
88    pub fn read_u16(&mut self) -> u16 {
89        buf_read_do!(self, u16, be);
90    }
91
92    pub fn read_u16_le(&mut self) -> u16 {
93        buf_read_do!(self, u16, le);
94    }
95
96    pub fn read_i16(&mut self) -> i16 {
97        buf_read_do!(self, i16, be);
98    }
99
100    pub fn read_i16_le(&mut self) -> i16 {
101        buf_read_do!(self, i16, le);
102    }
103
104    pub fn read_u32(&mut self) -> u32 {
105        buf_read_do!(self, u32, be);
106    }
107
108    pub fn read_u32_le(&mut self) -> u32 {
109        buf_read_do!(self, u32, le);
110    }
111
112    pub fn read_i32(&mut self) -> i32 {
113        buf_read_do!(self, i32, be);
114    }
115
116    pub fn read_i32_le(&mut self) -> i32 {
117        buf_read_do!(self, i32, le);
118    }
119
120    pub fn read_u64(&mut self) -> u64 {
121        buf_read_do!(self, u64, be);
122    }
123
124    pub fn read_u64_le(&mut self) -> u64 {
125        buf_read_do!(self, u64, le);
126    }
127
128    pub fn read_i64(&mut self) -> i64 {
129        buf_read_do!(self, i64, be);
130    }
131
132    pub fn read_i64_le(&mut self) -> i64 {
133        buf_read_do!(self, i64, le);
134    }
135
136    pub fn read_u128(&mut self) -> u128 {
137        buf_read_do!(self, u128, be);
138    }
139
140    pub fn read_u128_le(&mut self) -> u128 {
141        buf_read_do!(self, u128, le);
142    }
143
144    pub fn read_i128(&mut self) -> i128 {
145        buf_read_do!(self, i128, be);
146    }
147
148    pub fn read_i128_le(&mut self) -> i128 {
149        buf_read_do!(self, i128, le);
150    }
151
152    pub fn read_f32(&mut self) -> f32 {
153        buf_read_do!(self, f32, be);
154    }
155
156    pub fn read_f32_le(&mut self) -> f32 {
157        buf_read_do!(self, f32, le);
158    }
159
160    pub fn read_f64(&mut self) -> f64 {
161        buf_read_do!(self, f64, be);
162    }
163
164    pub fn read_f64_le(&mut self) -> f64 {
165        buf_read_do!(self, f64, le);
166    }
167
168    pub fn read_bytes(&mut self, dest: &mut [u8]) -> usize {
169        let left = self.remaining();
170        assert!(left >= dest.len());
171        let copy_len = if dest.len() < left { dest.len() } else { left };
172        let end = self.reader_index + copy_len;
173        dest[..copy_len].copy_from_slice(&self.buf[self.reader_index..end]);
174        self.reader_index = end;
175        copy_len
176    }
177
178    pub fn get_u8(&mut self, index: usize) -> u8 {
179        assert!(self.buf.len() > index);
180        self.buf[index]
181    }
182
183    pub fn get_i8(&mut self, index: usize) -> i8 {
184        self.get_u8(index) as i8
185    }
186
187    pub fn get_u16(&mut self, index: usize) -> u16 {
188        buf_get_do!(self, index, u16, be);
189    }
190
191    pub fn get_u16_le(&mut self, index: usize) -> u16 {
192        buf_get_do!(self, index, u16, le);
193    }
194
195    pub fn get_i16(&mut self, index: usize) -> i16 {
196        buf_get_do!(self, index, i16, be);
197    }
198
199    pub fn get_i16_le(&mut self, index: usize) -> i16 {
200        buf_get_do!(self, index, i16, le);
201    }
202
203    pub fn get_u32(&mut self, index: usize) -> u32 {
204        buf_get_do!(self, index, u32, be);
205    }
206
207    pub fn get_u32_le(&mut self, index: usize) -> u32 {
208        buf_get_do!(self, index, u32, le);
209    }
210
211    pub fn get_i32(&mut self, index: usize) -> i32 {
212        buf_get_do!(self, index, i32, be);
213    }
214
215    pub fn get_i32_le(&mut self, index: usize) -> i32 {
216        buf_get_do!(self, index, i32, le);
217    }
218
219    pub fn get_u64(&mut self, index: usize) -> u64 {
220        buf_get_do!(self, index, u64, be);
221    }
222
223    pub fn get_u64_le(&mut self, index: usize) -> u64 {
224        buf_get_do!(self, index, u64, le);
225    }
226
227    pub fn get_i64(&mut self, index: usize) -> i64 {
228        buf_get_do!(self, index, i64, be);
229    }
230
231    pub fn get_i64_le(&mut self, index: usize) -> i64 {
232        buf_get_do!(self, index, i64, le);
233    }
234
235    pub fn get_u128(&mut self, index: usize) -> u128 {
236        buf_get_do!(self, index, u128, be);
237    }
238
239    pub fn get_u128_le(&mut self, index: usize) -> u128 {
240        buf_get_do!(self, index, u128, le);
241    }
242
243    pub fn get_i128(&mut self, index: usize) -> i128 {
244        buf_get_do!(self, index, i128, be);
245    }
246
247    pub fn get_i128_le(&mut self, index: usize) -> i128 {
248        buf_get_do!(self, index, i128, le);
249    }
250
251    pub fn get_f32(&mut self, index: usize) -> f32 {
252        buf_get_do!(self, index, f32, be);
253    }
254
255    pub fn get_f32_le(&mut self, index: usize) -> f32 {
256        buf_get_do!(self, index, f32, le);
257    }
258
259    pub fn get_f64(&mut self, index: usize) -> f64 {
260        buf_get_do!(self, index, f64, be);
261    }
262
263    pub fn get_f64_le(&mut self, index: usize) -> f64 {
264        buf_get_do!(self, index, f64, le);
265    }
266
267    pub fn get_bytes(&mut self, index: usize, dest: &mut [u8]) -> usize {
268        assert!(self.buf.len() > index);
269        let copy_len = if (index + dest.len()) <= self.buf.len() {
270            dest.len()
271        } else {
272            self.buf.len() - index
273        };
274        dest[..copy_len].copy_from_slice(&self.buf[index..(index + copy_len)]);
275        copy_len
276    }
277
278    pub fn write_u8(&mut self, val: u8) {
279        assert!(self.buf.len() >= (self.writer_index + 1));
280        self.buf[self.writer_index] = val;
281        self.writer_index += 1;
282    }
283
284    pub fn write_u16(&mut self, val: u16) {
285        self.write_bytes(&val.to_be_bytes());
286    }
287
288    pub fn write_u16_le(&mut self, val: u16) {
289        self.write_bytes(&val.to_le_bytes());
290    }
291
292    pub fn write_i16(&mut self, val: i16) {
293        self.write_bytes(&val.to_be_bytes());
294    }
295
296    pub fn write_i16_le(&mut self, val: i16) {
297        self.write_bytes(&val.to_le_bytes());
298    }
299
300    pub fn write_u32(&mut self, val: u32) {
301        self.write_bytes(&val.to_be_bytes());
302    }
303
304    pub fn write_u32_le(&mut self, val: u32) {
305        self.write_bytes(&val.to_le_bytes());
306    }
307
308    pub fn write_i32(&mut self, val: i32) {
309        self.write_bytes(&val.to_be_bytes());
310    }
311
312    pub fn write_i32_le(&mut self, val: i32) {
313        self.write_bytes(&val.to_le_bytes());
314    }
315
316    pub fn write_u64(&mut self, val: u64) {
317        self.write_bytes(&val.to_be_bytes());
318    }
319
320    pub fn write_u64_le(&mut self, val: u64) {
321        self.write_bytes(&val.to_le_bytes());
322    }
323
324    pub fn write_i64(&mut self, val: i64) {
325        self.write_bytes(&val.to_be_bytes());
326    }
327
328    pub fn write_i64_le(&mut self, val: i64) {
329        self.write_bytes(&val.to_le_bytes());
330    }
331
332    pub fn write_u128(&mut self, val: u128) {
333        self.write_bytes(&val.to_be_bytes());
334    }
335
336    pub fn write_u128_le(&mut self, val: u128) {
337        self.write_bytes(&val.to_le_bytes());
338    }
339
340    pub fn write_i128(&mut self, val: i128) {
341        self.write_bytes(&val.to_be_bytes());
342    }
343
344    pub fn write_i128_le(&mut self, val: i128) {
345        self.write_bytes(&val.to_le_bytes());
346    }
347
348    pub fn write_f32(&mut self, val: f32) {
349        self.write_bytes(&val.to_be_bytes());
350    }
351
352    pub fn write_f32_le(&mut self, val: f32) {
353        self.write_bytes(&val.to_le_bytes());
354    }
355
356    pub fn write_f64(&mut self, val: f64) {
357        self.write_bytes(&val.to_be_bytes());
358    }
359
360    pub fn write_f64_le(&mut self, val: f64) {
361        self.write_bytes(&val.to_le_bytes());
362    }
363
364    pub fn write_bytes(&mut self, src: &[u8]) {
365        let end = self.writer_index + src.len();
366        assert!(self.buf.len() >= end);
367        self.buf[self.writer_index..end].copy_from_slice(src);
368        self.writer_index = end;
369    }
370
371    pub fn write_bytes_uncheck(&mut self, src: &[u8]) -> usize {
372        let copy_len = if (self.writer_index + src.len()) > self.buf.len() {
373            self.buf.len() - self.writer_index
374        } else {
375            src.len()
376        };
377        self.buf[self.writer_index..].copy_from_slice(&src[..copy_len]);
378        copy_len
379    }
380
381    pub fn set_u8(&mut self, index: usize, val: u8) {
382        assert!(self.buf.len() > index);
383        self.buf[index] = val;
384    }
385
386    pub fn set_u16(&mut self, index: usize, val: u16) {
387        self.set_bytes(index, &val.to_be_bytes());
388    }
389
390    pub fn set_u16_le(&mut self, index: usize, val: u16) {
391        self.set_bytes(index, &val.to_le_bytes());
392    }
393
394    pub fn set_i16(&mut self, index: usize, val: i16) {
395        self.set_bytes(index, &val.to_be_bytes());
396    }
397
398    pub fn set_i16_le(&mut self, index: usize, val: i16) {
399        self.set_bytes(index, &val.to_le_bytes());
400    }
401
402    pub fn set_u32(&mut self, index: usize, val: u32) {
403        self.set_bytes(index, &val.to_be_bytes());
404    }
405
406    pub fn set_u32_le(&mut self, index: usize, val: u32) {
407        self.set_bytes(index, &val.to_le_bytes());
408    }
409
410    pub fn set_i32(&mut self, index: usize, val: i32) {
411        self.set_bytes(index, &val.to_be_bytes());
412    }
413
414    pub fn set_i32_le(&mut self, index: usize, val: i32) {
415        self.set_bytes(index, &val.to_le_bytes());
416    }
417
418    pub fn set_u64(&mut self, index: usize, val: u64) {
419        self.set_bytes(index, &val.to_be_bytes());
420    }
421
422    pub fn set_u64_le(&mut self, index: usize, val: u64) {
423        self.set_bytes(index, &val.to_le_bytes());
424    }
425
426    pub fn set_i64(&mut self, index: usize, val: i64) {
427        self.set_bytes(index, &val.to_be_bytes());
428    }
429
430    pub fn set_i64_le(&mut self, index: usize, val: i64) {
431        self.set_bytes(index, &val.to_le_bytes());
432    }
433
434    pub fn set_u128(&mut self, index: usize, val: u128) {
435        self.set_bytes(index, &val.to_be_bytes());
436    }
437
438    pub fn set_u128_le(&mut self, index: usize, val: u128) {
439        self.set_bytes(index, &val.to_le_bytes());
440    }
441
442    pub fn set_i128(&mut self, index: usize, val: i128) {
443        self.set_bytes(index, &val.to_be_bytes());
444    }
445
446    pub fn set_i128_le(&mut self, index: usize, val: i128) {
447        self.set_bytes(index, &val.to_le_bytes());
448    }
449
450    pub fn set_f32(&mut self, index: usize, val: f32) {
451        self.set_bytes(index, &val.to_be_bytes());
452    }
453
454    pub fn set_f32_le(&mut self, index: usize, val: f32) {
455        self.set_bytes(index, &val.to_le_bytes());
456    }
457
458    pub fn set_f64(&mut self, index: usize, val: f64) {
459        self.set_bytes(index, &val.to_be_bytes());
460    }
461
462    pub fn set_f64_le(&mut self, index: usize, val: f64) {
463        self.set_bytes(index, &val.to_le_bytes());
464    }
465
466    pub fn set_bytes(&mut self, index: usize, src: &[u8]) {
467        let end = index + src.len();
468        assert!(self.buf.len() >= end);
469        self.buf[index..end].copy_from_slice(src);
470    }
471
472    pub fn set_reader_index(&mut self, index: usize) {
473        assert!(self.buf.len() >= index && index <= self.writer_index);
474        self.reader_index = index;
475    }
476
477    pub fn reader_index(&self) -> usize {
478        self.reader_index
479    }
480
481    pub fn set_writer_index(&mut self, index: usize) {
482        assert!(self.buf.len() >= index && index >= self.reader_index);
483        self.writer_index = index;
484    }
485
486    pub fn writer_index(&self) -> usize {
487        self.writer_index
488    }
489
490    pub fn set_index(&mut self, reader_index: usize, writer_index: usize) {
491        assert!(reader_index <= writer_index && self.buf.len() >= writer_index);
492        self.reader_index = reader_index;
493        self.writer_index = writer_index;
494    }
495
496    pub fn clear(&mut self) {
497        self.reader_index = 0;
498        self.writer_index = 0;
499    }
500
501    pub fn remaining(&self) -> usize {
502        self.writer_index - self.reader_index
503    }
504
505    pub fn capacity(&self) -> usize {
506        self.buf.len()
507    }
508
509    pub fn as_slice(&mut self) -> &mut [u8] {
510        &mut self.buf[self.reader_index..self.writer_index]
511    }
512
513    pub fn as_raw_slice(&mut self) -> &mut [u8] {
514        self.buf
515    }
516}
517
518impl std::fmt::Display for BufViewMut<'_> {
519    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
520        write!(
521            f,
522            "reader_index: {}, writer_index: {}, capacity: {}",
523            self.reader_index(),
524            self.writer_index(),
525            self.capacity()
526        )
527    }
528}
529
530impl<'a> Write for BufViewMut<'a> {
531    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
532        let len = self.write_bytes_uncheck(buf);
533        Ok(len)
534    }
535
536    fn flush(&mut self) -> io::Result<()> {
537        Ok(())
538    }
539}
buf_view/buf_view_mut.rs

buf_view/
buf_view_mut.rs
