1 //! Bytestream reading/writing functionality.
2 pub use std::io::SeekFrom;
4 use std::io::prelude::*;
7 /// A list specifying general bytestream reading and writing errors.
12 /// Wrong seek position was provided.
14 /// Tried to call read() on bytestream writer or write() on bytestream reader.
16 /// Functionality is not implemented.
26 /// A specialised `Result` type for bytestream operations.
27 pub type ByteIOResult<T> = Result<T, ByteIOError>;
29 /// Common trait for bytestream operations.
31 /// Reads data into provided buffer. Fails if it cannot fill whole buffer.
32 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
33 /// Reads data into provided buffer. Partial read is treated as success.
34 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
35 /// Reads data into provided buffer but does not advance read position.
36 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
37 /// Reads single byte from the stream.
38 fn read_byte(&mut self) -> ByteIOResult<u8>;
39 /// Returns the next byte value in the stream without advancing read position.
40 fn peek_byte(&mut self) -> ByteIOResult<u8>;
41 /// Writes buffer to the stream.
42 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()>;
43 /// Returns current read or write position.
44 fn tell(&mut self) -> u64;
45 /// Seeks to the provided position.
46 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
47 /// Tells whether this is end of stream.
48 fn is_eof(&self) -> bool;
49 /// Reports whether stream is seekable or not.
50 fn is_seekable(&mut self) -> bool;
51 /// Returns stream size or -1 if it is not known.
52 fn size(&mut self) -> i64;
55 /// High-level bytestream reader.
57 /// User is supposed to create some reader implementing [`ByteIO`] trait e.g. [`MemoryReader`] and use it to create `ByteReader` which can be used for reading e.g. various integer types.
62 /// use nihav_core::io::byteio::{MemoryReader,ByteReader};
63 /// # use nihav_core::io::byteio::ByteIOResult;
65 /// # fn foo() -> ByteIOResult<()> {
66 /// let memory: [u8; 4] = [ 0, 42, 42, 0 ];
67 /// let mut mr = MemoryReader::new_read(&memory);
68 /// let mut br = ByteReader::new(&mut mr);
69 /// let val = br.read_u16be()?; // read 16-bit big-endian integer, should be 42
70 /// let val = br.read_u16le()?; // read 16-bit little-endian integer, should be 42 as well
75 /// [`ByteIO`]: ./trait.ByteIO.html
76 /// [`MemoryReader`]: ./struct.MemoryReader.html
78 pub struct ByteReader<'a> {
82 /// Bytestream reader from memory.
83 pub struct MemoryReader<'a> {
88 /// Bytestream reader from file.
89 pub struct FileReader<'a> {
94 macro_rules! read_int {
95 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
97 let mut buf: $inttype = 0;
98 $s.read_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
104 macro_rules! peek_int {
105 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
107 let mut buf: $inttype = 0;
108 $s.peek_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
114 macro_rules! read_int_func {
115 ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
116 /// Reads integer of certain size and endianness.
117 pub fn $s(src: &[u8]) -> ByteIOResult<$inttype> {
118 if src.len() < $size { return Err(ByteIOError::ReadError); }
120 let mut buf: $inttype = 0;
121 ptr::copy_nonoverlapping(src.as_ptr(), &mut buf as *mut $inttype as *mut u8, std::mem::size_of::<$inttype>());
128 read_int_func!(read_u16be, u16, 2, to_be);
129 read_int_func!(read_u16le, u16, 2, to_le);
130 read_int_func!(read_u32be, u32, 4, to_be);
131 read_int_func!(read_u32le, u32, 4, to_le);
132 read_int_func!(read_u64be, u64, 8, to_be);
133 read_int_func!(read_u64le, u64, 8, to_le);
135 /// Reads 24-bit big-endian integer.
140 /// use nihav_core::io::byteio::read_u24be;
141 /// # use nihav_core::io::byteio::ByteIOResult;
143 /// # fn foo() -> ByteIOResult<()> {
144 /// let src: [u8; 3] = [ 1, 2, 3];
145 /// let value = read_u24be(&src)?; // should return 0x010203
149 pub fn read_u24be(src: &[u8]) -> ByteIOResult<u32> {
150 if src.len() < 3 { return Err(ByteIOError::ReadError); }
151 Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
153 /// Reads 24-bit little-endian integer.
154 pub fn read_u24le(src: &[u8]) -> ByteIOResult<u32> {
155 if src.len() < 3 { return Err(ByteIOError::ReadError); }
156 Ok((u32::from(src[2]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[0]))
158 /// Reads 32-bit big-endian floating point number.
159 pub fn read_f32be(src: &[u8]) -> ByteIOResult<f32> { Ok(f32::from_bits(read_u32be(src)?)) }
160 /// Reads 32-bit little-endian floating point number.
161 pub fn read_f32le(src: &[u8]) -> ByteIOResult<f32> { Ok(f32::from_bits(read_u32le(src)?)) }
162 /// Reads 64-bit big-endian floating point number.
163 pub fn read_f64be(src: &[u8]) -> ByteIOResult<f64> { Ok(f64::from_bits(read_u64be(src)?)) }
164 /// Reads 64-bit little-endian floating point number.
165 pub fn read_f64le(src: &[u8]) -> ByteIOResult<f64> { Ok(f64::from_bits(read_u64le(src)?)) }
167 macro_rules! write_int_func {
168 ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
169 /// Writes integer of certain size and endianness into byte buffer.
170 pub fn $s(dst: &mut [u8], val: $inttype) -> ByteIOResult<()> {
171 if dst.len() < $size { return Err(ByteIOError::WriteError); }
173 let val = val.$which();
174 ptr::copy_nonoverlapping(&val as *const $inttype as *const u8, dst.as_mut_ptr(), std::mem::size_of::<$inttype>());
181 write_int_func!(write_u16be, u16, 2, to_be);
182 write_int_func!(write_u16le, u16, 2, to_le);
183 write_int_func!(write_u32be, u32, 4, to_be);
184 write_int_func!(write_u32le, u32, 4, to_le);
185 write_int_func!(write_u64be, u64, 8, to_be);
186 write_int_func!(write_u64le, u64, 8, to_le);
188 /// Writes 24-bit big-endian integer to the provided buffer.
193 /// use nihav_core::io::byteio::write_u24be;
194 /// # use nihav_core::io::byteio::ByteIOResult;
196 /// # fn foo() -> ByteIOResult<()> {
197 /// let mut dst = [0u8; 3];
198 /// write_u24be(&mut dst, 0x010203)?;
199 /// // dst should contain [ 1, 2, 3] now
203 #[allow(clippy::identity_op)]
204 pub fn write_u24be(dst: &mut [u8], val: u32) -> ByteIOResult<()> {
205 if dst.len() < 3 { return Err(ByteIOError::WriteError); }
206 dst[0] = (val >> 16) as u8;
207 dst[1] = (val >> 8) as u8;
208 dst[2] = (val >> 0) as u8;
211 /// Writes 24-bit little-endian integer to the provided buffer.
212 #[allow(clippy::identity_op)]
213 pub fn write_u24le(dst: &mut [u8], val: u32) -> ByteIOResult<()> {
214 if dst.len() < 3 { return Err(ByteIOError::WriteError); }
215 dst[0] = (val >> 0) as u8;
216 dst[1] = (val >> 8) as u8;
217 dst[2] = (val >> 16) as u8;
220 /// Writes 32-bit big-endian floating point number to the provided buffer.
221 pub fn write_f32be(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32be(dst, val.to_bits()) }
222 /// Writes 32-bit little-endian floating point number to the provided buffer.
223 pub fn write_f32le(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32le(dst, val.to_bits()) }
224 /// Writes 64-bit big-endian floating point number to the provided buffer.
225 pub fn write_f64be(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64be(dst, val.to_bits()) }
226 /// Writes 64-bit little-endian floating point number to the provided buffer.
227 pub fn write_f64le(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64le(dst, val.to_bits()) }
229 impl<'a> ByteReader<'a> {
230 /// Constructs a new instance of bytestream reader.
235 /// use nihav_core::io::byteio::{MemoryReader,ByteReader};
236 /// # use nihav_core::io::byteio::ByteIOResult;
238 /// # fn foo() -> ByteIOResult<()> {
239 /// let memory: [u8; 4] = [ 0, 42, 42, 0 ];
240 /// let mut mr = MemoryReader::new_read(&memory);
241 /// let mut br = ByteReader::new(&mut mr);
245 pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io } }
247 /// Reads data into provided buffer. Partial read is treated as success.
248 pub fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
249 self.io.read_buf(buf)
252 /// Reads data into provided buffer. Partial read is treated as success.
253 pub fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
254 self.io.read_buf_some(buf)
257 /// Reads data into provided buffer but does not advance read position.
258 pub fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
259 self.io.peek_buf(buf)
262 /// Reads single byte from the stream.
263 pub fn read_byte(&mut self) -> ByteIOResult<u8> {
267 /// Returns the next byte value in the stream without advancing read position.
268 pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
272 /// Reads four-byte array from the stream.
273 pub fn read_tag(&mut self) -> ByteIOResult<[u8; 4]> {
274 let mut buf = [0u8; 4];
275 self.io.read_buf(&mut buf)?;
279 /// Reads four-byte array from the stream without advancing read position.
280 pub fn peek_tag(&mut self) -> ByteIOResult<[u8; 4]> {
281 let mut buf = [0u8; 4];
282 self.io.peek_buf(&mut buf)?;
286 /// Reads 16-bit big-endian integer from the stream.
287 pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
288 read_int!(self, u16, 2, to_be)
291 /// Reads 16-bit big-endian integer from the stream without advancing read position.
292 pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
293 peek_int!(self, u16, 2, to_be)
296 /// Reads 24-bit big-endian integer from the stream.
297 pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
298 let p16 = self.read_u16be()?;
299 let p8 = self.read_byte()?;
300 Ok((u32::from(p16) << 8) | u32::from(p8))
303 /// Reads 24-bit big-endian integer from the stream without advancing read position.
304 pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
305 let mut src: [u8; 3] = [0; 3];
306 self.peek_buf(&mut src)?;
307 Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
310 /// Reads 32-bit big-endian integer from the stream.
311 pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
312 read_int!(self, u32, 4, to_be)
315 /// Reads 32-bit big-endian integer from the stream without advancing read position.
316 pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
317 peek_int!(self, u32, 4, to_be)
320 /// Reads 64-bit big-endian integer from the stream.
321 pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
322 read_int!(self, u64, 8, to_be)
325 /// Reads 64-bit big-endian integer from the stream without advancing read position.
326 pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
327 peek_int!(self, u64, 8, to_be)
330 /// Reads 32-bit big-endian floating point number from the stream.
331 pub fn read_f32be(&mut self) -> ByteIOResult<f32> {
332 Ok(f32::from_bits(self.read_u32be()?))
335 /// Reads 32-bit big-endian floating point number from the stream without advancing read position.
336 pub fn peek_f32be(&mut self) -> ByteIOResult<f32> {
337 Ok(f32::from_bits(self.peek_u32be()?))
340 /// Reads 64-bit big-endian floating point number from the stream.
341 pub fn read_f64be(&mut self) -> ByteIOResult<f64> {
342 Ok(f64::from_bits(self.read_u64be()?))
345 /// Reads 64-bit big-endian floating point number from the stream without advancing read position.
346 pub fn peek_f64be(&mut self) -> ByteIOResult<f64> {
347 Ok(f64::from_bits(self.peek_u64be()?))
350 /// Reads 16-bit little-endian integer from the stream.
351 pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
352 read_int!(self, u16, 2, to_le)
355 /// Reads 16-bit little-endian integer from the stream without advancing read position.
356 pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
357 peek_int!(self, u16, 2, to_le)
360 /// Reads 24-bit little-endian integer from the stream.
361 pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
362 let p8 = self.read_byte()?;
363 let p16 = self.read_u16le()?;
364 Ok((u32::from(p16) << 8) | u32::from(p8))
367 /// Reads 24-bit little-endian integer from the stream without advancing read position.
368 pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
369 let mut src: [u8; 3] = [0; 3];
370 self.peek_buf(&mut src)?;
371 Ok(u32::from(src[0]) | (u32::from(src[1]) << 8) | (u32::from(src[2]) << 16))
374 /// Reads 32-bit little-endian integer from the stream.
375 pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
376 read_int!(self, u32, 4, to_le)
379 /// Reads 32-bit little-endian integer from the stream without advancing read position.
380 pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
381 peek_int!(self, u32, 4, to_le)
384 /// Reads 64-bit little-endian integer from the stream.
385 pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
386 read_int!(self, u64, 8, to_le)
389 /// Reads 64-bit little-endian integer from the stream without advancing read position.
390 pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
391 peek_int!(self, u64, 8, to_le)
394 /// Reads 32-bit little-endian floating point number from the stream.
395 pub fn read_f32le(&mut self) -> ByteIOResult<f32> {
396 Ok(f32::from_bits(self.read_u32le()?))
399 /// Reads 32-bit little-endian floating point number from the stream without advancing read position.
400 pub fn peek_f32le(&mut self) -> ByteIOResult<f32> {
401 Ok(f32::from_bits(self.peek_u32le()?))
404 /// Reads 64-bit little-endian floating point number from the stream.
405 pub fn read_f64le(&mut self) -> ByteIOResult<f64> {
406 Ok(f64::from_bits(self.read_u64le()?))
409 /// Reads 64-bit little-endian floating point number from the stream without advancing read position.
410 pub fn peek_f64le(&mut self) -> ByteIOResult<f64> {
411 Ok(f64::from_bits(self.peek_u64le()?))
414 /// Skips requested number of bytes.
415 pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
416 if self.io.is_seekable() {
417 self.io.seek(SeekFrom::Current(len as i64))?;
420 let mut buf : [u8; 16] = [0; 16];
422 while ssize > bref.len() {
423 self.io.read_buf(bref)?;
427 self.io.read_byte()?;
434 /// Returns current read position.
435 pub fn tell(&mut self) -> u64 {
439 /// Seeks to the provided position.
440 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
444 /// Tells whether this is end of stream.
445 pub fn is_eof(&self) -> bool {
449 /// Returns stream size or -1 if it is not known.
450 pub fn size(&mut self) -> i64 {
454 /// Reports number of bytes left in the stream.
455 pub fn left(&mut self) -> i64 {
456 let size = self.io.size();
457 if size == -1 { return -1; }
458 size - (self.io.tell() as i64)
462 impl<'a> MemoryReader<'a> {
463 /// Constructs a new instance of `MemoryReader`.
464 pub fn new_read(buf: &'a [u8]) -> Self {
465 MemoryReader { buf, pos: 0 }
468 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
469 if pos < 0 || (pos as usize) > self.buf.len() {
470 return Err(ByteIOError::WrongRange);
472 self.pos = pos as usize;
477 impl<'a> ByteIO for MemoryReader<'a> {
478 fn read_byte(&mut self) -> ByteIOResult<u8> {
479 if self.is_eof() { return Err(ByteIOError::EOF); }
480 let res = self.buf[self.pos];
485 fn peek_byte(&mut self) -> ByteIOResult<u8> {
486 if self.is_eof() { return Err(ByteIOError::EOF); }
487 Ok(self.buf[self.pos])
490 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
491 let copy_size = if self.buf.len() - self.pos < buf.len() { self.buf.len() - self.pos } else { buf.len() };
492 if copy_size == 0 { return Err(ByteIOError::EOF); }
493 let dst = &mut buf[0..copy_size];
494 dst.copy_from_slice(&self.buf[self.pos..][..copy_size]);
498 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
499 let read_size = self.peek_buf(buf)?;
500 if read_size < buf.len() { return Err(ByteIOError::EOF); }
501 self.pos += read_size;
505 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
506 let read_size = self.peek_buf(buf)?;
507 self.pos += read_size;
511 #[allow(unused_variables)]
512 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
513 Err(ByteIOError::NotImplemented)
516 fn tell(&mut self) -> u64 {
520 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
521 let cur_pos = self.pos as i64;
522 let cur_size = self.buf.len() as i64;
524 SeekFrom::Start(x) => self.real_seek(x as i64),
525 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
526 SeekFrom::End(x) => self.real_seek(cur_size + x),
530 fn is_eof(&self) -> bool {
531 self.pos >= self.buf.len()
534 fn is_seekable(&mut self) -> bool {
538 fn size(&mut self) -> i64 {
539 self.buf.len() as i64
543 impl<'a> FileReader<'a> {
545 /// Constructs a new instance of `FileReader`.
546 pub fn new_read(file: &'a mut File) -> Self {
547 FileReader { file, eof : false }
551 impl<'a> ByteIO for FileReader<'a> {
552 fn read_byte(&mut self) -> ByteIOResult<u8> {
553 let mut byte : [u8; 1] = [0];
554 let ret = self.file.read(&mut byte);
555 if ret.is_err() { return Err(ByteIOError::ReadError); }
556 let sz = ret.unwrap();
557 if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
561 fn peek_byte(&mut self) -> ByteIOResult<u8> {
562 let b = self.read_byte()?;
563 self.seek(SeekFrom::Current(-1))?;
567 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
568 let ret = self.file.read(buf);
569 if ret.is_err() { return Err(ByteIOError::ReadError); }
570 let sz = ret.unwrap();
571 if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
575 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
576 let ret = self.file.read(buf);
577 if ret.is_err() { return Err(ByteIOError::ReadError); }
578 let sz = ret.unwrap();
579 if sz < buf.len() { self.eof = true; }
583 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
584 let size = self.read_buf(buf)?;
585 self.seek(SeekFrom::Current(-(size as i64)))?;
589 #[allow(unused_variables)]
590 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
591 Err(ByteIOError::NotImplemented)
594 fn tell(&mut self) -> u64 {
595 self.file.seek(SeekFrom::Current(0)).unwrap()
598 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
599 let res = self.file.seek(pos);
602 Err(_) => Err(ByteIOError::SeekError),
606 fn is_eof(&self) -> bool {
610 fn is_seekable(&mut self) -> bool {
614 fn size(&mut self) -> i64 {
619 /// High-level bytestream writer.
621 /// User is supposed to create some writer implementing [`ByteIO`] trait e.g. [`MemoryWriter`] and use it to create `ByteWriter` which can be used for writing e.g. various integer types.
626 /// use nihav_core::io::byteio::{MemoryWriter,ByteWriter};
627 /// # use nihav_core::io::byteio::ByteIOResult;
629 /// # fn foo() -> ByteIOResult<()> {
630 /// let mut memory = [0u8; 4];
631 /// let mut mw = MemoryWriter::new_write(&mut memory);
632 /// let mut bw = ByteWriter::new(&mut mw);
633 /// let val = bw.write_u16be(42)?; // memory should be [ 0, 42, 0, 0 ]
634 /// let val = bw.write_u16le(42)?; // memory should be [ 0, 42, 42, 0 ]
639 /// [`ByteIO`]: ./trait.ByteIO.html
640 /// [`MemoryWriter`]: ./struct.MemoryWriter.html
642 pub struct ByteWriter<'a> {
646 /// Bytestream writer to memory.
647 pub struct MemoryWriter<'a> {
652 /// Bytestream writer to file.
653 pub struct FileWriter {
657 /// Bytestream writer to memory.
659 /// Unlike [`MemoryWriter`] which writes to an array of fixed size, `GrowableMemoryWriter` grows output size when output size exceeds capacity.
661 /// [`MemoryWriter`]: ./struct.MemoryWriter.html
662 pub struct GrowableMemoryWriter<'a> {
663 buf: &'a mut Vec<u8>,
667 impl<'a> ByteWriter<'a> {
668 /// Constructs a new instance of `ByteWriter`.
669 pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io } }
671 /// Writes byte array to the output.
672 pub fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
673 self.io.write_buf(buf)
676 /// Writes single byte to the output.
677 pub fn write_byte(&mut self, val: u8) -> ByteIOResult<()> {
678 let buf: [u8; 1] = [val];
679 self.io.write_buf(&buf)
682 /// Writes 16-bit big-endian integer to the output.
683 pub fn write_u16be(&mut self, val: u16) -> ByteIOResult<()> {
684 let buf: [u8; 2] = [((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
685 self.io.write_buf(&buf)
688 /// Writes 16-bit little-endian integer to the output.
689 pub fn write_u16le(&mut self, val: u16) -> ByteIOResult<()> {
690 let buf: [u8; 2] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8];
691 self.io.write_buf(&buf)
694 /// Writes 24-bit big-endian integer to the output.
695 pub fn write_u24be(&mut self, val: u32) -> ByteIOResult<()> {
696 let buf: [u8; 3] = [((val >> 16) & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
700 /// Writes 24-bit little-endian integer to the output.
701 pub fn write_u24le(&mut self, val: u32) -> ByteIOResult<()> {
702 let buf: [u8; 3] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, ((val >> 16) & 0xFF) as u8];
706 /// Writes 32-bit big-endian integer to the output.
707 pub fn write_u32be(&mut self, val: u32) -> ByteIOResult<()> {
708 self.write_u16be(((val >> 16) & 0xFFFF) as u16)?;
709 self.write_u16be((val & 0xFFFF) as u16)
712 /// Writes 32-bit little-endian integer to the output.
713 pub fn write_u32le(&mut self, val: u32) -> ByteIOResult<()> {
714 self.write_u16le((val & 0xFFFF) as u16)?;
715 self.write_u16le(((val >> 16) & 0xFFFF) as u16)
718 /// Writes 64-bit big-endian integer to the output.
719 pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
720 self.write_u32be((val >> 32) as u32)?;
721 self.write_u32be(val as u32)
724 /// Writes 64-bit little-endian integer to the output.
725 pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
726 self.write_u32le(val as u32)?;
727 self.write_u32le((val >> 32) as u32)
730 /// Writes 32-bit big-endian floating point number to the output.
731 pub fn write_f32be(&mut self, val: f32) -> ByteIOResult<()> {
732 self.write_u32be(val.to_bits())
735 /// Writes 32-bit little-endian floating point number to the output.
736 pub fn write_f32le(&mut self, val: f32) -> ByteIOResult<()> {
737 self.write_u32le(val.to_bits())
740 /// Writes 64-bit big-endian floating point number to the output.
741 pub fn write_f64be(&mut self, val: f64) -> ByteIOResult<()> {
742 self.write_u64be(val.to_bits())
745 /// Writes 64-bit little-endian floating point number to the output.
746 pub fn write_f64le(&mut self, val: f64) -> ByteIOResult<()> {
747 self.write_u64le(val.to_bits())
750 /// Reports the current write position.
751 pub fn tell(&mut self) -> u64 {
755 /// Seeks to the requested position.
756 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
760 /// Reports the amount of bytes the writer can still write (-1 if unknown).
761 pub fn size_left(&mut self) -> i64 {
762 let sz = self.io.size();
763 if sz == -1 { return -1; }
764 sz - (self.tell() as i64)
768 impl<'a> MemoryWriter<'a> {
770 /// Constructs a new instance of `MemoryWriter`.
771 pub fn new_write(buf: &'a mut [u8]) -> Self {
772 MemoryWriter { buf, pos: 0 }
775 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
776 if pos < 0 || (pos as usize) > self.buf.len() {
777 return Err(ByteIOError::WrongRange)
779 self.pos = pos as usize;
784 impl<'a> ByteIO for MemoryWriter<'a> {
785 #[allow(unused_variables)]
786 fn read_byte(&mut self) -> ByteIOResult<u8> {
787 Err(ByteIOError::NotImplemented)
790 #[allow(unused_variables)]
791 fn peek_byte(&mut self) -> ByteIOResult<u8> {
792 Err(ByteIOError::NotImplemented)
795 #[allow(unused_variables)]
796 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
797 Err(ByteIOError::NotImplemented)
800 #[allow(unused_variables)]
801 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
802 Err(ByteIOError::NotImplemented)
805 #[allow(unused_variables)]
806 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
807 Err(ByteIOError::NotImplemented)
810 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
811 if self.pos + buf.len() > self.buf.len() { return Err(ByteIOError::WriteError); }
812 self.buf[self.pos..][..buf.len()].copy_from_slice(buf);
813 self.pos += buf.len();
817 fn tell(&mut self) -> u64 {
821 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
822 let cur_pos = self.pos as i64;
823 let cur_size = self.buf.len() as i64;
825 SeekFrom::Start(x) => self.real_seek(x as i64),
826 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
827 SeekFrom::End(x) => self.real_seek(cur_size + x),
831 fn is_eof(&self) -> bool {
832 self.pos >= self.buf.len()
835 fn is_seekable(&mut self) -> bool {
839 fn size(&mut self) -> i64 {
840 self.buf.len() as i64
844 impl<'a> GrowableMemoryWriter<'a> {
846 /// Constructs a new instance of `GrowableMemoryWriter`.
847 pub fn new_write(buf: &'a mut Vec<u8>) -> Self {
848 GrowableMemoryWriter { buf, pos: 0 }
851 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
852 if pos < 0 || (pos as usize) > self.buf.len() {
853 return Err(ByteIOError::WrongRange)
855 self.pos = pos as usize;
860 impl<'a> ByteIO for GrowableMemoryWriter<'a> {
861 #[allow(unused_variables)]
862 fn read_byte(&mut self) -> ByteIOResult<u8> {
863 Err(ByteIOError::NotImplemented)
866 #[allow(unused_variables)]
867 fn peek_byte(&mut self) -> ByteIOResult<u8> {
868 Err(ByteIOError::NotImplemented)
871 #[allow(unused_variables)]
872 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
873 Err(ByteIOError::NotImplemented)
876 #[allow(unused_variables)]
877 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
878 Err(ByteIOError::NotImplemented)
881 #[allow(unused_variables)]
882 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
883 Err(ByteIOError::NotImplemented)
886 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
887 if self.pos + buf.len() > self.buf.len() {
888 self.buf.resize(self.pos + buf.len(), 0);
890 self.buf[self.pos..][..buf.len()].copy_from_slice(buf);
891 self.pos += buf.len();
895 fn tell(&mut self) -> u64 {
899 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
900 let cur_pos = self.pos as i64;
901 let cur_size = self.buf.len() as i64;
903 SeekFrom::Start(x) => self.real_seek(x as i64),
904 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
905 SeekFrom::End(x) => self.real_seek(cur_size + x),
909 fn is_eof(&self) -> bool {
910 self.pos >= self.buf.len()
913 fn is_seekable(&mut self) -> bool {
917 fn size(&mut self) -> i64 {
918 self.buf.len() as i64
923 /// Constructs a new instance of `FileWriter`.
924 pub fn new_write(file: File) -> Self {
929 impl ByteIO for FileWriter {
930 #[allow(unused_variables)]
931 fn read_byte(&mut self) -> ByteIOResult<u8> {
932 Err(ByteIOError::NotImplemented)
935 #[allow(unused_variables)]
936 fn peek_byte(&mut self) -> ByteIOResult<u8> {
937 Err(ByteIOError::NotImplemented)
940 #[allow(unused_variables)]
941 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
942 Err(ByteIOError::NotImplemented)
945 #[allow(unused_variables)]
946 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
947 Err(ByteIOError::NotImplemented)
950 #[allow(unused_variables)]
951 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
952 Err(ByteIOError::NotImplemented)
955 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
956 match self.file.write_all(buf) {
958 Err(_) => Err(ByteIOError::WriteError),
962 fn tell(&mut self) -> u64 {
963 self.file.seek(SeekFrom::Current(0)).unwrap()
966 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
967 let res = self.file.seek(pos);
970 Err(_) => Err(ByteIOError::SeekError),
974 fn is_eof(&self) -> bool {
978 fn is_seekable(&mut self) -> bool {
982 fn size(&mut self) -> i64 {
994 //const DATA : &'static [u8] = include_bytes!("../../assets/file");
995 let buf: [u8; 64] = [1; 64];
996 let mut mr = MemoryReader::new_read(&buf);
997 let mut reader = ByteReader::new(&mut mr);
998 assert_eq!(reader.read_byte().unwrap(), 0x01u8);
999 assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
1000 assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
1001 assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
1002 assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
1003 let mut file = File::open("assets/Misc/MaoMacha.asx").unwrap();
1004 let mut fr = FileReader::new_read(&mut file);
1005 let mut br2 = ByteReader::new(&mut fr);
1006 assert_eq!(br2.read_byte().unwrap(), 0x30);
1007 assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
1008 assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
1009 assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
1010 assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);
1014 let mut buf: [u8; 64] = [0; 64];
1016 let mut mw = MemoryWriter::new_write(&mut buf);
1017 let mut bw = ByteWriter::new(&mut mw);
1018 bw.write_byte(0x00).unwrap();
1019 bw.write_u16be(0x0102).unwrap();
1020 bw.write_u24be(0x030405).unwrap();
1021 bw.write_u32be(0x06070809).unwrap();
1022 bw.write_u64be(0x0A0B0C0D0E0F1011).unwrap();
1023 bw.write_byte(0x00).unwrap();
1024 bw.write_u16le(0x0201).unwrap();
1025 bw.write_u24le(0x050403).unwrap();
1026 bw.write_u32le(0x09080706).unwrap();
1027 bw.write_u64le(0x11100F0E0D0C0B0A).unwrap();
1028 assert_eq!(bw.size_left(), 28);
1031 assert_eq!(buf[(i + 0x00) as usize], i);
1032 assert_eq!(buf[(i + 0x12) as usize], i);