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