1 //! Bytestream reading/writing functionality.
2 pub use std::io::SeekFrom;
3 use std::io::prelude::*;
6 /// A list specifying general bytestream reading and writing errors.
11 /// Wrong seek position was provided.
13 /// Tried to call read() on bytestream writer or write() on bytestream reader.
15 /// Functionality is not implemented.
25 /// A specialised `Result` type for bytestream operations.
26 pub type ByteIOResult<T> = Result<T, ByteIOError>;
28 /// Common trait for bytestream operations.
30 /// Reads data into provided buffer. Fails if it cannot fill whole buffer.
31 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
32 /// Reads data into provided buffer. Partial read is treated as success.
33 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
34 /// Reads data into provided buffer but does not advance read position.
35 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
36 /// Reads single byte from the stream.
37 fn read_byte(&mut self) -> ByteIOResult<u8>;
38 /// Returns the next byte value in the stream without advancing read position.
39 fn peek_byte(&mut self) -> ByteIOResult<u8>;
40 /// Writes buffer to the stream.
41 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()>;
42 /// Returns current read or write position.
43 fn tell(&mut self) -> u64;
44 /// Seeks to the provided position.
45 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
46 /// Tells whether this is end of stream.
47 fn is_eof(&self) -> bool;
48 /// Reports whether stream is seekable or not.
49 fn is_seekable(&mut self) -> bool;
50 /// Returns stream size or -1 if it is not known.
51 fn size(&mut self) -> i64;
54 /// High-level bytestream reader.
56 /// 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.
61 /// use nihav_core::io::byteio::{MemoryReader,ByteReader};
62 /// # use nihav_core::io::byteio::ByteIOResult;
64 /// # fn foo() -> ByteIOResult<()> {
65 /// let memory: [u8; 4] = [ 0, 42, 42, 0 ];
66 /// let mut mr = MemoryReader::new_read(&memory);
67 /// let mut br = ByteReader::new(&mut mr);
68 /// let val = br.read_u16be()?; // read 16-bit big-endian integer, should be 42
69 /// let val = br.read_u16le()?; // read 16-bit little-endian integer, should be 42 as well
74 /// [`ByteIO`]: ./trait.ByteIO.html
75 /// [`MemoryReader`]: ./struct.MemoryReader.html
77 pub struct ByteReader<'a> {
81 /// Bytestream reader from memory.
82 pub struct MemoryReader<'a> {
87 /// Bytestream reader from anything implementing `std::io::Read` and `std::io::Seek`.
88 pub struct FileReader<T: Read+Seek> {
93 macro_rules! read_int {
94 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
96 let mut buf: $inttype = 0;
97 $s.read_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
103 macro_rules! peek_int {
104 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
106 let mut buf: $inttype = 0;
107 $s.peek_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
113 macro_rules! read_int_func {
114 ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
115 /// Reads integer of certain size and endianness.
116 pub fn $s(src: &[u8]) -> ByteIOResult<$inttype> {
117 if src.len() < $size { return Err(ByteIOError::ReadError); }
119 let mut buf: $inttype = 0;
120 ptr::copy_nonoverlapping(src.as_ptr(), &mut buf as *mut $inttype as *mut u8, std::mem::size_of::<$inttype>());
127 read_int_func!(read_u16be, u16, 2, to_be);
128 read_int_func!(read_u16le, u16, 2, to_le);
129 read_int_func!(read_u32be, u32, 4, to_be);
130 read_int_func!(read_u32le, u32, 4, to_le);
131 read_int_func!(read_u64be, u64, 8, to_be);
132 read_int_func!(read_u64le, u64, 8, to_le);
134 /// Reads 24-bit big-endian integer.
139 /// use nihav_core::io::byteio::read_u24be;
140 /// # use nihav_core::io::byteio::ByteIOResult;
142 /// # fn foo() -> ByteIOResult<()> {
143 /// let src: [u8; 3] = [ 1, 2, 3];
144 /// let value = read_u24be(&src)?; // should return 0x010203
148 pub fn read_u24be(src: &[u8]) -> ByteIOResult<u32> {
149 if src.len() < 3 { return Err(ByteIOError::ReadError); }
150 Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
152 /// Reads 24-bit little-endian integer.
153 pub fn read_u24le(src: &[u8]) -> ByteIOResult<u32> {
154 if src.len() < 3 { return Err(ByteIOError::ReadError); }
155 Ok((u32::from(src[2]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[0]))
157 /// Reads 32-bit big-endian floating point number.
158 pub fn read_f32be(src: &[u8]) -> ByteIOResult<f32> { Ok(f32::from_bits(read_u32be(src)?)) }
159 /// Reads 32-bit little-endian floating point number.
160 pub fn read_f32le(src: &[u8]) -> ByteIOResult<f32> { Ok(f32::from_bits(read_u32le(src)?)) }
161 /// Reads 64-bit big-endian floating point number.
162 pub fn read_f64be(src: &[u8]) -> ByteIOResult<f64> { Ok(f64::from_bits(read_u64be(src)?)) }
163 /// Reads 64-bit little-endian floating point number.
164 pub fn read_f64le(src: &[u8]) -> ByteIOResult<f64> { Ok(f64::from_bits(read_u64le(src)?)) }
166 macro_rules! write_int_func {
167 ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
168 /// Writes integer of certain size and endianness into byte buffer.
169 pub fn $s(dst: &mut [u8], val: $inttype) -> ByteIOResult<()> {
170 if dst.len() < $size { return Err(ByteIOError::WriteError); }
172 let val = val.$which();
173 ptr::copy_nonoverlapping(&val as *const $inttype as *const u8, dst.as_mut_ptr(), std::mem::size_of::<$inttype>());
180 write_int_func!(write_u16be, u16, 2, to_be);
181 write_int_func!(write_u16le, u16, 2, to_le);
182 write_int_func!(write_u32be, u32, 4, to_be);
183 write_int_func!(write_u32le, u32, 4, to_le);
184 write_int_func!(write_u64be, u64, 8, to_be);
185 write_int_func!(write_u64le, u64, 8, to_le);
187 /// Writes 24-bit big-endian integer to the provided buffer.
192 /// use nihav_core::io::byteio::write_u24be;
193 /// # use nihav_core::io::byteio::ByteIOResult;
195 /// # fn foo() -> ByteIOResult<()> {
196 /// let mut dst = [0u8; 3];
197 /// write_u24be(&mut dst, 0x010203)?;
198 /// // dst should contain [ 1, 2, 3] now
202 #[allow(clippy::identity_op)]
203 pub fn write_u24be(dst: &mut [u8], val: u32) -> ByteIOResult<()> {
204 if dst.len() < 3 { return Err(ByteIOError::WriteError); }
205 dst[0] = (val >> 16) as u8;
206 dst[1] = (val >> 8) as u8;
207 dst[2] = (val >> 0) as u8;
210 /// Writes 24-bit little-endian integer to the provided buffer.
211 #[allow(clippy::identity_op)]
212 pub fn write_u24le(dst: &mut [u8], val: u32) -> ByteIOResult<()> {
213 if dst.len() < 3 { return Err(ByteIOError::WriteError); }
214 dst[0] = (val >> 0) as u8;
215 dst[1] = (val >> 8) as u8;
216 dst[2] = (val >> 16) as u8;
219 /// Writes 32-bit big-endian floating point number to the provided buffer.
220 pub fn write_f32be(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32be(dst, val.to_bits()) }
221 /// Writes 32-bit little-endian floating point number to the provided buffer.
222 pub fn write_f32le(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32le(dst, val.to_bits()) }
223 /// Writes 64-bit big-endian floating point number to the provided buffer.
224 pub fn write_f64be(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64be(dst, val.to_bits()) }
225 /// Writes 64-bit little-endian floating point number to the provided buffer.
226 pub fn write_f64le(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64le(dst, val.to_bits()) }
228 impl<'a> ByteReader<'a> {
229 /// Constructs a new instance of bytestream reader.
234 /// use nihav_core::io::byteio::{MemoryReader,ByteReader};
235 /// # use nihav_core::io::byteio::ByteIOResult;
237 /// # fn foo() -> ByteIOResult<()> {
238 /// let memory: [u8; 4] = [ 0, 42, 42, 0 ];
239 /// let mut mr = MemoryReader::new_read(&memory);
240 /// let mut br = ByteReader::new(&mut mr);
244 pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io } }
246 /// Reads data into provided buffer. Partial read is treated as success.
247 pub fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
248 self.io.read_buf(buf)
251 /// Reads data into provided buffer. Partial read is treated as success.
252 pub fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
253 self.io.read_buf_some(buf)
256 /// Reads data into provided buffer but does not advance read position.
257 pub fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
258 self.io.peek_buf(buf)
261 /// Reads single byte from the stream.
262 pub fn read_byte(&mut self) -> ByteIOResult<u8> {
266 /// Returns the next byte value in the stream without advancing read position.
267 pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
271 /// Reads four-byte array from the stream.
272 pub fn read_tag(&mut self) -> ByteIOResult<[u8; 4]> {
273 let mut buf = [0u8; 4];
274 self.io.read_buf(&mut buf)?;
278 /// Reads four-byte array from the stream without advancing read position.
279 pub fn peek_tag(&mut self) -> ByteIOResult<[u8; 4]> {
280 let mut buf = [0u8; 4];
281 self.io.peek_buf(&mut buf)?;
285 /// Reads 16-bit big-endian integer from the stream.
286 pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
287 read_int!(self, u16, 2, to_be)
290 /// Reads 16-bit big-endian integer from the stream without advancing read position.
291 pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
292 peek_int!(self, u16, 2, to_be)
295 /// Reads 24-bit big-endian integer from the stream.
296 pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
297 let p16 = self.read_u16be()?;
298 let p8 = self.read_byte()?;
299 Ok((u32::from(p16) << 8) | u32::from(p8))
302 /// Reads 24-bit big-endian integer from the stream without advancing read position.
303 pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
304 let mut src: [u8; 3] = [0; 3];
305 self.peek_buf(&mut src)?;
306 Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
309 /// Reads 32-bit big-endian integer from the stream.
310 pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
311 read_int!(self, u32, 4, to_be)
314 /// Reads 32-bit big-endian integer from the stream without advancing read position.
315 pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
316 peek_int!(self, u32, 4, to_be)
319 /// Reads 64-bit big-endian integer from the stream.
320 pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
321 read_int!(self, u64, 8, to_be)
324 /// Reads 64-bit big-endian integer from the stream without advancing read position.
325 pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
326 peek_int!(self, u64, 8, to_be)
329 /// Reads 32-bit big-endian floating point number from the stream.
330 pub fn read_f32be(&mut self) -> ByteIOResult<f32> {
331 Ok(f32::from_bits(self.read_u32be()?))
334 /// Reads 32-bit big-endian floating point number from the stream without advancing read position.
335 pub fn peek_f32be(&mut self) -> ByteIOResult<f32> {
336 Ok(f32::from_bits(self.peek_u32be()?))
339 /// Reads 64-bit big-endian floating point number from the stream.
340 pub fn read_f64be(&mut self) -> ByteIOResult<f64> {
341 Ok(f64::from_bits(self.read_u64be()?))
344 /// Reads 64-bit big-endian floating point number from the stream without advancing read position.
345 pub fn peek_f64be(&mut self) -> ByteIOResult<f64> {
346 Ok(f64::from_bits(self.peek_u64be()?))
349 /// Reads 16-bit little-endian integer from the stream.
350 pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
351 read_int!(self, u16, 2, to_le)
354 /// Reads 16-bit little-endian integer from the stream without advancing read position.
355 pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
356 peek_int!(self, u16, 2, to_le)
359 /// Reads 24-bit little-endian integer from the stream.
360 pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
361 let p8 = self.read_byte()?;
362 let p16 = self.read_u16le()?;
363 Ok((u32::from(p16) << 8) | u32::from(p8))
366 /// Reads 24-bit little-endian integer from the stream without advancing read position.
367 pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
368 let mut src: [u8; 3] = [0; 3];
369 self.peek_buf(&mut src)?;
370 Ok(u32::from(src[0]) | (u32::from(src[1]) << 8) | (u32::from(src[2]) << 16))
373 /// Reads 32-bit little-endian integer from the stream.
374 pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
375 read_int!(self, u32, 4, to_le)
378 /// Reads 32-bit little-endian integer from the stream without advancing read position.
379 pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
380 peek_int!(self, u32, 4, to_le)
383 /// Reads 64-bit little-endian integer from the stream.
384 pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
385 read_int!(self, u64, 8, to_le)
388 /// Reads 64-bit little-endian integer from the stream without advancing read position.
389 pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
390 peek_int!(self, u64, 8, to_le)
393 /// Reads 32-bit little-endian floating point number from the stream.
394 pub fn read_f32le(&mut self) -> ByteIOResult<f32> {
395 Ok(f32::from_bits(self.read_u32le()?))
398 /// Reads 32-bit little-endian floating point number from the stream without advancing read position.
399 pub fn peek_f32le(&mut self) -> ByteIOResult<f32> {
400 Ok(f32::from_bits(self.peek_u32le()?))
403 /// Reads 64-bit little-endian floating point number from the stream.
404 pub fn read_f64le(&mut self) -> ByteIOResult<f64> {
405 Ok(f64::from_bits(self.read_u64le()?))
408 /// Reads 64-bit little-endian floating point number from the stream without advancing read position.
409 pub fn peek_f64le(&mut self) -> ByteIOResult<f64> {
410 Ok(f64::from_bits(self.peek_u64le()?))
413 /// Skips requested number of bytes.
414 pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
415 if self.io.is_seekable() {
416 self.io.seek(SeekFrom::Current(len as i64))?;
419 let mut buf : [u8; 16] = [0; 16];
421 while ssize > bref.len() {
422 self.io.read_buf(bref)?;
426 self.io.read_byte()?;
433 /// Returns current read position.
434 pub fn tell(&mut self) -> u64 {
438 /// Seeks to the provided position.
439 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
443 /// Tells whether this is end of stream.
444 pub fn is_eof(&self) -> bool {
448 /// Returns stream size or -1 if it is not known.
449 pub fn size(&mut self) -> i64 {
453 /// Reports number of bytes left in the stream.
454 pub fn left(&mut self) -> i64 {
455 let size = self.io.size();
456 if size == -1 { return -1; }
457 size - (self.io.tell() as i64)
461 impl<'a> MemoryReader<'a> {
462 /// Constructs a new instance of `MemoryReader`.
463 pub fn new_read(buf: &'a [u8]) -> Self {
464 MemoryReader { buf, pos: 0 }
467 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
468 if pos < 0 || (pos as usize) > self.buf.len() {
469 return Err(ByteIOError::WrongRange);
471 self.pos = pos as usize;
476 impl<'a> ByteIO for MemoryReader<'a> {
477 fn read_byte(&mut self) -> ByteIOResult<u8> {
478 if self.is_eof() { return Err(ByteIOError::EOF); }
479 let res = self.buf[self.pos];
484 fn peek_byte(&mut self) -> ByteIOResult<u8> {
485 if self.is_eof() { return Err(ByteIOError::EOF); }
486 Ok(self.buf[self.pos])
489 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
490 let copy_size = if self.buf.len() - self.pos < buf.len() { self.buf.len() - self.pos } else { buf.len() };
491 if copy_size == 0 { return Err(ByteIOError::EOF); }
492 let dst = &mut buf[0..copy_size];
493 dst.copy_from_slice(&self.buf[self.pos..][..copy_size]);
497 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
498 let read_size = self.peek_buf(buf)?;
499 if read_size < buf.len() { return Err(ByteIOError::EOF); }
500 self.pos += read_size;
504 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
505 let read_size = self.peek_buf(buf)?;
506 self.pos += read_size;
510 #[allow(unused_variables)]
511 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
512 Err(ByteIOError::NotImplemented)
515 fn tell(&mut self) -> u64 {
519 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
520 let cur_pos = self.pos as i64;
521 let cur_size = self.buf.len() as i64;
523 SeekFrom::Start(x) => self.real_seek(x as i64),
524 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
525 SeekFrom::End(x) => self.real_seek(cur_size + x),
529 fn is_eof(&self) -> bool {
530 self.pos >= self.buf.len()
533 fn is_seekable(&mut self) -> bool {
537 fn size(&mut self) -> i64 {
538 self.buf.len() as i64
542 impl<T: Read+Seek> FileReader<T> {
544 /// Constructs a new instance of `FileReader`.
545 pub fn new_read(file: T) -> Self {
546 FileReader { file: Box::new(file), eof : false }
550 impl<T: Read+Seek> ByteIO for FileReader<T> {
551 fn read_byte(&mut self) -> ByteIOResult<u8> {
552 let mut byte : [u8; 1] = [0];
553 let ret = self.file.read(&mut byte);
554 if ret.is_err() { return Err(ByteIOError::ReadError); }
555 let sz = ret.unwrap();
556 if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
560 fn peek_byte(&mut self) -> ByteIOResult<u8> {
561 let b = self.read_byte()?;
562 self.seek(SeekFrom::Current(-1))?;
566 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
567 let ret = self.file.read(buf);
568 if ret.is_err() { return Err(ByteIOError::ReadError); }
569 let sz = ret.unwrap();
570 if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
574 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
575 let ret = self.file.read(buf);
576 if ret.is_err() { return Err(ByteIOError::ReadError); }
577 let sz = ret.unwrap();
578 if sz < buf.len() { self.eof = true; }
582 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
583 let size = self.read_buf(buf)?;
584 self.seek(SeekFrom::Current(-(size as i64)))?;
588 #[allow(unused_variables)]
589 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
590 Err(ByteIOError::NotImplemented)
593 fn tell(&mut self) -> u64 {
594 self.file.seek(SeekFrom::Current(0)).unwrap()
597 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
598 let res = self.file.seek(pos);
601 Err(_) => Err(ByteIOError::SeekError),
605 fn is_eof(&self) -> bool {
609 fn is_seekable(&mut self) -> bool {
613 fn size(&mut self) -> i64 {
618 /// High-level bytestream writer.
620 /// 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.
625 /// use nihav_core::io::byteio::{MemoryWriter,ByteWriter};
626 /// # use nihav_core::io::byteio::ByteIOResult;
628 /// # fn foo() -> ByteIOResult<()> {
629 /// let mut memory = [0u8; 4];
630 /// let mut mw = MemoryWriter::new_write(&mut memory);
631 /// let mut bw = ByteWriter::new(&mut mw);
632 /// let val = bw.write_u16be(42)?; // memory should be [ 0, 42, 0, 0 ]
633 /// let val = bw.write_u16le(42)?; // memory should be [ 0, 42, 42, 0 ]
638 /// [`ByteIO`]: ./trait.ByteIO.html
639 /// [`MemoryWriter`]: ./struct.MemoryWriter.html
641 pub struct ByteWriter<'a> {
645 /// Bytestream writer to memory.
646 pub struct MemoryWriter<'a> {
651 /// Bytestream writer to anything implementing `std::io::Write` and `std::io::Seek`.
652 pub struct FileWriter<T: Write+Seek> {
656 /// Bytestream writer to memory.
658 /// Unlike [`MemoryWriter`] which writes to an array of fixed size, `GrowableMemoryWriter` grows output size when output size exceeds capacity.
660 /// [`MemoryWriter`]: ./struct.MemoryWriter.html
661 pub struct GrowableMemoryWriter<'a> {
662 buf: &'a mut Vec<u8>,
666 impl<'a> ByteWriter<'a> {
667 /// Constructs a new instance of `ByteWriter`.
668 pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io } }
670 /// Writes byte array to the output.
671 pub fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
672 self.io.write_buf(buf)
675 /// Writes single byte to the output.
676 pub fn write_byte(&mut self, val: u8) -> ByteIOResult<()> {
677 let buf: [u8; 1] = [val];
678 self.io.write_buf(&buf)
681 /// Writes 16-bit big-endian integer to the output.
682 pub fn write_u16be(&mut self, val: u16) -> ByteIOResult<()> {
683 let buf: [u8; 2] = [((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
684 self.io.write_buf(&buf)
687 /// Writes 16-bit little-endian integer to the output.
688 pub fn write_u16le(&mut self, val: u16) -> ByteIOResult<()> {
689 let buf: [u8; 2] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8];
690 self.io.write_buf(&buf)
693 /// Writes 24-bit big-endian integer to the output.
694 pub fn write_u24be(&mut self, val: u32) -> ByteIOResult<()> {
695 let buf: [u8; 3] = [((val >> 16) & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
699 /// Writes 24-bit little-endian integer to the output.
700 pub fn write_u24le(&mut self, val: u32) -> ByteIOResult<()> {
701 let buf: [u8; 3] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, ((val >> 16) & 0xFF) as u8];
705 /// Writes 32-bit big-endian integer to the output.
706 pub fn write_u32be(&mut self, val: u32) -> ByteIOResult<()> {
707 self.write_u16be(((val >> 16) & 0xFFFF) as u16)?;
708 self.write_u16be((val & 0xFFFF) as u16)
711 /// Writes 32-bit little-endian integer to the output.
712 pub fn write_u32le(&mut self, val: u32) -> ByteIOResult<()> {
713 self.write_u16le((val & 0xFFFF) as u16)?;
714 self.write_u16le(((val >> 16) & 0xFFFF) as u16)
717 /// Writes 64-bit big-endian integer to the output.
718 pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
719 self.write_u32be((val >> 32) as u32)?;
720 self.write_u32be(val as u32)
723 /// Writes 64-bit little-endian integer to the output.
724 pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
725 self.write_u32le(val as u32)?;
726 self.write_u32le((val >> 32) as u32)
729 /// Writes 32-bit big-endian floating point number to the output.
730 pub fn write_f32be(&mut self, val: f32) -> ByteIOResult<()> {
731 self.write_u32be(val.to_bits())
734 /// Writes 32-bit little-endian floating point number to the output.
735 pub fn write_f32le(&mut self, val: f32) -> ByteIOResult<()> {
736 self.write_u32le(val.to_bits())
739 /// Writes 64-bit big-endian floating point number to the output.
740 pub fn write_f64be(&mut self, val: f64) -> ByteIOResult<()> {
741 self.write_u64be(val.to_bits())
744 /// Writes 64-bit little-endian floating point number to the output.
745 pub fn write_f64le(&mut self, val: f64) -> ByteIOResult<()> {
746 self.write_u64le(val.to_bits())
749 /// Reports the current write position.
750 pub fn tell(&mut self) -> u64 {
754 /// Seeks to the requested position.
755 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
759 /// Reports the amount of bytes the writer can still write (-1 if unknown).
760 pub fn size_left(&mut self) -> i64 {
761 let sz = self.io.size();
762 if sz == -1 { return -1; }
763 sz - (self.tell() as i64)
767 impl<'a> MemoryWriter<'a> {
769 /// Constructs a new instance of `MemoryWriter`.
770 pub fn new_write(buf: &'a mut [u8]) -> Self {
771 MemoryWriter { buf, pos: 0 }
774 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
775 if pos < 0 || (pos as usize) > self.buf.len() {
776 return Err(ByteIOError::WrongRange)
778 self.pos = pos as usize;
783 impl<'a> ByteIO for MemoryWriter<'a> {
784 #[allow(unused_variables)]
785 fn read_byte(&mut self) -> ByteIOResult<u8> {
786 Err(ByteIOError::NotImplemented)
789 #[allow(unused_variables)]
790 fn peek_byte(&mut self) -> ByteIOResult<u8> {
791 Err(ByteIOError::NotImplemented)
794 #[allow(unused_variables)]
795 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
796 Err(ByteIOError::NotImplemented)
799 #[allow(unused_variables)]
800 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
801 Err(ByteIOError::NotImplemented)
804 #[allow(unused_variables)]
805 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
806 Err(ByteIOError::NotImplemented)
809 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
810 if self.pos + buf.len() > self.buf.len() { return Err(ByteIOError::WriteError); }
811 self.buf[self.pos..][..buf.len()].copy_from_slice(buf);
812 self.pos += buf.len();
816 fn tell(&mut self) -> u64 {
820 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
821 let cur_pos = self.pos as i64;
822 let cur_size = self.buf.len() as i64;
824 SeekFrom::Start(x) => self.real_seek(x as i64),
825 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
826 SeekFrom::End(x) => self.real_seek(cur_size + x),
830 fn is_eof(&self) -> bool {
831 self.pos >= self.buf.len()
834 fn is_seekable(&mut self) -> bool {
838 fn size(&mut self) -> i64 {
839 self.buf.len() as i64
843 impl<'a> GrowableMemoryWriter<'a> {
845 /// Constructs a new instance of `GrowableMemoryWriter`.
846 pub fn new_write(buf: &'a mut Vec<u8>) -> Self {
847 GrowableMemoryWriter { buf, pos: 0 }
850 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
851 if pos < 0 || (pos as usize) > self.buf.len() {
852 return Err(ByteIOError::WrongRange)
854 self.pos = pos as usize;
859 impl<'a> ByteIO for GrowableMemoryWriter<'a> {
860 #[allow(unused_variables)]
861 fn read_byte(&mut self) -> ByteIOResult<u8> {
862 Err(ByteIOError::NotImplemented)
865 #[allow(unused_variables)]
866 fn peek_byte(&mut self) -> ByteIOResult<u8> {
867 Err(ByteIOError::NotImplemented)
870 #[allow(unused_variables)]
871 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
872 Err(ByteIOError::NotImplemented)
875 #[allow(unused_variables)]
876 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
877 Err(ByteIOError::NotImplemented)
880 #[allow(unused_variables)]
881 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
882 Err(ByteIOError::NotImplemented)
885 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
886 if self.pos + buf.len() > self.buf.len() {
887 self.buf.resize(self.pos + buf.len(), 0);
889 self.buf[self.pos..][..buf.len()].copy_from_slice(buf);
890 self.pos += buf.len();
894 fn tell(&mut self) -> u64 {
898 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
899 let cur_pos = self.pos as i64;
900 let cur_size = self.buf.len() as i64;
902 SeekFrom::Start(x) => self.real_seek(x as i64),
903 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
904 SeekFrom::End(x) => self.real_seek(cur_size + x),
908 fn is_eof(&self) -> bool {
909 self.pos >= self.buf.len()
912 fn is_seekable(&mut self) -> bool {
916 fn size(&mut self) -> i64 {
917 self.buf.len() as i64
921 impl<T: Write+Seek> FileWriter<T> {
922 /// Constructs a new instance of `FileWriter`.
923 pub fn new_write(file: T) -> Self {
924 FileWriter { file: Box::new(file) }
928 impl<T: Write+Seek> ByteIO for FileWriter<T> {
929 #[allow(unused_variables)]
930 fn read_byte(&mut self) -> ByteIOResult<u8> {
931 Err(ByteIOError::NotImplemented)
934 #[allow(unused_variables)]
935 fn peek_byte(&mut self) -> ByteIOResult<u8> {
936 Err(ByteIOError::NotImplemented)
939 #[allow(unused_variables)]
940 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
941 Err(ByteIOError::NotImplemented)
944 #[allow(unused_variables)]
945 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
946 Err(ByteIOError::NotImplemented)
949 #[allow(unused_variables)]
950 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
951 Err(ByteIOError::NotImplemented)
954 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
955 match self.file.write_all(buf) {
957 Err(_) => Err(ByteIOError::WriteError),
961 fn tell(&mut self) -> u64 {
962 self.file.seek(SeekFrom::Current(0)).unwrap()
965 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
966 let res = self.file.seek(pos);
969 Err(_) => Err(ByteIOError::SeekError),
973 fn is_eof(&self) -> bool {
977 fn is_seekable(&mut self) -> bool {
981 fn size(&mut self) -> i64 {
993 //const DATA : &'static [u8] = include_bytes!("../../assets/file");
994 let buf: [u8; 64] = [1; 64];
995 let mut mr = MemoryReader::new_read(&buf);
996 let mut reader = ByteReader::new(&mut mr);
997 assert_eq!(reader.read_byte().unwrap(), 0x01u8);
998 assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
999 assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
1000 assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
1001 assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
1002 let mut file = File::open("assets/Misc/MaoMacha.asx").unwrap();
1003 let mut fr = FileReader::new_read(&mut file);
1004 let mut br2 = ByteReader::new(&mut fr);
1005 assert_eq!(br2.read_byte().unwrap(), 0x30);
1006 assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
1007 assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
1008 assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
1009 assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);
1013 let mut buf: [u8; 64] = [0; 64];
1015 let mut mw = MemoryWriter::new_write(&mut buf);
1016 let mut bw = ByteWriter::new(&mut mw);
1017 bw.write_byte(0x00).unwrap();
1018 bw.write_u16be(0x0102).unwrap();
1019 bw.write_u24be(0x030405).unwrap();
1020 bw.write_u32be(0x06070809).unwrap();
1021 bw.write_u64be(0x0A0B0C0D0E0F1011).unwrap();
1022 bw.write_byte(0x00).unwrap();
1023 bw.write_u16le(0x0201).unwrap();
1024 bw.write_u24le(0x050403).unwrap();
1025 bw.write_u32le(0x09080706).unwrap();
1026 bw.write_u64le(0x11100F0E0D0C0B0A).unwrap();
1027 assert_eq!(bw.size_left(), 28);
1030 assert_eq!(buf[(i + 0x00) as usize], i);
1031 assert_eq!(buf[(i + 0x12) as usize], i);