Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/src/conv.rs

14.2 KiB, 46 runs

created by r1870400018:461, 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 int::DatInt,
4 usr::UsrKindId,
5};
6
7use oxedyne_fe2o3_core::{
8 prelude::*,
9};
10use oxedyne_fe2o3_num::{
11 float::{
12 Float32,
13 Float64,
14 },
15};
16
17use std::{
18 collections::BTreeMap,
19 convert::TryFrom,
20 time::Duration,
21};
22
23use bigdecimal::BigDecimal;
24use num_bigint::BigInt;
25
26
27pub trait FromDatMap : Default {
28 fn from_datmap(map: DaticleMap) -> Outcome<Self>;
29}
30
31pub trait ToDatMap : Default {
32 fn to_datmap(input_struct: Self) -> Dat;
33}
34
35pub trait ToDat {
36 fn to_dat(&self) -> Outcome<Dat>;
37}
38
39pub trait IntoDat: ToDat {
40 fn into_dat(self) -> Outcome<Dat> where Self: Sized {
41 self.to_dat()
42 }
43}
44
45pub trait FromDat {
46 fn from_dat(dat: Dat) -> Outcome<Self> where Self: Sized;
47}
48
49impl AsRef<Dat> for &Dat {
50 fn as_ref(&self) -> &Dat {
51 *self
52 }
53}
54
55impl ToDat for Dat {
56 fn to_dat(&self) -> Outcome<Dat> {
57 Ok(self.clone())
58 }
59}
60
61impl FromDat for Dat {
62 fn from_dat(dat: Dat) -> Outcome<Self> {
63 Ok(dat)
64 }
65}
66
67// From, ToDat and FromDat conversions for native and fundamental types.
68//
69// Atomic Kinds ===========================
70// Logic
71to_from_dat! { bool, Bool }
72// Fixed
73to_from_dat! { u8, U8 }
74to_from_dat! { u16, U16 }
75to_from_dat! { u32, U32 }
76to_from_dat! { u64, U64 }
77to_from_dat! { u128, U128 }
78to_from_dat! { i8, I8 }
79to_from_dat! { i16, I16 }
80to_from_dat! { i32, I32 }
81to_from_dat! { i64, I64 }
82to_from_dat! { i128, I128 }
83to_from_dat! { Float32, F32 }
84to_from_dat! { Float64, F64 }
85// Variable
86to_from_dat! { BigInt, Aint }
87to_from_dat! { BigDecimal, Adec }
88to_from_dat! { String, Str }
89// Molecule Kinds =========================
90// Unitary
91// Heterogenous
92to_from_dat! { Vec<Dat>, List }
93to_from_dat_boxed! { [Dat; 2], Tup2 }
94to_from_dat_boxed! { [Dat; 3], Tup3 }
95to_from_dat_boxed! { [Dat; 4], Tup4 }
96to_from_dat_boxed! { [Dat; 5], Tup5 }
97to_from_dat_boxed! { [Dat; 6], Tup6 }
98to_from_dat_boxed! { [Dat; 7], Tup7 }
99to_from_dat_boxed! { [Dat; 8], Tup8 }
100to_from_dat_boxed! { [Dat; 9], Tup9 }
101to_from_dat_boxed! { [Dat; 10], Tup10 }
102// Homogenous
103// Variable length bytes
104to_from_dat! { Vec<u8>, BU64 }
105// Fixed length bytes
106to_from_dat! { [u8; 2], B2 }
107to_from_dat! { [u8; 3], B3 }
108to_from_dat! { [u8; 4], B4 }
109to_from_dat! { [u8; 5], B5 }
110to_from_dat! { [u8; 6], B6 }
111to_from_dat! { [u8; 7], B7 }
112to_from_dat! { [u8; 8], B8 }
113to_from_dat! { [u8; 9], B9 }
114to_from_dat! { [u8; 10], B10 }
115to_from_dat! { [u8; 16], B16 }
116to_from_dat! { B32, B32 }
117impl From<[u8; 32]> for Dat {
118 fn from(x: [u8; 32]) -> Self {
119 Dat::B32(B32(x))
120 }
121}
122// Fixed length numbers
123
124to_from_dat! { [u16; 2], Tup2u16 }
125to_from_dat! { [u16; 3], Tup3u16 }
126to_from_dat! { [u16; 4], Tup4u16 }
127to_from_dat! { [u16; 5], Tup5u16 }
128to_from_dat! { [u16; 6], Tup6u16 }
129to_from_dat! { [u16; 7], Tup7u16 }
130to_from_dat! { [u16; 8], Tup8u16 }
131to_from_dat! { [u16; 9], Tup9u16 }
132to_from_dat! { [u16; 10], Tup10u16 }
133
134to_from_dat! { [u32; 2], Tup2u32 }
135to_from_dat! { [u32; 3], Tup3u32 }
136to_from_dat! { [u32; 4], Tup4u32 }
137to_from_dat! { [u32; 5], Tup5u32 }
138to_from_dat! { [u32; 6], Tup6u32 }
139to_from_dat! { [u32; 7], Tup7u32 }
140to_from_dat! { [u32; 8], Tup8u32 }
141to_from_dat! { [u32; 9], Tup9u32 }
142to_from_dat! { [u32; 10], Tup10u32 }
143
144to_from_dat! { [u64; 2], Tup2u64 }
145to_from_dat! { [u64; 3], Tup3u64 }
146to_from_dat! { [u64; 4], Tup4u64 }
147to_from_dat! { [u64; 5], Tup5u64 }
148to_from_dat! { [u64; 6], Tup6u64 }
149to_from_dat! { [u64; 7], Tup7u64 }
150to_from_dat! { [u64; 8], Tup8u64 }
151to_from_dat! { [u64; 9], Tup9u64 }
152to_from_dat! { [u64; 10], Tup10u64 }
153
154to_from_dat! { [i8; 2], Tup2i8 }
155to_from_dat! { [i8; 3], Tup3i8 }
156to_from_dat! { [i8; 4], Tup4i8 }
157to_from_dat! { [i8; 5], Tup5i8 }
158to_from_dat! { [i8; 6], Tup6i8 }
159to_from_dat! { [i8; 7], Tup7i8 }
160to_from_dat! { [i8; 8], Tup8i8 }
161to_from_dat! { [i8; 9], Tup9i8 }
162to_from_dat! { [i8; 10], Tup10i8 }
163
164to_from_dat! { [i16; 2], Tup2i16 }
165to_from_dat! { [i16; 3], Tup3i16 }
166to_from_dat! { [i16; 4], Tup4i16 }
167to_from_dat! { [i16; 5], Tup5i16 }
168to_from_dat! { [i16; 6], Tup6i16 }
169to_from_dat! { [i16; 7], Tup7i16 }
170to_from_dat! { [i16; 8], Tup8i16 }
171to_from_dat! { [i16; 9], Tup9i16 }
172to_from_dat! { [i16; 10], Tup10i16 }
173
174to_from_dat! { [i32; 2], Tup2i32 }
175to_from_dat! { [i32; 3], Tup3i32 }
176to_from_dat! { [i32; 4], Tup4i32 }
177to_from_dat! { [i32; 5], Tup5i32 }
178to_from_dat! { [i32; 6], Tup6i32 }
179to_from_dat! { [i32; 7], Tup7i32 }
180to_from_dat! { [i32; 8], Tup8i32 }
181to_from_dat! { [i32; 9], Tup9i32 }
182to_from_dat! { [i32; 10], Tup10i32 }
183
184to_from_dat! { [i64; 2], Tup2i64 }
185to_from_dat! { [i64; 3], Tup3i64 }
186to_from_dat! { [i64; 4], Tup4i64 }
187to_from_dat! { [i64; 5], Tup5i64 }
188to_from_dat! { [i64; 6], Tup6i64 }
189to_from_dat! { [i64; 7], Tup7i64 }
190to_from_dat! { [i64; 8], Tup8i64 }
191to_from_dat! { [i64; 9], Tup9i64 }
192to_from_dat! { [i64; 10], Tup10i64 }
193
194impl From<Vec<String>> for Dat {
195 fn from(v: Vec<String>) -> Self {
196 let mut vd = Vec::new();
197 for d in v {
198 vd.push(dat!(d));
199 }
200 Dat::Vek(Vek(vd))
201 }
202}
203
204// Conversions for standard library compound types.
205
206impl ToDat for Duration {
207 fn to_dat(&self) -> Outcome<Dat> {
208 Ok(Dat::U64(self.as_nanos() as u64))
209 }
210}
211
212impl FromDat for Duration {
213 fn from_dat(dat: Dat) -> Outcome<Self> {
214 Ok(Self::from_nanos(try_extract_dat!(dat, U64)))
215 }
216}
217
218best_from_int_to_dat! { u8 }
219best_from_int_to_dat! { u16 }
220best_from_int_to_dat! { u32 }
221best_from_int_to_dat! { u64 }
222best_from_int_to_dat! { u128 }
223best_from_int_to_dat! { i8 }
224best_from_int_to_dat! { i16 }
225best_from_int_to_dat! { i32 }
226best_from_int_to_dat! { i64 }
227best_from_int_to_dat! { i128 }
228
229// The BestFrom trait defaults to From, so implement this default for all the following types.
230// Atomic Kinds ===========================
231// Logic
232impl BestFrom<bool> for Dat {}
233// Fixed
234impl BestFrom<Float32> for Dat {}
235impl BestFrom<Float64> for Dat {}
236// Variable
237impl BestFrom<BigInt> for Dat {}
238impl BestFrom<BigDecimal> for Dat {}
239impl BestFrom<String> for Dat {}
240// Molecule Kinds =========================
241// Unitary
242// Heterogenous
243impl BestFrom<Vec<Dat>> for Dat {}
244impl BestFrom<[Dat; 2]> for Dat {}
245impl BestFrom<[Dat; 3]> for Dat {}
246impl BestFrom<[Dat; 4]> for Dat {}
247impl BestFrom<[Dat; 5]> for Dat {}
248impl BestFrom<[Dat; 6]> for Dat {}
249impl BestFrom<[Dat; 7]> for Dat {}
250impl BestFrom<[Dat; 8]> for Dat {}
251impl BestFrom<[Dat; 9]> for Dat {}
252impl BestFrom<[Dat; 10]> for Dat {}
253// Homogenous
254// Variable length bytes
255impl BestFrom<Vec<u8>> for Dat {}
256// Fixed length bytes
257impl BestFrom<[u8; 2]> for Dat {}
258impl BestFrom<[u8; 3]> for Dat {}
259impl BestFrom<[u8; 4]> for Dat {}
260impl BestFrom<[u8; 5]> for Dat {}
261impl BestFrom<[u8; 6]> for Dat {}
262impl BestFrom<[u8; 7]> for Dat {}
263impl BestFrom<[u8; 8]> for Dat {}
264impl BestFrom<[u8; 9]> for Dat {}
265impl BestFrom<[u8; 10]> for Dat {}
266impl BestFrom<[u8; 16]> for Dat {}
267impl BestFrom<B32> for Dat {}
268impl BestFrom<[u8; 32]> for Dat {}
269// Fixed length numbers
270impl BestFrom<[u16; 2]> for Dat {}
271impl BestFrom<[u16; 3]> for Dat {}
272impl BestFrom<[u16; 4]> for Dat {}
273impl BestFrom<[u16; 5]> for Dat {}
274impl BestFrom<[u16; 6]> for Dat {}
275impl BestFrom<[u16; 7]> for Dat {}
276impl BestFrom<[u16; 8]> for Dat {}
277impl BestFrom<[u16; 9]> for Dat {}
278impl BestFrom<[u16; 10]> for Dat {}
279
280impl BestFrom<[u32; 2]> for Dat {}
281impl BestFrom<[u32; 3]> for Dat {}
282impl BestFrom<[u32; 4]> for Dat {}
283impl BestFrom<[u32; 5]> for Dat {}
284impl BestFrom<[u32; 6]> for Dat {}
285impl BestFrom<[u32; 7]> for Dat {}
286impl BestFrom<[u32; 8]> for Dat {}
287impl BestFrom<[u32; 9]> for Dat {}
288impl BestFrom<[u32; 10]> for Dat {}
289
290impl BestFrom<[u64; 2]> for Dat {}
291impl BestFrom<[u64; 3]> for Dat {}
292impl BestFrom<[u64; 4]> for Dat {}
293impl BestFrom<[u64; 5]> for Dat {}
294impl BestFrom<[u64; 6]> for Dat {}
295impl BestFrom<[u64; 7]> for Dat {}
296impl BestFrom<[u64; 8]> for Dat {}
297impl BestFrom<[u64; 9]> for Dat {}
298impl BestFrom<[u64; 10]> for Dat {}
299
300impl From<()> for Dat {
301 fn from(_: ()) -> Self {
302 Self::Empty
303 }
304}
305
306impl BestFrom<()> for Dat {}
307
308impl TryFrom<usize> for Dat {
309 type Error = Error<ErrTag>;
310
311 fn try_from(n: usize) -> std::result::Result<Self, Self::Error> {
312 Ok(match std::mem::size_of::<usize>() {
313 1 => Self::U8(n as u8),
314 2 => Self::U16(n as u16),
315 4 => Self::U32(n as u32),
316 8 => Self::U64(n as u64),
317 16 => Self::U128(n as u128),
318 s => return Err(err!(
319 "The usize for this machine is {}, which has not yet been \
320 mapped to a daticle kind.", s;
321 System, Unimplemented)),
322 })
323 }
324}
325
326impl TryFrom<isize> for Dat {
327 type Error = Error<ErrTag>;
328
329 fn try_from(n: isize) -> std::result::Result<Self, Self::Error> {
330 Ok(match std::mem::size_of::<isize>() {
331 1 => Self::I8(n as i8),
332 2 => Self::I16(n as i16),
333 4 => Self::I32(n as i32),
334 8 => Self::I64(n as i64),
335 16 => Self::I128(n as i128),
336 s => return Err(err!(
337 "The isize for this machine is {}, which has not yet been \
338 mapped to a daticle kind.", s;
339 System, Unimplemented)),
340 })
341 }
342}
343
344impl From<f32> for Dat {
345 fn from(f: f32) -> Self {
346 Self::F32(Float32(f))
347 }
348}
349
350impl BestFrom<f32> for Dat {}
351
352impl From<f64> for Dat {
353 fn from(f: f64) -> Self {
354 Self::F64(Float64(f))
355 }
356}
357
358impl BestFrom<f64> for Dat {}
359
360impl<'a> From<&'a [u8]> for Dat {
361 fn from(v: &'a [u8]) -> Self {
362 Self::BU64(v.to_vec())
363 }
364}
365
366impl<'a> BestFrom<&'a [u8]> for Dat {}
367
368impl<'a> From<&'a str> for Dat {
369 fn from(s: &'a str) -> Self {
370 Self::Str(s.to_string())
371 }
372}
373
374impl<'a> BestFrom<&'a str> for Dat {}
375
376impl<D: Into<Dat>> From<Box<D>> for Dat {
377 fn from(v: Box<D>) -> Self {
378 Self::Box(Box::new((*v).into()))
379 }
380}
381
382impl<D: Into<Dat>> BestFrom<Box<D>> for Dat {}
383
384impl<D: Into<Dat>> From<Option<D>> for Dat {
385 fn from(v: Option<D>) -> Self {
386 match v {
387 Some(d) => Self::Opt(Box::new(Some(d.into()))),
388 None => Self::Opt(Box::new(None)),
389 }
390 }
391}
392
393impl<D: Into<Dat>> BestFrom<Option<D>> for Dat {}
394
395impl TryFrom<Dat> for Vec<String> {
396 type Error = Error<ErrTag>;
397
398 fn try_from(dat: Dat) -> Result<Self, Self::Error> {
399 dat.get_string_list().ok_or(err!(
400 "Daticle '{:?}' is not a list or vek of strings.", dat;
401 Conversion, String))
402 }
403}
404
405impl<'a> TryFrom<&'a Dat> for Vec<String> {
406 type Error = Error<ErrTag>;
407
408 fn try_from(dat: &'a Dat) -> Result<Self, Self::Error> {
409 dat.get_string_list().ok_or(err!(
410 "Daticle '{:?}' is not a list or vek of strings.", dat;
411 Conversion, String))
412 }
413}
414
415impl TryFrom<(UsrKindId, Option<Dat>)> for Dat {
416 type Error = Error<ErrTag>;
417
418 fn try_from((ukid, optd): (UsrKindId, Option<Dat>)) -> std::result::Result<Self, Self::Error> {
419 let ok = match &optd {
420 Some(dat) => match ukid.kind() {
421 Some(kind) => if dat.kind() == **kind { true } else { false },
422 None => false,
423 },
424 None => match ukid.kind() {
425 Some(_kind) => false,
426 None => true,
427 },
428 };
429 if !ok {
430 return Err(err!(
431 "Usr daticle requires kind {:?} but {:?} received.",
432 ukid.kind(), optd;
433 Input, Invalid, Mismatch));
434 }
435 Ok(Self::Usr(ukid, match optd {
436 None => None,
437 Some(dat) => Some(Box::new(dat)),
438 }))
439 }
440}
441
442impl TryFrom<Vec<Dat>> for Vek {
443 type Error = Error<ErrTag>;
444
445 fn try_from(v: Vec<Dat>) -> std::result::Result<Self, Self::Error> {
446 if v.len() > 1 {
447 let kind = v[0].kind();
448 let mut count: usize = 2;
449 for d in v.iter().skip(1) {
450 if !d.kind().equals(&kind) {
451 return Err(err!(
452 "Cannot construct a Vek from the given Vec because the \
453 kind of item {}, {:?} differs from the kind, {:?} of the \
454 first item.", count, d.kind(), kind;
455 Input, Invalid, Mismatch));
456 }
457 count += 1;
458 }
459 }
460 Ok(Self(v))
461 }
462}
463
464impl<
465 K: Into<Dat>,
466 V: Into<Dat>,
467>
468 From<BTreeMap<K, V>> for Dat
469{
470 fn from(v: BTreeMap<K, V>) -> Self {
471 let mut map = DaticleMap::new();
472 for (key, val) in v {
473 map.insert(key.into(), val.into());
474 }
475 Self::Map(map)
476 }
477}
478
479impl Dat {
480
481 // Used in FromDatMap
482 enum_getter! { get_bool, bool, Bool }
483 enum_getter! { get_bigint, BigInt, Aint }
484 enum_getter! { get_bigdecimal, BigDecimal, Adec }
485 enum_getter! { get_string, String, Str }
486 enum_getter! { get_bytes, Vec<u8>, BU64 }
487 // TODO B256??
488 enum_getter! { get_list, Vec<Dat>, List }
489 enum_getter! { get_map, DaticleMap, Map }
490 enum_getter! { get_box, Box<Dat>, Box }
491 enum_getter! { get_box_opt, Box<Option<Dat>>, Opt }
492
493 enum_getter_numeric! { get_u8, u8 }
494 enum_getter_numeric! { get_u16, u16 }
495 enum_getter_numeric! { get_u32, u32 }
496 enum_getter_numeric! { get_u64, u64 }
497 enum_getter_numeric! { get_u128, u128 }
498 enum_getter_numeric! { get_i8, i8 }
499 enum_getter_numeric! { get_i16, i16 }
500 enum_getter_numeric! { get_i32, i32 }
501 enum_getter_numeric! { get_i64, i64 }
502 enum_getter_numeric! { get_i128, i128 }
503 enum_getter_numeric! { get_float32, Float32 }
504 enum_getter_numeric! { get_float64, Float64 }
505}
506
507