Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/src/daticle.rs

28.8 KiB, 13 runs

created by r1870400018:463, 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 note::NoteConfig,
4 usr::UsrKindId,
5};
6
7use oxedyne_fe2o3_core::prelude::*;
8use oxedyne_fe2o3_num::{
9 float::{
10 Float32,
11 Float64,
12 },
13};
14
15use std::{
16 collections::{
17 BTreeMap,
18 VecDeque,
19 },
20};
21
22use bigdecimal::BigDecimal;
23use num_bigint::BigInt;
24
25
26pub trait Daticle {
27 fn kind(&self) -> Kind;
28}
29
30/// An enumeration for owned serialisation and deserialisation.
31#[derive(Clone, Eq, Ord, PartialEq, PartialOrd)]
32pub enum Dat {
33 // Atomic Kinds ===========================
34 // Logic
35 Empty,
36 Bool(bool),
37 // Fixed
38 U8(u8),
39 U16(u16),
40 U32(u32),
41 U64(u64),
42 U128(u128),
43 I8(i8),
44 I16(i16),
45 I32(i32),
46 I64(i64),
47 I128(i128),
48 F32(Float32),
49 F64(Float64),
50 // Variable
51 Aint(BigInt),
52 Adec(BigDecimal),
53 C64(u64),
54 Str(String),
55 // Molecule Kinds =========================
56 // Unitary
57 Usr(UsrKindId, Option<Box<Dat>>),
58 Box(Box<Dat>),
59 Opt(Box<Option<Dat>>),
60 ABox(NoteConfig, Box<Dat>, String),
61 // Heterogenous
62 List(Vec<Dat>),
63 Tup2(Box<[Dat; 2]>),
64 Tup3(Box<[Dat; 3]>),
65 Tup4(Box<[Dat; 4]>),
66 Tup5(Box<[Dat; 5]>),
67 Tup6(Box<[Dat; 6]>),
68 Tup7(Box<[Dat; 7]>),
69 Tup8(Box<[Dat; 8]>),
70 Tup9(Box<[Dat; 9]>),
71 Tup10(Box<[Dat; 10]>),
72 Map(DaticleMap),
73 OrdMap(OrdDaticleMap),
74 // Homogenous
75 Vek(Vek),
76 // Variable length bytes
77 BU8(Vec<u8>),
78 BU16(Vec<u8>),
79 BU32(Vec<u8>),
80 BU64(Vec<u8>),
81 BC64(Vec<u8>),
82 // Fixed length bytes
83 B2([u8; 2]),
84 B3([u8; 3]),
85 B4([u8; 4]),
86 B5([u8; 5]),
87 B6([u8; 6]),
88 B7([u8; 7]),
89 B8([u8; 8]),
90 B9([u8; 9]),
91 B10([u8; 10]),
92 B16([u8; 16]),
93 B32(B32),
94 // Fixed length numbers
95 Tup2u8([u8; 2]),
96 Tup3u8([u8; 3]),
97 Tup4u8([u8; 4]),
98 Tup5u8([u8; 5]),
99 Tup6u8([u8; 6]),
100 Tup7u8([u8; 7]),
101 Tup8u8([u8; 8]),
102 Tup9u8([u8; 9]),
103 Tup10u8([u8; 10]),
104
105 Tup2u16([u16; 2]),
106 Tup3u16([u16; 3]),
107 Tup4u16([u16; 4]),
108 Tup5u16([u16; 5]),
109 Tup6u16([u16; 6]),
110 Tup7u16([u16; 7]),
111 Tup8u16([u16; 8]),
112 Tup9u16([u16; 9]),
113 Tup10u16([u16; 10]),
114
115 Tup2u32([u32; 2]),
116 Tup3u32([u32; 3]),
117 Tup4u32([u32; 4]),
118 Tup5u32([u32; 5]),
119 Tup6u32([u32; 6]),
120 Tup7u32([u32; 7]),
121 Tup8u32([u32; 8]),
122 Tup9u32([u32; 9]),
123 Tup10u32([u32; 10]),
124
125 Tup2u64([u64; 2]),
126 Tup3u64([u64; 3]),
127 Tup4u64([u64; 4]),
128 Tup5u64([u64; 5]),
129 Tup6u64([u64; 6]),
130 Tup7u64([u64; 7]),
131 Tup8u64([u64; 8]),
132 Tup9u64([u64; 9]),
133 Tup10u64([u64; 10]),
134
135 Tup2i8([i8; 2]),
136 Tup3i8([i8; 3]),
137 Tup4i8([i8; 4]),
138 Tup5i8([i8; 5]),
139 Tup6i8([i8; 6]),
140 Tup7i8([i8; 7]),
141 Tup8i8([i8; 8]),
142 Tup9i8([i8; 9]),
143 Tup10i8([i8; 10]),
144
145 Tup2i16([i16; 2]),
146 Tup3i16([i16; 3]),
147 Tup4i16([i16; 4]),
148 Tup5i16([i16; 5]),
149 Tup6i16([i16; 6]),
150 Tup7i16([i16; 7]),
151 Tup8i16([i16; 8]),
152 Tup9i16([i16; 9]),
153 Tup10i16([i16; 10]),
154
155 Tup2i32([i32; 2]),
156 Tup3i32([i32; 3]),
157 Tup4i32([i32; 4]),
158 Tup5i32([i32; 5]),
159 Tup6i32([i32; 6]),
160 Tup7i32([i32; 7]),
161 Tup8i32([i32; 8]),
162 Tup9i32([i32; 9]),
163 Tup10i32([i32; 10]),
164
165 Tup2i64([i64; 2]),
166 Tup3i64([i64; 3]),
167 Tup4i64([i64; 4]),
168 Tup5i64([i64; 5]),
169 Tup6i64([i64; 6]),
170 Tup7i64([i64; 7]),
171 Tup8i64([i64; 8]),
172 Tup9i64([i64; 9]),
173 Tup10i64([i64; 10]),
174
175 //// Scheduled for removal
176 //PartKey(PartId),
177}
178
179impl Default for Dat {
180 fn default() -> Self {
181 Self::Empty
182 }
183}
184
185new_type!(Vek, Vec<Dat>, Clone, Eq, Ord, PartialEq, PartialOrd);
186
187impl IntoIterator for Vek {
188 type Item = Dat;
189 type IntoIter = std::vec::IntoIter<Dat>;
190
191 fn into_iter(self) -> Self::IntoIter {
192 self.0.into_iter()
193 }
194}
195
196/// Iterates recursively over daticles, including map keys. This consuming iterator wraps elements
197/// of collections of associated data, even if they are not daticles.
198pub struct IterDat {
199 stack: VecDeque<Dat>,
200}
201
202impl IterDat {
203
204 pub fn new(dat: Dat) -> Self {
205 let mut stack = VecDeque::new();
206 stack.push_back(dat);
207 Self { stack }
208 }
209
210 fn flatten(
211 dat: Dat,
212 stack: &mut VecDeque<Dat>,
213 ) {
214 match dat {
215 Dat::List(v) => {
216 for d in v.into_iter().rev() {
217 stack.push_front(d);
218 }
219 },
220 Dat::Tup2(a) => {
221 for d in a.into_iter().rev() {
222 stack.push_front(d);
223 }
224 },
225 Dat::Tup3(a) => {
226 for d in a.into_iter().rev() {
227 stack.push_front(d);
228 }
229 },
230 Dat::Tup4(a) => {
231 for d in a.into_iter().rev() {
232 stack.push_front(d);
233 }
234 },
235 Dat::Tup5(a) => {
236 for d in a.into_iter().rev() {
237 stack.push_front(d);
238 }
239 },
240 Dat::Tup6(a) => {
241 for d in a.into_iter().rev() {
242 stack.push_front(d);
243 }
244 },
245 Dat::Tup7(a) => {
246 for d in a.into_iter().rev() {
247 stack.push_front(d);
248 }
249 },
250 Dat::Tup8(a) => {
251 for d in a.into_iter().rev() {
252 stack.push_front(d);
253 }
254 },
255 Dat::Tup9(a) => {
256 for d in a.into_iter().rev() {
257 stack.push_front(d);
258 }
259 },
260 Dat::Tup10(a) => {
261 for d in a.into_iter().rev() {
262 stack.push_front(d);
263 }
264 },
265 Dat::Map(m) => {
266 for (kdat, vdat) in m.into_iter().rev() {
267 stack.push_front(vdat);
268 stack.push_front(kdat);
269 }
270 },
271 Dat::OrdMap(m) => {
272 for (mk, vdat) in m.into_iter().rev() {
273 stack.push_front(vdat);
274 stack.push_front(mk.into_dat());
275 }
276 },
277 Dat::Vek(vek) => {
278 for d in vek.0.into_iter().rev() {
279 stack.push_front(d);
280 }
281 },
282 Dat::BU8(v) |
283 Dat::BU16(v) |
284 Dat::BU32(v) |
285 Dat::BU64(v) |
286 Dat::BC64(v) => {
287 for n in v.into_iter().rev() {
288 stack.push_front(Dat::U8(n));
289 }
290 },
291 Dat::B2(a) => {
292 for n in a.into_iter().rev() {
293 stack.push_front(Dat::U8(n));
294 }
295 },
296 Dat::B3(a) => {
297 for n in a.into_iter().rev() {
298 stack.push_front(Dat::U8(n));
299 }
300 },
301 Dat::B4(a) => {
302 for n in a.into_iter().rev() {
303 stack.push_front(Dat::U8(n));
304 }
305 },
306 Dat::B5(a) => {
307 for n in a.into_iter().rev() {
308 stack.push_front(Dat::U8(n));
309 }
310 },
311 Dat::B6(a) => {
312 for n in a.into_iter().rev() {
313 stack.push_front(Dat::U8(n));
314 }
315 },
316 Dat::B7(a) => {
317 for n in a.into_iter().rev() {
318 stack.push_front(Dat::U8(n));
319 }
320 },
321 Dat::B8(a) => {
322 for n in a.into_iter().rev() {
323 stack.push_front(Dat::U8(n));
324 }
325 },
326 Dat::B9(a) => {
327 for n in a.into_iter().rev() {
328 stack.push_front(Dat::U8(n));
329 }
330 },
331 Dat::B10(a) => {
332 for n in a.into_iter().rev() {
333 stack.push_front(Dat::U8(n));
334 }
335 },
336 Dat::B16(a) => {
337 for n in a.into_iter().rev() {
338 stack.push_front(Dat::U8(n));
339 }
340 },
341 Dat::B32(a) => {
342 for n in a.into_iter().rev() {
343 stack.push_front(Dat::U8(n));
344 }
345 },
346 Dat::Tup2u8(a) => {
347 for n in a.into_iter().rev() {
348 stack.push_front(Dat::U8(n));
349 }
350 },
351 Dat::Tup3u8(a) => {
352 for n in a.into_iter().rev() {
353 stack.push_front(Dat::U8(n));
354 }
355 },
356 Dat::Tup4u8(a) => {
357 for n in a.into_iter().rev() {
358 stack.push_front(Dat::U8(n));
359 }
360 },
361 Dat::Tup5u8(a) => {
362 for n in a.into_iter().rev() {
363 stack.push_front(Dat::U8(n));
364 }
365 },
366 Dat::Tup6u8(a) => {
367 for n in a.into_iter().rev() {
368 stack.push_front(Dat::U8(n));
369 }
370 },
371 Dat::Tup7u8(a) => {
372 for n in a.into_iter().rev() {
373 stack.push_front(Dat::U8(n));
374 }
375 },
376 Dat::Tup8u8(a) => {
377 for n in a.into_iter().rev() {
378 stack.push_front(Dat::U8(n));
379 }
380 },
381 Dat::Tup9u8(a) => {
382 for n in a.into_iter().rev() {
383 stack.push_front(Dat::U8(n));
384 }
385 },
386 Dat::Tup10u8(a) => {
387 for n in a.into_iter().rev() {
388 stack.push_front(Dat::U8(n));
389 }
390 },
391 Dat::Tup2u16(a) => {
392 for n in a.into_iter().rev() {
393 stack.push_front(Dat::U16(n));
394 }
395 },
396 Dat::Tup3u16(a) => {
397 for n in a.into_iter().rev() {
398 stack.push_front(Dat::U16(n));
399 }
400 },
401 Dat::Tup4u16(a) => {
402 for n in a.into_iter().rev() {
403 stack.push_front(Dat::U16(n));
404 }
405 },
406 Dat::Tup5u16(a) => {
407 for n in a.into_iter().rev() {
408 stack.push_front(Dat::U16(n));
409 }
410 },
411 Dat::Tup6u16(a) => {
412 for n in a.into_iter().rev() {
413 stack.push_front(Dat::U16(n));
414 }
415 },
416 Dat::Tup7u16(a) => {
417 for n in a.into_iter().rev() {
418 stack.push_front(Dat::U16(n));
419 }
420 },
421 Dat::Tup8u16(a) => {
422 for n in a.into_iter().rev() {
423 stack.push_front(Dat::U16(n));
424 }
425 },
426 Dat::Tup9u16(a) => {
427 for n in a.into_iter().rev() {
428 stack.push_front(Dat::U16(n));
429 }
430 },
431 Dat::Tup10u16(a) => {
432 for n in a.into_iter().rev() {
433 stack.push_front(Dat::U16(n));
434 }
435 },
436 Dat::Tup2u32(a) => {
437 for n in a.into_iter().rev() {
438 stack.push_front(Dat::U32(n));
439 }
440 },
441 Dat::Tup3u32(a) => {
442 for n in a.into_iter().rev() {
443 stack.push_front(Dat::U32(n));
444 }
445 },
446 Dat::Tup4u32(a) => {
447 for n in a.into_iter().rev() {
448 stack.push_front(Dat::U32(n));
449 }
450 },
451 Dat::Tup5u32(a) => {
452 for n in a.into_iter().rev() {
453 stack.push_front(Dat::U32(n));
454 }
455 },
456 Dat::Tup6u32(a) => {
457 for n in a.into_iter().rev() {
458 stack.push_front(Dat::U32(n));
459 }
460 },
461 Dat::Tup7u32(a) => {
462 for n in a.into_iter().rev() {
463 stack.push_front(Dat::U32(n));
464 }
465 },
466 Dat::Tup8u32(a) => {
467 for n in a.into_iter().rev() {
468 stack.push_front(Dat::U32(n));
469 }
470 },
471 Dat::Tup9u32(a) => {
472 for n in a.into_iter().rev() {
473 stack.push_front(Dat::U32(n));
474 }
475 },
476 Dat::Tup10u32(a) => {
477 for n in a.into_iter().rev() {
478 stack.push_front(Dat::U32(n));
479 }
480 },
481 Dat::Tup2u64(a) => {
482 for n in a.into_iter().rev() {
483 stack.push_front(Dat::U64(n));
484 }
485 },
486 Dat::Tup3u64(a) => {
487 for n in a.into_iter().rev() {
488 stack.push_front(Dat::U64(n));
489 }
490 },
491 Dat::Tup4u64(a) => {
492 for n in a.into_iter().rev() {
493 stack.push_front(Dat::U64(n));
494 }
495 },
496 Dat::Tup5u64(a) => {
497 for n in a.into_iter().rev() {
498 stack.push_front(Dat::U64(n));
499 }
500 },
501 Dat::Tup6u64(a) => {
502 for n in a.into_iter().rev() {
503 stack.push_front(Dat::U64(n));
504 }
505 },
506 Dat::Tup7u64(a) => {
507 for n in a.into_iter().rev() {
508 stack.push_front(Dat::U64(n));
509 }
510 },
511 Dat::Tup8u64(a) => {
512 for n in a.into_iter().rev() {
513 stack.push_front(Dat::U64(n));
514 }
515 },
516 Dat::Tup9u64(a) => {
517 for n in a.into_iter().rev() {
518 stack.push_front(Dat::U64(n));
519 }
520 },
521 Dat::Tup10u64(a) => {
522 for n in a.into_iter().rev() {
523 stack.push_front(Dat::U64(n));
524 }
525 },
526 Dat::Tup2i8(a) => {
527 for n in a.into_iter().rev() {
528 stack.push_front(Dat::I8(n));
529 }
530 },
531 Dat::Tup3i8(a) => {
532 for n in a.into_iter().rev() {
533 stack.push_front(Dat::I8(n));
534 }
535 },
536 Dat::Tup4i8(a) => {
537 for n in a.into_iter().rev() {
538 stack.push_front(Dat::I8(n));
539 }
540 },
541 Dat::Tup5i8(a) => {
542 for n in a.into_iter().rev() {
543 stack.push_front(Dat::I8(n));
544 }
545 },
546 Dat::Tup6i8(a) => {
547 for n in a.into_iter().rev() {
548 stack.push_front(Dat::I8(n));
549 }
550 },
551 Dat::Tup7i8(a) => {
552 for n in a.into_iter().rev() {
553 stack.push_front(Dat::I8(n));
554 }
555 },
556 Dat::Tup8i8(a) => {
557 for n in a.into_iter().rev() {
558 stack.push_front(Dat::I8(n));
559 }
560 },
561 Dat::Tup9i8(a) => {
562 for n in a.into_iter().rev() {
563 stack.push_front(Dat::I8(n));
564 }
565 },
566 Dat::Tup10i8(a) => {
567 for n in a.into_iter().rev() {
568 stack.push_front(Dat::I8(n));
569 }
570 },
571 Dat::Tup2i16(a) => {
572 for n in a.into_iter().rev() {
573 stack.push_front(Dat::I16(n));
574 }
575 },
576 Dat::Tup3i16(a) => {
577 for n in a.into_iter().rev() {
578 stack.push_front(Dat::I16(n));
579 }
580 },
581 Dat::Tup4i16(a) => {
582 for n in a.into_iter().rev() {
583 stack.push_front(Dat::I16(n));
584 }
585 },
586 Dat::Tup5i16(a) => {
587 for n in a.into_iter().rev() {
588 stack.push_front(Dat::I16(n));
589 }
590 },
591 Dat::Tup6i16(a) => {
592 for n in a.into_iter().rev() {
593 stack.push_front(Dat::I16(n));
594 }
595 },
596 Dat::Tup7i16(a) => {
597 for n in a.into_iter().rev() {
598 stack.push_front(Dat::I16(n));
599 }
600 },
601 Dat::Tup8i16(a) => {
602 for n in a.into_iter().rev() {
603 stack.push_front(Dat::I16(n));
604 }
605 },
606 Dat::Tup9i16(a) => {
607 for n in a.into_iter().rev() {
608 stack.push_front(Dat::I16(n));
609 }
610 },
611 Dat::Tup10i16(a) => {
612 for n in a.into_iter().rev() {
613 stack.push_front(Dat::I16(n));
614 }
615 },
616 Dat::Tup2i32(a) => {
617 for n in a.into_iter().rev() {
618 stack.push_front(Dat::I32(n));
619 }
620 },
621 Dat::Tup3i32(a) => {
622 for n in a.into_iter().rev() {
623 stack.push_front(Dat::I32(n));
624 }
625 },
626 Dat::Tup4i32(a) => {
627 for n in a.into_iter().rev() {
628 stack.push_front(Dat::I32(n));
629 }
630 },
631 Dat::Tup5i32(a) => {
632 for n in a.into_iter().rev() {
633 stack.push_front(Dat::I32(n));
634 }
635 },
636 Dat::Tup6i32(a) => {
637 for n in a.into_iter().rev() {
638 stack.push_front(Dat::I32(n));
639 }
640 },
641 Dat::Tup7i32(a) => {
642 for n in a.into_iter().rev() {
643 stack.push_front(Dat::I32(n));
644 }
645 },
646 Dat::Tup8i32(a) => {
647 for n in a.into_iter().rev() {
648 stack.push_front(Dat::I32(n));
649 }
650 },
651 Dat::Tup9i32(a) => {
652 for n in a.into_iter().rev() {
653 stack.push_front(Dat::I32(n));
654 }
655 },
656 Dat::Tup10i32(a) => {
657 for n in a.into_iter().rev() {
658 stack.push_front(Dat::I32(n));
659 }
660 },
661 Dat::Tup2i64(a) => {
662 for n in a.into_iter().rev() {
663 stack.push_front(Dat::I64(n));
664 }
665 },
666 Dat::Tup3i64(a) => {
667 for n in a.into_iter().rev() {
668 stack.push_front(Dat::I64(n));
669 }
670 },
671 Dat::Tup4i64(a) => {
672 for n in a.into_iter().rev() {
673 stack.push_front(Dat::I64(n));
674 }
675 },
676 Dat::Tup5i64(a) => {
677 for n in a.into_iter().rev() {
678 stack.push_front(Dat::I64(n));
679 }
680 },
681 Dat::Tup6i64(a) => {
682 for n in a.into_iter().rev() {
683 stack.push_front(Dat::I64(n));
684 }
685 },
686 Dat::Tup7i64(a) => {
687 for n in a.into_iter().rev() {
688 stack.push_front(Dat::I64(n));
689 }
690 },
691 Dat::Tup8i64(a) => {
692 for n in a.into_iter().rev() {
693 stack.push_front(Dat::I64(n));
694 }
695 },
696 Dat::Tup9i64(a) => {
697 for n in a.into_iter().rev() {
698 stack.push_front(Dat::I64(n));
699 }
700 },
701 Dat::Tup10i64(a) => {
702 for n in a.into_iter().rev() {
703 stack.push_front(Dat::I64(n));
704 }
705 },
706 _ => (),
707 }
708 }
709}
710
711impl Iterator for IterDat {
712 type Item = Dat;
713
714 fn next(&mut self) -> Option<Self::Item> {
715 loop {
716 if let Some(dat) = self.stack.pop_front() {
717 if dat.must_iterdat_flatten() {
718 Self::flatten(dat, &mut self.stack);
719 } else {
720 return match dat {
721 Dat::Usr(_, optboxd) => match optboxd {
722 Some(boxd) => Some(*boxd),
723 None => None,
724 },
725 Dat::Box(boxd) => Some(*boxd),
726 Dat::Opt(boxoptd) => match *boxoptd {
727 Some(d) => Some(d),
728 None => None,
729 },
730 _ => Some(dat),
731 };
732 }
733 } else {
734 return None;
735 }
736 }
737 }
738}
739
740/// Iterates recursively over daticles but ignores map keys. Unlike `IterDat`, which iterates over
741/// individual elements of associated data collections even when they are not made up of daticles,
742/// wrapping them in daticles if necessary, this iterator returns daticles with native homogenous
743/// data intact. For example, both iterators return `Dat::U8(42)`, `Dat::Str("hello")` for the
744/// heterogenous `Dat::List([42u8, "hello"])`. But in the case of `Dat::B2([42u8, 43])` containing
745/// an homogenous native array, `IterDat` returns `Dat::U8(42)`, `Dat::U8(43)` while
746/// `IterDatValsMut` returns `Dat::B2([42u8,43])`.
747pub struct IterDatValsMut<'a> {
748 stack: VecDeque<&'a mut Dat>,
749}
750
751impl<'a> IterDatValsMut<'a> {
752
753 pub fn new(dat: &'a mut Dat) -> Self {
754 let mut stack = VecDeque::new();
755 stack.push_back(dat);
756 Self { stack }
757 }
758
759 fn flatten(
760 dat: &'a mut Dat,
761 stack: &mut VecDeque<&'a mut Dat>,
762 ) {
763 match dat {
764 Dat::List(v) => {
765 for d in v.iter_mut().rev() {
766 stack.push_front(d);
767 }
768 },
769 Dat::Tup2(a) => {
770 for d in a.iter_mut().rev() {
771 stack.push_front(d);
772 }
773 },
774 Dat::Tup3(a) => {
775 for d in a.iter_mut().rev() {
776 stack.push_front(d);
777 }
778 },
779 Dat::Tup4(a) => {
780 for d in a.iter_mut().rev() {
781 stack.push_front(d);
782 }
783 },
784 Dat::Tup5(a) => {
785 for d in a.iter_mut().rev() {
786 stack.push_front(d);
787 }
788 },
789 Dat::Tup6(a) => {
790 for d in a.iter_mut().rev() {
791 stack.push_front(d);
792 }
793 },
794 Dat::Tup7(a) => {
795 for d in a.iter_mut().rev() {
796 stack.push_front(d);
797 }
798 },
799 Dat::Tup8(a) => {
800 for d in a.iter_mut().rev() {
801 stack.push_front(d);
802 }
803 },
804 Dat::Tup9(a) => {
805 for d in a.iter_mut().rev() {
806 stack.push_front(d);
807 }
808 },
809 Dat::Tup10(a) => {
810 for d in a.iter_mut().rev() {
811 stack.push_front(d);
812 }
813 },
814 Dat::Map(m) => {
815 for (_kdat, vdat) in m.iter_mut().rev() {
816 stack.push_front(vdat);
817 }
818 },
819 Dat::OrdMap(m) => {
820 for (_mk, vdat) in m.iter_mut().rev() {
821 stack.push_front(vdat);
822 }
823 },
824 Dat::Vek(vek) => {
825 for d in vek.0.iter_mut().rev() {
826 stack.push_front(d);
827 }
828 },
829 _ => (),
830 }
831 }
832
833}
834
835impl<'a> Iterator for IterDatValsMut<'a> {
836 type Item = &'a mut Dat;
837
838 fn next(&mut self) -> Option<Self::Item> {
839 loop {
840 if let Some(dat) = self.stack.pop_front() {
841 if dat.must_iterdatvalsmut_flatten() {
842 Self::flatten(dat, &mut self.stack);
843 } else {
844 return match dat {
845 Dat::Usr(_, optboxd) => match optboxd {
846 Some(boxd) => Some(&mut *boxd),
847 None => None,
848 },
849 Dat::Box(boxd) => Some(&mut *boxd),
850 Dat::Opt(boxoptd) => match &mut **boxoptd {
851 Some(d) => Some(d),
852 None => None,
853 },
854 _ => Some(dat),
855 };
856 }
857 } else {
858 return None;
859 }
860 }
861 }
862}
863
864impl Dat {
865
866 pub const USIZE_BYTES: usize = std::mem::size_of::<usize>();
867 pub const ISIZE_BYTES: usize = std::mem::size_of::<isize>();
868
869 pub const OMAP_ORDER_START_DEFAULT: u64 = 1_000;
870 pub const OMAP_ORDER_DELTA_DEFAULT: u64 = 100;
871
872 pub fn try_vek_from(v: Vec<Self>) -> Outcome<Self> {
873 Ok(Self::Vek(res!(Vek::try_from(v))))
874 }
875
876 /// Normalise the `Dat`icle. Currently this includes conversion of `Dat::OrdMap` to `Dat::Map`.
877 pub fn normalise(self) -> Self {
878 match self {
879 Dat::OrdMap(map1) => {
880 let mut map2 = DaticleMap::new();
881 for (k, v) in map1 {
882 map2.insert(k.into_dat(), v);
883 }
884 Self::Map(map2)
885 },
886 _ => self,
887 }
888 }
889
890 pub fn list_get<'a>(&self, ind: usize) -> Option<&Self> {
891 if let Dat::List(v) = self {
892 if ind < v.len() {
893 return Some(&v[ind]);
894 }
895 }
896 None
897 }
898
899 pub fn get_string_list(&self) -> Option<Vec<String>> {
900 match self {
901 Self::List(v) | Self::Vek(Vek(v)) => {
902 let mut vecstr = Vec::new();
903 for d in v {
904 if let Dat::Str(s) = d {
905 vecstr.push(s.clone());
906 } else {
907 return None;
908 }
909 }
910 Some(vecstr)
911 },
912 _ => None,
913 }
914 }
915
916 pub fn get_b32_string_map(&self) -> Option<BTreeMap<B32, String>> {
917 match self {
918 Self::Map(map1) => {
919 let mut map2 = BTreeMap::new();
920 for (kdat, vdat) in map1 {
921 if let Dat::B32(b) = kdat {
922 if let Dat::Str(s) = vdat {
923 map2.insert(B32(**b), s.clone());
924 } else {
925 return None;
926 }
927 } else {
928 return None;
929 }
930 }
931 Some(map2)
932 },
933 _ => None,
934 }
935 }
936
937 /// Pass-through getter for use by [`FromDatMap`] derive macro.
938 pub fn get_dat(&self) -> Option<Dat> {
939 Some(self.clone())
940 }
941
942 const U8_MAX_AS_U16: u16 = u8::MAX as u16;
943
944 const U8_MAX_AS_U32: u32 = u8::MAX as u32;
945 const U16_MAX_AS_U32: u32 = u16::MAX as u32;
946
947 const U8_MAX_AS_U64: u64 = u8::MAX as u64;
948 const U16_MAX_AS_U64: u64 = u16::MAX as u64;
949 const U32_MAX_AS_U64: u64 = u32::MAX as u64;
950
951 const U8_MAX_AS_USIZE: usize = u8::MAX as usize;
952 const U16_MAX_AS_USIZE: usize = u16::MAX as usize;
953 const U32_MAX_AS_USIZE: usize = u32::MAX as usize;
954
955 pub fn u16dat(v: u16) -> Self {
956 if v < Self::U8_MAX_AS_U16 {
957 Dat::U8(v as u8)
958 } else {
959 Dat::U16(v)
960 }
961 }
962
963 pub fn u32dat(v: u32) -> Self {
964 if v < Self::U8_MAX_AS_U32 {
965 Dat::U8(v as u8)
966 } else if v < Self::U16_MAX_AS_U32 {
967 Dat::U16(v as u16)
968 } else {
969 Dat::U32(v)
970 }
971 }
972
973 pub fn u64dat(v: u64) -> Self {
974 if v < Self::U8_MAX_AS_U64 {
975 Dat::U8(v as u8)
976 } else if v < Self::U16_MAX_AS_U64 {
977 Dat::U16(v as u16)
978 } else if v < Self::U32_MAX_AS_U64 {
979 Dat::U32(v as u32)
980 } else {
981 Dat::U64(v)
982 }
983 }
984
985 pub fn bytdat(v: Vec<u8>) -> Self {
986 let len = v.len();
987 if len < Self::U8_MAX_AS_USIZE {
988 Dat::BU8(v)
989 } else if len < Self::U16_MAX_AS_USIZE {
990 Dat::BU16(v)
991 } else if len < Self::U32_MAX_AS_USIZE {
992 Dat::BU32(v)
993 } else {
994 Dat::BU64(v)
995 }
996 }
997
998 pub fn bytes_move(self) -> Option<Vec<u8>> {
999 match self {
1000 Dat::BU8(v) |
1001 Dat::BU16(v) |
1002 Dat::BU32(v) |
1003 Dat::BU64(v) |
1004 Dat::BC64(v) => Some(v),
1005 _ => None,
1006 }
1007 }
1008
1009 pub fn bytes_ref<'a>(&'a self) -> Option<&'a Vec<u8>> {
1010 match self {
1011 Dat::BU8(v) |
1012 Dat::BU16(v) |
1013 Dat::BU32(v) |
1014 Dat::BU64(v) |
1015 Dat::BC64(v) => Some(v),
1016 _ => None,
1017 }
1018 }
1019}