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