bin_rs/reader/
bytes.rs

1use crate::Endian;
2use std::io::{Error, ErrorKind, SeekFrom};
3
4use super::BinaryReader;
5
6/// BytesReader from creating Slice `&[u8]` or `Vec<u8>`,
7/// no use Read trait
8#[derive(Debug, Clone)]
9pub struct BytesReader {
10  buffer: Vec<u8>,
11  ptr: usize,
12  endian: Endian,
13}
14
15impl BytesReader {
16  pub fn new(buffer: &[u8]) -> Self {
17    Self {
18      buffer: buffer.to_vec(),
19      ptr: 0,
20      endian: crate::system_endian(),
21    }
22  }
23
24  #[deprecated(since = "0.0.10", note = "Use new function `from(Vec<u8>)` instead")]
25  pub fn from_vec(buffer: Vec<u8>) -> Self {
26    Self::from(buffer)
27  }
28
29  fn check_bound(&mut self, size: usize) -> Result<(), Error> {
30    if self.ptr + size > self.buffer.len() {
31      let s = format!(
32        "ountbound call ptr {} + {} but buffer length {}",
33        self.ptr,
34        size,
35        &self.buffer.len()
36      );
37      Err(Error::new(ErrorKind::Other, s))
38    } else {
39      Ok(())
40    }
41  }
42}
43
44impl From<Vec<u8>> for BytesReader {
45  fn from(buffer: Vec<u8>) -> Self {
46    Self {
47      buffer,
48      ptr: 0,
49      endian: crate::system_endian(),
50    }
51  }
52}
53
54impl From<&[u8]> for BytesReader {
55  fn from(buffer: &[u8]) -> Self {
56    Self {
57      buffer: buffer.to_vec(),
58      ptr: 0,
59      endian: crate::system_endian(),
60    }
61  }
62}
63
64impl From<&Vec<u8>> for BytesReader {
65  fn from(buffer: &Vec<u8>) -> Self {
66    Self {
67      buffer: buffer.to_vec(),
68      ptr: 0,
69      endian: crate::system_endian(),
70    }
71  }
72}
73
74#[cfg(feature = "serde")]
75impl From<bytes::Bytes> for BytesReader {
76  fn from(buffer: bytes::Bytes) -> Self {
77    let buffer = buffer.to_vec();
78    Self {
79      buffer,
80      ptr: 0,
81      endian: crate::system_endian(),
82    }
83  }
84}
85
86impl BinaryReader for BytesReader {
87  fn offset(&mut self) -> Result<u64, Error> {
88    Ok(self.ptr as u64)
89  }
90
91  fn set_endian(&mut self, endian: Endian) {
92    self.endian = endian;
93  }
94
95  fn endian(&self) -> Endian {
96    self.endian
97  }
98
99  fn read_byte(&mut self) -> Result<u8, Error> {
100    self.check_bound(1)?;
101    let b = &self.buffer[self.ptr];
102    self.ptr += 1;
103    Ok(*b)
104  }
105
106  fn read_u8(&mut self) -> Result<u8, Error> {
107    self.read_byte()
108  }
109
110  fn read_i8(&mut self) -> Result<i8, Error> {
111    Ok(self.read_byte()? as i8)
112  }
113
114  fn read_exact(&mut self, array: &mut [u8]) -> Result<(), Error> {
115    let len = array.len();
116    self.check_bound(len)?;
117    for i in 0..len {
118      array[i] = self.buffer[self.ptr + i];
119    }
120    self.ptr += len;
121    Ok(())
122  }
123
124  fn read_bytes_as_vec(&mut self, len: usize) -> Result<Vec<u8>, Error> {
125    self.check_bound(len)?;
126    let mut c: Vec<u8> = Vec::new();
127    for i in 0..len {
128      c.push(self.buffer[self.ptr + i]);
129    }
130    self.ptr += len;
131    Ok(c)
132  }
133
134  // This function read bytes, but it does not move pointer.
135  /// ```
136  /// use bin_rs::reader::*;
137  /// use std::io::Error;
138  /// fn test() ->  Result<(),Error> {
139  ///    let buffer = b"Hello World!";
140  ///    let mut reader = BytesReader::new(buffer);
141  ///    let buffer1 = reader.read_bytes_no_move(4)?;
142  /// // assert_eq!(buffer1,b"Hell");
143  ///    let buffer1 = reader.read_bytes_as_vec(4)?;
144  /// // assert_eq!(buffer1,b"Hell");
145  ///    let buffer1 = reader.read_bytes_as_vec(4)?;
146  /// // assert_eq!(buffer1,b"o Wo");
147  ///    return Ok(())
148  /// }
149  /// ```
150  ///
151  fn read_bytes_no_move(&mut self, len: usize) -> Result<Vec<u8>, Error> {
152    self.check_bound(len)?;
153    let mut c: Vec<u8> = Vec::new();
154    for i in 0..len {
155      c.push(self.buffer[self.ptr + i]);
156    }
157    Ok(c)
158  }
159
160  fn read_u16(&mut self) -> Result<u16, Error> {
161    match self.endian {
162      Endian::BigEndian => self.read_u16_be(),
163      Endian::LittleEndian => self.read_u16_le(),
164    }
165  }
166
167  fn read_u32(&mut self) -> Result<u32, Error> {
168    match self.endian {
169      Endian::BigEndian => self.read_u32_be(),
170      Endian::LittleEndian => self.read_u32_le(),
171    }
172  }
173
174  fn read_u64(&mut self) -> Result<u64, Error> {
175    match self.endian {
176      Endian::BigEndian => self.read_u64_be(),
177      Endian::LittleEndian => self.read_u64_le(),
178    }
179  }
180
181  fn read_u128(&mut self) -> Result<u128, Error> {
182    match self.endian {
183      Endian::BigEndian => self.read_u128_be(),
184      Endian::LittleEndian => self.read_u128_le(),
185    }
186  }
187
188  fn read_i16(&mut self) -> Result<i16, Error> {
189    match self.endian {
190      Endian::BigEndian => self.read_i16_be(),
191      Endian::LittleEndian => self.read_i16_le(),
192    }
193  }
194
195  fn read_i32(&mut self) -> Result<i32, Error> {
196    match self.endian {
197      Endian::BigEndian => self.read_i32_be(),
198      Endian::LittleEndian => self.read_i32_le(),
199    }
200  }
201
202  fn read_i64(&mut self) -> Result<i64, Error> {
203    match self.endian {
204      Endian::BigEndian => self.read_i64_be(),
205      Endian::LittleEndian => self.read_i64_le(),
206    }
207  }
208
209  fn read_i128(&mut self) -> Result<i128, Error> {
210    match self.endian {
211      Endian::BigEndian => self.read_i128_be(),
212      Endian::LittleEndian => self.read_i128_le(),
213    }
214  }
215
216  fn read_f32(&mut self) -> Result<f32, Error> {
217    match self.endian {
218      Endian::BigEndian => self.read_f32_be(),
219      Endian::LittleEndian => self.read_f32_le(),
220    }
221  }
222
223  fn read_f64(&mut self) -> Result<f64, Error> {
224    match self.endian {
225      Endian::BigEndian => self.read_f64_be(),
226      Endian::LittleEndian => self.read_f64_le(),
227    }
228  }
229
230  fn read_u16_be(&mut self) -> Result<u16, Error> {
231    let len = 2;
232    self.check_bound(len)?;
233    let ptr = self.ptr;
234    self.ptr += len;
235    let buf = &&self.buffer;
236    let array = [buf[ptr], buf[ptr + 1]];
237    Ok(u16::from_be_bytes(array))
238  }
239
240  fn read_u32_be(&mut self) -> Result<u32, Error> {
241    let len = 4;
242    self.check_bound(len)?;
243    let ptr = self.ptr;
244    self.ptr += len;
245    let buf = &self.buffer;
246    let array = [buf[ptr], buf[ptr + 1], buf[ptr + 2], buf[ptr + 3]];
247    Ok(u32::from_be_bytes(array))
248  }
249
250  fn read_u64_be(&mut self) -> Result<u64, Error> {
251    let len = 8;
252    self.check_bound(len)?;
253    let ptr = self.ptr;
254    self.ptr += len;
255    let buf = &self.buffer;
256    let array = [
257      buf[ptr],
258      buf[ptr + 1],
259      buf[ptr + 2],
260      buf[ptr + 3],
261      buf[ptr + 4],
262      buf[ptr + 5],
263      buf[ptr + 6],
264      buf[ptr + 7],
265    ];
266    Ok(u64::from_be_bytes(array))
267  }
268
269  fn read_u128_be(&mut self) -> Result<u128, Error> {
270    let len = 16;
271    self.check_bound(len)?;
272    let ptr = self.ptr;
273    self.ptr += len;
274    let buf = &self.buffer;
275    let array = [
276      buf[ptr],
277      buf[ptr + 1],
278      buf[ptr + 2],
279      buf[ptr + 3],
280      buf[ptr + 4],
281      buf[ptr + 5],
282      buf[ptr + 6],
283      buf[ptr + 7],
284      buf[ptr + 8],
285      buf[ptr + 9],
286      buf[ptr + 10],
287      buf[ptr + 11],
288      buf[ptr + 12],
289      buf[ptr + 13],
290      buf[ptr + 14],
291      buf[ptr + 15],
292    ];
293    Ok(u128::from_be_bytes(array))
294  }
295
296  fn read_i16_be(&mut self) -> Result<i16, Error> {
297    let len = 2;
298    self.check_bound(len)?;
299    let ptr = self.ptr;
300    self.ptr += len;
301    let buf = &self.buffer;
302    let array = [buf[ptr], buf[ptr + 1]];
303    Ok(i16::from_be_bytes(array))
304  }
305
306  fn read_i32_be(&mut self) -> Result<i32, Error> {
307    let len = 4;
308    self.check_bound(len)?;
309    let ptr = self.ptr;
310    self.ptr += len;
311    let buf = &self.buffer;
312    let array = [buf[ptr], buf[ptr + 1], buf[ptr + 2], buf[ptr + 3]];
313    Ok(i32::from_be_bytes(array))
314  }
315
316  fn read_i64_be(&mut self) -> Result<i64, Error> {
317    let len = 8;
318    self.check_bound(len)?;
319    let ptr = self.ptr;
320    self.ptr += len;
321    let buf = &self.buffer;
322    let array = [
323      buf[ptr],
324      buf[ptr + 1],
325      buf[ptr + 2],
326      buf[ptr + 3],
327      buf[ptr + 4],
328      buf[ptr + 5],
329      buf[ptr + 6],
330      buf[ptr + 7],
331    ];
332    Ok(i64::from_be_bytes(array))
333  }
334
335  fn read_i128_be(&mut self) -> Result<i128, Error> {
336    let len = 16;
337    self.check_bound(len)?;
338    let ptr = self.ptr;
339    self.ptr += len;
340    let buf = &self.buffer;
341    let array = [
342      buf[ptr],
343      buf[ptr + 1],
344      buf[ptr + 2],
345      buf[ptr + 3],
346      buf[ptr + 4],
347      buf[ptr + 5],
348      buf[ptr + 6],
349      buf[ptr + 7],
350      buf[ptr + 8],
351      buf[ptr + 9],
352      buf[ptr + 10],
353      buf[ptr + 11],
354      buf[ptr + 12],
355      buf[ptr + 13],
356      buf[ptr + 14],
357      buf[ptr + 15],
358    ];
359    Ok(i128::from_be_bytes(array))
360  }
361
362  fn read_f32_be(&mut self) -> Result<f32, Error> {
363    let len = 4;
364    self.check_bound(len)?;
365    let ptr = self.ptr;
366    self.ptr += len;
367    let buf = &self.buffer;
368
369    let array = [buf[ptr], buf[ptr + 1], buf[ptr + 2], buf[ptr + 3]];
370    Ok(f32::from_be_bytes(array))
371  }
372
373  fn read_f64_be(&mut self) -> Result<f64, Error> {
374    let len = 8;
375    self.check_bound(len)?;
376    let ptr = self.ptr;
377    self.ptr += len;
378    let buf = &self.buffer;
379    let array = [
380      buf[ptr],
381      buf[ptr + 1],
382      buf[ptr + 2],
383      buf[ptr + 3],
384      buf[ptr + 4],
385      buf[ptr + 5],
386      buf[ptr + 6],
387      buf[ptr + 7],
388    ];
389    Ok(f64::from_be_bytes(array))
390  }
391
392  fn read_u16_le(&mut self) -> Result<u16, Error> {
393    let len = 2;
394    self.check_bound(len)?;
395    let ptr = self.ptr;
396    self.ptr += len;
397    let buf = &self.buffer;
398    let array = [buf[ptr], buf[ptr + 1]];
399    Ok(u16::from_le_bytes(array))
400  }
401
402  fn read_u32_le(&mut self) -> Result<u32, Error> {
403    let len = 4;
404    self.check_bound(len)?;
405    let ptr = self.ptr;
406    self.ptr += len;
407    let buf = &self.buffer;
408    let array = [buf[ptr], buf[ptr + 1], buf[ptr + 2], buf[ptr + 3]];
409    Ok(u32::from_le_bytes(array))
410  }
411
412  fn read_u64_le(&mut self) -> Result<u64, Error> {
413    let len = 8;
414    self.check_bound(len)?;
415    let ptr = self.ptr;
416    self.ptr += len;
417    let buf = &self.buffer;
418    let array = [
419      buf[ptr],
420      buf[ptr + 1],
421      buf[ptr + 2],
422      buf[ptr + 3],
423      buf[ptr + 4],
424      buf[ptr + 5],
425      buf[ptr + 6],
426      buf[ptr + 7],
427    ];
428    Ok(u64::from_le_bytes(array))
429  }
430
431  fn read_u128_le(&mut self) -> Result<u128, Error> {
432    let len = 16;
433    self.check_bound(len)?;
434    let ptr = self.ptr;
435    self.ptr += len;
436    let buf = &self.buffer;
437    let array = [
438      buf[ptr],
439      buf[ptr + 1],
440      buf[ptr + 2],
441      buf[ptr + 3],
442      buf[ptr + 4],
443      buf[ptr + 5],
444      buf[ptr + 6],
445      buf[ptr + 7],
446      buf[ptr + 8],
447      buf[ptr + 9],
448      buf[ptr + 10],
449      buf[ptr + 11],
450      buf[ptr + 12],
451      buf[ptr + 13],
452      buf[ptr + 14],
453      buf[ptr + 15],
454    ];
455    Ok(u128::from_le_bytes(array))
456  }
457
458  fn read_i16_le(&mut self) -> Result<i16, Error> {
459    let len = 2;
460    self.check_bound(len)?;
461    let ptr = self.ptr;
462    self.ptr += len;
463    let buf = &self.buffer;
464    let array = [buf[ptr], buf[ptr + 1]];
465    Ok(i16::from_le_bytes(array))
466  }
467
468  fn read_i32_le(&mut self) -> Result<i32, Error> {
469    let len = 4;
470    self.check_bound(len)?;
471    let ptr = self.ptr;
472    self.ptr += len;
473    let buf = &self.buffer;
474    let array = [buf[ptr], buf[ptr + 1], buf[ptr + 2], buf[ptr + 3]];
475    Ok(i32::from_le_bytes(array))
476  }
477
478  fn read_i64_le(&mut self) -> Result<i64, Error> {
479    let len = 8;
480    self.check_bound(len)?;
481    let ptr = self.ptr;
482    self.ptr += len;
483    let buf = &self.buffer;
484    let array = [
485      buf[ptr],
486      buf[ptr + 1],
487      buf[ptr + 2],
488      buf[ptr + 3],
489      buf[ptr + 4],
490      buf[ptr + 5],
491      buf[ptr + 6],
492      buf[ptr + 7],
493    ];
494    Ok(i64::from_le_bytes(array))
495  }
496
497  fn read_i128_le(&mut self) -> Result<i128, Error> {
498    let len = 16;
499    self.check_bound(len)?;
500    let ptr = self.ptr;
501    self.ptr += len;
502    let buf = &self.buffer;
503    let array = [
504      buf[ptr],
505      buf[ptr + 1],
506      buf[ptr + 2],
507      buf[ptr + 3],
508      buf[ptr + 4],
509      buf[ptr + 5],
510      buf[ptr + 6],
511      buf[ptr + 7],
512      buf[ptr + 8],
513      buf[ptr + 9],
514      buf[ptr + 10],
515      buf[ptr + 11],
516      buf[ptr + 12],
517      buf[ptr + 13],
518      buf[ptr + 14],
519      buf[ptr + 15],
520    ];
521    Ok(i128::from_le_bytes(array))
522  }
523
524  fn read_f32_le(&mut self) -> Result<f32, Error> {
525    let len = 4;
526    self.check_bound(len)?;
527    let ptr = self.ptr;
528    self.ptr += len;
529    let buf = &self.buffer;
530
531    let array = [buf[ptr], buf[ptr + 1], buf[ptr + 2], buf[ptr + 3]];
532    Ok(f32::from_le_bytes(array))
533  }
534
535  fn read_f64_le(&mut self) -> Result<f64, Error> {
536    let len = 8;
537    self.check_bound(len)?;
538    let ptr = self.ptr;
539    self.ptr += len;
540    let buf = &self.buffer;
541
542    let array = [
543      buf[ptr],
544      buf[ptr + 1],
545      buf[ptr + 2],
546      buf[ptr + 3],
547      buf[ptr + 4],
548      buf[ptr + 5],
549      buf[ptr + 6],
550      buf[ptr + 7],
551    ];
552    Ok(f64::from_le_bytes(array))
553  }
554
555  #[cfg(feature = "codec")]
556  fn read_local_string(&mut self, size: usize, code: CodeType) -> Result<String, Error> {
557    self.check_bound(size)?;
558    self.ptr += size;
559    Err(Error::new(ErrorKind::Other, "No impl"));
560  }
561
562  /// skip_ptr skips offset size bytes
563  fn skip_ptr(&mut self, size: usize) -> Result<usize, Error> {
564    self.check_bound(size)?;
565    self.ptr += size;
566    Ok(size)
567  }
568
569  fn seek(&mut self, seek: SeekFrom) -> std::result::Result<u64, Error> {
570    match seek {
571      SeekFrom::Start(pos) => {
572        if pos > self.buffer.len() as u64 {
573          let s = format!(
574            "set offset {},but buffer length is{}",
575            pos,
576            self.buffer.len()
577          );
578          return Err(Error::new(ErrorKind::Other, s));
579        }
580        self.ptr = pos as usize;
581        Ok(self.ptr as u64)
582      }
583      SeekFrom::End(pos_) => {
584        let pos = self.buffer.len() as i64 + pos_;
585        if pos < 0 || pos > (self.buffer.len() as i64) {
586          let s = format!(
587            "set offset {},but buffer length is {}",
588            pos,
589            self.buffer.len()
590          );
591          return Err(Error::new(ErrorKind::Other, s));
592        }
593        self.ptr = pos as usize;
594        Ok(self.ptr as u64)
595      }
596      SeekFrom::Current(pos) => {
597        let ptr = (self.ptr as i64) + pos;
598        if (self.buffer.len() as i64) < ptr || ptr < 0 {
599          let s = format!(
600            "set offset {},but buffer length is{}",
601            ptr,
602            self.buffer.len()
603          );
604          return Err(Error::new(ErrorKind::Other, s));
605        }
606        self.ptr = ptr as usize;
607        Ok(self.ptr as u64)
608      }
609    }
610  }
611}
bin_rs/reader/bytes.rs

bin_rs/reader/
bytes.rs
