1use std::collections::BTreeMap;
2
3use serde::{
4 de::{
5 value::{MapDeserializer, SeqDeserializer},
6 DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, Unexpected, VariantAccess,
7 Visitor,
8 },
9 Deserialize, Deserializer,
10};
11
12use crate::{Error, Value};
13
14impl<'de> Deserialize<'de> for Value {
15 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
16 where
17 D: Deserializer<'de>,
18 {
19 struct ValueVisitor;
20
21 impl<'de> Visitor<'de> for ValueVisitor {
22 type Value = Value;
23
24 fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
25 formatter.write_str(
26 "a JSON-like value (number, float, string, object, boolean, array, or null)",
27 )
28 }
29
30 fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
31 where
32 M: MapAccess<'de>,
33 {
34 let mut map = BTreeMap::new();
35
36 while let Some((key, value)) = access.next_entry()? {
37 map.insert(key, value);
38 }
39
40 Ok(Value::Object(map))
41 }
42
43 fn visit_unit<E>(self) -> Result<Self::Value, E>
44 where
45 E: serde::de::Error,
46 {
47 Ok(Value::Null)
48 }
49
50 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
51 where
52 E: serde::de::Error,
53 {
54 Ok(v.into())
55 }
56
57 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
58 where
59 E: serde::de::Error,
60 {
61 Ok(v.into())
62 }
63
64 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
65 where
66 E: serde::de::Error,
67 {
68 Ok(v.into())
69 }
70
71 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
72 where
73 E: serde::de::Error,
74 {
75 Ok(v.into())
76 }
77
78 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
79 where
80 E: serde::de::Error,
81 {
82 Ok(v.into())
83 }
84
85 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
86 where
87 A: serde::de::SeqAccess<'de>,
88 {
89 let mut elements = Vec::with_capacity(seq.size_hint().unwrap_or(0));
90 while let Some(element) = seq.next_element()? {
91 elements.push(element);
92 }
93 Ok(Value::Array(elements))
94 }
95
96 fn visit_none<E>(self) -> Result<Self::Value, E>
97 where
98 E: serde::de::Error,
99 {
100 Ok(Value::Null)
101 }
102 }
103 deserializer.deserialize_any(ValueVisitor)
104 }
105}
106
107struct EnumDeserializer {
108 variant: String,
109 value: Option<Value>,
110}
111
112impl<'de> EnumAccess<'de> for EnumDeserializer {
113 type Error = Error;
114 type Variant = VariantDeserializer;
115
116 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
117 where
118 V: DeserializeSeed<'de>,
119 {
120 let variant = self.variant.into_deserializer();
121 let visitor = VariantDeserializer { value: self.value };
122 seed.deserialize(variant).map(|v| (v, visitor))
123 }
124}
125
126struct VariantDeserializer {
127 value: Option<Value>,
128}
129
130impl<'de> VariantAccess<'de> for VariantDeserializer {
131 type Error = Error;
132
133 fn unit_variant(self) -> Result<(), Error> {
134 match self.value {
135 Some(value) => Deserialize::deserialize(value),
136 None => Ok(()),
137 }
138 }
139
140 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
141 where
142 T: DeserializeSeed<'de>,
143 {
144 match self.value {
145 Some(value) => seed.deserialize(value),
146 None => Err(serde::de::Error::invalid_type(
147 Unexpected::UnitVariant,
148 &"newtype variant",
149 )),
150 }
151 }
152
153 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
154 where
155 V: Visitor<'de>,
156 {
157 match self.value {
158 Some(Value::Array(v)) => {
159 if v.is_empty() {
160 visitor.visit_unit()
161 } else {
162 visit_array(v, visitor)
163 }
164 }
165 Some(other) => Err(serde::de::Error::invalid_type(
166 other.unexpected(),
167 &"tuple variant",
168 )),
169 None => Err(serde::de::Error::invalid_type(
170 Unexpected::UnitVariant,
171 &"tuple variant",
172 )),
173 }
174 }
175
176 fn struct_variant<V>(
177 self,
178 _fields: &'static [&'static str],
179 visitor: V,
180 ) -> Result<V::Value, Error>
181 where
182 V: Visitor<'de>,
183 {
184 match self.value {
185 Some(Value::Object(v)) => visit_object(v, visitor),
186 Some(other) => Err(serde::de::Error::invalid_type(
187 other.unexpected(),
188 &"struct variant",
189 )),
190 None => Err(serde::de::Error::invalid_type(
191 Unexpected::UnitVariant,
192 &"struct variant",
193 )),
194 }
195 }
196}
197
198impl<'de> IntoDeserializer<'de, Error> for Value {
199 type Deserializer = Self;
200
201 fn into_deserializer(self) -> Self::Deserializer {
202 self
203 }
204}
205
206impl<'de> Deserializer<'de> for Value {
207 type Error = Error;
208
209 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
210 where
211 V: Visitor<'de>,
212 {
213 match self {
214 Self::Null => visitor.visit_unit(),
215 Self::Bool(b) => visitor.visit_bool(b),
216 Self::String(str) => visitor.visit_str(str.as_str()),
217 Self::Unsigned(i) => visitor.visit_u64(i),
218 Self::Signed(i) => visitor.visit_i64(i),
219 Self::Float(f) => visitor.visit_f64(f),
220 Self::Array(arr) => visit_array(arr, visitor),
221 Self::Object(obj) => visit_object(obj, visitor),
222 }
223 }
224
225 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
226 where
227 V: Visitor<'de>,
228 {
229 if let Some(bool) = self.as_bool() {
230 return visitor.visit_bool(bool);
231 }
232 Err(self.invalid_type(&visitor))
233 }
234
235 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
236 where
237 V: Visitor<'de>,
238 {
239 self.deserialize_i64(visitor)
240 }
241
242 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
243 where
244 V: Visitor<'de>,
245 {
246 self.deserialize_i64(visitor)
247 }
248
249 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
250 where
251 V: Visitor<'de>,
252 {
253 self.deserialize_i64(visitor)
254 }
255
256 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
257 where
258 V: Visitor<'de>,
259 {
260 if let Some(i) = self.as_signed() {
261 return visitor.visit_i64(i);
262 }
263 Err(self.invalid_type(&visitor))
264 }
265
266 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
267 where
268 V: Visitor<'de>,
269 {
270 self.deserialize_u64(visitor)
271 }
272
273 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
274 where
275 V: Visitor<'de>,
276 {
277 self.deserialize_u64(visitor)
278 }
279
280 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
281 where
282 V: Visitor<'de>,
283 {
284 self.deserialize_u64(visitor)
285 }
286
287 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
288 where
289 V: Visitor<'de>,
290 {
291 if let Some(i) = self.as_unsigned() {
292 return visitor.visit_u64(i);
293 }
294 Err(self.invalid_type(&visitor))
295 }
296
297 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
298 where
299 V: Visitor<'de>,
300 {
301 self.deserialize_f64(visitor)
302 }
303
304 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
305 where
306 V: Visitor<'de>,
307 {
308 if let Some(f) = self.as_float() {
309 return visitor.visit_f64(f);
310 }
311 Err(self.invalid_type(&visitor))
312 }
313
314 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
315 where
316 V: Visitor<'de>,
317 {
318 self.deserialize_string(visitor)
319 }
320
321 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
322 where
323 V: Visitor<'de>,
324 {
325 if let Some(s) = self.as_str() {
326 return visitor.visit_str(s);
327 }
328 Err(self.invalid_type(&visitor))
329 }
330
331 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
332 where
333 V: Visitor<'de>,
334 {
335 if let Some(s) = self.as_str() {
336 return visitor.visit_string(s.to_owned());
337 }
338 Err(self.invalid_type(&visitor))
339 }
340
341 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
342 where
343 V: Visitor<'de>,
344 {
345 match self {
346 Value::String(v) => visitor.visit_str(v.as_str()),
347 Value::Array(v) => visit_array(v, visitor),
348 _ => Err(self.invalid_type(&visitor)),
349 }
350 }
351
352 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
353 where
354 V: Visitor<'de>,
355 {
356 self.deserialize_bytes(visitor)
357 }
358
359 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
360 where
361 V: Visitor<'de>,
362 {
363 match self {
364 Value::Null => visitor.visit_none(),
365 _ => visitor.visit_some(self),
366 }
367 }
368
369 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
370 where
371 V: Visitor<'de>,
372 {
373 if self.is_null() {
374 return visitor.visit_unit();
375 }
376 Err(self.invalid_type(&visitor))
377 }
378
379 fn deserialize_unit_struct<V>(
380 self,
381 _: &'static str,
382 visitor: V,
383 ) -> Result<V::Value, Self::Error>
384 where
385 V: Visitor<'de>,
386 {
387 self.deserialize_unit(visitor)
388 }
389
390 fn deserialize_newtype_struct<V>(
391 self,
392 _: &'static str,
393 visitor: V,
394 ) -> Result<V::Value, Self::Error>
395 where
396 V: Visitor<'de>,
397 {
398 visitor.visit_newtype_struct(self)
399 }
400
401 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
402 where
403 V: Visitor<'de>,
404 {
405 if let Self::Array(arr) = self {
406 return visit_array(arr, visitor);
407 }
408 Err(self.invalid_type(&visitor))
409 }
410
411 fn deserialize_tuple<V>(self, _: usize, visitor: V) -> Result<V::Value, Self::Error>
412 where
413 V: Visitor<'de>,
414 {
415 self.deserialize_seq(visitor)
416 }
417
418 fn deserialize_tuple_struct<V>(
419 self,
420 _: &'static str,
421 _: usize,
422 visitor: V,
423 ) -> Result<V::Value, Self::Error>
424 where
425 V: Visitor<'de>,
426 {
427 self.deserialize_seq(visitor)
428 }
429
430 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
431 where
432 V: Visitor<'de>,
433 {
434 if let Self::Object(obj) = self {
435 return visit_object(obj, visitor);
436 }
437 Err(self.invalid_type(&visitor))
438 }
439
440 fn deserialize_struct<V>(
441 self,
442 _: &'static str,
443 _: &'static [&'static str],
444 visitor: V,
445 ) -> Result<V::Value, Self::Error>
446 where
447 V: Visitor<'de>,
448 {
449 match self {
450 Value::Object(obj) => visit_object(obj, visitor),
451 Value::Array(arr) => visit_array(arr, visitor),
452 _ => Err(self.invalid_type(&visitor)),
453 }
454 }
455
456 fn deserialize_enum<V>(
457 self,
458 _: &'static str,
459 _: &'static [&'static str],
460 visitor: V,
461 ) -> Result<V::Value, Self::Error>
462 where
463 V: Visitor<'de>,
464 {
465 let (variant, value) = match self {
466 Value::Object(value) => {
467 let mut iter = value.into_iter();
468 let (variant, value) = match iter.next() {
469 Some(v) => v,
470 None => {
471 return Err(serde::de::Error::invalid_value(
472 Unexpected::Map,
473 &"map with a single key",
474 ));
475 }
476 };
477 if iter.next().is_some() {
479 return Err(serde::de::Error::invalid_value(
480 Unexpected::Map,
481 &"map with a single key",
482 ));
483 }
484 (variant, Some(value))
485 }
486 Value::String(variant) => (variant, None),
487 other => {
488 return Err(serde::de::Error::invalid_type(
489 other.unexpected(),
490 &"string or map",
491 ));
492 }
493 };
494
495 visitor.visit_enum(EnumDeserializer { variant, value })
496 }
497
498 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
499 where
500 V: Visitor<'de>,
501 {
502 self.deserialize_string(visitor)
503 }
504
505 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
506 where
507 V: Visitor<'de>,
508 {
509 visitor.visit_unit()
510 }
511}
512
513impl<'de> IntoDeserializer<'de, Error> for &'de Value {
514 type Deserializer = Self;
515
516 fn into_deserializer(self) -> Self::Deserializer {
517 self
518 }
519}
520
521impl<'de> Deserializer<'de> for &'de Value {
522 type Error = Error;
523
524 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
525 where
526 V: Visitor<'de>,
527 {
528 match self {
529 Value::Null => visitor.visit_unit(),
530 Value::Bool(b) => visitor.visit_bool(*b),
531 Value::String(str) => visitor.visit_borrowed_str(str),
532 Value::Unsigned(i) => visitor.visit_u64(*i),
533 Value::Signed(i) => visitor.visit_i64(*i),
534 Value::Float(f) => visitor.visit_f64(*f),
535 Value::Array(arr) => visit_array_ref(arr, visitor),
536 Value::Object(obj) => visit_object_ref(obj, visitor),
537 }
538 }
539
540 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
541 where
542 V: Visitor<'de>,
543 {
544 if let Some(bool) = self.as_bool() {
545 return visitor.visit_bool(bool);
546 }
547 Err(self.invalid_type(&visitor))
548 }
549
550 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
551 where
552 V: Visitor<'de>,
553 {
554 self.deserialize_i64(visitor)
555 }
556
557 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
558 where
559 V: Visitor<'de>,
560 {
561 self.deserialize_i64(visitor)
562 }
563
564 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
565 where
566 V: Visitor<'de>,
567 {
568 self.deserialize_i64(visitor)
569 }
570
571 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
572 where
573 V: Visitor<'de>,
574 {
575 if let Some(i) = self.as_signed() {
576 return visitor.visit_i64(i);
577 }
578 Err(self.invalid_type(&visitor))
579 }
580
581 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
582 where
583 V: Visitor<'de>,
584 {
585 self.deserialize_u64(visitor)
586 }
587
588 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
589 where
590 V: Visitor<'de>,
591 {
592 self.deserialize_u64(visitor)
593 }
594
595 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
596 where
597 V: Visitor<'de>,
598 {
599 self.deserialize_u64(visitor)
600 }
601
602 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
603 where
604 V: Visitor<'de>,
605 {
606 if let Some(i) = self.as_unsigned() {
607 return visitor.visit_u64(i);
608 }
609 Err(self.invalid_type(&visitor))
610 }
611
612 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
613 where
614 V: Visitor<'de>,
615 {
616 self.deserialize_f64(visitor)
617 }
618
619 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
620 where
621 V: Visitor<'de>,
622 {
623 if let Some(f) = self.as_float() {
624 return visitor.visit_f64(f);
625 }
626 Err(self.invalid_type(&visitor))
627 }
628
629 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
630 where
631 V: Visitor<'de>,
632 {
633 self.deserialize_string(visitor)
634 }
635
636 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
637 where
638 V: Visitor<'de>,
639 {
640 if let Some(s) = self.as_str() {
641 return visitor.visit_borrowed_str(s);
642 }
643 Err(self.invalid_type(&visitor))
644 }
645
646 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
647 where
648 V: Visitor<'de>,
649 {
650 if let Some(s) = self.as_str() {
651 return visitor.visit_borrowed_str(s);
652 }
653 Err(self.invalid_type(&visitor))
654 }
655
656 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
657 where
658 V: Visitor<'de>,
659 {
660 match self {
661 Value::String(v) => visitor.visit_borrowed_str(v),
662 Value::Array(v) => visit_array_ref(v, visitor),
663 _ => Err(self.invalid_type(&visitor)),
664 }
665 }
666
667 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
668 where
669 V: Visitor<'de>,
670 {
671 self.deserialize_bytes(visitor)
672 }
673
674 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
675 where
676 V: Visitor<'de>,
677 {
678 match self {
679 Value::Null => visitor.visit_none(),
680 _ => visitor.visit_some(self),
681 }
682 }
683
684 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
685 where
686 V: Visitor<'de>,
687 {
688 if self.is_null() {
689 return visitor.visit_unit();
690 }
691 Err(self.invalid_type(&visitor))
692 }
693
694 fn deserialize_unit_struct<V>(
695 self,
696 _: &'static str,
697 visitor: V,
698 ) -> Result<V::Value, Self::Error>
699 where
700 V: Visitor<'de>,
701 {
702 self.deserialize_unit(visitor)
703 }
704
705 fn deserialize_newtype_struct<V>(
706 self,
707 _: &'static str,
708 visitor: V,
709 ) -> Result<V::Value, Self::Error>
710 where
711 V: Visitor<'de>,
712 {
713 visitor.visit_newtype_struct(self)
714 }
715
716 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
717 where
718 V: Visitor<'de>,
719 {
720 if let Value::Array(arr) = self {
721 return visit_array_ref(arr, visitor);
722 }
723 Err(self.invalid_type(&visitor))
724 }
725
726 fn deserialize_tuple<V>(self, _: usize, visitor: V) -> Result<V::Value, Self::Error>
727 where
728 V: Visitor<'de>,
729 {
730 self.deserialize_seq(visitor)
731 }
732
733 fn deserialize_tuple_struct<V>(
734 self,
735 _: &'static str,
736 _: usize,
737 visitor: V,
738 ) -> Result<V::Value, Self::Error>
739 where
740 V: Visitor<'de>,
741 {
742 self.deserialize_seq(visitor)
743 }
744
745 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
746 where
747 V: Visitor<'de>,
748 {
749 if let Value::Object(obj) = self {
750 return visit_object_ref(obj, visitor);
751 }
752 Err(self.invalid_type(&visitor))
753 }
754
755 fn deserialize_struct<V>(
756 self,
757 _: &'static str,
758 _: &'static [&'static str],
759 visitor: V,
760 ) -> Result<V::Value, Self::Error>
761 where
762 V: Visitor<'de>,
763 {
764 match self {
765 Value::Object(obj) => visit_object_ref(obj, visitor),
766 Value::Array(arr) => visit_array_ref(arr, visitor),
767 _ => Err(self.invalid_type(&visitor)),
768 }
769 }
770
771 fn deserialize_enum<V>(
772 self,
773 _: &'static str,
774 _: &'static [&'static str],
775 visitor: V,
776 ) -> Result<V::Value, Self::Error>
777 where
778 V: Visitor<'de>,
779 {
780 let (variant, value) = match self {
781 Value::Object(value) => {
782 let mut iter = value.iter();
783 let (variant, value) = match iter.next() {
784 Some(v) => v,
785 None => {
786 return Err(serde::de::Error::invalid_value(
787 Unexpected::Map,
788 &"map with a single key",
789 ));
790 }
791 };
792 if iter.next().is_some() {
793 return Err(serde::de::Error::invalid_value(
794 Unexpected::Map,
795 &"map with a single key",
796 ));
797 }
798 (variant, Some(value))
799 }
800 Value::String(variant) => (variant, None),
801 other => {
802 return Err(serde::de::Error::invalid_type(
803 other.unexpected(),
804 &"string or map",
805 ));
806 }
807 };
808
809 visitor.visit_enum(EnumRefDeserializer { variant, value })
810 }
811
812 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
813 where
814 V: Visitor<'de>,
815 {
816 self.deserialize_string(visitor)
817 }
818
819 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
820 where
821 V: Visitor<'de>,
822 {
823 visitor.visit_unit()
824 }
825}
826
827struct EnumRefDeserializer<'de> {
828 variant: &'de str,
829 value: Option<&'de Value>,
830}
831
832impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
833 type Error = Error;
834 type Variant = VariantRefDeserializer<'de>;
835
836 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
837 where
838 V: DeserializeSeed<'de>,
839 {
840 let variant = self.variant.into_deserializer();
841 let visitor = VariantRefDeserializer { value: self.value };
842 seed.deserialize(variant).map(|v| (v, visitor))
843 }
844}
845
846struct VariantRefDeserializer<'de> {
847 value: Option<&'de Value>,
848}
849
850impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
851 type Error = Error;
852
853 fn unit_variant(self) -> Result<(), Error> {
854 match self.value {
855 Some(value) => Deserialize::deserialize(value),
856 None => Ok(()),
857 }
858 }
859
860 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
861 where
862 T: DeserializeSeed<'de>,
863 {
864 match self.value {
865 Some(value) => seed.deserialize(value),
866 None => Err(serde::de::Error::invalid_type(
867 Unexpected::UnitVariant,
868 &"newtype variant",
869 )),
870 }
871 }
872
873 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
874 where
875 V: Visitor<'de>,
876 {
877 match self.value {
878 Some(Value::Array(v)) => {
879 if v.is_empty() {
880 visitor.visit_unit()
881 } else {
882 visit_array_ref(v, visitor)
883 }
884 }
885 Some(other) => Err(serde::de::Error::invalid_type(
886 other.unexpected(),
887 &"tuple variant",
888 )),
889 None => Err(serde::de::Error::invalid_type(
890 Unexpected::UnitVariant,
891 &"tuple variant",
892 )),
893 }
894 }
895
896 fn struct_variant<V>(
897 self,
898 _fields: &'static [&'static str],
899 visitor: V,
900 ) -> Result<V::Value, Error>
901 where
902 V: Visitor<'de>,
903 {
904 match self.value {
905 Some(Value::Object(v)) => visit_object_ref(v, visitor),
906 Some(other) => Err(serde::de::Error::invalid_type(
907 other.unexpected(),
908 &"struct variant",
909 )),
910 None => Err(serde::de::Error::invalid_type(
911 Unexpected::UnitVariant,
912 &"struct variant",
913 )),
914 }
915 }
916}
917
918fn visit_object<'de, V>(object: BTreeMap<String, Value>, visitor: V) -> Result<V::Value, Error>
919where
920 V: Visitor<'de>,
921{
922 visitor.visit_map(&mut MapDeserializer::new(object.into_iter()))
923}
924
925fn visit_object_ref<'de, V>(
926 object: &'de BTreeMap<String, Value>,
927 visitor: V,
928) -> Result<V::Value, Error>
929where
930 V: Visitor<'de>,
931{
932 visitor.visit_map(&mut MapDeserializer::new(
933 object.iter().map(|(key, value)| (key.as_str(), value)),
934 ))
935}
936
937fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error>
938where
939 V: Visitor<'de>,
940{
941 visitor.visit_seq(&mut SeqDeserializer::new(array.into_iter()))
942}
943
944fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error>
945where
946 V: Visitor<'de>,
947{
948 visitor.visit_seq(&mut SeqDeserializer::new(array.iter()))
949}
950
951#[test]
952fn deserialize_from_owned() {
953 use crate::test::{test_struct, test_value, TestStruct};
954
955 let value = test_value();
956
957 let my_struct_result = TestStruct::deserialize(value);
958
959 assert!(my_struct_result.is_ok());
960 assert!(my_struct_result.unwrap() == test_struct());
961}
962
963#[test]
964fn deserialize_from_ref() {
965 use crate::test::{test_struct, test_value, TestStruct};
966
967 let value = test_value();
968
969 let my_struct_result = TestStruct::deserialize(&value);
970
971 assert!(my_struct_result.is_ok());
972 assert!(my_struct_result.unwrap() == test_struct());
973}