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