Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/src/bdat/count.rs

22.4 KiB, 26 runs

created by r1870400018:445, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1use crate::{
2 prelude::*,
3 usr::UsrKindId,
4};
5
6use oxedyne_fe2o3_core::prelude::*;
7
8use std::{
9 convert::TryFrom,
10 io::{
11 self,
12 SeekFrom,
13 },
14};
15
16
17impl Dat {
18
19 fn count_c64<R: io::Read>(r: &mut R, code: u8) -> Outcome<(usize, usize)> {
20 match code - Self::C64_CODE_START {
21 1 => {
22 let mut v = [0;1];
23 res!(r.read_exact(&mut v));
24 Ok((Self::read_c64_as_usize(&v), 1))
25 },
26 2 => {
27 let mut v = [0;2];
28 res!(r.read_exact(&mut v));
29 Ok((Self::read_c64_as_usize(&v), 2))
30 },
31 3 => {
32 let mut v = [0;3];
33 res!(r.read_exact(&mut v));
34 Ok((Self::read_c64_as_usize(&v), 3))
35 },
36 4 => {
37 let mut v = [0;4];
38 res!(r.read_exact(&mut v));
39 Ok((Self::read_c64_as_usize(&v), 4))
40 },
41 5 => {
42 let mut v = [0;5];
43 res!(r.read_exact(&mut v));
44 Ok((Self::read_c64_as_usize(&v), 5))
45 },
46 6 => {
47 let mut v = [0;6];
48 res!(r.read_exact(&mut v));
49 Ok((Self::read_c64_as_usize(&v), 6))
50 },
51 7 => {
52 let mut v = [0;7];
53 res!(r.read_exact(&mut v));
54 Ok((Self::read_c64_as_usize(&v), 7))
55 },
56 8 => {
57 let mut v = [0;8];
58 res!(r.read_exact(&mut v));
59 Ok((Self::read_c64_as_usize(&v), 8))
60 },
61 _ => unreachable!(),
62 }
63 }
64
65 pub fn count_bytes<RS: io::Read + io::Seek>(rs: &mut RS) -> Outcome<usize> {
66 let mut count: usize = 0;
67 res!(Self::count_bytes_muncher(rs, &mut count));
68 Ok(count)
69 }
70
71 /// This method counts the raw bytes for an encoded `Dat`, whilst also moving the reader
72 /// cursor position to the end of the `Dat`.
73 pub fn count_bytes_muncher<RS: io::Read + io::Seek>(
74 mut rs: &mut RS,
75 count: &mut usize,
76 )
77 -> Outcome<()>
78 {
79 let mut dcode = [0; 1];
80 match rs.read_exact(&mut dcode) {
81 Err(e) => match e.kind() {
82 std::io::ErrorKind::UnexpectedEof => return Ok(()),
83 _ => return Err(err!(e,
84 "While trying to read Dat code from reader.";
85 Decode, Bytes)),
86 },
87 Ok(()) => (),
88 }
89 *count += 1;
90 match dcode[0] {
91 // Atomic Kinds ===========================
92 // Logic
93 Self::EMPTY_CODE |
94 Self::TRUE_CODE |
95 Self::FALSE_CODE |
96 Self::OPT_NONE_CODE => return Ok(()),
97 // Fixed
98 Self::U8_CODE => {
99 // +---+---+
100 // | c | |
101 // +---+---+
102 // \___/
103 // |
104 // u8
105 //
106 res!(rs.seek(SeekFrom::Current(1)));
107 *count += 1;
108 return Ok(());
109 },
110 Self::U16_CODE => {
111 // MSB LSB
112 // +---+---+---+
113 // | c | | |
114 // +---+---+---+
115 // \_______/
116 // |
117 // u16
118 //
119 res!(rs.seek(SeekFrom::Current(2)));
120 *count += 2;
121 return Ok(());
122 },
123 Self::U32_CODE => {
124 // MSB LSB
125 // +---+---+---+---+---+
126 // | c | | | | |
127 // +---+---+---+---+---+
128 // \_______________/
129 // |
130 // u32
131 //
132 res!(rs.seek(SeekFrom::Current(4)));
133 *count += 4;
134 return Ok(());
135 },
136 Self::U64_CODE => {
137 // MSB LSB
138 // +---+---+---+---+---+---+---+---+---+
139 // | c | | | | | | | | |
140 // +---+---+---+---+---+---+---+---+---+
141 // \_______________________________/
142 // |
143 // u64
144 //
145 res!(rs.seek(SeekFrom::Current(8)));
146 *count += 8;
147 return Ok(());
148 },
149 Self::U128_CODE => {
150 // MSB LSB
151 // +---+---+---+---+---+---+---+---+---+
152 // | c | | | | | | | | |
153 // +---+---+---+---+---+---+---+---+---+
154 // \_______________________________/
155 // |
156 // u128
157 //
158 res!(rs.seek(SeekFrom::Current(16)));
159 *count += 16;
160 return Ok(());
161 },
162 Self::I8_CODE => {
163 // +---+---+
164 // | c | |
165 // +---+---+
166 // \___/
167 // |
168 // i8
169 //
170 res!(rs.seek(SeekFrom::Current(1)));
171 *count += 1;
172 return Ok(());
173 },
174 Self::I16_CODE => {
175 // MSB LSB
176 // +---+---+---+
177 // | c | | |
178 // +---+---+---+
179 // \_______/
180 // |
181 // i16
182 //
183 res!(rs.seek(SeekFrom::Current(2)));
184 *count += 2;
185 return Ok(());
186 },
187 Self::I32_CODE => {
188 // MSB LSB
189 // +---+---+---+---+---+
190 // | c | | | | |
191 // +---+---+---+---+---+
192 // \_______________/
193 // |
194 // i32
195 //
196 res!(rs.seek(SeekFrom::Current(4)));
197 *count += 4;
198 return Ok(());
199 },
200 Self::I64_CODE => {
201 // MSB LSB
202 // +---+---+---+---+---+---+---+---+---+
203 // | c | | | | | | | | |
204 // +---+---+---+---+---+---+---+---+---+
205 // \_______________________________/
206 // |
207 // i64
208 //
209 res!(rs.seek(SeekFrom::Current(8)));
210 *count += 8;
211 return Ok(());
212 },
213 Self::I128_CODE => {
214 // MSB LSB
215 // +---+---+---+---+---+---+---+---+---+
216 // | c | | | | | | | | |
217 // +---+---+---+---+---+---+---+---+---+
218 // \_______________________________/
219 // |
220 // i128
221 //
222 res!(rs.seek(SeekFrom::Current(16)));
223 *count += 16;
224 return Ok(());
225 },
226 Self::F32_CODE => {
227 // MSB LSB
228 // +---+---+---+---+---+
229 // | c | | | | |
230 // +---+---+---+---+---+
231 // \_______________/
232 // |
233 // f32
234 //
235 res!(rs.seek(SeekFrom::Current(4)));
236 *count += 4;
237 return Ok(());
238 },
239 Self::F64_CODE => {
240 // MSB LSB
241 // +---+---+---+---+---+---+---+---+---+
242 // | c | | | | | | | | |
243 // +---+---+---+---+---+---+---+---+---+
244 // \_______________________________/
245 // |
246 // f64
247 //
248 res!(rs.seek(SeekFrom::Current(8)));
249 *count += 8;
250 return Ok(());
251 },
252 // Variable
253 Self::BC64_CODE |
254 Self::STR_CODE |
255 Self::AINT_CODE |
256 Self::ADEC_CODE |
257 Self::LIST_CODE |
258 Self::VEK_CODE |
259 Self::MAP_CODE |
260 Self::OMAP_CODE => {
261 //
262 // 0 1 2 ... n 1 2 ... v
263 // +---+---+---+---+---+---+---+---+---+
264 // | c | | | | | | ... | |
265 // +---+---+---+---+---+---+---+---+---+
266 // \______________/\______________/
267 // | |
268 // c64 payload bytes
269 //
270 let mut c64code = [0;1];
271 res!(rs.read_exact(&mut c64code));
272 *count += 1;
273 if c64code[0] < Self::C64_CODE_START || c64code[0] > Self::C64_CODE_START + 8 {
274 return Err(err!(
275 "Expected a valid Dat::C64 code between {} and {} inclusive, \
276 instead found {}.", Self::C64_CODE_START, Self::C64_CODE_START + 8,
277 c64code[0];
278 Invalid, Input, Decode, Bytes));
279 }
280 if c64code[0] == Self::C64_CODE_START {
281 return Ok(());
282 }
283 // Avoid the use of the heap for the C64, for what it's worth.
284 let (vlen, c64len) = res!(Self::count_c64(&mut rs, c64code[0]));
285 *count += c64len + vlen;
286 if vlen > i64::MAX as usize {
287 return Err(err!(
288 "The size of the payload (the value contained in the Dat::C64), \
289 {} bytes, exceeds the maximum increment that can be added to the \
290 reader cursor position of {}.", vlen, i64::MAX;
291 Invalid, Input, Decode, Bytes));
292 }
293 res!(rs.seek(SeekFrom::Current(vlen as i64)));
294 return Ok(())
295 },
296 Self::C64_CODE_START..=Self::C64_CODE_END => { // C64
297 //
298 // MSB big endian LSB
299 // +---+---+---+---+---+---+---+---+
300 // | 0 | 0 | 0 | 0 | 0 | 0 | 0 |128|
301 // +---+---+---+---+---+---+---+---+
302 // \_______________________________/
303 // |
304 // u64
305 //
306 // Potential encoding for: Dat::C64
307 // +---+---+---+
308 // | c | n |128| n = 1
309 // +---+---+---+
310 // \___________/
311 // |
312 // c64
313 //
314 // Actual encoding for: Dat::C64
315 // +---+---+
316 // | c |128| c -> c + 1 (n = 1 incorporated into prefix code)
317 // +---+---+
318 // \_______/
319 // |
320 // c64
321 //
322 if dcode[0] < Self::C64_CODE_START || dcode[0] > Self::C64_CODE_START + 8 {
323 return Err(err!(
324 "Expected a valid Dat::C64 code between {} and {} inclusive, \
325 instead found {}.", Self::C64_CODE_START, Self::C64_CODE_START + 8,
326 dcode[0];
327 Invalid, Input, Decode, Bytes));
328 }
329 if dcode[0] == Self::C64_CODE_START {
330 return Ok(());
331 }
332 let c64len = dcode[0] - Self::C64_CODE_START;
333 *count += c64len as usize;
334 res!(rs.seek(SeekFrom::Current(c64len as i64)));
335 return Ok(());
336 },
337 // Molecule Kinds =========================
338 // Unitary
339 Self::USR_CODE => {
340 //
341 // +---+---+---+---+---+---+---+---+---+
342 // | c | u16 | | | | | | |
343 // +---+---+---+---+---+---+---+---+---+
344 // ^ ^ ^ \___________________/
345 // | | | |
346 // | | opt code inner Dat
347 // | ukid_code (if some)
348 // daticle
349 // code
350 //
351 const CODE_LEN: usize = UsrKindId::CODE_BYTE_LEN;
352 let code_len = try_into!(i64, CODE_LEN);
353 res!(rs.seek(SeekFrom::Current(code_len)));
354 *count += CODE_LEN;
355 let mut v = [0; 1];
356 res!(rs.read_exact(&mut v));
357 *count += 1;
358 let opt_code = v[0];
359 if opt_code == Self::OPT_SOME_CODE {
360 res!(Self::count_bytes_muncher(rs, count));
361 }
362 return Ok(());
363 },
364 Self::BOX_CODE => {
365 //
366 // +---+---+---+---+---+---+---+---+---+
367 // | c | | | | | | | | |
368 // +---+---+---+---+---+---+---+---+---+
369 // \_______________________________/
370 // |
371 // inner Dat
372 //
373 // Dat::Box(k) byte encoding does nothing more than prepend Dat k with
374 // Dat::BOX_CODE
375 //
376 res!(Self::count_bytes_muncher(rs, count));
377 return Ok(())
378 },
379 Self::OPT_SOME_CODE => {
380 //
381 // +---+---+---+---+---+---+---+---+---+
382 // | c | | | | | | | | |
383 // +---+---+---+---+---+---+---+---+---+
384 // \_______________________________/
385 // |
386 // inner Dat
387 //
388 // Dat::Opt(Some(k)) byte encoding does nothing more than prepend Dat k
389 // with Dat::OPT_SOME_CODE
390 //
391 res!(Self::count_bytes_muncher(rs, count));
392 return Ok(());
393 },
394 // Heterogenous
395 Self::TUP2_CODE |
396 Self::TUP3_CODE |
397 Self::TUP4_CODE |
398 Self::TUP5_CODE |
399 Self::TUP6_CODE |
400 Self::TUP7_CODE |
401 Self::TUP8_CODE |
402 Self::TUP9_CODE |
403 Self::TUP10_CODE => {
404 //
405 // 0 1 ...
406 // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
407 // | c | c | | | c | | | c | | | | ... | |
408 // +---+---+---+---+---+---+---+---+---+---+---+---+---+---+
409 // \__________/\__________/\______________/ ...
410 // | | |
411 // item item item
412 //
413 let n = dcode[0] - Self::TUP_SERIES_START + 2;
414 for _ in 0..n {
415 res!(Self::count_bytes_muncher(rs, count));
416 }
417 return Ok(())
418 },
419 // Homogenous
420 // Variable length bytes
421 Self::BU8_CODE => {
422 //
423 // 0 1 1 2 ... v
424 // +---+---+---+---+---+---+ Fixed size, raw u8 for payload length
425 // | c | | | ... | |
426 // +---+---+---+---+---+---+
427 // \__/\______________/
428 // | |
429 // raw u8 payload bytes
430 //
431 let mut v = [0;1];
432 res!(rs.read_exact(&mut v));
433 let vlen = u8::from_be_bytes(
434 res!(<[u8; 1]>::try_from(&v[..]), Decode, Bytes)
435 ) as usize;
436 *count += 1 + vlen;
437 res!(rs.seek(SeekFrom::Current(vlen as i64)));
438 return Ok(())
439 },
440 Self::BU16_CODE => {
441 //
442 // 0 1 2 1 2 ... v
443 // +---+---+---+---+---+---+---+ Fixed size, raw u16 for payload length
444 // | c | | | | ... | |
445 // +---+---+---+---+---+---+---+
446 // \______/\______________/
447 // | |
448 // raw u16 payload bytes
449 //
450 let mut v = [0;2];
451 res!(rs.read_exact(&mut v));
452 let vlen = u16::from_be_bytes(
453 res!(<[u8; 2]>::try_from(&v[..]), Decode, Bytes)
454 ) as usize;
455 *count += 2 + vlen;
456 res!(rs.seek(SeekFrom::Current(vlen as i64)));
457 return Ok(())
458 },
459 Self::BU32_CODE => {
460 //
461 // 0 1 2 ... 4 1 2 ... v
462 // +---+---+---+---+---+---+---+---+---+ Fixed size, raw u32 for payload length
463 // | c | | | | | | ... | |
464 // +---+---+---+---+---+---+---+---+---+
465 // \______________/\______________/
466 // | |
467 // raw u32 payload bytes
468 //
469 let mut v = [0;4];
470 res!(rs.read_exact(&mut v));
471 let vlen = u32::from_be_bytes(
472 res!(<[u8; 4]>::try_from(&v[..]), Decode, Bytes)
473 ) as usize;
474 *count += 4 + vlen;
475 res!(rs.seek(SeekFrom::Current(vlen as i64)));
476 return Ok(())
477 },
478 Self::BU64_CODE => {
479 //
480 // 0 1 2 ... 8 1 2 ... v
481 // +---+---+---+---+---+---+---+---+---+ Fixed size, raw u64 for payload length
482 // | c | | | | | | ... | |
483 // +---+---+---+---+---+---+---+---+---+
484 // \______________/\______________/
485 // | |
486 // raw u64 payload bytes
487 //
488 let mut v = [0;8];
489 res!(rs.read_exact(&mut v));
490 let vlen = u64::from_be_bytes(
491 res!(<[u8; 8]>::try_from(&v[..]), Decode, Bytes)
492 ) as usize;
493 *count += 8 + vlen;
494 if vlen > i64::MAX as usize {
495 return Err(err!(
496 "The size of the payload (the value contained in the u64), \
497 {} bytes, exceeds the maximum increment that can be added to the \
498 reader cursor position of {}.", vlen, i64::MAX;
499 Invalid, Input, Decode, Bytes));
500 }
501 res!(rs.seek(SeekFrom::Current(vlen as i64)));
502 return Ok(())
503 },
504 // Fixed length bytes
505 Self::B2_CODE => binary_count_byte_tuple! { u8, 2, rs, count },
506 Self::B3_CODE => binary_count_byte_tuple! { u8, 3, rs, count },
507 Self::B4_CODE => binary_count_byte_tuple! { u8, 4, rs, count },
508 Self::B5_CODE => binary_count_byte_tuple! { u8, 5, rs, count },
509 Self::B6_CODE => binary_count_byte_tuple! { u8, 6, rs, count },
510 Self::B7_CODE => binary_count_byte_tuple! { u8, 7, rs, count },
511 Self::B8_CODE => binary_count_byte_tuple! { u8, 8, rs, count },
512 Self::B9_CODE => binary_count_byte_tuple! { u8, 9, rs, count },
513 Self::B10_CODE => binary_count_byte_tuple! { u8, 10, rs, count },
514 Self::B16_CODE => binary_count_byte_tuple! { u8, 16, rs, count },
515 Self::B32_CODE => binary_count_byte_tuple! { u8, 32, rs, count },
516 // Fixed length numbers
517 Self::TUP2_U16_CODE => binary_count_byte_tuple! { u16, 2, rs, count },
518 Self::TUP3_U16_CODE => binary_count_byte_tuple! { u16, 3, rs, count },
519 Self::TUP4_U16_CODE => binary_count_byte_tuple! { u16, 4, rs, count },
520 Self::TUP5_U16_CODE => binary_count_byte_tuple! { u16, 5, rs, count },
521 Self::TUP6_U16_CODE => binary_count_byte_tuple! { u16, 6, rs, count },
522 Self::TUP7_U16_CODE => binary_count_byte_tuple! { u16, 7, rs, count },
523 Self::TUP8_U16_CODE => binary_count_byte_tuple! { u16, 8, rs, count },
524 Self::TUP9_U16_CODE => binary_count_byte_tuple! { u16, 9, rs, count },
525 Self::TUP10_U16_CODE => binary_count_byte_tuple! { u16, 10, rs, count },
526
527 Self::TUP2_U32_CODE => binary_count_byte_tuple! { u32, 2, rs, count },
528 Self::TUP3_U32_CODE => binary_count_byte_tuple! { u32, 3, rs, count },
529 Self::TUP4_U32_CODE => binary_count_byte_tuple! { u32, 4, rs, count },
530 Self::TUP5_U32_CODE => binary_count_byte_tuple! { u32, 5, rs, count },
531 Self::TUP6_U32_CODE => binary_count_byte_tuple! { u32, 6, rs, count },
532 Self::TUP7_U32_CODE => binary_count_byte_tuple! { u32, 7, rs, count },
533 Self::TUP8_U32_CODE => binary_count_byte_tuple! { u32, 8, rs, count },
534 Self::TUP9_U32_CODE => binary_count_byte_tuple! { u32, 9, rs, count },
535 Self::TUP10_U32_CODE => binary_count_byte_tuple! { u32, 10, rs, count },
536
537 Self::TUP2_U64_CODE => binary_count_byte_tuple! { u64, 2, rs, count },
538 Self::TUP3_U64_CODE => binary_count_byte_tuple! { u64, 3, rs, count },
539 Self::TUP4_U64_CODE => binary_count_byte_tuple! { u64, 4, rs, count },
540 Self::TUP5_U64_CODE => binary_count_byte_tuple! { u64, 5, rs, count },
541 Self::TUP6_U64_CODE => binary_count_byte_tuple! { u64, 6, rs, count },
542 Self::TUP7_U64_CODE => binary_count_byte_tuple! { u64, 7, rs, count },
543 Self::TUP8_U64_CODE => binary_count_byte_tuple! { u64, 8, rs, count },
544 Self::TUP9_U64_CODE => binary_count_byte_tuple! { u64, 9, rs, count },
545 Self::TUP10_U64_CODE => binary_count_byte_tuple! { u64, 10, rs, count },
546
547 code => return Err(err!(
548 "Dat identification code {} not recognised.", code;
549 Invalid, Input)),
550 }
551 }
552}