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 peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize>;
21 fn read_byte(&mut self) -> ByteIOResult<u8>;
22 fn peek_byte(&mut self) -> ByteIOResult<u8>;
23 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<usize>;
24 fn tell(&mut self) -> u64;
25 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
26 fn is_eof(&mut self) -> bool;
27 fn is_seekable(&mut self) -> bool;
31 pub struct ByteReader<'a> {
35 pub struct MemoryReader<'a> {
41 pub struct FileReader<'a> {
46 macro_rules! read_int {
47 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
48 let mut buf = [0; $size];
49 try!($s.read_buf(&mut buf));
51 Ok((*(buf.as_ptr() as *const $inttype)).$which())
56 macro_rules! peek_int {
57 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
58 let mut buf = [0; $size];
59 try!($s.peek_buf(&mut buf));
61 Ok((*(buf.as_ptr() as *const $inttype)).$which())
66 impl<'a> ByteReader<'a> {
67 pub fn new(io: &'a mut ByteIO) -> ByteReader { ByteReader { io: io } }
69 pub fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
73 pub fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
77 pub fn read_byte(&mut self) -> ByteIOResult<u8> {
81 pub fn peek_byte(&mut self) -> ByteIOResult<u8> {
85 pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
86 read_int!(self, u16, 2, to_be)
89 pub fn peek_u16be(&mut self) -> ByteIOResult<u16> {
90 peek_int!(self, u16, 2, to_be)
93 pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
94 let p16 = self.read_u16be()?;
95 let p8 = self.read_byte()?;
96 Ok(((p16 as u32) << 8) | (p8 as u32))
99 pub fn peek_u24be(&mut self) -> ByteIOResult<u32> {
100 let mut src: [u8; 3] = [0; 3];
101 self.peek_buf(&mut src)?;
102 Ok(((src[0] as u32) << 16) | ((src[1] as u32) << 8) | (src[2] as u32))
105 pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
106 read_int!(self, u32, 4, to_be)
109 pub fn peek_u32be(&mut self) -> ByteIOResult<u32> {
110 peek_int!(self, u32, 4, to_be)
113 pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
114 read_int!(self, u64, 8, to_be)
117 pub fn peek_u64be(&mut self) -> ByteIOResult<u64> {
118 peek_int!(self, u64, 8, to_be)
121 pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
122 read_int!(self, u16, 2, to_le)
125 pub fn peek_u16le(&mut self) -> ByteIOResult<u16> {
126 peek_int!(self, u16, 2, to_le)
129 pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
130 let p8 = self.read_byte()?;
131 let p16 = self.read_u16le()?;
132 Ok(((p16 as u32) << 8) | (p8 as u32))
135 pub fn peek_u24le(&mut self) -> ByteIOResult<u32> {
136 let mut src: [u8; 3] = [0; 3];
137 self.peek_buf(&mut src)?;
138 Ok((src[0] as u32) | ((src[1] as u32) << 8) | ((src[2] as u32) << 16))
141 pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
142 read_int!(self, u32, 4, to_le)
145 pub fn peek_u32le(&mut self) -> ByteIOResult<u32> {
146 peek_int!(self, u32, 4, to_le)
149 pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
150 read_int!(self, u64, 8, to_le)
153 pub fn peek_u64le(&mut self) -> ByteIOResult<u64> {
154 peek_int!(self, u64, 8, to_le)
157 pub fn read_skip(&mut self, len: usize) -> ByteIOResult<()> {
158 if self.io.is_seekable() {
159 self.io.seek(SeekFrom::Current(len as i64))?;
162 let mut buf : [u8; 16] = [0; 16];
163 let mut bref = &mut buf;
164 while ssize > bref.len() {
165 self.io.read_buf(bref)?;
169 self.io.read_byte()?;
176 pub fn tell(&mut self) -> u64 {
180 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
184 pub fn is_eof(&mut self) -> bool {
189 impl<'a> MemoryReader<'a> {
191 pub fn new_read(buf: &'a [u8]) -> Self {
192 MemoryReader { buf: buf, size: buf.len(), pos: 0 }
195 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
196 if pos < 0 || (pos as usize) > self.size {
197 return Err(ByteIOError::WrongRange)
199 self.pos = pos as usize;
204 impl<'a> ByteIO for MemoryReader<'a> {
205 fn read_byte(&mut self) -> ByteIOResult<u8> {
206 if self.is_eof() { return Err(ByteIOError::EOF); }
207 let res = self.buf[self.pos];
208 self.pos = self.pos + 1;
212 fn peek_byte(&mut self) -> ByteIOResult<u8> {
213 if self.is_eof() { return Err(ByteIOError::EOF); }
214 Ok(self.buf[self.pos])
217 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
218 let copy_size = if self.size - self.pos < buf.len() { self.size } else { buf.len() };
219 if copy_size == 0 { return Err(ByteIOError::EOF); }
220 for i in 0..copy_size {
221 buf[i] = self.buf[self.pos + i];
226 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
227 let read_size = self.peek_buf(buf)?;
228 self.pos += read_size;
232 #[allow(unused_variables)]
233 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<usize> {
234 Err(ByteIOError::NotImplemented)
237 fn tell(&mut self) -> u64 {
241 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
242 let cur_pos = self.pos as i64;
243 let cur_size = self.size as i64;
245 SeekFrom::Start(x) => self.real_seek(x as i64),
246 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
247 SeekFrom::End(x) => self.real_seek(cur_size + x),
251 fn is_eof(&mut self) -> bool {
252 self.pos >= self.size
255 fn is_seekable(&mut self) -> bool {
260 impl<'a> FileReader<'a> {
262 pub fn new_read(file: &'a mut File) -> Self {
263 FileReader { file: file, eof : false }
267 impl<'a> ByteIO for FileReader<'a> {
268 fn read_byte(&mut self) -> ByteIOResult<u8> {
269 let mut byte : [u8; 1] = [0];
270 let err = self.file.read(&mut byte);
271 if let Err(_) = err { return Err(ByteIOError::ReadError); }
272 let sz = err.unwrap();
273 if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
277 fn peek_byte(&mut self) -> ByteIOResult<u8> {
278 let b = self.read_byte()?;
279 self.seek(SeekFrom::Current(-1))?;
283 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
284 let res = self.file.read(buf);
285 if let Err(_) = res { return Err(ByteIOError::ReadError); }
286 let sz = res.unwrap();
287 if sz < buf.len() { self.eof = true; }
291 fn peek_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
292 let size = self.read_buf(buf)?;
293 self.seek(SeekFrom::Current(-(size as i64)))?;
297 #[allow(unused_variables)]
298 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<usize> {
299 Err(ByteIOError::NotImplemented)
302 fn tell(&mut self) -> u64 {
303 self.file.seek(SeekFrom::Current(0)).unwrap()
306 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
307 let res = self.file.seek(pos);
310 Err(_) => Err(ByteIOError::SeekError),
314 fn is_eof(&mut self) -> bool {
318 fn is_seekable(&mut self) -> bool {
330 //const DATA : &'static [u8] = include_bytes!("../../assets/file");
331 let buf: [u8; 64] = [1; 64];
332 let mut mr = MemoryReader::new_read(&buf);
333 let mut reader = ByteReader::new(&mut mr);
334 assert_eq!(reader.read_byte().unwrap(), 0x01u8);
335 assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
336 assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
337 assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
338 assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
339 let mut file = File::open("assets/MaoMacha.asx").unwrap();
340 let mut fr = FileReader::new_read(&mut file);
341 let mut br2 = ByteReader::new(&mut fr);
342 assert_eq!(br2.read_byte().unwrap(), 0x30);
343 assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
344 assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
345 assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
346 assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);