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