nihav-core/src/io/byteio.rs

   1 //! Bytestream reading/writing functionality.
   2 pub use std::io::SeekFrom;
   3 use std::fs::File;
   4 use std::io::prelude::*;
   5 use std::ptr;
   6
   7 /// A list specifying general bytestream reading and writing errors.
   8 #[derive(Debug)]
   9 pub enum ByteIOError {
  10     /// End of stream.
  11     EOF,
  12     /// Wrong seek position was provided.
  13     WrongRange,
  14     /// Tried to call read() on bytestream writer or write() on bytestream reader.
  15     WrongIOMode,
  16     /// Functionality is not implemented.
  17     NotImplemented,
  18     /// Read error.
  19     ReadError,
  20     /// Write error.
  21     WriteError,
  22     /// Seeking failed.
  23     SeekError,
  24 }
  25
  26 /// A specialised `Result` type for bytestream operations.
  27 pub type ByteIOResult<T> = Result<T, ByteIOError>;
  28
  29 /// Common trait for bytestream operations.
  30 pub trait ByteIO {
  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;
  53 }
  54
  55 /// High-level bytestream reader.
  56 ///
  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.
  58 ///
  59 /// # Examples
  60 ///
  61 /// ````
  62 /// use nihav_core::io::byteio::{MemoryReader,ByteReader};
  63 /// # use nihav_core::io::byteio::ByteIOResult;
  64 ///
  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
  71 /// # Ok(())
  72 /// # }
  73 /// ````
  74 ///
  75 /// [`ByteIO`]: ./trait.ByteIO.html
  76 /// [`MemoryReader`]: ./struct.MemoryReader.html
  77 #[allow(dead_code)]
  78 pub struct ByteReader<'a> {
  79     io: &'a mut ByteIO,
  80 }
  81
  82 /// Bytestream reader from memory.
  83 pub struct MemoryReader<'a> {
  84     buf:      &'a [u8],
  85     pos:      usize,
  86 }
  87
  88 /// Bytestream reader from file.
  89 pub struct FileReader<'a> {
  90     file:     &'a File,
  91     eof:      bool,
  92 }
  93
  94 macro_rules! read_int {
  95     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
  96         unsafe {
  97             let mut buf: $inttype = 0;
  98             $s.read_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
  99             Ok(buf.$which())
 100         }
 101     })
 102 }
 103
 104 macro_rules! peek_int {
 105     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
 106         unsafe {
 107             let mut buf: $inttype = 0;
 108             $s.peek_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
 109             Ok(buf.$which())
 110         }
 111     })
 112 }
 113
 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); }
 119             unsafe {
 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>());
 122                 Ok(buf.$which())
 123             }
 124         }
 125     }
 126 }
 127
 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);
 134
 135 /// Reads 24-bit big-endian integer.
 136 ///
 137 /// # Example
 138 ///
 139 /// ````
 140 /// use nihav_core::io::byteio::read_u24be;
 141 /// # use nihav_core::io::byteio::ByteIOResult;
 142 ///
 143 /// # fn foo() -> ByteIOResult<()> {
 144 /// let src: [u8; 3] = [ 1, 2, 3];
 145 /// let value = read_u24be(&src)?; // should return 0x010203
 146 /// # Ok(())
 147 /// # }
 148 /// ````
 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]))
 152 }
 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]))
 157 }
 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)?)) }
 166
 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); }
 172             unsafe {
 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>());
 175             }
 176             Ok(())
 177         }
 178     }
 179 }
 180
 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);
 187
 188 /// Writes 24-bit big-endian integer to the provided buffer.
 189 ///
 190 /// # Example
 191 ///
 192 /// ````
 193 /// use nihav_core::io::byteio::write_u24be;
 194 /// # use nihav_core::io::byteio::ByteIOResult;
 195 ///
 196 /// # fn foo() -> ByteIOResult<()> {
 197 /// let mut dst = [0u8; 3];
 198 /// write_u24be(&mut dst, 0x010203)?;
 199 /// // dst should contain [ 1, 2, 3] now
 200 /// # Ok(())
 201 /// # }
 202 /// ````
 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;
 208     Ok(())
 209 }
 210 /// Writes 24-bit little-endian integer to the provided buffer.
 211 pub fn write_u24le(dst: &mut [u8], val: u32) -> ByteIOResult<()> {
 212     if dst.len() < 3 { return Err(ByteIOError::WriteError); }
 213     dst[0] = (val >>  0) as u8;
 214     dst[1] = (val >>  8) as u8;
 215     dst[2] = (val >> 16) as u8;
 216     Ok(())
 217 }
 218 /// Writes 32-bit big-endian floating point number to the provided buffer.
 219 pub fn write_f32be(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32be(dst, val.to_bits()) }
 220 /// Writes 32-bit little-endian floating point number to the provided buffer.
 221 pub fn write_f32le(dst: &mut [u8], val: f32) -> ByteIOResult<()> { write_u32le(dst, val.to_bits()) }
 222 /// Writes 64-bit big-endian floating point number to the provided buffer.
 223 pub fn write_f64be(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64be(dst, val.to_bits()) }
 224 /// Writes 64-bit little-endian floating point number to the provided buffer.
 225 pub fn write_f64le(dst: &mut [u8], val: f64) -> ByteIOResult<()> { write_u64le(dst, val.to_bits()) }
 226
 227 impl<'a> ByteReader<'a> {
 228     /// Constructs a new instance of bytestream reader.
 229     ///
 230     /// # Examples
 231     ///
 232     /// ````
 233     /// use nihav_core::io::byteio::{MemoryReader,ByteReader};
 234     /// # use nihav_core::io::byteio::ByteIOResult;
 235     ///
 236     /// # fn foo() -> ByteIOResult<()> {
 237     /// let memory: [u8; 4] = [ 0, 42, 42, 0 ];
 238     /// let mut mr = MemoryReader::new_read(&memory);
 239     /// let mut br = ByteReader::new(&mut mr);
 240     /// # Ok(())
 241     /// # }
 242     /// ````
 243     pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io } }
 244
 245     /// Reads data into provided buffer. Partial read is treated as success.
 246     pub fn read_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 247         self.io.read_buf(buf)
 248     }
 249
 250     /// Reads data into provided buffer. Partial read is treated as success.
 251     pub fn read_buf_some(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 252         self.io.read_buf_some(buf)
 253     }
 254
 255     /// Reads data into provided buffer but does not advance read position.
 256     pub fn peek_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 257         self.io.peek_buf(buf)
 258     }
 259
 260     /// Reads single byte from the stream.
 261     pub fn read_byte(&mut self) -> ByteIOResult<u8> {
 262         self.io.read_byte()
 263     }
 264
 265     /// Returns the next byte value in the stream without advancing read position.
 266     pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
 267         self.io.peek_byte()
 268     }
 269
 270     /// Reads 16-bit big-endian integer from the stream.
 271     pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
 272         read_int!(self, u16, 2, to_be)
 273     }
 274
 275     /// Reads 16-bit big-endian integer from the stream without advancing read position.
 276     pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
 277         peek_int!(self, u16, 2, to_be)
 278     }
 279
 280     /// Reads 24-bit big-endian integer from the stream.
 281     pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
 282         let p16 = self.read_u16be()?;
 283         let p8 = self.read_byte()?;
 284         Ok((u32::from(p16) << 8) | u32::from(p8))
 285     }
 286
 287     /// Reads 24-bit big-endian integer from the stream without advancing read position.
 288     pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
 289         let mut src: [u8; 3] = [0; 3];
 290         self.peek_buf(&mut src)?;
 291         Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
 292     }
 293
 294     /// Reads 32-bit big-endian integer from the stream.
 295     pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
 296         read_int!(self, u32, 4, to_be)
 297     }
 298
 299     /// Reads 32-bit big-endian integer from the stream without advancing read position.
 300     pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
 301         peek_int!(self, u32, 4, to_be)
 302     }
 303
 304     /// Reads 64-bit big-endian integer from the stream.
 305     pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
 306         read_int!(self, u64, 8, to_be)
 307     }
 308
 309     /// Reads 64-bit big-endian integer from the stream without advancing read position.
 310     pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
 311         peek_int!(self, u64, 8, to_be)
 312     }
 313
 314     /// Reads 32-bit big-endian floating point number from the stream.
 315     pub fn read_f32be(&mut self) -> ByteIOResult<f32> {
 316         Ok(f32::from_bits(self.read_u32be()?))
 317     }
 318
 319     /// Reads 32-bit big-endian floating point number from the stream without advancing read position.
 320     pub fn peek_f32be(&mut self) -> ByteIOResult<f32> {
 321         Ok(f32::from_bits(self.peek_u32be()?))
 322     }
 323
 324     /// Reads 64-bit big-endian floating point number from the stream.
 325     pub fn read_f64be(&mut self) -> ByteIOResult<f64> {
 326         Ok(f64::from_bits(self.read_u64be()?))
 327     }
 328
 329     /// Reads 64-bit big-endian floating point number from the stream without advancing read position.
 330     pub fn peek_f64be(&mut self) -> ByteIOResult<f64> {
 331         Ok(f64::from_bits(self.peek_u64be()?))
 332     }
 333
 334     /// Reads 16-bit little-endian integer from the stream.
 335     pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
 336         read_int!(self, u16, 2, to_le)
 337     }
 338
 339     /// Reads 16-bit little-endian integer from the stream without advancing read position.
 340     pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
 341         peek_int!(self, u16, 2, to_le)
 342     }
 343
 344     /// Reads 24-bit little-endian integer from the stream.
 345     pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
 346         let p8 = self.read_byte()?;
 347         let p16 = self.read_u16le()?;
 348         Ok((u32::from(p16) << 8) | u32::from(p8))
 349     }
 350
 351     /// Reads 24-bit little-endian integer from the stream without advancing read position.
 352     pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
 353         let mut src: [u8; 3] = [0; 3];
 354         self.peek_buf(&mut src)?;
 355         Ok(u32::from(src[0]) | (u32::from(src[1]) << 8) | (u32::from(src[2]) << 16))
 356     }
 357
 358     /// Reads 32-bit little-endian integer from the stream.
 359     pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
 360         read_int!(self, u32, 4, to_le)
 361     }
 362
 363     /// Reads 32-bit little-endian integer from the stream without advancing read position.
 364     pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
 365         peek_int!(self, u32, 4, to_le)
 366     }
 367
 368     /// Reads 64-bit little-endian integer from the stream.
 369     pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
 370         read_int!(self, u64, 8, to_le)
 371     }
 372
 373     /// Reads 64-bit little-endian integer from the stream without advancing read position.
 374     pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
 375         peek_int!(self, u64, 8, to_le)
 376     }
 377
 378     /// Reads 32-bit little-endian floating point number from the stream.
 379     pub fn read_f32le(&mut self) -> ByteIOResult<f32> {
 380         Ok(f32::from_bits(self.read_u32le()?))
 381     }
 382
 383     /// Reads 32-bit little-endian floating point number from the stream without advancing read position.
 384     pub fn peek_f32le(&mut self) -> ByteIOResult<f32> {
 385         Ok(f32::from_bits(self.peek_u32le()?))
 386     }
 387
 388     /// Reads 64-bit little-endian floating point number from the stream.
 389     pub fn read_f64le(&mut self) -> ByteIOResult<f64> {
 390         Ok(f64::from_bits(self.read_u64le()?))
 391     }
 392
 393     /// Reads 64-bit little-endian floating point number from the stream without advancing read position.
 394     pub fn peek_f64le(&mut self) -> ByteIOResult<f64> {
 395         Ok(f64::from_bits(self.peek_u64le()?))
 396     }
 397
 398     /// Skips requested number of bytes.
 399     pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
 400         if self.io.is_seekable() {
 401             self.io.seek(SeekFrom::Current(len as i64))?;
 402         } else {
 403             let mut ssize = len;
 404             let mut buf : [u8; 16] = [0; 16];
 405             let bref = &mut buf;
 406             while ssize > bref.len() {
 407                 self.io.read_buf(bref)?;
 408                 ssize -= bref.len();
 409             }
 410             while ssize > 0 {
 411                 self.io.read_byte()?;
 412                 ssize -= 1;
 413             }
 414         }
 415         Ok(())
 416     }
 417
 418     /// Returns current read position.
 419     pub fn tell(&mut self) -> u64 {
 420         self.io.tell()
 421     }
 422
 423     /// Seeks to the provided position.
 424     pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 425         self.io.seek(pos)
 426     }
 427
 428     /// Tells whether this is end of stream.
 429     pub fn is_eof(&self) -> bool {
 430         self.io.is_eof()
 431     }
 432
 433     /// Returns stream size or -1 if it is not known.
 434     pub fn size(&mut self) -> i64 {
 435         self.io.size()
 436     }
 437
 438     /// Reports number of bytes left in the stream.
 439     pub fn left(&mut self) -> i64 {
 440         let size = self.io.size();
 441         if size == -1 { return -1; }
 442         size - (self.io.tell() as i64)
 443     }
 444 }
 445
 446 impl<'a> MemoryReader<'a> {
 447     /// Constructs a new instance of `MemoryReader`.
 448     pub fn new_read(buf: &'a [u8]) -> Self {
 449         MemoryReader { buf, pos: 0 }
 450     }
 451
 452     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
 453         if pos < 0 || (pos as usize) > self.buf.len() {
 454             return Err(ByteIOError::WrongRange);
 455         }
 456         self.pos = pos as usize;
 457         Ok(pos as u64)
 458     }
 459 }
 460
 461 impl<'a> ByteIO for MemoryReader<'a> {
 462     fn read_byte(&mut self) -> ByteIOResult<u8> {
 463         if self.is_eof() { return Err(ByteIOError::EOF); }
 464         let res = self.buf[self.pos];
 465         self.pos += 1;
 466         Ok(res)
 467     }
 468
 469     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 470         if self.is_eof() { return Err(ByteIOError::EOF); }
 471         Ok(self.buf[self.pos])
 472     }
 473
 474     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 475         let copy_size = if self.buf.len() - self.pos < buf.len() { self.buf.len() } else { buf.len() };
 476         if copy_size == 0 { return Err(ByteIOError::EOF); }
 477         let dst = &mut buf[0..copy_size];
 478         dst.copy_from_slice(&self.buf[self.pos..][..copy_size]);
 479         Ok(copy_size)
 480     }
 481
 482     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 483         let read_size = self.peek_buf(buf)?;
 484         if read_size < buf.len() { return Err(ByteIOError::EOF); }
 485         self.pos += read_size;
 486         Ok(read_size)
 487     }
 488
 489     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 490         let read_size = self.peek_buf(buf)?;
 491         self.pos += read_size;
 492         Ok(read_size)
 493     }
 494
 495     #[allow(unused_variables)]
 496     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 497         Err(ByteIOError::NotImplemented)
 498     }
 499
 500     fn tell(&mut self) -> u64 {
 501         self.pos as u64
 502     }
 503
 504     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 505         let cur_pos  = self.pos       as i64;
 506         let cur_size = self.buf.len() as i64;
 507         match pos {
 508             SeekFrom::Start(x)   => self.real_seek(x as i64),
 509             SeekFrom::Current(x) => self.real_seek(cur_pos + x),
 510             SeekFrom::End(x)     => self.real_seek(cur_size + x),
 511         }
 512     }
 513
 514     fn is_eof(&self) -> bool {
 515         self.pos >= self.buf.len()
 516     }
 517
 518     fn is_seekable(&mut self) -> bool {
 519         true
 520     }
 521
 522     fn size(&mut self) -> i64 {
 523         self.buf.len() as i64
 524     }
 525 }
 526
 527 impl<'a> FileReader<'a> {
 528
 529     /// Constructs a new instance of `FileReader`.
 530     pub fn new_read(file: &'a mut File) -> Self {
 531         FileReader { file, eof : false }
 532     }
 533 }
 534
 535 impl<'a> ByteIO for FileReader<'a> {
 536     fn read_byte(&mut self) -> ByteIOResult<u8> {
 537         let mut byte : [u8; 1] = [0];
 538         let ret = self.file.read(&mut byte);
 539         if ret.is_err() { return Err(ByteIOError::ReadError); }
 540         let sz = ret.unwrap();
 541         if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
 542         Ok (byte[0])
 543     }
 544
 545     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 546         let b = self.read_byte()?;
 547         self.seek(SeekFrom::Current(-1))?;
 548         Ok(b)
 549     }
 550
 551     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 552         let ret = self.file.read(buf);
 553         if ret.is_err() { return Err(ByteIOError::ReadError); }
 554         let sz = ret.unwrap();
 555         if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
 556         Ok(sz)
 557     }
 558
 559     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 560         let ret = self.file.read(buf);
 561         if ret.is_err() { return Err(ByteIOError::ReadError); }
 562         let sz = ret.unwrap();
 563         if sz < buf.len() { self.eof = true; }
 564         Ok(sz)
 565     }
 566
 567     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 568         let size = self.read_buf(buf)?;
 569         self.seek(SeekFrom::Current(-(size as i64)))?;
 570         Ok(size)
 571     }
 572
 573     #[allow(unused_variables)]
 574     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 575         Err(ByteIOError::NotImplemented)
 576     }
 577
 578     fn tell(&mut self) -> u64 {
 579         self.file.seek(SeekFrom::Current(0)).unwrap()
 580     }
 581
 582     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 583         let res = self.file.seek(pos);
 584         match res {
 585             Ok(r) => Ok(r),
 586             Err(_) => Err(ByteIOError::SeekError),
 587         }
 588     }
 589
 590     fn is_eof(&self) -> bool {
 591         self.eof
 592     }
 593
 594     fn is_seekable(&mut self) -> bool {
 595         true
 596     }
 597
 598     fn size(&mut self) -> i64 {
 599         -1
 600     }
 601 }
 602
 603 /// High-level bytestream writer.
 604 ///
 605 /// 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.
 606 ///
 607 /// # Examples
 608 ///
 609 /// ````
 610 /// use nihav_core::io::byteio::{MemoryWriter,ByteWriter};
 611 /// # use nihav_core::io::byteio::ByteIOResult;
 612 ///
 613 /// # fn foo() -> ByteIOResult<()> {
 614 /// let mut memory = [0u8; 4];
 615 /// let mut mw = MemoryWriter::new_write(&mut memory);
 616 /// let mut bw = ByteWriter::new(&mut mw);
 617 /// let val = bw.write_u16be(42)?; // memory should be [ 0, 42, 0, 0 ]
 618 /// let val = bw.write_u16le(42)?; // memory should be [ 0, 42, 42, 0 ]
 619 /// # Ok(())
 620 /// # }
 621 /// ````
 622 ///
 623 /// [`ByteIO`]: ./trait.ByteIO.html
 624 /// [`MemoryWriter`]: ./struct.MemoryWriter.html
 625 #[allow(dead_code)]
 626 pub struct ByteWriter<'a> {
 627     io: &'a mut ByteIO,
 628 }
 629
 630 /// Bytestream writer to memory.
 631 pub struct MemoryWriter<'a> {
 632     buf:      &'a mut [u8],
 633     pos:      usize,
 634 }
 635
 636 /// Bytestream writer to file.
 637 pub struct FileWriter {
 638     file:     File,
 639 }
 640
 641 impl<'a> ByteWriter<'a> {
 642     /// Constructs a new instance of `ByteWriter`.
 643     pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io } }
 644
 645     /// Writes byte array to the output.
 646     pub fn write_buf(&mut self, buf: &[u8])  -> ByteIOResult<()> {
 647         self.io.write_buf(buf)
 648     }
 649
 650     /// Writes single byte to the output.
 651     pub fn write_byte(&mut self, val: u8) -> ByteIOResult<()> {
 652         let buf: [u8; 1] = [val];
 653         self.io.write_buf(&buf)
 654     }
 655
 656     /// Writes 16-bit big-endian integer to the output.
 657     pub fn write_u16be(&mut self, val: u16) -> ByteIOResult<()> {
 658         let buf: [u8; 2] = [((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
 659         self.io.write_buf(&buf)
 660     }
 661
 662     /// Writes 16-bit little-endian integer to the output.
 663     pub fn write_u16le(&mut self, val: u16) -> ByteIOResult<()> {
 664         let buf: [u8; 2] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8];
 665         self.io.write_buf(&buf)
 666     }
 667
 668     /// Writes 24-bit big-endian integer to the output.
 669     pub fn write_u24be(&mut self, val: u32) -> ByteIOResult<()> {
 670         let buf: [u8; 3] = [((val >> 16) & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
 671         self.write_buf(&buf)
 672     }
 673
 674     /// Writes 24-bit little-endian integer to the output.
 675     pub fn write_u24le(&mut self, val: u32) -> ByteIOResult<()> {
 676         let buf: [u8; 3] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, ((val >> 16) & 0xFF) as u8];
 677         self.write_buf(&buf)
 678     }
 679
 680     /// Writes 32-bit big-endian integer to the output.
 681     pub fn write_u32be(&mut self, val: u32) -> ByteIOResult<()> {
 682         self.write_u16be(((val >> 16) & 0xFFFF) as u16)?;
 683         self.write_u16be((val & 0xFFFF) as u16)
 684     }
 685
 686     /// Writes 32-bit little-endian integer to the output.
 687     pub fn write_u32le(&mut self, val: u32) -> ByteIOResult<()> {
 688         self.write_u16le((val & 0xFFFF) as u16)?;
 689         self.write_u16le(((val >> 16) & 0xFFFF) as u16)
 690     }
 691
 692     /// Writes 64-bit big-endian integer to the output.
 693     pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
 694         self.write_u32be((val >> 32) as u32)?;
 695         self.write_u32be(val as u32)
 696     }
 697
 698     /// Writes 64-bit little-endian integer to the output.
 699     pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
 700         self.write_u32le(val as u32)?;
 701         self.write_u32le((val >> 32) as u32)
 702     }
 703
 704     /// Writes 32-bit big-endian floating point number to the output.
 705     pub fn write_f32be(&mut self, val: f32) -> ByteIOResult<()> {
 706         self.write_u32be(val.to_bits())
 707     }
 708
 709     /// Writes 32-bit little-endian floating point number to the output.
 710     pub fn write_f32le(&mut self, val: f32) -> ByteIOResult<()> {
 711         self.write_u32le(val.to_bits())
 712     }
 713
 714     /// Writes 64-bit big-endian floating point number to the output.
 715     pub fn write_f64be(&mut self, val: f64) -> ByteIOResult<()> {
 716         self.write_u64be(val.to_bits())
 717     }
 718
 719     /// Writes 64-bit little-endian floating point number to the output.
 720     pub fn write_f64le(&mut self, val: f64) -> ByteIOResult<()> {
 721         self.write_u64le(val.to_bits())
 722     }
 723
 724     /// Reports the current write position.
 725     pub fn tell(&mut self) -> u64 {
 726         self.io.tell()
 727     }
 728
 729     /// Seeks to the requested position.
 730     pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 731         self.io.seek(pos)
 732     }
 733
 734     /// Reports the amount of bytes the writer can still write (-1 if unknown).
 735     pub fn size_left(&mut self) -> i64 {
 736         let sz = self.io.size();
 737         if sz == -1 { return -1; }
 738         sz - (self.tell() as i64)
 739     }
 740 }
 741
 742 impl<'a> MemoryWriter<'a> {
 743
 744     /// Constructs a new instance of `MemoryWriter`.
 745     pub fn new_write(buf: &'a mut [u8]) -> Self {
 746         MemoryWriter { buf, pos: 0 }
 747     }
 748
 749     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
 750         if pos < 0 || (pos as usize) > self.buf.len() {
 751             return Err(ByteIOError::WrongRange)
 752         }
 753         self.pos = pos as usize;
 754         Ok(pos as u64)
 755     }
 756 }
 757
 758 impl<'a> ByteIO for MemoryWriter<'a> {
 759     #[allow(unused_variables)]
 760     fn read_byte(&mut self) -> ByteIOResult<u8> {
 761         Err(ByteIOError::NotImplemented)
 762     }
 763
 764     #[allow(unused_variables)]
 765     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 766         Err(ByteIOError::NotImplemented)
 767     }
 768
 769     #[allow(unused_variables)]
 770     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 771         Err(ByteIOError::NotImplemented)
 772     }
 773
 774     #[allow(unused_variables)]
 775     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 776         Err(ByteIOError::NotImplemented)
 777     }
 778
 779     #[allow(unused_variables)]
 780     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 781         Err(ByteIOError::NotImplemented)
 782     }
 783
 784     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 785         if self.pos + buf.len() > self.buf.len() { return Err(ByteIOError::WriteError); }
 786         for i in 0..buf.len() {
 787             self.buf[self.pos + i] = buf[i];
 788         }
 789         self.pos += buf.len();
 790         Ok(())
 791     }
 792
 793     fn tell(&mut self) -> u64 {
 794         self.pos as u64
 795     }
 796
 797     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 798         let cur_pos  = self.pos       as i64;
 799         let cur_size = self.buf.len() as i64;
 800         match pos {
 801             SeekFrom::Start(x)   => self.real_seek(x as i64),
 802             SeekFrom::Current(x) => self.real_seek(cur_pos + x),
 803             SeekFrom::End(x)     => self.real_seek(cur_size + x),
 804         }
 805     }
 806
 807     fn is_eof(&self) -> bool {
 808         self.pos >= self.buf.len()
 809     }
 810
 811     fn is_seekable(&mut self) -> bool {
 812         true
 813     }
 814
 815     fn size(&mut self) -> i64 {
 816         self.buf.len() as i64
 817     }
 818 }
 819
 820 impl FileWriter {
 821     /// Constructs a new instance of `FileWriter`.
 822     pub fn new_write(file: File) -> Self {
 823         FileWriter { file }
 824     }
 825 }
 826
 827 impl ByteIO for FileWriter {
 828     #[allow(unused_variables)]
 829     fn read_byte(&mut self) -> ByteIOResult<u8> {
 830         Err(ByteIOError::NotImplemented)
 831     }
 832
 833     #[allow(unused_variables)]
 834     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 835         Err(ByteIOError::NotImplemented)
 836     }
 837
 838     #[allow(unused_variables)]
 839     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 840         Err(ByteIOError::NotImplemented)
 841     }
 842
 843     #[allow(unused_variables)]
 844     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 845         Err(ByteIOError::NotImplemented)
 846     }
 847
 848     #[allow(unused_variables)]
 849     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 850         Err(ByteIOError::NotImplemented)
 851     }
 852
 853     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 854         match self.file.write_all(buf) {
 855             Ok(()) => Ok(()),
 856             Err(_) => Err(ByteIOError::WriteError),
 857         }
 858     }
 859
 860     fn tell(&mut self) -> u64 {
 861         self.file.seek(SeekFrom::Current(0)).unwrap()
 862     }
 863
 864     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 865         let res = self.file.seek(pos);
 866         match res {
 867             Ok(r) => Ok(r),
 868             Err(_) => Err(ByteIOError::SeekError),
 869         }
 870     }
 871
 872     fn is_eof(&self) -> bool {
 873         false
 874     }
 875
 876     fn is_seekable(&mut self) -> bool {
 877         true
 878     }
 879
 880     fn size(&mut self) -> i64 {
 881         -1
 882     }
 883 }
 884
 885 #[cfg(test)]
 886 mod test {
 887     use super::*;
 888     use std::fs::File;
 889
 890     #[test]
 891     fn test_read() {
 892         //const DATA : &'static [u8] = include_bytes!("../../assets/file");
 893         let buf: [u8; 64] = [1; 64];
 894         let mut mr = MemoryReader::new_read(&buf);
 895         let mut reader = ByteReader::new(&mut mr);
 896         assert_eq!(reader.read_byte().unwrap(),  0x01u8);
 897         assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
 898         assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
 899         assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
 900         assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
 901         let mut file = File::open("assets/Misc/MaoMacha.asx").unwrap();
 902         let mut fr = FileReader::new_read(&mut file);
 903         let mut br2 = ByteReader::new(&mut fr);
 904         assert_eq!(br2.read_byte().unwrap(), 0x30);
 905         assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
 906         assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
 907         assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
 908         assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);
 909     }
 910     #[test]
 911     fn test_write() {
 912         let mut buf: [u8; 64] = [0; 64];
 913         {
 914             let mut mw = MemoryWriter::new_write(&mut buf);
 915             let mut bw = ByteWriter::new(&mut mw);
 916             bw.write_byte(0x00).unwrap();
 917             bw.write_u16be(0x0102).unwrap();
 918             bw.write_u24be(0x030405).unwrap();
 919             bw.write_u32be(0x06070809).unwrap();
 920             bw.write_u64be(0x0A0B0C0D0E0F1011).unwrap();
 921             bw.write_byte(0x00).unwrap();
 922             bw.write_u16le(0x0201).unwrap();
 923             bw.write_u24le(0x050403).unwrap();
 924             bw.write_u32le(0x09080706).unwrap();
 925             bw.write_u64le(0x11100F0E0D0C0B0A).unwrap();
 926             assert_eq!(bw.size_left(), 28);
 927         }
 928         for i in 0..0x12 {
 929             assert_eq!(buf[(i + 0x00) as usize], i);
 930             assert_eq!(buf[(i + 0x12) as usize], i);
 931         }
 932     }
 933 }