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_byte(&mut self) -> ByteIOResult<u8>;
21 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<usize>;
22 fn tell(&mut self) -> u64;
23 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64>;
24 fn is_eof(&mut self) -> bool;
25 fn is_seekable(&mut self) -> bool;
29 pub struct ByteReader<'a> {
33 pub struct MemoryReader<'a> {
40 pub struct FileReader<'a> {
45 macro_rules! read_int {
46 ($s: ident, $inttype: ty, $size: expr, $which: ident) => ({
47 let mut buf = [0; $size];
48 try!($s.read_buf(&mut buf));
50 Ok((*(buf.as_ptr() as *const $inttype)).$which())
55 impl<'a> ByteReader<'a> {
56 pub fn new(io: &'a mut ByteIO) -> ByteReader { ByteReader { io: io } }
58 pub fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
62 pub fn read_byte(&mut self) -> ByteIOResult<u8> {
66 pub fn read_u16be(&mut self) -> ByteIOResult<u16> {
67 read_int!(self, u16, 2, to_be)
70 pub fn read_u24be(&mut self) -> ByteIOResult<u32> {
71 let p16 = self.read_u16be();
72 if let Err(e) = p16 { return Err(e); }
73 let p8 = self.read_byte();
74 if let Err(e) = p8 { return Err(e); }
75 Ok(((p16.unwrap() as u32) << 8) | (p8.unwrap() as u32))
78 pub fn read_u32be(&mut self) -> ByteIOResult<u32> {
79 read_int!(self, u32, 4, to_be)
82 pub fn read_u64be(&mut self) -> ByteIOResult<u64> {
83 read_int!(self, u64, 8, to_be)
86 pub fn read_u16le(&mut self) -> ByteIOResult<u16> {
87 read_int!(self, u16, 2, to_le)
90 pub fn read_u24le(&mut self) -> ByteIOResult<u32> {
91 let p8 = self.read_byte();
92 if let Err(e) = p8 { return Err(e); }
93 let p16 = self.read_u16le();
94 if let Err(e) = p16 { return Err(e); }
95 Ok(((p16.unwrap() as u32) << 8) | (p8.unwrap() as u32))
98 pub fn read_u32le(&mut self) -> ByteIOResult<u32> {
99 read_int!(self, u32, 4, to_le)
102 pub fn read_u64le(&mut self) -> ByteIOResult<u64> {
103 read_int!(self, u64, 8, to_le)
106 pub fn read_skip(&mut self, len: usize) -> ByteIOResult<u64> {
107 if self.io.is_seekable() {
108 self.io.seek(SeekFrom::Current(len as i64))?;
111 let mut buf : [u8; 16] = [0; 16];
112 let mut bref = &mut buf;
113 while ssize > bref.len() {
114 self.io.read_buf(bref)?;
118 self.io.read_byte()?;
125 pub fn tell(&mut self) -> u64 {
129 pub fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
133 pub fn is_eof(&mut self) -> bool {
138 impl<'a> MemoryReader<'a> {
140 pub fn new_read(buf: &'a [u8]) -> Self {
141 MemoryReader { buf: buf, size: buf.len(), pos: 0, do_write: false }
144 fn real_seek(&mut self, pos: i64) -> ByteIOResult<u64> {
145 if pos < 0 || (pos as usize) > self.size {
146 return Err(ByteIOError::WrongRange)
148 self.pos = pos as usize;
152 fn check_read_perm(&self) -> ByteIOResult<()> {
154 Err(ByteIOError::WrongIOMode)
160 fn check_write_perm(&self) -> ByteIOResult<()> {
162 Err(ByteIOError::WrongIOMode)
169 impl<'a> ByteIO for MemoryReader<'a> {
170 fn read_byte(&mut self) -> ByteIOResult<u8> {
171 self.check_read_perm()?;
172 if self.is_eof() { return Err(ByteIOError::EOF); }
173 let res = self.buf[self.pos];
174 self.pos = self.pos + 1;
178 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
179 self.check_read_perm()?;
180 let copy_size = if self.size - self.pos < buf.len() { self.size } else { buf.len() };
181 if copy_size == 0 { return Err(ByteIOError::EOF); }
182 for i in 0..copy_size {
183 buf[i] = self.buf[self.pos + i];
185 self.pos += copy_size;
189 #[allow(unused_variables)]
190 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<usize> {
191 self.check_write_perm()?;
192 Err(ByteIOError::NotImplemented)
195 fn tell(&mut self) -> u64 {
199 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
200 let cur_pos = self.pos as i64;
201 let cur_size = self.size as i64;
203 SeekFrom::Start(x) => self.real_seek(x as i64),
204 SeekFrom::Current(x) => self.real_seek(cur_pos + x),
205 SeekFrom::End(x) => self.real_seek(cur_size + x),
209 fn is_eof(&mut self) -> bool {
210 self.pos >= self.size
213 fn is_seekable(&mut self) -> bool {
218 impl<'a> FileReader<'a> {
220 pub fn new_read(file: &'a mut File) -> Self {
221 FileReader { file: file, eof : false }
225 impl<'a> ByteIO for FileReader<'a> {
226 fn read_byte(&mut self) -> ByteIOResult<u8> {
227 let mut byte : [u8; 1] = [0];
228 let err = self.file.read(&mut byte);
229 if let Err(_) = err { return Err(ByteIOError::ReadError); }
230 let sz = err.unwrap();
231 if sz == 0 { self.eof = true; return Err(ByteIOError::EOF); }
235 fn read_buf(&mut self, buf: &mut [u8]) -> ByteIOResult<usize> {
236 let res = self.file.read(buf);
237 if let Err(_) = res { return Err(ByteIOError::ReadError); }
238 let sz = res.unwrap();
239 if sz < buf.len() { self.eof = true; }
243 #[allow(unused_variables)]
244 fn write_buf(&mut self, buf: &[u8]) -> ByteIOResult<usize> {
245 Err(ByteIOError::NotImplemented)
248 fn tell(&mut self) -> u64 {
249 self.file.seek(SeekFrom::Current(0)).unwrap()
252 fn seek(&mut self, pos: SeekFrom) -> ByteIOResult<u64> {
253 let res = self.file.seek(pos);
256 Err(_) => Err(ByteIOError::SeekError),
260 fn is_eof(&mut self) -> bool {
264 fn is_seekable(&mut self) -> bool {
276 //const DATA : &'static [u8] = include_bytes!("../../assets/file");
277 let buf: [u8; 64] = [1; 64];
278 let mut mr = MemoryReader::new_read(&buf);
279 let mut reader = ByteReader::new(&mut mr);
280 assert_eq!(reader.read_byte().unwrap(), 0x01u8);
281 assert_eq!(reader.read_u16le().unwrap(), 0x0101u16);
282 assert_eq!(reader.read_u24le().unwrap(), 0x010101u32);
283 assert_eq!(reader.read_u32le().unwrap(), 0x01010101u32);
284 assert_eq!(reader.read_u64le().unwrap(), 0x0101010101010101u64);
285 let mut file = File::open("assets/MaoMacha.asx").unwrap();
286 let mut fr = FileReader::new_read(&mut file);
287 let mut br2 = ByteReader::new(&mut fr);
288 assert_eq!(br2.read_byte().unwrap(), 0x30);
289 assert_eq!(br2.read_u24be().unwrap(), 0x26B275);
290 assert_eq!(br2.read_u24le().unwrap(), 0xCF668E);
291 assert_eq!(br2.read_u32be().unwrap(), 0x11A6D900);
292 assert_eq!(br2.read_u32le().unwrap(), 0xCE6200AA);