1use crate::{Typ, ValArray, Value};
2use ahash::{AHashMap, AHashSet};
3use anyhow::{anyhow, bail, Result};
4use arcstr::ArcStr;
5use bytes::Bytes;
6use chrono::prelude::*;
7use compact_str::CompactString;
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: FromValue + Send + Sync + 'static> FromValue for LPooled<Vec<T>> {
707 fn from_value(v: Value) -> Result<Self> {
708 macro_rules! convert {
709 ($a:expr) => {{
710 let mut t: LPooled<Vec<T>> = LPooled::take();
711 for elt in $a.iter() {
712 t.push(elt.clone().cast_to::<T>()?)
713 }
714 Ok(t)
715 }};
716 }
717 match v {
718 Value::Array(a) => convert!(a),
719 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
720 match v {
721 Value::Array(a) => convert!(a),
722 _ => bail!("can't cast"),
723 }
724 }),
725 }
726 }
727
728 fn get(v: Value) -> Option<Self> {
729 <LPooled<Vec<T>> as FromValue>::from_value(v).ok()
730 }
731}
732
733impl<T: Into<Value>> From<LPooled<Vec<T>>> for Value {
734 fn from(mut v: LPooled<Vec<T>>) -> Value {
735 Value::Array(ValArray::from_iter_exact(v.drain(..).map(|e| e.into())))
736 }
737}
738
739impl<T: Into<Value> + Clone + Send + Sync> From<GPooled<Vec<T>>> for Value {
740 fn from(mut v: GPooled<Vec<T>>) -> Value {
741 Value::Array(ValArray::from_iter_exact(v.drain(..).map(|e| e.into())))
742 }
743}
744
745impl<const S: usize, T: FromValue> FromValue for [T; S] {
746 fn from_value(v: Value) -> Result<Self> {
747 macro_rules! convert {
748 ($elts:expr) => {{
749 let a = $elts
750 .iter()
751 .map(|v| <T as FromValue>::from_value(v.clone()))
752 .collect::<Result<SmallVec<[T; S]>>>()?;
753 Ok(a.into_inner().map_err(|_| anyhow!("size mismatch"))?)
754 }};
755 }
756 match v {
757 Value::Array(a) if a.len() == S => convert!(a),
758 Value::Array(_) => bail!("size mismatch"),
759 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
760 match v {
761 Value::Array(a) if a.len() == S => convert!(a),
762 Value::Array(_) => bail!("size mismatch"),
763 _ => bail!("can't cast"),
764 }
765 }),
766 }
767 }
768
769 fn get(v: Value) -> Option<Self> {
770 match v {
771 Value::Array(a) if a.len() == S => {
772 let a = a
773 .iter()
774 .map(|v| <T as FromValue>::get(v.clone()))
775 .collect::<Option<SmallVec<[T; S]>>>()?;
776 a.into_inner().ok()
777 }
778 _ => None,
779 }
780 }
781}
782
783impl<const S: usize, T: Into<Value>> From<[T; S]> for Value {
784 fn from(v: [T; S]) -> Self {
785 Value::Array(ValArray::from_iter_exact(v.into_iter().map(|e| e.into())))
786 }
787}
788
789impl<const S: usize, T: FromValue> FromValue for SmallVec<[T; S]> {
790 fn from_value(v: Value) -> Result<Self> {
791 macro_rules! convert {
792 ($elts:expr) => {
793 $elts
794 .iter()
795 .map(|v| <T as FromValue>::from_value(v.clone()))
796 .collect::<Result<SmallVec<_>>>()
797 };
798 }
799 match v {
800 Value::Array(a) => Ok(convert!(a)?),
801 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
802 match v {
803 Value::Array(a) => Ok(convert!(a)?),
804 _ => bail!("can't cast"),
805 }
806 }),
807 }
808 }
809
810 fn get(v: Value) -> Option<Self> {
811 match v {
812 Value::Array(elts) => elts
813 .iter()
814 .map(|v| FromValue::get(v.clone()))
815 .collect::<Option<SmallVec<_>>>(),
816 _ => None,
817 }
818 }
819}
820
821impl<const S: usize, T: Into<Value>> From<SmallVec<[T; S]>> for Value {
822 fn from(v: SmallVec<[T; S]>) -> Self {
823 Value::Array(ValArray::from_iter_exact(v.into_iter().map(|e| e.into())))
824 }
825}
826
827macro_rules! tuple {
828 ($len:literal, $(($i:literal, $t:ident, $v:ident)),+) =>{
829 impl<$($t: FromValue),+> FromValue for ($($t),+) {
830 fn from_value(v: Value) -> Result<Self> {
831 match v {
832 Value::Array(a) if a.len() == $len => {
833 Ok(($(a[$i].clone().cast_to::<$t>()?),+))
834 },
835 Value::Array(_) => bail!("not a tuple of length {}", $len),
836 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
837 match v {
838 Value::Array(a) if a.len() == $len => {
839 Ok(($(a[$i].clone().cast_to::<$t>()?),+))
840 },
841 Value::Array(_) => bail!("not a tuple of length {}", $len),
842 _ => bail!("can't cast"),
843 }
844 }),
845 }
846 }
847 }
848
849 impl<$($t: Into<Value>),+> From<($($t),+)> for Value {
850 fn from(($($v),+): ($($t),+)) -> Value {
851 Value::Array([$($v.into()),+].into())
852 }
853 }
854 }
855}
856
857tuple!(2, (0, T, t), (1, U, u));
858tuple!(3, (0, T, t), (1, U, u), (2, V, v));
859tuple!(4, (0, T, t), (1, U, u), (2, V, v), (3, W, w));
860tuple!(5, (0, T, t), (1, U, u), (2, V, v), (3, W, w), (4, X, x));
861tuple!(6, (0, T, t), (1, U, u), (2, V, v), (3, W, w), (4, X, x), (5, Y, y));
862tuple!(7, (0, T, t), (1, U, u), (2, V, v), (3, W, w), (4, X, x), (5, Y, y), (6, Z, z));
863tuple!(
864 8,
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);
874tuple!(
875 9,
876 (0, T, t),
877 (1, U, u),
878 (2, V, v),
879 (3, W, w),
880 (4, X, x),
881 (5, Y, y),
882 (6, Z, z),
883 (7, A, a),
884 (8, B, b)
885);
886tuple!(
887 10,
888 (0, T, t),
889 (1, U, u),
890 (2, V, v),
891 (3, W, w),
892 (4, X, x),
893 (5, Y, y),
894 (6, Z, z),
895 (7, A, a),
896 (8, B, b),
897 (9, C, c)
898);
899tuple!(
900 11,
901 (0, T, t),
902 (1, U, u),
903 (2, V, v),
904 (3, W, w),
905 (4, X, x),
906 (5, Y, y),
907 (6, Z, z),
908 (7, A, a),
909 (8, B, b),
910 (9, C, c),
911 (10, D, d)
912);
913tuple!(
914 12,
915 (0, T, t),
916 (1, U, u),
917 (2, V, v),
918 (3, W, w),
919 (4, X, x),
920 (5, Y, y),
921 (6, Z, z),
922 (7, A, a),
923 (8, B, b),
924 (9, C, c),
925 (10, D, d),
926 (11, E, e)
927);
928tuple!(
929 13,
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);
944tuple!(
945 14,
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);
961tuple!(
962 15,
963 (0, T, t),
964 (1, U, u),
965 (2, V, v),
966 (3, W, w),
967 (4, X, x),
968 (5, Y, y),
969 (6, Z, z),
970 (7, A, a),
971 (8, B, b),
972 (9, C, c),
973 (10, D, d),
974 (11, E, e),
975 (12, F, f),
976 (13, G, g),
977 (14, H, h)
978);
979tuple!(
980 16,
981 (0, T, t),
982 (1, U, u),
983 (2, V, v),
984 (3, W, w),
985 (4, X, x),
986 (5, Y, y),
987 (6, Z, z),
988 (7, A, a),
989 (8, B, b),
990 (9, C, c),
991 (10, D, d),
992 (11, E, e),
993 (12, F, f),
994 (13, G, g),
995 (14, H, h),
996 (15, I, i)
997);
998tuple!(
999 17,
1000 (0, T, t),
1001 (1, U, u),
1002 (2, V, v),
1003 (3, W, w),
1004 (4, X, x),
1005 (5, Y, y),
1006 (6, Z, z),
1007 (7, A, a),
1008 (8, B, b),
1009 (9, C, c),
1010 (10, D, d),
1011 (11, E, e),
1012 (12, F, f),
1013 (13, G, g),
1014 (14, H, h),
1015 (15, I, i),
1016 (16, J, j)
1017);
1018tuple!(
1019 18,
1020 (0, T, t),
1021 (1, U, u),
1022 (2, V, v),
1023 (3, W, w),
1024 (4, X, x),
1025 (5, Y, y),
1026 (6, Z, z),
1027 (7, A, a),
1028 (8, B, b),
1029 (9, C, c),
1030 (10, D, d),
1031 (11, E, e),
1032 (12, F, f),
1033 (13, G, g),
1034 (14, H, h),
1035 (15, I, i),
1036 (16, J, j),
1037 (17, K, k)
1038);
1039tuple!(
1040 19,
1041 (0, T, t),
1042 (1, U, u),
1043 (2, V, v),
1044 (3, W, w),
1045 (4, X, x),
1046 (5, Y, y),
1047 (6, Z, z),
1048 (7, A, a),
1049 (8, B, b),
1050 (9, C, c),
1051 (10, D, d),
1052 (11, E, e),
1053 (12, F, f),
1054 (13, G, g),
1055 (14, H, h),
1056 (15, I, i),
1057 (16, J, j),
1058 (17, K, k),
1059 (18, L, l)
1060);
1061tuple!(
1062 20,
1063 (0, T, t),
1064 (1, U, u),
1065 (2, V, v),
1066 (3, W, w),
1067 (4, X, x),
1068 (5, Y, y),
1069 (6, Z, z),
1070 (7, A, a),
1071 (8, B, b),
1072 (9, C, c),
1073 (10, D, d),
1074 (11, E, e),
1075 (12, F, f),
1076 (13, G, g),
1077 (14, H, h),
1078 (15, I, i),
1079 (16, J, j),
1080 (17, K, k),
1081 (18, L, l),
1082 (19, M, m)
1083);
1084
1085impl<K: FromValue + Eq + Hash, V: FromValue, S: BuildHasher + Default> FromValue
1086 for HashMap<K, V, S>
1087{
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>, S: BuildHasher + Default> From<HashMap<K, V, S>>
1116 for Value
1117{
1118 fn from(h: HashMap<K, V, S>) -> Value {
1119 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1120 }
1121}
1122
1123impl<K: FromValue + Eq + Hash, V: FromValue, S: BuildHasher + Default> FromValue
1124 for LPooled<HashMap<K, V, S>>
1125{
1126 fn from_value(v: Value) -> Result<Self> {
1127 macro_rules! convert {
1128 ($a:expr) => {
1129 $a.iter().map(|v| v.clone().cast_to::<(K, V)>()).collect()
1130 };
1131 }
1132 match v {
1133 Value::Array(a) => convert!(a),
1134 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1135 match v {
1136 Value::Array(a) => convert!(a),
1137 _ => bail!("can't cast"),
1138 }
1139 }),
1140 }
1141 }
1142
1143 fn get(v: Value) -> Option<Self> {
1144 match v {
1145 Value::Array(elts) => {
1146 elts.iter().map(|v| v.clone().get_as::<(K, V)>()).collect()
1147 }
1148 _ => None,
1149 }
1150 }
1151}
1152
1153impl<K: Hash + Eq + Into<Value>, V: Into<Value>, S: BuildHasher + Default>
1154 From<LPooled<HashMap<K, V, S>>> for Value
1155{
1156 fn from(mut h: LPooled<HashMap<K, V, S>>) -> Value {
1157 Value::Array(ValArray::from_iter_exact(h.drain().map(|v| v.into())))
1158 }
1159}
1160
1161impl<K: FromValue + Eq + Hash, V: FromValue> FromValue for AHashMap<K, V> {
1162 fn from_value(v: Value) -> Result<Self> {
1163 macro_rules! convert {
1164 ($a:expr) => {
1165 $a.iter().map(|v| v.clone().cast_to::<(K, V)>()).collect()
1166 };
1167 }
1168 match v {
1169 Value::Array(a) => convert!(a),
1170 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1171 match v {
1172 Value::Array(a) => convert!(a),
1173 _ => bail!("can't cast"),
1174 }
1175 }),
1176 }
1177 }
1178
1179 fn get(v: Value) -> Option<Self> {
1180 match v {
1181 Value::Array(elts) => {
1182 elts.iter().map(|v| v.clone().get_as::<(K, V)>()).collect()
1183 }
1184 _ => None,
1185 }
1186 }
1187}
1188
1189impl<K: Into<Value>, V: Into<Value>> From<AHashMap<K, V>> for Value {
1190 fn from(h: AHashMap<K, V>) -> Value {
1191 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1192 }
1193}
1194
1195impl<K: FromValue + Eq + Hash, V: FromValue> FromValue for LPooled<AHashMap<K, V>> {
1196 fn from_value(v: Value) -> Result<Self> {
1197 macro_rules! convert {
1198 ($a:expr) => {
1199 $a.iter().map(|v| v.clone().cast_to::<(K, V)>()).collect()
1200 };
1201 }
1202 match v {
1203 Value::Array(a) => convert!(a),
1204 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1205 match v {
1206 Value::Array(a) => convert!(a),
1207 _ => bail!("can't cast"),
1208 }
1209 }),
1210 }
1211 }
1212
1213 fn get(v: Value) -> Option<Self> {
1214 match v {
1215 Value::Array(elts) => {
1216 elts.iter().map(|v| v.clone().get_as::<(K, V)>()).collect()
1217 }
1218 _ => None,
1219 }
1220 }
1221}
1222
1223impl<K: Hash + Eq + Into<Value>, V: Into<Value>> From<LPooled<AHashMap<K, V>>> for Value {
1224 fn from(mut h: LPooled<AHashMap<K, V>>) -> Value {
1225 Value::Array(ValArray::from_iter_exact(h.drain().map(|v| v.into())))
1226 }
1227}
1228
1229impl<K: FromValue + Ord, V: FromValue> FromValue for BTreeMap<K, V> {
1230 fn from_value(v: Value) -> Result<Self> {
1231 macro_rules! convert {
1232 ($a:expr) => {
1233 $a.iter().map(|v| v.clone().cast_to::<(K, V)>()).collect()
1234 };
1235 }
1236 match v {
1237 Value::Array(a) => convert!(a),
1238 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1239 match v {
1240 Value::Array(a) => convert!(a),
1241 _ => bail!("can't cast"),
1242 }
1243 }),
1244 }
1245 }
1246
1247 fn get(v: Value) -> Option<Self> {
1248 match v {
1249 Value::Array(elts) => {
1250 elts.iter().map(|v| v.clone().get_as::<(K, V)>()).collect()
1251 }
1252 _ => None,
1253 }
1254 }
1255}
1256
1257impl<K: Into<Value>, V: Into<Value>> From<BTreeMap<K, V>> for Value {
1258 fn from(v: BTreeMap<K, V>) -> Self {
1259 Value::Array(ValArray::from_iter_exact(v.into_iter().map(|v| v.into())))
1260 }
1261}
1262
1263impl<K: FromValue + Eq + Hash, S: BuildHasher + Default> FromValue for HashSet<K, S> {
1264 fn from_value(v: Value) -> Result<Self> {
1265 macro_rules! convert {
1266 ($a:expr) => {
1267 $a.iter().map(|v| v.clone().cast_to::<K>()).collect()
1268 };
1269 }
1270 match v {
1271 Value::Array(a) => convert!(a),
1272 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1273 match v {
1274 Value::Array(a) => convert!(a),
1275 _ => bail!("can't cast"),
1276 }
1277 }),
1278 }
1279 }
1280
1281 fn get(v: Value) -> Option<Self> {
1282 match v {
1283 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1284 _ => None,
1285 }
1286 }
1287}
1288
1289impl<K: Into<Value>, S: BuildHasher + Default> From<HashSet<K, S>> for Value {
1290 fn from(h: HashSet<K, S>) -> Value {
1291 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1292 }
1293}
1294
1295impl<K: FromValue + Eq + Hash, S: BuildHasher + Default> FromValue
1296 for LPooled<HashSet<K, S>>
1297{
1298 fn from_value(v: Value) -> Result<Self> {
1299 macro_rules! convert {
1300 ($a:expr) => {
1301 $a.iter().map(|v| v.clone().cast_to::<K>()).collect()
1302 };
1303 }
1304 match v {
1305 Value::Array(a) => convert!(a),
1306 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1307 match v {
1308 Value::Array(a) => convert!(a),
1309 _ => bail!("can't cast"),
1310 }
1311 }),
1312 }
1313 }
1314
1315 fn get(v: Value) -> Option<Self> {
1316 match v {
1317 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1318 _ => None,
1319 }
1320 }
1321}
1322
1323impl<K: Hash + Eq + Into<Value>, S: BuildHasher + Default> From<LPooled<HashSet<K, S>>>
1324 for Value
1325{
1326 fn from(mut h: LPooled<HashSet<K, S>>) -> Value {
1327 Value::Array(ValArray::from_iter_exact(h.drain().map(|v| v.into())))
1328 }
1329}
1330
1331impl<K: FromValue + Eq + Hash> FromValue for AHashSet<K> {
1332 fn from_value(v: Value) -> Result<Self> {
1333 macro_rules! convert {
1334 ($a:expr) => {
1335 $a.iter().map(|v| v.clone().cast_to::<K>()).collect()
1336 };
1337 }
1338 match v {
1339 Value::Array(a) => convert!(a),
1340 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1341 match v {
1342 Value::Array(a) => convert!(a),
1343 _ => bail!("can't cast"),
1344 }
1345 }),
1346 }
1347 }
1348
1349 fn get(v: Value) -> Option<Self> {
1350 match v {
1351 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1352 _ => None,
1353 }
1354 }
1355}
1356
1357impl<K: Into<Value>> From<AHashSet<K>> for Value {
1358 fn from(h: AHashSet<K>) -> Value {
1359 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1360 }
1361}
1362
1363impl<K: FromValue + Eq + Hash> FromValue for LPooled<AHashSet<K>> {
1364 fn from_value(v: Value) -> Result<Self> {
1365 macro_rules! convert {
1366 ($a:expr) => {
1367 $a.iter().map(|v| v.clone().cast_to::<K>()).collect()
1368 };
1369 }
1370 match v {
1371 Value::Array(a) => convert!(a),
1372 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1373 match v {
1374 Value::Array(a) => convert!(a),
1375 _ => bail!("can't cast"),
1376 }
1377 }),
1378 }
1379 }
1380
1381 fn get(v: Value) -> Option<Self> {
1382 match v {
1383 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1384 _ => None,
1385 }
1386 }
1387}
1388
1389impl<K: Hash + Eq + Into<Value>> From<LPooled<AHashSet<K>>> for Value {
1390 fn from(mut h: LPooled<AHashSet<K>>) -> Value {
1391 Value::Array(ValArray::from_iter_exact(h.drain().map(|v| v.into())))
1392 }
1393}
1394
1395impl<K: FromValue + Ord> FromValue for BTreeSet<K> {
1396 fn from_value(v: Value) -> Result<Self> {
1397 macro_rules! convert {
1398 ($a:expr) => {
1399 $a.iter().map(|v| v.clone().cast_to::<K>()).collect()
1400 };
1401 }
1402 match v {
1403 Value::Array(a) => convert!(a),
1404 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1405 match v {
1406 Value::Array(a) => convert!(a),
1407 _ => bail!("can't cast"),
1408 }
1409 }),
1410 }
1411 }
1412
1413 fn get(v: Value) -> Option<Self> {
1414 match v {
1415 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1416 _ => None,
1417 }
1418 }
1419}
1420
1421impl<K: Into<Value>> From<BTreeSet<K>> for Value {
1422 fn from(s: BTreeSet<K>) -> Self {
1423 Value::Array(ValArray::from_iter_exact(s.into_iter().map(|v| v.into())))
1424 }
1425}
1426
1427impl<K: FromValue + Eq + Hash, V: FromValue, S: BuildHasher + Default> FromValue
1428 for IndexMap<K, V, S>
1429{
1430 fn from_value(v: Value) -> Result<Self> {
1431 macro_rules! convert {
1432 ($a:expr) => {
1433 $a.iter().map(|v| v.clone().cast_to::<(K, V)>()).collect()
1434 };
1435 }
1436 match v {
1437 Value::Array(a) => convert!(a),
1438 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1439 match v {
1440 Value::Array(a) => convert!(a),
1441 _ => bail!("can't cast"),
1442 }
1443 }),
1444 }
1445 }
1446
1447 fn get(v: Value) -> Option<Self> {
1448 match v {
1449 Value::Array(elts) => {
1450 elts.iter().map(|v| v.clone().get_as::<(K, V)>()).collect()
1451 }
1452 _ => None,
1453 }
1454 }
1455}
1456
1457impl<K: Into<Value>, V: Into<Value>, S: BuildHasher + Default> From<IndexMap<K, V, S>>
1458 for Value
1459{
1460 fn from(h: IndexMap<K, V, S>) -> Value {
1461 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1462 }
1463}
1464
1465impl<K: FromValue + Eq + Hash, V: FromValue, S: BuildHasher + Default> FromValue
1466 for LPooled<IndexMap<K, V, S>>
1467{
1468 fn from_value(v: Value) -> Result<Self> {
1469 macro_rules! convert {
1470 ($a:expr) => {
1471 $a.iter().map(|v| v.clone().cast_to::<(K, V)>()).collect()
1472 };
1473 }
1474 match v {
1475 Value::Array(a) => convert!(a),
1476 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1477 match v {
1478 Value::Array(a) => convert!(a),
1479 _ => bail!("can't cast"),
1480 }
1481 }),
1482 }
1483 }
1484
1485 fn get(v: Value) -> Option<Self> {
1486 match v {
1487 Value::Array(elts) => {
1488 elts.iter().map(|v| v.clone().get_as::<(K, V)>()).collect()
1489 }
1490 _ => None,
1491 }
1492 }
1493}
1494
1495impl<K: Hash + Eq + Into<Value>, V: Into<Value>, S: BuildHasher + Default>
1496 From<LPooled<IndexMap<K, V, S>>> for Value
1497{
1498 fn from(mut h: LPooled<IndexMap<K, V, S>>) -> Value {
1499 Value::Array(ValArray::from_iter_exact(h.drain(..).map(|v| v.into())))
1500 }
1501}
1502
1503impl<K: FromValue + Eq + Hash, S: BuildHasher + Default> FromValue for IndexSet<K, S> {
1504 fn from_value(v: Value) -> Result<Self> {
1505 macro_rules! convert {
1506 ($a:expr) => {
1507 $a.iter()
1508 .map(|v| v.clone().cast_to::<K>())
1509 .collect::<Result<IndexSet<K, S>>>()
1510 };
1511 }
1512 match v {
1513 Value::Array(a) => convert!(a),
1514 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1515 match v {
1516 Value::Array(a) => convert!(a),
1517 _ => bail!("can't cast"),
1518 }
1519 }),
1520 }
1521 }
1522
1523 fn get(v: Value) -> Option<Self> {
1524 match v {
1525 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1526 _ => None,
1527 }
1528 }
1529}
1530
1531impl<K: Into<Value>, S: BuildHasher + Default> From<IndexSet<K, S>> for Value {
1532 fn from(h: IndexSet<K, S>) -> Value {
1533 Value::Array(ValArray::from_iter_exact(h.into_iter().map(|v| v.into())))
1534 }
1535}
1536
1537impl<K: FromValue + Eq + Hash, S: BuildHasher + Default> FromValue
1538 for LPooled<IndexSet<K, S>>
1539{
1540 fn from_value(v: Value) -> Result<Self> {
1541 macro_rules! convert {
1542 ($a:expr) => {
1543 $a.iter()
1544 .map(|v| v.clone().cast_to::<K>())
1545 .collect::<Result<LPooled<IndexSet<K, S>>>>()
1546 };
1547 }
1548 match v {
1549 Value::Array(a) => convert!(a),
1550 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1551 match v {
1552 Value::Array(a) => convert!(a),
1553 _ => bail!("can't cast"),
1554 }
1555 }),
1556 }
1557 }
1558
1559 fn get(v: Value) -> Option<Self> {
1560 match v {
1561 Value::Array(elts) => elts.iter().map(|v| v.clone().get_as::<K>()).collect(),
1562 _ => None,
1563 }
1564 }
1565}
1566
1567impl<K: Hash + Eq + Into<Value>, S: BuildHasher + Default> From<LPooled<IndexSet<K, S>>>
1568 for Value
1569{
1570 fn from(mut h: LPooled<IndexSet<K, S>>) -> Value {
1571 Value::Array(ValArray::from_iter_exact(h.drain(..).map(|v| v.into())))
1572 }
1573}
1574
1575impl<T: FromValue> FromValue for Option<T> {
1576 fn from_value(v: Value) -> Result<Self> {
1577 match v {
1578 Value::Null => Ok(None),
1579 v => v.cast_to::<T>().map(|v| Some(v)),
1580 }
1581 }
1582
1583 fn get(v: Value) -> Option<Self> {
1584 match v {
1585 Value::Null => Some(None),
1586 v => v.get_as::<T>().map(|v| Some(v)),
1587 }
1588 }
1589}
1590
1591impl<T: Into<Value>> From<Option<T>> for Value {
1592 fn from(o: Option<T>) -> Value {
1593 o.map(|v| v.into()).unwrap_or(Value::Null)
1594 }
1595}
1596
1597use enumflags2::{_internal::RawBitFlags, BitFlag, BitFlags};
1598impl<T> FromValue for BitFlags<T>
1599where
1600 T: BitFlag,
1601 <T as RawBitFlags>::Numeric: FromValue,
1602{
1603 fn from_value(v: Value) -> Result<Self> {
1604 let bits = v.cast_to::<<T as RawBitFlags>::Numeric>()?;
1605 BitFlags::from_bits(bits).map_err(|_| anyhow!("invalid bits"))
1606 }
1607
1608 fn get(v: Value) -> Option<Self> {
1609 let bits = v.get_as::<<T as RawBitFlags>::Numeric>()?;
1610 BitFlags::from_bits(bits).ok()
1611 }
1612}
1613
1614impl<T> From<BitFlags<T>> for Value
1615where
1616 T: BitFlag,
1617 <T as RawBitFlags>::Numeric: Into<Value>,
1618{
1619 fn from(v: BitFlags<T>) -> Self {
1620 v.bits().into()
1621 }
1622}
1623
1624impl FromValue for uuid::Uuid {
1625 fn from_value(v: Value) -> Result<Self> {
1626 match v {
1627 Value::String(v) => Ok(v.parse::<uuid::Uuid>()?),
1628 _ => bail!("can't cast"),
1629 }
1630 }
1631
1632 fn get(v: Value) -> Option<Self> {
1633 <uuid::Uuid as FromValue>::from_value(v).ok()
1634 }
1635}
1636
1637impl From<uuid::Uuid> for Value {
1638 fn from(id: uuid::Uuid) -> Self {
1639 Value::from(id.to_string())
1640 }
1641}
1642
1643thread_local! {
1644 static POOLS: RefCell<AHashMap<TypeId, Box<dyn Any>>> =
1645 RefCell::new(AHashMap::default());
1646}
1647
1648impl<T: FromValue + Send + Sync + 'static> FromValue for GPooled<Vec<T>> {
1649 fn from_value(v: Value) -> Result<Self> {
1650 macro_rules! convert {
1651 ($a:expr) => {{
1652 let mut t = POOLS.with(|pools| {
1653 let mut pools = pools.borrow_mut();
1654 let pool: &mut Pool<Vec<T>> = pools
1655 .entry(TypeId::of::<Vec<T>>())
1656 .or_insert_with(|| Box::new(Pool::<Vec<T>>::new(10000, 10000)))
1657 .downcast_mut()
1658 .unwrap();
1659 pool.take()
1660 });
1661 for elt in $a.iter() {
1662 t.push(elt.clone().cast_to::<T>()?)
1663 }
1664 Ok(t)
1665 }};
1666 }
1667 match v {
1668 Value::Array(a) => convert!(a),
1669 v => v.cast(Typ::Array).ok_or_else(|| anyhow!("can't cast")).and_then(|v| {
1670 match v {
1671 Value::Array(a) => convert!(a),
1672 _ => bail!("can't cast"),
1673 }
1674 }),
1675 }
1676 }
1677
1678 fn get(v: Value) -> Option<Self> {
1679 <GPooled<Vec<T>> as FromValue>::from_value(v).ok()
1680 }
1681}