1use crate::{Typ, ValArray, Value};
2use anyhow::{anyhow, bail, Result};
3use arcstr::ArcStr;
4use bytes::Bytes;
5use chrono::prelude::*;
6use compact_str::CompactString;
7use fxhash::FxHashMap;
8use indexmap::{IndexMap, IndexSet};
9use netidx_core::path::Path;
10use poolshark::global::{GPooled, Pool};
11use rust_decimal::Decimal;
12use smallvec::SmallVec;
13use std::{
14 any::{Any, TypeId},
15 cell::RefCell,
16 collections::{BTreeMap, BTreeSet, HashMap, HashSet},
17 convert::{From, Into},
18 hash::{BuildHasher, Hash},
19 time::Duration,
20};
21use triomphe::Arc;
22
23pub trait FromValue {
24 fn from_value(v: Value) -> Result<Self>
26 where
27 Self: Sized;
28
29 fn get(v: Value) -> Option<Self>
32 where
33 Self: Sized,
34 {
35 FromValue::from_value(v).ok()
36 }
37}
38
39impl FromValue for Value {
40 fn from_value(v: Value) -> Result<Self> {
41 Ok(v)
42 }
43
44 fn get(v: Value) -> Option<Self> {
45 Some(v)
46 }
47}
48
49impl<T: Into<Value> + Copy> From<&T> for Value {
50 fn from(v: &T) -> Value {
51 (*v).into()
52 }
53}
54
55impl FromValue for u8 {
56 fn from_value(v: Value) -> Result<Self> {
57 let v = v.cast_to::<u32>()?;
58 if v <= u8::MAX as u32 {
59 Ok(v as u8)
60 } else {
61 bail!("can't cast")
62 }
63 }
64
65 fn get(v: Value) -> Option<Self> {
66 match v {
67 Value::U32(v) | Value::V32(v) => Some(v as u8),
68 Value::U64(v) | Value::V64(v) => Some(v as u8),
69 Value::I32(v) | Value::Z32(v) => Some(v as u8),
70 Value::I64(v) | Value::Z64(v) => Some(v as u8),
71 _ => None,
72 }
73 }
74}
75
76impl From<u8> for Value {
77 fn from(v: u8) -> Value {
78 Value::U32(v as u32)
79 }
80}
81
82impl FromValue for i8 {
83 fn from_value(v: Value) -> Result<Self> {
84 let v = v.cast_to::<i32>()?;
85 if v <= i8::MAX as i32 && v >= i8::MIN as i32 {
86 Ok(v as i8)
87 } else {
88 bail!("can't cast")
89 }
90 }
91
92 fn get(v: Value) -> Option<Self> {
93 match v {
94 Value::U32(v) | Value::V32(v) => Some(v as i8),
95 Value::U64(v) | Value::V64(v) => Some(v as i8),
96 Value::I32(v) | Value::Z32(v) => Some(v as i8),
97 Value::I64(v) | Value::Z64(v) => Some(v as i8),
98 _ => None,
99 }
100 }
101}
102
103impl From<i8> for Value {
104 fn from(v: i8) -> Value {
105 Value::I32(v as i32)
106 }
107}
108
109impl FromValue for u16 {
110 fn from_value(v: Value) -> Result<Self> {
111 let v = v.cast_to::<u32>()?;
112 if v <= u16::MAX as u32 {
113 Ok(v as u16)
114 } else {
115 bail!("can't cast")
116 }
117 }
118
119 fn get(v: Value) -> Option<Self> {
120 match v {
121 Value::U32(v) | Value::V32(v) => Some(v as u16),
122 Value::U64(v) | Value::V64(v) => Some(v as u16),
123 Value::I32(v) | Value::Z32(v) => Some(v as u16),
124 Value::I64(v) | Value::Z64(v) => Some(v as u16),
125 _ => None,
126 }
127 }
128}
129
130impl From<u16> for Value {
131 fn from(v: u16) -> Value {
132 Value::U32(v as u32)
133 }
134}
135
136impl FromValue for i16 {
137 fn from_value(v: Value) -> Result<Self> {
138 let v = v.cast_to::<i32>()?;
139 if v <= i16::MAX as i32 && v >= i16::MIN as i32 {
140 Ok(v as i16)
141 } else {
142 bail!("can't cast")
143 }
144 }
145
146 fn get(v: Value) -> Option<Self> {
147 match v {
148 Value::U32(v) | Value::V32(v) => Some(v as i16),
149 Value::U64(v) | Value::V64(v) => Some(v as i16),
150 Value::I32(v) | Value::Z32(v) => Some(v as i16),
151 Value::I64(v) | Value::Z64(v) => Some(v as i16),
152 _ => None,
153 }
154 }
155}
156
157impl From<i16> for Value {
158 fn from(v: i16) -> Value {
159 Value::I32(v as i32)
160 }
161}
162
163impl FromValue for u32 {
164 fn from_value(v: Value) -> Result<Self> {
165 match v {
166 Value::U32(v) | Value::V32(v) => Ok(v),
167 Value::U64(v) | Value::V64(v) => Ok(v as u32),
168 Value::I32(v) | Value::Z32(v) => Ok(v as u32),
169 Value::I64(v) | Value::Z64(v) => Ok(v as u32),
170 v => {
171 v.cast(Typ::U32).ok_or_else(|| anyhow!("can't cast")).and_then(
172 |v| match v {
173 Value::U32(v) => Ok(v),
174 _ => bail!("can't cast"),
175 },
176 )
177 }
178 }
179 }
180
181 fn get(v: Value) -> Option<Self> {
182 match v {
183 Value::U32(v) | Value::V32(v) => Some(v),
184 Value::U64(v) | Value::V64(v) => Some(v as u32),
185 Value::I32(v) | Value::Z32(v) => Some(v as u32),
186 Value::I64(v) | Value::Z64(v) => Some(v as u32),
187 _ => None,
188 }
189 }
190}
191
192impl From<u32> for Value {
193 fn from(v: u32) -> Value {
194 Value::U32(v)
195 }
196}
197
198impl FromValue for i32 {
199 fn from_value(v: Value) -> Result<Self> {
200 match v {
201 Value::I32(v) | Value::Z32(v) => Ok(v),
202 Value::U32(v) | Value::V32(v) => Ok(v as i32),
203 Value::U64(v) | Value::V64(v) => Ok(v as i32),
204 Value::I64(v) | Value::Z64(v) => Ok(v as i32),
205 v => {
206 v.cast(Typ::I32).ok_or_else(|| anyhow!("can't cast")).and_then(
207 |v| match v {
208 Value::I32(v) => Ok(v),
209 _ => bail!("can't cast"),
210 },
211 )
212 }
213 }
214 }
215
216 fn get(v: Value) -> Option<Self> {
217 match v {
218 Value::I32(v) | Value::Z32(v) => Some(v),
219 Value::U32(v) | Value::V32(v) => Some(v as i32),
220 Value::U64(v) | Value::V64(v) => Some(v as i32),
221 Value::I64(v) | Value::Z64(v) => Some(v as i32),
222 _ => None,
223 }
224 }
225}
226
227impl From<i32> for Value {
228 fn from(v: i32) -> Value {
229 Value::I32(v)
230 }
231}
232
233impl FromValue for u64 {
234 fn from_value(v: Value) -> Result<Self> {
235 match v {
236 Value::U64(v) | Value::V64(v) => Ok(v),
237 Value::U32(v) | Value::V32(v) => Ok(v as u64),
238 Value::I32(v) | Value::Z32(v) => Ok(v as u64),
239 Value::I64(v) | Value::Z64(v) => Ok(v as u64),
240 v => {
241 v.cast(Typ::U64).ok_or_else(|| anyhow!("can't cast")).and_then(
242 |v| match v {
243 Value::U64(v) => Ok(v),
244 _ => bail!("can't cast"),
245 },
246 )
247 }
248 }
249 }
250
251 fn get(v: Value) -> Option<Self> {
252 match v {
253 Value::U64(v) | Value::V64(v) => Some(v),
254 Value::U32(v) | Value::V32(v) => Some(v as u64),
255 Value::I32(v) | Value::Z32(v) => Some(v as u64),
256 Value::I64(v) | Value::Z64(v) => Some(v as u64),
257 _ => None,
258 }
259 }
260}
261
262impl From<u64> for Value {
263 fn from(v: u64) -> Value {
264 Value::U64(v)
265 }
266}
267
268impl From<usize> for Value {
269 fn from(v: usize) -> Value {
270 Value::U64(v as u64)
271 }
272}
273
274impl FromValue for usize {
275 fn from_value(v: Value) -> Result<Self> {
276 match v {
277 Value::U64(v) | Value::V64(v) => Ok(v as usize),
278 Value::U32(v) | Value::V32(v) => Ok(v as usize),
279 Value::I32(v) | Value::Z32(v) => Ok(v as usize),
280 Value::I64(v) | Value::Z64(v) => Ok(v as usize),
281 v => {
282 v.cast(Typ::U64).ok_or_else(|| anyhow!("can't cast")).and_then(
283 |v| match v {
284 Value::U64(v) => Ok(v as usize),
285 _ => bail!("can't cast"),
286 },
287 )
288 }
289 }
290 }
291
292 fn get(v: Value) -> Option<Self> {
293 match v {
294 Value::U64(v) | Value::V64(v) => Some(v as usize),
295 Value::U32(v) | Value::V32(v) => Some(v as usize),
296 Value::I32(v) | Value::Z32(v) => Some(v as usize),
297 Value::I64(v) | Value::Z64(v) => Some(v as usize),
298 _ => None,
299 }
300 }
301}
302
303impl FromValue for i64 {
304 fn from_value(v: Value) -> Result<Self> {
305 match v {
306 Value::I64(v) | Value::Z64(v) => Ok(v),
307 Value::U32(v) | Value::V32(v) => Ok(v as i64),
308 Value::U64(v) | Value::V64(v) => Ok(v as i64),
309 Value::I32(v) | Value::Z32(v) => Ok(v as i64),
310 v => {
311 v.cast(Typ::I64).ok_or_else(|| anyhow!("can't cast")).and_then(
312 |v| match v {
313 Value::I64(v) => Ok(v),
314 _ => bail!("can't cast"),
315 },
316 )
317 }
318 }
319 }
320
321 fn get(v: Value) -> Option<Self> {
322 match v {
323 Value::I64(v) | Value::Z64(v) => Some(v),
324 Value::U32(v) | Value::V32(v) => Some(v as i64),
325 Value::U64(v) | Value::V64(v) => Some(v as i64),
326 Value::I32(v) | Value::Z32(v) => Some(v as i64),
327 _ => None,
328 }
329 }
330}
331
332impl From<i64> for Value {
333 fn from(v: i64) -> Value {
334 Value::I64(v)
335 }
336}
337
338impl FromValue for f32 {
339 fn from_value(v: Value) -> Result<Self> {
340 match v {
341 Value::F32(v) => Ok(v),
342 Value::F64(v) => Ok(v as f32),
343 v => {
344 v.cast(Typ::F32).ok_or_else(|| anyhow!("can't cast")).and_then(
345 |v| match v {
346 Value::F32(v) => Ok(v),
347 _ => bail!("can't cast"),
348 },
349 )
350 }
351 }
352 }
353
354 fn get(v: Value) -> Option<Self> {
355 match v {
356 Value::F32(v) => Some(v),
357 Value::F64(v) => Some(v as f32),
358 _ => None,
359 }
360 }
361}
362
363impl From<f32> for Value {
364 fn from(v: f32) -> Value {
365 Value::F32(v)
366 }
367}
368
369impl FromValue for f64 {
370 fn from_value(v: Value) -> Result<Self> {
371 match v {
372 Value::F64(v) => Ok(v),
373 Value::F32(v) => Ok(v as f64),
374 v => {
375 v.cast(Typ::F64).ok_or_else(|| anyhow!("can't cast")).and_then(
376 |v| match v {
377 Value::F64(v) => Ok(v),
378 _ => bail!("can't cast"),
379 },
380 )
381 }
382 }
383 }
384
385 fn get(v: Value) -> Option<Self> {
386 match v {
387 Value::F64(v) => Some(v),
388 Value::F32(v) => Some(v as f64),
389 _ => None,
390 }
391 }
392}
393
394impl From<f64> for Value {
395 fn from(v: f64) -> Value {
396 Value::F64(v)
397 }
398}
399
400impl FromValue for Decimal {
401 fn from_value(v: Value) -> Result<Self> {
402 match v {
403 Value::Decimal(v) => Ok(*v),
404 v => {
405 v.cast(Typ::Decimal).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
406 match v {
407 Value::Decimal(v) => Ok(*v),
408 _ => bail!("can't cast"),
409 }
410 })
411 }
412 }
413 }
414
415 fn get(v: Value) -> Option<Self> {
416 match v {
417 Value::Decimal(v) => Some(*v),
418 _ => None,
419 }
420 }
421}
422
423impl From<Decimal> for Value {
424 fn from(value: Decimal) -> Self {
425 Value::Decimal(Arc::new(value))
426 }
427}
428
429impl FromValue for Bytes {
430 fn from_value(v: Value) -> Result<Self> {
431 match v {
432 Value::Bytes(b) => Ok(b.into()),
433 v => v.cast(Typ::Bytes).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
434 match v {
435 Value::Bytes(b) => Ok(b.into()),
436 _ => bail!("can't cast"),
437 }
438 }),
439 }
440 }
441
442 fn get(v: Value) -> Option<Self> {
443 match v {
444 Value::Bytes(b) => Some(b.into()),
445 _ => None,
446 }
447 }
448}
449
450impl From<Bytes> for Value {
451 fn from(v: Bytes) -> Value {
452 Value::Bytes(v.into())
453 }
454}
455
456impl FromValue for Path {
457 fn from_value(v: Value) -> Result<Self> {
458 v.cast_to::<ArcStr>().map(Path::from)
459 }
460
461 fn get(v: Value) -> Option<Self> {
462 match v {
463 Value::String(c) => Some(Path::from(c)),
464 _ => None,
465 }
466 }
467}
468
469impl From<Path> for Value {
470 fn from(v: Path) -> Value {
471 Value::String(v.into())
472 }
473}
474
475impl FromValue for String {
476 fn from_value(v: Value) -> Result<Self> {
477 v.cast_to::<ArcStr>().map(|c| String::from(c.as_str()))
478 }
479
480 fn get(v: Value) -> Option<Self> {
481 match v {
482 Value::String(c) => Some(String::from(c.as_str())),
483 _ => None,
484 }
485 }
486}
487
488impl From<String> for Value {
489 fn from(v: String) -> Value {
490 Value::String(v.into())
491 }
492}
493
494impl From<&'static str> for Value {
495 fn from(v: &'static str) -> Value {
496 Value::String(v.into())
497 }
498}
499
500impl FromValue for ArcStr {
501 fn from_value(v: Value) -> Result<Self> {
502 match v {
503 Value::String(s) => Ok(s),
504 v => v.cast(Typ::String).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
505 match v {
506 Value::String(s) => Ok(s),
507 _ => bail!("can't cast"),
508 }
509 }),
510 }
511 }
512
513 fn get(v: Value) -> Option<Self> {
514 match v {
515 Value::String(c) => Some(c),
516 _ => None,
517 }
518 }
519}
520
521impl From<ArcStr> for Value {
522 fn from(v: ArcStr) -> Value {
523 Value::String(v)
524 }
525}
526
527impl FromValue for CompactString {
528 fn from_value(v: Value) -> Result<Self> {
529 match v {
530 Value::String(s) => Ok(CompactString::from(s.as_str())),
531 v => v.cast(Typ::String).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
532 match v {
533 Value::String(s) => Ok(CompactString::from(s.as_str())),
534 _ => bail!("can't cast"),
535 }
536 }),
537 }
538 }
539
540 fn get(v: Value) -> Option<Self> {
541 match v {
542 Value::String(c) => Some(CompactString::from(c.as_str())),
543 _ => None,
544 }
545 }
546}
547
548impl From<CompactString> for Value {
549 fn from(v: CompactString) -> Value {
550 Value::String(ArcStr::from(v.as_str()))
551 }
552}
553
554impl FromValue for DateTime<Utc> {
555 fn from_value(v: Value) -> Result<Self> {
556 match v {
557 Value::DateTime(d) => Ok(*d),
558 v => {
559 v.cast(Typ::DateTime).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
560 match v {
561 Value::DateTime(d) => Ok(*d),
562 _ => bail!("can't cast"),
563 }
564 })
565 }
566 }
567 }
568
569 fn get(v: Value) -> Option<Self> {
570 match v {
571 Value::DateTime(d) => Some(*d),
572 _ => None,
573 }
574 }
575}
576
577impl From<DateTime<Utc>> for Value {
578 fn from(v: DateTime<Utc>) -> Value {
579 Value::DateTime(Arc::new(v))
580 }
581}
582
583impl FromValue for Duration {
584 fn from_value(v: Value) -> Result<Self> {
585 match v {
586 Value::Duration(d) => Ok(*d),
587 v => {
588 v.cast(Typ::Duration).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
589 match v {
590 Value::Duration(d) => Ok(*d),
591 _ => bail!("can't cast"),
592 }
593 })
594 }
595 }
596 }
597
598 fn get(v: Value) -> Option<Self> {
599 match v {
600 Value::Duration(d) => Some(*d),
601 _ => None,
602 }
603 }
604}
605
606impl From<Duration> for Value {
607 fn from(v: Duration) -> Value {
608 Value::Duration(Arc::new(v))
609 }
610}
611
612impl FromValue for bool {
613 fn from_value(v: Value) -> Result<Self> {
614 match v {
615 Value::Bool(b) => Ok(b),
616 v => v.cast(Typ::Bool).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
617 match v {
618 Value::Bool(b) => Ok(b),
619 _ => bail!("can't cast"),
620 }
621 }),
622 }
623 }
624
625 fn get(v: Value) -> Option<Self> {
626 match v {
627 Value::Bool(b) => Some(b),
628 _ => None,
629 }
630 }
631}
632
633impl From<bool> for Value {
634 fn from(v: bool) -> Value {
635 Value::Bool(v)
636 }
637}
638
639impl FromValue for ValArray {
640 fn from_value(v: Value) -> Result<Self> {
641 match v {
642 Value::Array(a) => Ok(a),
643 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
644 match v {
645 Value::Array(elts) => Ok(elts),
646 _ => bail!("can't cast"),
647 }
648 }),
649 }
650 }
651
652 fn get(v: Value) -> Option<Self> {
653 match v {
654 Value::Array(elts) => Some(elts),
655 _ => None,
656 }
657 }
658}
659
660impl From<ValArray> for Value {
661 fn from(v: ValArray) -> Value {
662 Value::Array(v)
663 }
664}
665
666impl<T: FromValue> FromValue for Vec<T> {
667 fn from_value(v: Value) -> Result<Self> {
668 macro_rules! convert {
669 ($elts:expr) => {
670 $elts
671 .iter()
672 .map(|v| <T as FromValue>::from_value(v.clone()))
673 .collect::<Result<Vec<_>>>()
674 };
675 }
676 match v {
677 Value::Array(a) => Ok(convert!(a)?),
678 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
679 match v {
680 Value::Array(a) => Ok(convert!(a)?),
681 _ => bail!("can't cast"),
682 }
683 }),
684 }
685 }
686
687 fn get(v: Value) -> Option<Self> {
688 match v {
689 Value::Array(elts) => {
690 elts.iter().map(|v| FromValue::get(v.clone())).collect::<Option<Vec<_>>>()
691 }
692 _ => None,
693 }
694 }
695}
696
697impl<T: Into<Value>> From<Vec<T>> for Value {
698 fn from(v: Vec<T>) -> Value {
699 Value::Array(ValArray::from_iter_exact(v.into_iter().map(|e| e.into())))
700 }
701}
702
703impl<T: Into<Value> + Clone + Send + Sync> From<GPooled<Vec<T>>> for Value {
704 fn from(mut v: GPooled<Vec<T>>) -> Value {
705 Value::Array(ValArray::from_iter_exact(v.drain(..).map(|e| e.into())))
706 }
707}
708
709impl<const S: usize, T: FromValue> FromValue for [T; S] {
710 fn from_value(v: Value) -> Result<Self> {
711 macro_rules! convert {
712 ($elts:expr) => {{
713 let a = $elts
714 .iter()
715 .map(|v| <T as FromValue>::from_value(v.clone()))
716 .collect::<Result<SmallVec<[T; S]>>>()?;
717 Ok(a.into_inner().map_err(|_| anyhow!("size mismatch"))?)
718 }};
719 }
720 match v {
721 Value::Array(a) if a.len() == S => convert!(a),
722 Value::Array(_) => bail!("size mismatch"),
723 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
724 match v {
725 Value::Array(a) if a.len() == S => convert!(a),
726 Value::Array(_) => bail!("size mismatch"),
727 _ => bail!("can't cast"),
728 }
729 }),
730 }
731 }
732
733 fn get(v: Value) -> Option<Self> {
734 match v {
735 Value::Array(a) if a.len() == S => {
736 let a = a
737 .iter()
738 .map(|v| <T as FromValue>::get(v.clone()))
739 .collect::<Option<SmallVec<[T; S]>>>()?;
740 a.into_inner().ok()
741 }
742 _ => None,
743 }
744 }
745}
746
747impl<const S: usize, T: Into<Value>> From<[T; S]> for Value {
748 fn from(v: [T; S]) -> Self {
749 Value::Array(ValArray::from_iter_exact(v.into_iter().map(|e| e.into())))
750 }
751}
752
753impl<const S: usize, T: FromValue> FromValue for SmallVec<[T; S]> {
754 fn from_value(v: Value) -> Result<Self> {
755 macro_rules! convert {
756 ($elts:expr) => {
757 $elts
758 .iter()
759 .map(|v| <T as FromValue>::from_value(v.clone()))
760 .collect::<Result<SmallVec<_>>>()
761 };
762 }
763 match v {
764 Value::Array(a) => Ok(convert!(a)?),
765 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
766 match v {
767 Value::Array(a) => Ok(convert!(a)?),
768 _ => bail!("can't cast"),
769 }
770 }),
771 }
772 }
773
774 fn get(v: Value) -> Option<Self> {
775 match v {
776 Value::Array(elts) => elts
777 .iter()
778 .map(|v| FromValue::get(v.clone()))
779 .collect::<Option<SmallVec<_>>>(),
780 _ => None,
781 }
782 }
783}
784
785impl<const S: usize, T: Into<Value>> From<SmallVec<[T; S]>> for Value {
786 fn from(v: SmallVec<[T; S]>) -> Self {
787 Value::Array(ValArray::from_iter_exact(v.into_iter().map(|e| e.into())))
788 }
789}
790
791macro_rules! tuple {
792 ($len:literal, $(($i:literal, $t:ident, $v:ident)),+) =>{
793 impl<$($t: FromValue),+> FromValue for ($($t),+) {
794 fn from_value(v: Value) -> Result<Self> {
795 match v {
796 Value::Array(a) if a.len() == $len => {
797 Ok(($(a[$i].clone().cast_to::<$t>()?),+))
798 },
799 Value::Array(_) => bail!("not a tuple of length {}", $len),
800 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
801 match v {
802 Value::Array(a) if a.len() == $len => {
803 Ok(($(a[$i].clone().cast_to::<$t>()?),+))
804 },
805 Value::Array(_) => bail!("not a tuple of length {}", $len),
806 _ => bail!("can't cast"),
807 }
808 }),
809 }
810 }
811 }
812
813 impl<$($t: Into<Value>),+> From<($($t),+)> for Value {
814 fn from(($($v),+): ($($t),+)) -> Value {
815 Value::Array([$($v.into()),+].into())
816 }
817 }
818 }
819}
820
821tuple!(2, (0, T, t), (1, U, u));
822tuple!(3, (0, T, t), (1, U, u), (2, V, v));
823tuple!(4, (0, T, t), (1, U, u), (2, V, v), (3, W, w));
824tuple!(5, (0, T, t), (1, U, u), (2, V, v), (3, W, w), (4, X, x));
825tuple!(6, (0, T, t), (1, U, u), (2, V, v), (3, W, w), (4, X, x), (5, Y, y));
826tuple!(7, (0, T, t), (1, U, u), (2, V, v), (3, W, w), (4, X, x), (5, Y, y), (6, Z, z));
827tuple!(
828 8,
829 (0, T, t),
830 (1, U, u),
831 (2, V, v),
832 (3, W, w),
833 (4, X, x),
834 (5, Y, y),
835 (6, Z, z),
836 (7, A, a)
837);
838tuple!(
839 9,
840 (0, T, t),
841 (1, U, u),
842 (2, V, v),
843 (3, W, w),
844 (4, X, x),
845 (5, Y, y),
846 (6, Z, z),
847 (7, A, a),
848 (8, B, b)
849);
850tuple!(
851 10,
852 (0, T, t),
853 (1, U, u),
854 (2, V, v),
855 (3, W, w),
856 (4, X, x),
857 (5, Y, y),
858 (6, Z, z),
859 (7, A, a),
860 (8, B, b),
861 (9, C, c)
862);
863tuple!(
864 11,
865 (0, T, t),
866 (1, U, u),
867 (2, V, v),
868 (3, W, w),
869 (4, X, x),
870 (5, Y, y),
871 (6, Z, z),
872 (7, A, a),
873 (8, B, b),
874 (9, C, c),
875 (10, D, d)
876);
877tuple!(
878 12,
879 (0, T, t),
880 (1, U, u),
881 (2, V, v),
882 (3, W, w),
883 (4, X, x),
884 (5, Y, y),
885 (6, Z, z),
886 (7, A, a),
887 (8, B, b),
888 (9, C, c),
889 (10, D, d),
890 (11, E, e)
891);
892tuple!(
893 13,
894 (0, T, t),
895 (1, U, u),
896 (2, V, v),
897 (3, W, w),
898 (4, X, x),
899 (5, Y, y),
900 (6, Z, z),
901 (7, A, a),
902 (8, B, b),
903 (9, C, c),
904 (10, D, d),
905 (11, E, e),
906 (12, F, f)
907);
908tuple!(
909 14,
910 (0, T, t),
911 (1, U, u),
912 (2, V, v),
913 (3, W, w),
914 (4, X, x),
915 (5, Y, y),
916 (6, Z, z),
917 (7, A, a),
918 (8, B, b),
919 (9, C, c),
920 (10, D, d),
921 (11, E, e),
922 (12, F, f),
923 (13, G, g)
924);
925tuple!(
926 15,
927 (0, T, t),
928 (1, U, u),
929 (2, V, v),
930 (3, W, w),
931 (4, X, x),
932 (5, Y, y),
933 (6, Z, z),
934 (7, A, a),
935 (8, B, b),
936 (9, C, c),
937 (10, D, d),
938 (11, E, e),
939 (12, F, f),
940 (13, G, g),
941 (14, H, h)
942);
943tuple!(
944 16,
945 (0, T, t),
946 (1, U, u),
947 (2, V, v),
948 (3, W, w),
949 (4, X, x),
950 (5, Y, y),
951 (6, Z, z),
952 (7, A, a),
953 (8, B, b),
954 (9, C, c),
955 (10, D, d),
956 (11, E, e),
957 (12, F, f),
958 (13, G, g),
959 (14, H, h),
960 (15, I, i)
961);
962tuple!(
963 17,
964 (0, T, t),
965 (1, U, u),
966 (2, V, v),
967 (3, W, w),
968 (4, X, x),
969 (5, Y, y),
970 (6, Z, z),
971 (7, A, a),
972 (8, B, b),
973 (9, C, c),
974 (10, D, d),
975 (11, E, e),
976 (12, F, f),
977 (13, G, g),
978 (14, H, h),
979 (15, I, i),
980 (16, J, j)
981);
982tuple!(
983 18,
984 (0, T, t),
985 (1, U, u),
986 (2, V, v),
987 (3, W, w),
988 (4, X, x),
989 (5, Y, y),
990 (6, Z, z),
991 (7, A, a),
992 (8, B, b),
993 (9, C, c),
994 (10, D, d),
995 (11, E, e),
996 (12, F, f),
997 (13, G, g),
998 (14, H, h),
999 (15, I, i),
1000 (16, J, j),
1001 (17, K, k)
1002);
1003tuple!(
1004 19,
1005 (0, T, t),
1006 (1, U, u),
1007 (2, V, v),
1008 (3, W, w),
1009 (4, X, x),
1010 (5, Y, y),
1011 (6, Z, z),
1012 (7, A, a),
1013 (8, B, b),
1014 (9, C, c),
1015 (10, D, d),
1016 (11, E, e),
1017 (12, F, f),
1018 (13, G, g),
1019 (14, H, h),
1020 (15, I, i),
1021 (16, J, j),
1022 (17, K, k),
1023 (18, L, l)
1024);
1025tuple!(
1026 20,
1027 (0, T, t),
1028 (1, U, u),
1029 (2, V, v),
1030 (3, W, w),
1031 (4, X, x),
1032 (5, Y, y),
1033 (6, Z, z),
1034 (7, A, a),
1035 (8, B, b),
1036 (9, C, c),
1037 (10, D, d),
1038 (11, E, e),
1039 (12, F, f),
1040 (13, G, g),
1041 (14, H, h),
1042 (15, I, i),
1043 (16, J, j),
1044 (17, K, k),
1045 (18, L, l),
1046 (19, M, m)
1047);
1048
1049impl<K: FromValue + Eq + Hash, V: FromValue, S: BuildHasher + Default> FromValue
1050 for HashMap<K, V, S>
1051{
1052 fn from_value(v: Value) -> Result<Self> {
1053 macro_rules! convert {
1054 ($a:expr) => {
1055 $a.iter().map(|v| v.clone().cast_to::<(K, V)>()).collect()
1056 };
1057 }
1058 match v {
1059 Value::Array(a) => convert!(a),
1060 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1061 match v {
1062 Value::Array(a) => convert!(a),
1063 _ => bail!("can't cast"),
1064 }
1065 }),
1066 }
1067 }
1068
1069 fn get(v: Value) -> Option<Self> {
1070 match v {
1071 Value::Array(elts) => {
1072 elts.iter().map(|v| v.clone().get_as::<(K, V)>()).collect()
1073 }
1074 _ => None,
1075 }
1076 }
1077}
1078
1079impl<K: Into<Value>, V: Into<Value>, S: BuildHasher + Default> From<HashMap<K, V, S>>
1080 for Value
1081{
1082 fn from(h: HashMap<K, V, S>) -> Value {
1083 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1084 }
1085}
1086
1087impl<K: FromValue + Ord, V: FromValue> FromValue for BTreeMap<K, V> {
1088 fn from_value(v: Value) -> Result<Self> {
1089 macro_rules! convert {
1090 ($a:expr) => {
1091 $a.iter().map(|v| v.clone().cast_to::<(K, V)>()).collect()
1092 };
1093 }
1094 match v {
1095 Value::Array(a) => convert!(a),
1096 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1097 match v {
1098 Value::Array(a) => convert!(a),
1099 _ => bail!("can't cast"),
1100 }
1101 }),
1102 }
1103 }
1104
1105 fn get(v: Value) -> Option<Self> {
1106 match v {
1107 Value::Array(elts) => {
1108 elts.iter().map(|v| v.clone().get_as::<(K, V)>()).collect()
1109 }
1110 _ => None,
1111 }
1112 }
1113}
1114
1115impl<K: Into<Value>, V: Into<Value>> From<BTreeMap<K, V>> for Value {
1116 fn from(v: BTreeMap<K, V>) -> Self {
1117 Value::Array(ValArray::from_iter_exact(v.into_iter().map(|v| v.into())))
1118 }
1119}
1120
1121impl<K: FromValue + Eq + Hash, S: BuildHasher + Default> FromValue for HashSet<K, S> {
1122 fn from_value(v: Value) -> Result<Self> {
1123 macro_rules! convert {
1124 ($a:expr) => {
1125 $a.iter().map(|v| v.clone().cast_to::<K>()).collect()
1126 };
1127 }
1128 match v {
1129 Value::Array(a) => convert!(a),
1130 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1131 match v {
1132 Value::Array(a) => convert!(a),
1133 _ => bail!("can't cast"),
1134 }
1135 }),
1136 }
1137 }
1138
1139 fn get(v: Value) -> Option<Self> {
1140 match v {
1141 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1142 _ => None,
1143 }
1144 }
1145}
1146
1147impl<K: Into<Value>, S: BuildHasher + Default> From<HashSet<K, S>> for Value {
1148 fn from(h: HashSet<K, S>) -> Value {
1149 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1150 }
1151}
1152
1153impl<K: FromValue + Ord> FromValue for BTreeSet<K> {
1154 fn from_value(v: Value) -> Result<Self> {
1155 macro_rules! convert {
1156 ($a:expr) => {
1157 $a.iter().map(|v| v.clone().cast_to::<K>()).collect()
1158 };
1159 }
1160 match v {
1161 Value::Array(a) => convert!(a),
1162 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1163 match v {
1164 Value::Array(a) => convert!(a),
1165 _ => bail!("can't cast"),
1166 }
1167 }),
1168 }
1169 }
1170
1171 fn get(v: Value) -> Option<Self> {
1172 match v {
1173 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1174 _ => None,
1175 }
1176 }
1177}
1178
1179impl<K: Into<Value>> From<BTreeSet<K>> for Value {
1180 fn from(s: BTreeSet<K>) -> Self {
1181 Value::Array(ValArray::from_iter_exact(s.into_iter().map(|v| v.into())))
1182 }
1183}
1184
1185impl<K: FromValue + Eq + Hash, V: FromValue, S: BuildHasher + Default> FromValue
1186 for IndexMap<K, V, S>
1187{
1188 fn from_value(v: Value) -> Result<Self> {
1189 macro_rules! convert {
1190 ($a:expr) => {
1191 $a.iter().map(|v| v.clone().cast_to::<(K, V)>()).collect()
1192 };
1193 }
1194 match v {
1195 Value::Array(a) => convert!(a),
1196 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1197 match v {
1198 Value::Array(a) => convert!(a),
1199 _ => bail!("can't cast"),
1200 }
1201 }),
1202 }
1203 }
1204
1205 fn get(v: Value) -> Option<Self> {
1206 match v {
1207 Value::Array(elts) => {
1208 elts.iter().map(|v| v.clone().get_as::<(K, V)>()).collect()
1209 }
1210 _ => None,
1211 }
1212 }
1213}
1214
1215impl<K: Into<Value>, V: Into<Value>, S: BuildHasher + Default> From<IndexMap<K, V, S>>
1216 for Value
1217{
1218 fn from(h: IndexMap<K, V, S>) -> Value {
1219 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1220 }
1221}
1222
1223impl<K: FromValue + Eq + Hash, S: BuildHasher + Default> FromValue for IndexSet<K, S> {
1224 fn from_value(v: Value) -> Result<Self> {
1225 macro_rules! convert {
1226 ($a:expr) => {
1227 $a.iter()
1228 .map(|v| v.clone().cast_to::<K>())
1229 .collect::<Result<IndexSet<K, S>>>()
1230 };
1231 }
1232 match v {
1233 Value::Array(a) => convert!(a),
1234 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1235 match v {
1236 Value::Array(a) => convert!(a),
1237 _ => bail!("can't cast"),
1238 }
1239 }),
1240 }
1241 }
1242
1243 fn get(v: Value) -> Option<Self> {
1244 match v {
1245 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1246 _ => None,
1247 }
1248 }
1249}
1250
1251impl<K: Into<Value>, S: BuildHasher + Default> From<IndexSet<K, S>> for Value {
1252 fn from(h: IndexSet<K, S>) -> Value {
1253 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1254 }
1255}
1256
1257impl<T: FromValue> FromValue for Option<T> {
1258 fn from_value(v: Value) -> Result<Self> {
1259 match v {
1260 Value::Null => Ok(None),
1261 v => v.cast_to::<T>().map(|v| Some(v)),
1262 }
1263 }
1264
1265 fn get(v: Value) -> Option<Self> {
1266 match v {
1267 Value::Null => Some(None),
1268 v => v.get_as::<T>().map(|v| Some(v)),
1269 }
1270 }
1271}
1272
1273impl<T: Into<Value>> From<Option<T>> for Value {
1274 fn from(o: Option<T>) -> Value {
1275 o.map(|v| v.into()).unwrap_or(Value::Null)
1276 }
1277}
1278
1279use enumflags2::{BitFlag, BitFlags, _internal::RawBitFlags};
1280impl<T> FromValue for BitFlags<T>
1281where
1282 T: BitFlag,
1283 <T as RawBitFlags>::Numeric: FromValue,
1284{
1285 fn from_value(v: Value) -> Result<Self> {
1286 let bits = v.cast_to::<<T as RawBitFlags>::Numeric>()?;
1287 BitFlags::from_bits(bits).map_err(|_| anyhow!("invalid bits"))
1288 }
1289
1290 fn get(v: Value) -> Option<Self> {
1291 let bits = v.get_as::<<T as RawBitFlags>::Numeric>()?;
1292 BitFlags::from_bits(bits).ok()
1293 }
1294}
1295
1296impl<T> From<BitFlags<T>> for Value
1297where
1298 T: BitFlag,
1299 <T as RawBitFlags>::Numeric: Into<Value>,
1300{
1301 fn from(v: BitFlags<T>) -> Self {
1302 v.bits().into()
1303 }
1304}
1305
1306impl FromValue for uuid::Uuid {
1307 fn from_value(v: Value) -> Result<Self> {
1308 match v {
1309 Value::String(v) => Ok(v.parse::<uuid::Uuid>()?),
1310 _ => bail!("can't cast"),
1311 }
1312 }
1313
1314 fn get(v: Value) -> Option<Self> {
1315 <uuid::Uuid as FromValue>::from_value(v).ok()
1316 }
1317}
1318
1319impl From<uuid::Uuid> for Value {
1320 fn from(id: uuid::Uuid) -> Self {
1321 Value::from(id.to_string())
1322 }
1323}
1324
1325thread_local! {
1326 static POOLS: RefCell<FxHashMap<TypeId, Box<dyn Any>>> =
1327 RefCell::new(HashMap::default());
1328}
1329
1330impl<T: FromValue + Send + Sync + 'static> FromValue for GPooled<Vec<T>> {
1331 fn from_value(v: Value) -> Result<Self> {
1332 macro_rules! convert {
1333 ($a:expr) => {{
1334 let mut t = POOLS.with(|pools| {
1335 let mut pools = pools.borrow_mut();
1336 let pool: &mut Pool<Vec<T>> = pools
1337 .entry(TypeId::of::<Vec<T>>())
1338 .or_insert_with(|| Box::new(Pool::<Vec<T>>::new(10000, 10000)))
1339 .downcast_mut()
1340 .unwrap();
1341 pool.take()
1342 });
1343 for elt in $a.iter() {
1344 t.push(elt.clone().cast_to::<T>()?)
1345 }
1346 Ok(t)
1347 }};
1348 }
1349 match v {
1350 Value::Array(a) => convert!(a),
1351 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1352 match v {
1353 Value::Array(a) => convert!(a),
1354 _ => bail!("can't cast"),
1355 }
1356 }),
1357 }
1358 }
1359
1360 fn get(v: Value) -> Option<Self> {
1361 <GPooled<Vec<T>> as FromValue>::from_value(v).ok()
1362 }
1363}