3 use std::io::prelude::*;
16 type ByteIOResult<T> = Result<T, ByteIOError>;
19 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
20 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
21 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
22 fn read_byte(&mut self) -> ByteIOResult<u8>;
23 fn peek_byte(&mut self) -> ByteIOResult<u8>;
24 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()>;
25 fn tell(&mut self) -> u64;
26 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
27 fn is_eof(&mut self) -> bool;
28 fn is_seekable(&mut self) -> bool;
29 fn size(&mut self) -> i64;
33 pub struct ByteReader<'a> {
37 pub struct MemoryReader<'a> {
43 pub struct FileReader<'a> {
48 macro_rules! read_int {
49 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
50 let mut buf = [0; $size];
51 try!($s.read_buf(&mut buf));
53 Ok((*(buf.as_ptr() as *const $inttype)).$which())
58 macro_rules! peek_int {
59 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
60 let mut buf = [0; $size];
61 try!($s.peek_buf(&mut buf));
63 Ok((*(buf.as_ptr() as *const $inttype)).$which())
68 impl<'a> ByteReader<'a> {
69 pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io: io } }
71 pub fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
75 pub fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
76 self.io.read_buf_some(buf)
79 pub fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
83 pub fn read_byte(&mut self) -> ByteIOResult<u8> {
87 pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
91 pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
92 read_int!(self, u16, 2, to_be)
95 pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
96 peek_int!(self, u16, 2, to_be)
99 pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
100 let p16 = self.read_u16be()?;
101 let p8 = self.read_byte()?;
102 Ok(((p16 as u32) << 8) | (p8 as u32))
105 pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
106 let mut src: [u8; 3] = [0; 3];
107 self.peek_buf(&mut src)?;
108 Ok(((src[0] as u32) << 16) | ((src[1] as u32) << 8) | (src[2] as u32))
111 pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
112 read_int!(self, u32, 4, to_be)
115 pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
116 peek_int!(self, u32, 4, to_be)
119 pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
120 read_int!(self, u64, 8, to_be)
123 pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
124 peek_int!(self, u64, 8, to_be)
127 pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
128 read_int!(self, u16, 2, to_le)
131 pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
132 peek_int!(self, u16, 2, to_le)
135 pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
136 let p8 = self.read_byte()?;
137 let p16 = self.read_u16le()?;
138 Ok(((p16 as u32) << 8) | (p8 as u32))
141 pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
142 let mut src: [u8; 3] = [0; 3];
143 self.peek_buf(&mut src)?;
144 Ok((src[0] as u32) | ((src[1] as u32) << 8) | ((src[2] as u32) << 16))
147 pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
148 read_int!(self, u32, 4, to_le)
151 pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
152 peek_int!(self, u32, 4, to_le)
155 pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
156 read_int!(self, u64, 8, to_le)
159 pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
160 peek_int!(self, u64, 8, to_le)
163 pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
164 if self.io.is_seekable() {
165 self.io.seek(SeekFrom::Current(len as i64))?;
168 let mut buf : [u8; 16] = [0; 16];
169 let mut bref = &mut buf;
170 while ssize > bref.len() {
171 self.io.read_buf(bref)?;
175 self.io.read_byte()?;
182 pub fn tell(&mut self) -> u64 {
186 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
190 pub fn is_eof(&mut self) -> bool {
195 impl<'a> MemoryReader<'a> {
197 pub fn new_read(buf: &'a [u8]) -> Self {
198 MemoryReader { buf: buf, size: buf.len(), pos: 0 }
201 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
202 if pos < 0 || (pos as usize) > self.size {
203 return Err(ByteIOError::WrongRange)
205 self.pos = pos as usize;
210 impl<'a> ByteIO for MemoryReader<'a> {
211 fn read_byte(&mut self) -> ByteIOResult<u8> {
212 if self.is_eof() { return Err(ByteIOError::EOF); }
213 let res = self.buf[self.pos];
214 self.pos = self.pos + 1;
218 fn peek_byte(&mut self) -> ByteIOResult<u8> {
219 if self.is_eof() { return Err(ByteIOError::EOF); }
220 Ok(self.buf[self.pos])
223 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
224 let copy_size = if self.size - self.pos < buf.len() { self.size } else { buf.len() };
225 if copy_size == 0 { return Err(ByteIOError::EOF); }
226 for i in 0..copy_size {
227 buf[i] = self.buf[self.pos + i];
232 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
233 let read_size = self.peek_buf(buf)?;
234 if read_size < buf.len() { return Err(ByteIOError::EOF); }
235 self.pos += read_size;
239 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
240 let read_size = self.peek_buf(buf)?;
241 self.pos += read_size;
245 #[allow(unused_variables)]
246 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
247 Err(ByteIOError::NotImplemented)
250 fn tell(&mut self) -> u64 {
254 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
255 let cur_pos = self.pos as i64;
256 let cur_size = self.size as i64;
258 SeekFrom::Start(x) => self.real_seek(x as i64),
259 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
260 SeekFrom::End(x) => self.real_seek(cur_size + x),
264 fn is_eof(&mut self) -> bool {
265 self.pos >= self.size
268 fn is_seekable(&mut self) -> bool {
272 fn size(&mut self) -> i64 {
273 self.buf.len() as i64
277 impl<'a> FileReader<'a> {
279 pub fn new_read(file: &'a mut File) -> Self {
280 FileReader { file: file, eof : false }
284 impl<'a> ByteIO for FileReader<'a> {
285 fn read_byte(&mut self) -> ByteIOResult<u8> {
286 let mut byte : [u8; 1] = [0];
287 let err = self.file.read(&mut byte);
288 if let Err(_) = err { return Err(ByteIOError::ReadError); }
289 let sz = err.unwrap();
290 if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
294 fn peek_byte(&mut self) -> ByteIOResult<u8> {
295 let b = self.read_byte()?;
296 self.seek(SeekFrom::Current(-1))?;
300 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
301 let res = self.file.read(buf);
302 if let Err(_) = res { return Err(ByteIOError::ReadError); }
303 let sz = res.unwrap();
304 if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
308 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
309 let res = self.file.read(buf);
310 if let Err(_) = res { return Err(ByteIOError::ReadError); }
311 let sz = res.unwrap();
312 if sz < buf.len() { self.eof = true; }
316 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
317 let size = self.read_buf(buf)?;
318 self.seek(SeekFrom::Current(-(size as i64)))?;
322 #[allow(unused_variables)]
323 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
324 Err(ByteIOError::NotImplemented)
327 fn tell(&mut self) -> u64 {
328 self.file.seek(SeekFrom::Current(0)).unwrap()
331 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
332 let res = self.file.seek(pos);
335 Err(_) => Err(ByteIOError::SeekError),
339 fn is_eof(&mut self) -> bool {
343 fn is_seekable(&mut self) -> bool {
347 fn size(&mut self) -> i64 {
353 pub struct ByteWriter<'a> {
357 pub struct MemoryWriter<'a> {
363 pub struct FileWriter<'a> {
367 impl<'a> ByteWriter<'a> {
368 pub fn new(io: &'a mut ByteIO) -> Self { ByteWriter { io: io } }
370 pub fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
371 self.io.write_buf(buf)
374 pub fn write_byte(&mut self, val: u8) -> ByteIOResult<()> {
375 let buf: [u8; 1] = [val];
376 self.io.write_buf(&buf)
379 pub fn write_u16be(&mut self, val: u16) -> ByteIOResult<()> {
380 let buf: [u8; 2] = [((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
381 self.io.write_buf(&buf)
384 pub fn write_u16le(&mut self, val: u16) -> ByteIOResult<()> {
385 let buf: [u8; 2] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8];
386 self.io.write_buf(&buf)
389 pub fn write_u24be(&mut self, val: u32) -> ByteIOResult<()> {
390 let buf: [u8; 3] = [((val >> 16) & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, (val & 0xFF) as u8];
394 pub fn write_u24le(&mut self, val: u32) -> ByteIOResult<()> {
395 let buf: [u8; 3] = [(val & 0xFF) as u8, ((val >> 8) & 0xFF) as u8, ((val >> 16) & 0xFF) as u8];
399 pub fn write_u32be(&mut self, val: u32) -> ByteIOResult<()> {
400 self.write_u16be(((val >> 16) & 0xFFFF) as u16)?;
401 self.write_u16be((val & 0xFFFF) as u16)
404 pub fn write_u32le(&mut self, val: u32) -> ByteIOResult<()> {
405 self.write_u16le((val & 0xFFFF) as u16)?;
406 self.write_u16le(((val >> 16) & 0xFFFF) as u16)
409 pub fn write_u64be(&mut self, val: u64) -> ByteIOResult<()> {
410 self.write_u32be(((val >> 32) & 0xFFFFFFFF) as u32)?;
411 self.write_u32be((val & 0xFFFFFFFF) as u32)
414 pub fn write_u64le(&mut self, val: u64) -> ByteIOResult<()> {
415 self.write_u32le((val & 0xFFFFFFFF) as u32)?;
416 self.write_u32le(((val >> 32) & 0xFFFFFFFF) as u32)
419 pub fn tell(&mut self) -> u64 {
423 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
427 pub fn size_left(&mut self) -> i64 {
428 let sz = self.io.size();
429 if sz == -1 { return -1; }
430 sz - (self.tell() as i64)
434 impl<'a> MemoryWriter<'a> {
436 pub fn new_write(buf: &'a mut [u8]) -> Self {
438 MemoryWriter { buf: buf, size: len, pos: 0 }
441 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
442 if pos < 0 || (pos as usize) > self.size {
443 return Err(ByteIOError::WrongRange)
445 self.pos = pos as usize;
450 impl<'a> ByteIO for MemoryWriter<'a> {
451 #[allow(unused_variables)]
452 fn read_byte(&mut self) -> ByteIOResult<u8> {
453 Err(ByteIOError::NotImplemented)
456 #[allow(unused_variables)]
457 fn peek_byte(&mut self) -> ByteIOResult<u8> {
458 Err(ByteIOError::NotImplemented)
461 #[allow(unused_variables)]
462 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
463 Err(ByteIOError::NotImplemented)
466 #[allow(unused_variables)]
467 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
468 Err(ByteIOError::NotImplemented)
471 #[allow(unused_variables)]
472 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
473 Err(ByteIOError::NotImplemented)
476 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
477 if self.pos + buf.len() > self.size { return Err(ByteIOError::WriteError); }
478 for i in 0..buf.len() {
479 self.buf[self.pos + i] = buf[i];
481 self.pos += buf.len();
485 fn tell(&mut self) -> u64 {
489 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
490 let cur_pos = self.pos as i64;
491 let cur_size = self.size as i64;
493 SeekFrom::Start(x) => self.real_seek(x as i64),
494 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
495 SeekFrom::End(x) => self.real_seek(cur_size + x),
499 fn is_eof(&mut self) -> bool {
500 self.pos >= self.size
503 fn is_seekable(&mut self) -> bool {
507 fn size(&mut self) -> i64 {
508 self.buf.len() as i64
512 impl<'a> FileWriter<'a> {
513 pub fn new_write(file: &'a mut File) -> Self {
514 FileWriter { file: file }
518 impl<'a> ByteIO for FileWriter<'a> {
519 #[allow(unused_variables)]
520 fn read_byte(&mut self) -> ByteIOResult<u8> {
521 Err(ByteIOError::NotImplemented)
524 #[allow(unused_variables)]
525 fn peek_byte(&mut self) -> ByteIOResult<u8> {
526 Err(ByteIOError::NotImplemented)
529 #[allow(unused_variables)]
530 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
531 Err(ByteIOError::NotImplemented)
534 #[allow(unused_variables)]
535 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
536 Err(ByteIOError::NotImplemented)
539 #[allow(unused_variables)]
540 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
541 Err(ByteIOError::NotImplemented)
544 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<()> {
545 match self.file.write_all(buf) {
547 Err(_) => Err(ByteIOError::WriteError),
551 fn tell(&mut self) -> u64 {
552 self.file.seek(SeekFrom::Current(0)).unwrap()
555 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
556 let res = self.file.seek(pos);
559 Err(_) => Err(ByteIOError::SeekError),
563 fn is_eof(&mut self) -> bool {
567 fn is_seekable(&mut self) -> bool {
571 fn size(&mut self) -> i64 {
583 //const DATA : &'static [u8] = include_bytes!("../../assets/file");
584 let buf: [u8; 64] = [1; 64];
585 let mut mr = MemoryReader::new_read(&buf);
586 let mut reader = ByteReader::new(&mut mr);
587 assert_eq!(reader.read_byte().unwrap(), 0x01u8);
588 assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
589 assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
590 assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
591 assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
592 let mut file = File::open("assets/MaoMacha.asx").unwrap();
593 let mut fr = FileReader::new_read(&mut file);
594 let mut br2 = ByteReader::new(&mut fr);
595 assert_eq!(br2.read_byte().unwrap(), 0x30);
596 assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
597 assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
598 assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
599 assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);
603 let mut buf: [u8; 64] = [0; 64];
605 let mut mw = MemoryWriter::new_write(&mut buf);
606 let mut bw = ByteWriter::new(&mut mw);
607 bw.write_byte(0x00).unwrap();
608 bw.write_u16be(0x0102).unwrap();
609 bw.write_u24be(0x030405).unwrap();
610 bw.write_u32be(0x06070809).unwrap();
611 bw.write_u64be(0x0A0B0C0D0E0F1011).unwrap();
612 bw.write_byte(0x00).unwrap();
613 bw.write_u16le(0x0201).unwrap();
614 bw.write_u24le(0x050403).unwrap();
615 bw.write_u32le(0x09080706).unwrap();
616 bw.write_u64le(0x11100F0E0D0C0B0A).unwrap();
617 assert_eq!(bw.size_left(), 28);
620 assert_eq!(buf[(i + 0x00) as usize], i);
621 assert_eq!(buf[(i + 0x12) as usize], i);