nihav-core/src/io/byteio.rs

   1 pub use std::io::SeekFrom;
   2 use std::fs::File;
   3 use std::io::prelude::*;
   4 use std::ptr;
   5
   6 #[derive(Debug)]
   7 pub enum ByteIOError {
   8     EOF,
   9     WrongRange,
  10     WrongIOMode,
  11     NotImplemented,
  12     ReadError,
  13     WriteError,
  14     SeekError,
  15 }
  16
  17 pub type ByteIOResult<T> = Result<T, ByteIOError>;
  18
  19 pub trait ByteIO {
  20     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
  21     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
  22     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
  23     fn read_byte(&mut self) -> ByteIOResult<u8>;
  24     fn peek_byte(&mut self) -> ByteIOResult<u8>;
  25     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()>;
  26     fn tell(&mut self) -> u64;
  27     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
  28     fn is_eof(&self) -> bool;
  29     fn is_seekable(&mut self) -> bool;
  30     fn size(&mut self) -> i64;
  31 }
  32
  33 #[allow(dead_code)]
  34 pub struct ByteReader<'a> {
  35     io: &'a mut ByteIO,
  36 }
  37
  38 pub struct MemoryReader<'a> {
  39     buf:      &'a [u8],
  40     size:     usize,
  41     pos:      usize,
  42 }
  43
  44 pub struct FileReader<'a> {
  45     file:     &'a File,
  46     eof:      bool,
  47 }
  48
  49 macro_rules! read_int {
  50     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
  51         unsafe {
  52             let mut buf: $inttype = 0;
  53             $s.read_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
  54             Ok(buf.$which())
  55         }
  56     })
  57 }
  58
  59 macro_rules! peek_int {
  60     ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
  61         unsafe {
  62             let mut buf: $inttype = 0;
  63             $s.peek_buf(&mut *(&mut buf as *mut $inttype as *mut [u8; $size]))?;
  64             Ok(buf.$which())
  65         }
  66     })
  67 }
  68
  69 macro_rules! read_int_func {
  70     ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
  71         pub fn $s(src: &[u8]) -> ByteIOResult<$inttype> {
  72             if src.len() < $size { return Err(ByteIOError::ReadError); }
  73             unsafe {
  74                 let mut buf: $inttype = 0;
  75                 ptr::copy_nonoverlapping(src.as_ptr(), &mut buf as *mut $inttype as *mut u8, std::mem::size_of::<$inttype>());
  76                 Ok(buf.$which())
  77             }
  78         }
  79     }
  80 }
  81
  82 read_int_func!(read_u16be, u16, 2, to_be);
  83 read_int_func!(read_u16le, u16, 2, to_le);
  84 read_int_func!(read_u32be, u32, 4, to_be);
  85 read_int_func!(read_u32le, u32, 4, to_le);
  86 read_int_func!(read_u64be, u64, 8, to_be);
  87 read_int_func!(read_u64le, u64, 8, to_le);
  88
  89 pub fn read_u24be(src: &[u8]) -> ByteIOResult<u32> {
  90     if src.len() < 3 { return Err(ByteIOError::ReadError); }
  91     Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
  92 }
  93 pub fn read_u24le(src: &[u8]) -> ByteIOResult<u32> {
  94     if src.len() < 3 { return Err(ByteIOError::ReadError); }
  95     Ok((u32::from(src[2]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[0]))
  96 }
  97
  98 macro_rules! write_int_func {
  99     ($s: ident, $inttype: ty, $size: expr, $which: ident) => {
 100         pub fn $s(dst: &mut [u8], val: $inttype) -> ByteIOResult<()> {
 101             if dst.len() < $size { return Err(ByteIOError::WriteError); }
 102             unsafe {
 103                 let val = val.$which();
 104                 ptr::copy_nonoverlapping(&val as *const $inttype as *const u8, dst.as_mut_ptr(), std::mem::size_of::<$inttype>());
 105             }
 106             Ok(())
 107         }
 108     }
 109 }
 110
 111 write_int_func!(write_u16be, u16, 2, to_be);
 112 write_int_func!(write_u16le, u16, 2, to_le);
 113 write_int_func!(write_u32be, u32, 4, to_be);
 114 write_int_func!(write_u32le, u32, 4, to_le);
 115 write_int_func!(write_u64be, u64, 8, to_be);
 116 write_int_func!(write_u64le, u64, 8, to_le);
 117
 118 pub fn write_u24be(dst: &mut [u8], val: u32) -> ByteIOResult<()> {
 119     if dst.len() < 3 { return Err(ByteIOError::WriteError); }
 120     dst[0] = (val >> 16) as u8;
 121     dst[1] = (val >>  8) as u8;
 122     dst[2] = (val >>  0) as u8;
 123     Ok(())
 124 }
 125 pub fn write_u24le(dst: &mut [u8], val: u32) -> ByteIOResult<()> {
 126     if dst.len() < 3 { return Err(ByteIOError::WriteError); }
 127     dst[0] = (val >>  0) as u8;
 128     dst[1] = (val >>  8) as u8;
 129     dst[2] = (val >> 16) as u8;
 130     Ok(())
 131 }
 132
 133 impl<'a> ByteReader<'a> {
 134     pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io } }
 135
 136     pub fn read_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 137         self.io.read_buf(buf)
 138     }
 139
 140     pub fn read_buf_some(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 141         self.io.read_buf_some(buf)
 142     }
 143
 144     pub fn peek_buf(&mut self, buf: &mut [u8])  -> ByteIOResult<usize> {
 145         self.io.peek_buf(buf)
 146     }
 147
 148     pub fn read_byte(&mut self) -> ByteIOResult<u8> {
 149         self.io.read_byte()
 150     }
 151
 152     pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
 153         self.io.peek_byte()
 154     }
 155
 156     pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
 157         read_int!(self, u16, 2, to_be)
 158     }
 159
 160     pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
 161         peek_int!(self, u16, 2, to_be)
 162     }
 163
 164     pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
 165         let p16 = self.read_u16be()?;
 166         let p8 = self.read_byte()?;
 167         Ok((u32::from(p16) << 8) | u32::from(p8))
 168     }
 169
 170     pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
 171         let mut src: [u8; 3] = [0; 3];
 172         self.peek_buf(&mut src)?;
 173         Ok((u32::from(src[0]) << 16) | (u32::from(src[1]) << 8) | u32::from(src[2]))
 174     }
 175
 176     pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
 177         read_int!(self, u32, 4, to_be)
 178     }
 179
 180     pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
 181         peek_int!(self, u32, 4, to_be)
 182     }
 183
 184     pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
 185         read_int!(self, u64, 8, to_be)
 186     }
 187
 188     pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
 189         peek_int!(self, u64, 8, to_be)
 190     }
 191
 192     pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
 193         read_int!(self, u16, 2, to_le)
 194     }
 195
 196     pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
 197         peek_int!(self, u16, 2, to_le)
 198     }
 199
 200     pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
 201         let p8 = self.read_byte()?;
 202         let p16 = self.read_u16le()?;
 203         Ok((u32::from(p16) << 8) | u32::from(p8))
 204     }
 205
 206     pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
 207         let mut src: [u8; 3] = [0; 3];
 208         self.peek_buf(&mut src)?;
 209         Ok(u32::from(src[0]) | (u32::from(src[1]) << 8) | (u32::from(src[2]) << 16))
 210     }
 211
 212     pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
 213         read_int!(self, u32, 4, to_le)
 214     }
 215
 216     pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
 217         peek_int!(self, u32, 4, to_le)
 218     }
 219
 220     pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
 221         read_int!(self, u64, 8, to_le)
 222     }
 223
 224     pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
 225         peek_int!(self, u64, 8, to_le)
 226     }
 227
 228     pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
 229         if self.io.is_seekable() {
 230             self.io.seek(SeekFrom::Current(len as i64))?;
 231         } else {
 232             let mut ssize = len;
 233             let mut buf : [u8; 16] = [0; 16];
 234             let bref = &mut buf;
 235             while ssize > bref.len() {
 236                 self.io.read_buf(bref)?;
 237                 ssize -= bref.len();
 238             }
 239             while ssize > 0 {
 240                 self.io.read_byte()?;
 241                 ssize -= 1;
 242             }
 243         }
 244         Ok(())
 245     }
 246
 247     pub fn tell(&mut self) -> u64 {
 248         self.io.tell()
 249     }
 250
 251     pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 252         self.io.seek(pos)
 253     }
 254
 255     pub fn is_eof(&self) -> bool {
 256         self.io.is_eof()
 257     }
 258
 259     pub fn size(&mut self) -> i64 {
 260         self.io.size()
 261     }
 262
 263     pub fn left(&mut self) -> i64 {
 264         let size = self.io.size();
 265         if size == -1 { return -1; }
 266         size - (self.io.tell() as i64)
 267     }
 268 }
 269
 270 impl<'a> MemoryReader<'a> {
 271
 272     pub fn new_read(buf: &'a [u8]) -> Self {
 273         MemoryReader { buf, size: buf.len(), pos: 0 }
 274     }
 275
 276     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
 277         if pos < 0 || (pos as usize) > self.size {
 278             return Err(ByteIOError::WrongRange);
 279         }
 280         self.pos = pos as usize;
 281         Ok(pos as u64)
 282     }
 283 }
 284
 285 impl<'a> ByteIO for MemoryReader<'a> {
 286     fn read_byte(&mut self) -> ByteIOResult<u8> {
 287         if self.is_eof() { return Err(ByteIOError::EOF); }
 288         let res = self.buf[self.pos];
 289         self.pos += 1;
 290         Ok(res)
 291     }
 292
 293     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 294         if self.is_eof() { return Err(ByteIOError::EOF); }
 295         Ok(self.buf[self.pos])
 296     }
 297
 298     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 299         let copy_size = if self.size - self.pos < buf.len() { self.size } else { buf.len() };
 300         if copy_size == 0 { return Err(ByteIOError::EOF); }
 301         let dst = &mut buf[0..copy_size];
 302         dst.copy_from_slice(&self.buf[self.pos..][..copy_size]);
 303         Ok(copy_size)
 304     }
 305
 306     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 307         let read_size = self.peek_buf(buf)?;
 308         if read_size < buf.len() { return Err(ByteIOError::EOF); }
 309         self.pos += read_size;
 310         Ok(read_size)
 311     }
 312
 313     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 314         let read_size = self.peek_buf(buf)?;
 315         self.pos += read_size;
 316         Ok(read_size)
 317     }
 318
 319     #[allow(unused_variables)]
 320     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 321         Err(ByteIOError::NotImplemented)
 322     }
 323
 324     fn tell(&mut self) -> u64 {
 325         self.pos as u64
 326     }
 327
 328     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 329         let cur_pos  = self.pos  as i64;
 330         let cur_size = self.size as i64;
 331         match pos {
 332             SeekFrom::Start(x)   => self.real_seek(x as i64),
 333             SeekFrom::Current(x) => self.real_seek(cur_pos + x),
 334             SeekFrom::End(x)     => self.real_seek(cur_size + x),
 335         }
 336     }
 337
 338     fn is_eof(&self) -> bool {
 339         self.pos >= self.size
 340     }
 341
 342     fn is_seekable(&mut self) -> bool {
 343         true
 344     }
 345
 346     fn size(&mut self) -> i64 {
 347         self.buf.len() as i64
 348     }
 349 }
 350
 351 impl<'a> FileReader<'a> {
 352
 353     pub fn new_read(file: &'a mut File) -> Self {
 354         FileReader { file, eof : false }
 355     }
 356 }
 357
 358 impl<'a> ByteIO for FileReader<'a> {
 359     fn read_byte(&mut self) -> ByteIOResult<u8> {
 360         let mut byte : [u8; 1] = [0];
 361         let ret = self.file.read(&mut byte);
 362         if ret.is_err() { return Err(ByteIOError::ReadError); }
 363         let sz = ret.unwrap();
 364         if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
 365         Ok (byte[0])
 366     }
 367
 368     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 369         let b = self.read_byte()?;
 370         self.seek(SeekFrom::Current(-1))?;
 371         Ok(b)
 372     }
 373
 374     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 375         let ret = self.file.read(buf);
 376         if ret.is_err() { return Err(ByteIOError::ReadError); }
 377         let sz = ret.unwrap();
 378         if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
 379         Ok(sz)
 380     }
 381
 382     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 383         let ret = self.file.read(buf);
 384         if ret.is_err() { return Err(ByteIOError::ReadError); }
 385         let sz = ret.unwrap();
 386         if sz < buf.len() { self.eof = true; }
 387         Ok(sz)
 388     }
 389
 390     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 391         let size = self.read_buf(buf)?;
 392         self.seek(SeekFrom::Current(-(size as i64)))?;
 393         Ok(size)
 394     }
 395
 396     #[allow(unused_variables)]
 397     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 398         Err(ByteIOError::NotImplemented)
 399     }
 400
 401     fn tell(&mut self) -> u64 {
 402         self.file.seek(SeekFrom::Current(0)).unwrap()
 403     }
 404
 405     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 406         let res = self.file.seek(pos);
 407         match res {
 408             Ok(r) => Ok(r),
 409             Err(_) => Err(ByteIOError::SeekError),
 410         }
 411     }
 412
 413     fn is_eof(&self) -> bool {
 414         self.eof
 415     }
 416
 417     fn is_seekable(&mut self) -> bool {
 418         true
 419     }
 420
 421     fn size(&mut self) -> i64 {
 422         -1
 423     }
 424 }
 425
 426 #[allow(dead_code)]
 427 pub struct ByteWriter<'a> {
 428     io: &'a mut ByteIO,
 429 }
 430
 431 pub struct MemoryWriter<'a> {
 432     buf:      &'a mut [u8],
 433     size:     usize,
 434     pos:      usize,
 435 }
 436
 437 pub struct FileWriter {
 438     file:     File,
 439 }
 440
 441 impl<'a> ByteWriter<'a> {
 442     pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io } }
 443
 444     pub fn write_buf(&mut self, buf: &[u8])  -> ByteIOResult<()> {
 445         self.io.write_buf(buf)
 446     }
 447
 448     pub fn write_byte(&mut self, val: u8) -> ByteIOResult<()> {
 449         let buf: [u8; 1] = [val];
 450         self.io.write_buf(&buf)
 451     }
 452
 453     pub fn write_u16be(&mut self, val: u16) -> ByteIOResult<()> {
 454         let buf: [u8; 2] = [((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
 455         self.io.write_buf(&buf)
 456     }
 457
 458     pub fn write_u16le(&mut self, val: u16) -> ByteIOResult<()> {
 459         let buf: [u8; 2] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8];
 460         self.io.write_buf(&buf)
 461     }
 462
 463     pub fn write_u24be(&mut self, val: u32) -> ByteIOResult<()> {
 464         let buf: [u8; 3] = [((val >> 16) & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
 465         self.write_buf(&buf)
 466     }
 467
 468     pub fn write_u24le(&mut self, val: u32) -> ByteIOResult<()> {
 469         let buf: [u8; 3] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, ((val >> 16) & 0xFF) as u8];
 470         self.write_buf(&buf)
 471     }
 472
 473     pub fn write_u32be(&mut self, val: u32) -> ByteIOResult<()> {
 474         self.write_u16be(((val >> 16) & 0xFFFF) as u16)?;
 475         self.write_u16be((val & 0xFFFF) as u16)
 476     }
 477
 478     pub fn write_u32le(&mut self, val: u32) -> ByteIOResult<()> {
 479         self.write_u16le((val & 0xFFFF) as u16)?;
 480         self.write_u16le(((val >> 16) & 0xFFFF) as u16)
 481     }
 482
 483     pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
 484         self.write_u32be((val >> 32) as u32)?;
 485         self.write_u32be(val as u32)
 486     }
 487
 488     pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
 489         self.write_u32le(val as u32)?;
 490         self.write_u32le((val >> 32) as u32)
 491     }
 492
 493     pub fn tell(&mut self) -> u64 {
 494         self.io.tell()
 495     }
 496
 497     pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 498         self.io.seek(pos)
 499     }
 500
 501     pub fn size_left(&mut self) -> i64 {
 502         let sz = self.io.size();
 503         if sz == -1 { return -1; }
 504         sz - (self.tell() as i64)
 505     }
 506 }
 507
 508 impl<'a> MemoryWriter<'a> {
 509
 510     pub fn new_write(buf: &'a mut [u8]) -> Self {
 511         let len = buf.len();
 512         MemoryWriter { buf, size: len, pos: 0 }
 513     }
 514
 515     fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
 516         if pos < 0 || (pos as usize) > self.size {
 517             return Err(ByteIOError::WrongRange)
 518         }
 519         self.pos = pos as usize;
 520         Ok(pos as u64)
 521     }
 522 }
 523
 524 impl<'a> ByteIO for MemoryWriter<'a> {
 525     #[allow(unused_variables)]
 526     fn read_byte(&mut self) -> ByteIOResult<u8> {
 527         Err(ByteIOError::NotImplemented)
 528     }
 529
 530     #[allow(unused_variables)]
 531     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 532         Err(ByteIOError::NotImplemented)
 533     }
 534
 535     #[allow(unused_variables)]
 536     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 537         Err(ByteIOError::NotImplemented)
 538     }
 539
 540     #[allow(unused_variables)]
 541     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 542         Err(ByteIOError::NotImplemented)
 543     }
 544
 545     #[allow(unused_variables)]
 546     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 547         Err(ByteIOError::NotImplemented)
 548     }
 549
 550     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 551         if self.pos + buf.len() > self.size { return Err(ByteIOError::WriteError); }
 552         for i in 0..buf.len() {
 553             self.buf[self.pos + i] = buf[i];
 554         }
 555         self.pos += buf.len();
 556         Ok(())
 557     }
 558
 559     fn tell(&mut self) -> u64 {
 560         self.pos as u64
 561     }
 562
 563     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 564         let cur_pos  = self.pos  as i64;
 565         let cur_size = self.size as i64;
 566         match pos {
 567             SeekFrom::Start(x)   => self.real_seek(x as i64),
 568             SeekFrom::Current(x) => self.real_seek(cur_pos + x),
 569             SeekFrom::End(x)     => self.real_seek(cur_size + x),
 570         }
 571     }
 572
 573     fn is_eof(&self) -> bool {
 574         self.pos >= self.size
 575     }
 576
 577     fn is_seekable(&mut self) -> bool {
 578         true
 579     }
 580
 581     fn size(&mut self) -> i64 {
 582         self.buf.len() as i64
 583     }
 584 }
 585
 586 impl FileWriter {
 587     pub fn new_write(file: File) -> Self {
 588         FileWriter { file }
 589     }
 590 }
 591
 592 impl ByteIO for FileWriter {
 593     #[allow(unused_variables)]
 594     fn read_byte(&mut self) -> ByteIOResult<u8> {
 595         Err(ByteIOError::NotImplemented)
 596     }
 597
 598     #[allow(unused_variables)]
 599     fn peek_byte(&mut self) -> ByteIOResult<u8> {
 600         Err(ByteIOError::NotImplemented)
 601     }
 602
 603     #[allow(unused_variables)]
 604     fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 605         Err(ByteIOError::NotImplemented)
 606     }
 607
 608     #[allow(unused_variables)]
 609     fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 610         Err(ByteIOError::NotImplemented)
 611     }
 612
 613     #[allow(unused_variables)]
 614     fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
 615         Err(ByteIOError::NotImplemented)
 616     }
 617
 618     fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
 619         match self.file.write_all(buf) {
 620             Ok(()) => Ok(()),
 621             Err(_) => Err(ByteIOError::WriteError),
 622         }
 623     }
 624
 625     fn tell(&mut self) -> u64 {
 626         self.file.seek(SeekFrom::Current(0)).unwrap()
 627     }
 628
 629     fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
 630         let res = self.file.seek(pos);
 631         match res {
 632             Ok(r) => Ok(r),
 633             Err(_) => Err(ByteIOError::SeekError),
 634         }
 635     }
 636
 637     fn is_eof(&self) -> bool {
 638         false
 639     }
 640
 641     fn is_seekable(&mut self) -> bool {
 642         true
 643     }
 644
 645     fn size(&mut self) -> i64 {
 646         -1
 647     }
 648 }
 649
 650 #[cfg(test)]
 651 mod test {
 652     use super::*;
 653     use std::fs::File;
 654
 655     #[test]
 656     fn test_read() {
 657         //const DATA : &'static [u8] = include_bytes!("../../assets/file");
 658         let buf: [u8; 64] = [1; 64];
 659         let mut mr = MemoryReader::new_read(&buf);
 660         let mut reader = ByteReader::new(&mut mr);
 661         assert_eq!(reader.read_byte().unwrap(),  0x01u8);
 662         assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
 663         assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
 664         assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
 665         assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
 666         let mut file = File::open("assets/Misc/MaoMacha.asx").unwrap();
 667         let mut fr = FileReader::new_read(&mut file);
 668         let mut br2 = ByteReader::new(&mut fr);
 669         assert_eq!(br2.read_byte().unwrap(), 0x30);
 670         assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
 671         assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
 672         assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
 673         assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);
 674     }
 675     #[test]
 676     fn test_write() {
 677         let mut buf: [u8; 64] = [0; 64];
 678         {
 679             let mut mw = MemoryWriter::new_write(&mut buf);
 680             let mut bw = ByteWriter::new(&mut mw);
 681             bw.write_byte(0x00).unwrap();
 682             bw.write_u16be(0x0102).unwrap();
 683             bw.write_u24be(0x030405).unwrap();
 684             bw.write_u32be(0x06070809).unwrap();
 685             bw.write_u64be(0x0A0B0C0D0E0F1011).unwrap();
 686             bw.write_byte(0x00).unwrap();
 687             bw.write_u16le(0x0201).unwrap();
 688             bw.write_u24le(0x050403).unwrap();
 689             bw.write_u32le(0x09080706).unwrap();
 690             bw.write_u64le(0x11100F0E0D0C0B0A).unwrap();
 691             assert_eq!(bw.size_left(), 28);
 692         }
 693         for i in 0..0x12 {
 694             assert_eq!(buf[(i + 0x00) as usize], i);
 695             assert_eq!(buf[(i + 0x12) as usize], i);
 696         }
 697     }
 698 }