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