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<usize>;
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;
32 pub struct ByteReader<'a> {
36 pub struct MemoryReader<'a> {
42 pub struct FileReader<'a> {
47 macro_rules! read_int {
48 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
49 let mut buf = [0; $size];
50 try!($s.read_buf(&mut buf));
52 Ok((*(buf.as_ptr() as *const $inttype)).$which())
57 macro_rules! peek_int {
58 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
59 let mut buf = [0; $size];
60 try!($s.peek_buf(&mut buf));
62 Ok((*(buf.as_ptr() as *const $inttype)).$which())
67 impl<'a> ByteReader<'a> {
68 pub fn new(io: &'a mut ByteIO) -> Self { ByteReader { io: io } }
70 pub fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
74 pub fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
75 self.io.read_buf_some(buf)
78 pub fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
82 pub fn read_byte(&mut self) -> ByteIOResult<u8> {
86 pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
90 pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
91 read_int!(self, u16, 2, to_be)
94 pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
95 peek_int!(self, u16, 2, to_be)
98 pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
99 let p16 = self.read_u16be()?;
100 let p8 = self.read_byte()?;
101 Ok(((p16 as u32) << 8) | (p8 as u32))
104 pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
105 let mut src: [u8; 3] = [0; 3];
106 self.peek_buf(&mut src)?;
107 Ok(((src[0] as u32) << 16) | ((src[1] as u32) << 8) | (src[2] as u32))
110 pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
111 read_int!(self, u32, 4, to_be)
114 pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
115 peek_int!(self, u32, 4, to_be)
118 pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
119 read_int!(self, u64, 8, to_be)
122 pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
123 peek_int!(self, u64, 8, to_be)
126 pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
127 read_int!(self, u16, 2, to_le)
130 pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
131 peek_int!(self, u16, 2, to_le)
134 pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
135 let p8 = self.read_byte()?;
136 let p16 = self.read_u16le()?;
137 Ok(((p16 as u32) << 8) | (p8 as u32))
140 pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
141 let mut src: [u8; 3] = [0; 3];
142 self.peek_buf(&mut src)?;
143 Ok((src[0] as u32) | ((src[1] as u32) << 8) | ((src[2] as u32) << 16))
146 pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
147 read_int!(self, u32, 4, to_le)
150 pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
151 peek_int!(self, u32, 4, to_le)
154 pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
155 read_int!(self, u64, 8, to_le)
158 pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
159 peek_int!(self, u64, 8, to_le)
162 pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
163 if self.io.is_seekable() {
164 self.io.seek(SeekFrom::Current(len as i64))?;
167 let mut buf : [u8; 16] = [0; 16];
168 let mut bref = &mut buf;
169 while ssize > bref.len() {
170 self.io.read_buf(bref)?;
174 self.io.read_byte()?;
181 pub fn tell(&mut self) -> u64 {
185 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
189 pub fn is_eof(&mut self) -> bool {
194 impl<'a> MemoryReader<'a> {
196 pub fn new_read(buf: &'a [u8]) -> Self {
197 MemoryReader { buf: buf, size: buf.len(), pos: 0 }
200 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
201 if pos < 0 || (pos as usize) > self.size {
202 return Err(ByteIOError::WrongRange)
204 self.pos = pos as usize;
209 impl<'a> ByteIO for MemoryReader<'a> {
210 fn read_byte(&mut self) -> ByteIOResult<u8> {
211 if self.is_eof() { return Err(ByteIOError::EOF); }
212 let res = self.buf[self.pos];
213 self.pos = self.pos + 1;
217 fn peek_byte(&mut self) -> ByteIOResult<u8> {
218 if self.is_eof() { return Err(ByteIOError::EOF); }
219 Ok(self.buf[self.pos])
222 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
223 let copy_size = if self.size - self.pos < buf.len() { self.size } else { buf.len() };
224 if copy_size == 0 { return Err(ByteIOError::EOF); }
225 for i in 0..copy_size {
226 buf[i] = self.buf[self.pos + i];
231 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
232 let read_size = self.peek_buf(buf)?;
233 if read_size < buf.len() { return Err(ByteIOError::EOF); }
234 self.pos += read_size;
238 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
239 let read_size = self.peek_buf(buf)?;
240 self.pos += read_size;
244 #[allow(unused_variables)]
245 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<usize> {
246 Err(ByteIOError::NotImplemented)
249 fn tell(&mut self) -> u64 {
253 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
254 let cur_pos = self.pos as i64;
255 let cur_size = self.size as i64;
257 SeekFrom::Start(x) => self.real_seek(x as i64),
258 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
259 SeekFrom::End(x) => self.real_seek(cur_size + x),
263 fn is_eof(&mut self) -> bool {
264 self.pos >= self.size
267 fn is_seekable(&mut self) -> bool {
272 impl<'a> FileReader<'a> {
274 pub fn new_read(file: &'a mut File) -> Self {
275 FileReader { file: file, eof : false }
279 impl<'a> ByteIO for FileReader<'a> {
280 fn read_byte(&mut self) -> ByteIOResult<u8> {
281 let mut byte : [u8; 1] = [0];
282 let err = self.file.read(&mut byte);
283 if let Err(_) = err { return Err(ByteIOError::ReadError); }
284 let sz = err.unwrap();
285 if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
289 fn peek_byte(&mut self) -> ByteIOResult<u8> {
290 let b = self.read_byte()?;
291 self.seek(SeekFrom::Current(-1))?;
295 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
296 let res = self.file.read(buf);
297 if let Err(_) = res { return Err(ByteIOError::ReadError); }
298 let sz = res.unwrap();
299 if sz < buf.len() { self.eof = true; return Err(ByteIOError::EOF); }
303 fn read_buf_some(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
304 let res = self.file.read(buf);
305 if let Err(_) = res { return Err(ByteIOError::ReadError); }
306 let sz = res.unwrap();
307 if sz < buf.len() { self.eof = true; }
311 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
312 let size = self.read_buf(buf)?;
313 self.seek(SeekFrom::Current(-(size as i64)))?;
317 #[allow(unused_variables)]
318 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<usize> {
319 Err(ByteIOError::NotImplemented)
322 fn tell(&mut self) -> u64 {
323 self.file.seek(SeekFrom::Current(0)).unwrap()
326 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
327 let res = self.file.seek(pos);
330 Err(_) => Err(ByteIOError::SeekError),
334 fn is_eof(&mut self) -> bool {
338 fn is_seekable(&mut self) -> bool {
350 //const DATA : &'static [u8] = include_bytes!("../../assets/file");
351 let buf: [u8; 64] = [1; 64];
352 let mut mr = MemoryReader::new_read(&buf);
353 let mut reader = ByteReader::new(&mut mr);
354 assert_eq!(reader.read_byte().unwrap(), 0x01u8);
355 assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
356 assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
357 assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
358 assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
359 let mut file = File::open("assets/MaoMacha.asx").unwrap();
360 let mut fr = FileReader::new_read(&mut file);
361 let mut br2 = ByteReader::new(&mut fr);
362 assert_eq!(br2.read_byte().unwrap(), 0x30);
363 assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
364 assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
365 assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
366 assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);