bin_rs/reader/
stream.rs

1use crate::Endian;
2use std::fs::File;
3use std::io::BufRead;
4use std::io::BufReader;
5use std::io::Cursor;
6use std::io::Error;
7use std::io::ErrorKind;
8/// 0.0.8 Enable support for target_family other than "wasm", feature "stream" is disabled.
9///
10/// StreamReader from creating BufRead
11/// use BufRead trait
12use std::io::Read;
13use std::io::Seek;
14
15use std::path::PathBuf;
16
17use super::BinaryReader;
18
19#[derive(Copy, Debug, Clone)]
20pub struct StreamReader<R> {
21  reader: R,
22  endian: Endian,
23}
24
25impl StreamReader<BufReader<File>> {
26  #[cfg(not(target_family = "wasm"))]
27  pub fn from_file(filename: PathBuf) -> Result<Self, Error> {
28    let file = File::open(filename)?;
29    let reader = BufReader::new(file);
30    Ok(Self {
31      reader,
32      endian: crate::system_endian(),
33    })
34  }
35}
36
37impl<R: BufRead + Seek> StreamReader<R> {
38  pub fn new(reader: R) -> StreamReader<R> {
39    StreamReader {
40      reader,
41      endian: crate::system_endian(),
42    }
43  }
44}
45
46impl<R> From<R> for StreamReader<Cursor<R>>
47where
48  R: Read,
49{
50  fn from(reader: R) -> Self {
51    let reader = Cursor::new(reader);
52    Self {
53      reader,
54      endian: crate::system_endian(),
55    }
56  }
57}
58
59#[cfg(not(target_family = "wasm"))]
60impl From<File> for StreamReader<BufReader<File>> {
61  fn from(file: File) -> Self {
62    let reader = BufReader::new(file);
63    Self {
64      reader,
65      endian: crate::system_endian(),
66    }
67  }
68}
69
70impl<R: BufRead + Seek> BinaryReader for StreamReader<R> {
71  fn set_endian(&mut self, endian: Endian) {
72    self.endian = endian;
73  }
74
75  fn endian(&self) -> Endian {
76    self.endian
77  }
78
79  fn read_byte(&mut self) -> Result<u8, Error> {
80    let mut buffer = [0; 1];
81    self.reader.read_exact(&mut buffer)?;
82    Ok(buffer[0])
83  }
84  fn read_u8(&mut self) -> Result<u8, Error> {
85    self.read_byte()
86  }
87
88  fn read_i8(&mut self) -> Result<i8, Error> {
89    Ok(self.read_byte()? as i8)
90  }
91
92  fn read_exact(&mut self, array: &mut [u8]) -> std::result::Result<(), Error> {
93    self.reader.read_exact(array)?;
94    Ok(())
95  }
96
97  fn read_bytes_as_vec(&mut self, len: usize) -> Result<Vec<u8>, Error> {
98    let mut array: Vec<u8> = (0..len).map(|_| 0).collect();
99    self.reader.read_exact(&mut array)?;
100    Ok(array)
101  }
102
103  // This function read bytes and does not move pointer.
104  // However it's behavior dependences read buffer size.
105  fn read_bytes_no_move(&mut self, len: usize) -> Result<Vec<u8>, Error> {
106    let buffer = self.reader.fill_buf()?;
107    if buffer.len() < len {
108      let err = format!(
109        "Data shotage,request {} but read {} bytes",
110        len,
111        buffer.len()
112      );
113      return Err(Error::new(ErrorKind::Other, err));
114    }
115    let array: Vec<u8> = (0..len).map(|i| buffer[i]).collect();
116    Ok(array)
117  }
118
119  fn read_u16(&mut self) -> Result<u16, Error> {
120    match self.endian {
121      Endian::BigEndian => self.read_u16_be(),
122      Endian::LittleEndian => self.read_u16_le(),
123    }
124  }
125
126  fn read_u32(&mut self) -> Result<u32, Error> {
127    match self.endian {
128      Endian::BigEndian => self.read_u32_be(),
129      Endian::LittleEndian => self.read_u32_le(),
130    }
131  }
132
133  fn read_u64(&mut self) -> Result<u64, Error> {
134    match self.endian {
135      Endian::BigEndian => self.read_u64_be(),
136      Endian::LittleEndian => self.read_u64_le(),
137    }
138  }
139
140  fn read_u128(&mut self) -> Result<u128, Error> {
141    match self.endian {
142      Endian::BigEndian => self.read_u128_be(),
143      Endian::LittleEndian => self.read_u128_le(),
144    }
145  }
146
147  fn read_i16(&mut self) -> Result<i16, Error> {
148    match self.endian {
149      Endian::BigEndian => self.read_i16_be(),
150      Endian::LittleEndian => self.read_i16_le(),
151    }
152  }
153
154  fn read_i32(&mut self) -> Result<i32, Error> {
155    match self.endian {
156      Endian::BigEndian => self.read_i32_be(),
157      Endian::LittleEndian => self.read_i32_le(),
158    }
159  }
160
161  fn read_i64(&mut self) -> Result<i64, Error> {
162    match self.endian {
163      Endian::BigEndian => self.read_i64_be(),
164      Endian::LittleEndian => self.read_i64_le(),
165    }
166  }
167
168  fn read_i128(&mut self) -> Result<i128, Error> {
169    match self.endian {
170      Endian::BigEndian => self.read_i128_be(),
171      Endian::LittleEndian => self.read_i128_le(),
172    }
173  }
174
175  fn read_f32(&mut self) -> Result<f32, Error> {
176    match self.endian {
177      Endian::BigEndian => self.read_f32_be(),
178      Endian::LittleEndian => self.read_f32_le(),
179    }
180  }
181
182  fn read_f64(&mut self) -> Result<f64, Error> {
183    match self.endian {
184      Endian::BigEndian => self.read_f64_be(),
185      Endian::LittleEndian => self.read_f64_le(),
186    }
187  }
188
189  fn read_u16_be(&mut self) -> Result<u16, Error> {
190    let mut array = [0; 2];
191    self.reader.read_exact(&mut array)?;
192    Ok(u16::from_be_bytes(array))
193  }
194
195  fn read_u32_be(&mut self) -> Result<u32, Error> {
196    let mut array = [0; 4];
197    self.reader.read_exact(&mut array)?;
198    Ok(u32::from_be_bytes(array))
199  }
200
201  fn read_u64_be(&mut self) -> Result<u64, Error> {
202    let mut array = [0; 8];
203    self.reader.read_exact(&mut array)?;
204    Ok(u64::from_be_bytes(array))
205  }
206
207  fn read_u128_be(&mut self) -> Result<u128, Error> {
208    let mut array = [0; 16];
209    self.reader.read_exact(&mut array)?;
210    Ok(u128::from_be_bytes(array))
211  }
212
213  fn read_i16_be(&mut self) -> Result<i16, Error> {
214    let mut array = [0; 2];
215    self.reader.read_exact(&mut array)?;
216    Ok(i16::from_be_bytes(array))
217  }
218
219  fn read_i32_be(&mut self) -> Result<i32, Error> {
220    let mut array = [0; 4];
221    self.reader.read_exact(&mut array)?;
222    Ok(i32::from_be_bytes(array))
223  }
224
225  fn read_i64_be(&mut self) -> Result<i64, Error> {
226    let mut array = [0; 8];
227    self.reader.read_exact(&mut array)?;
228    Ok(i64::from_be_bytes(array))
229  }
230
231  fn read_i128_be(&mut self) -> Result<i128, Error> {
232    let mut array = [0; 16];
233    self.reader.read_exact(&mut array)?;
234    Ok(i128::from_be_bytes(array))
235  }
236
237  fn read_f32_be(&mut self) -> Result<f32, Error> {
238    let mut array = [0; 4];
239    self.reader.read_exact(&mut array)?;
240    Ok(f32::from_be_bytes(array))
241  }
242
243  fn read_f64_be(&mut self) -> Result<f64, Error> {
244    let mut array = [0; 8];
245    self.reader.read_exact(&mut array)?;
246    Ok(f64::from_be_bytes(array))
247  }
248
249  fn read_u16_le(&mut self) -> Result<u16, Error> {
250    let mut array = [0; 2];
251    self.reader.read_exact(&mut array)?;
252    Ok(u16::from_le_bytes(array))
253  }
254
255  fn read_u32_le(&mut self) -> Result<u32, Error> {
256    let mut array = [0; 4];
257    self.reader.read_exact(&mut array)?;
258    Ok(u32::from_le_bytes(array))
259  }
260
261  fn read_u64_le(&mut self) -> Result<u64, Error> {
262    let mut array = [0; 8];
263    self.reader.read_exact(&mut array)?;
264    Ok(u64::from_le_bytes(array))
265  }
266
267  fn read_u128_le(&mut self) -> Result<u128, Error> {
268    let mut array = [0; 16];
269    self.reader.read_exact(&mut array)?;
270    Ok(u128::from_le_bytes(array))
271  }
272
273  fn read_i16_le(&mut self) -> Result<i16, Error> {
274    let mut array = [0; 2];
275    self.reader.read_exact(&mut array)?;
276    Ok(i16::from_le_bytes(array))
277  }
278
279  fn read_i32_le(&mut self) -> Result<i32, Error> {
280    let mut array = [0; 4];
281    self.reader.read_exact(&mut array)?;
282    Ok(i32::from_le_bytes(array))
283  }
284
285  fn read_i64_le(&mut self) -> Result<i64, Error> {
286    let mut array = [0; 8];
287    self.reader.read_exact(&mut array)?;
288    Ok(i64::from_le_bytes(array))
289  }
290
291  fn read_i128_le(&mut self) -> Result<i128, Error> {
292    let mut array = [0; 16];
293    self.reader.read_exact(&mut array)?;
294    Ok(i128::from_le_bytes(array))
295  }
296
297  fn read_f32_le(&mut self) -> Result<f32, Error> {
298    let mut array = [0; 4];
299    self.reader.read_exact(&mut array)?;
300    Ok(f32::from_le_bytes(array))
301  }
302
303  fn read_f64_le(&mut self) -> Result<f64, Error> {
304    let mut array = [0; 8];
305    self.reader.read_exact(&mut array)?;
306    Ok(f64::from_le_bytes(array))
307  }
308
309  #[cfg(feature = "codec")]
310  fn read_local_string(&mut self, size: usize, code: CodeType) -> Result<String, Error> {
311    let mut array: Vec<u8> = (0..size).map(|_| 0).collect();
312    self.reader.read_exact(&mut array)?;
313
314    let buf = &array;
315    let mut s = Vec::new();
316    for i in 0..size {
317      if buf[i] == 0 {
318        break;
319      }
320      s.push(buf[i]);
321    }
322    let res = String::from_utf8(s);
323    match res {
324      Ok(strings) => {
325        return Ok(strings);
326      }
327      _ => {
328        let err = "This string can not read";
329        return Err(Error::new(ErrorKind::Other, err));
330      }
331    }
332  }
333
334  /// skip size byte
335  fn skip_ptr(&mut self, size: usize) -> Result<usize, Error> {
336    let mut array: Vec<u8> = (0..size).map(|_| 0).collect();
337    self.reader.read_exact(&mut array)?;
338    Ok(size)
339  }
340
341  fn offset(&mut self) -> std::result::Result<u64, Error> {
342    self.reader.stream_position()
343  }
344
345  fn seek(&mut self, seek: std::io::SeekFrom) -> std::result::Result<u64, Error> {
346    self.reader.seek(seek)
347  }
348}
bin_rs/reader/stream.rs

bin_rs/reader/
stream.rs
