1use std::borrow::Cow;
2use std::fmt;
3use std::slice;
4use std::str;
5use std::vec;
6
7use serde;
8use serde::de::{
9 Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, SeqAccess,
10 Unexpected, VariantAccess, Visitor,
11};
12
13use error::Error;
14use map::Map;
15use number::Number;
16use value::Value;
17
18use serde::de;
19
20#[cfg(feature = "arbitrary_precision")]
21use number::NumberFromString;
22
23impl<'de> Deserialize<'de> for Value {
24 #[inline]
25 fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
26 where
27 D: serde::Deserializer<'de>,
28 {
29 struct ValueVisitor;
30
31 impl<'de> Visitor<'de> for ValueVisitor {
32 type Value = Value;
33
34 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
35 formatter.write_str("any valid JSON value")
36 }
37
38 #[inline]
39 fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
40 Ok(Value::Bool(value))
41 }
42
43 #[inline]
44 fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
45 Ok(Value::Number(value.into()))
46 }
47
48 #[inline]
49 fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
50 Ok(Value::Number(value.into()))
51 }
52
53 #[inline]
54 fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
55 Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
56 }
57
58 #[inline]
59 fn visit_str<E>(self, value: &str) -> Result<Value, E>
60 where
61 E: serde::de::Error,
62 {
63 self.visit_string(String::from(value))
64 }
65
66 #[inline]
67 fn visit_string<E>(self, value: String) -> Result<Value, E> {
68 Ok(Value::String(value))
69 }
70
71 #[inline]
72 fn visit_none<E>(self) -> Result<Value, E> {
73 Ok(Value::Null)
74 }
75
76 #[inline]
77 fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
78 where
79 D: serde::Deserializer<'de>,
80 {
81 Deserialize::deserialize(deserializer)
82 }
83
84 #[inline]
85 fn visit_unit<E>(self) -> Result<Value, E> {
86 Ok(Value::Null)
87 }
88
89 #[inline]
90 fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
91 where
92 V: SeqAccess<'de>,
93 {
94 let mut vec = Vec::new();
95
96 while let Some(elem) = try!(visitor.next_element()) {
97 vec.push(elem);
98 }
99
100 Ok(Value::Array(vec))
101 }
102
103 fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
104 where
105 V: MapAccess<'de>,
106 {
107 match visitor.next_key_seed(KeyClassifier)? {
108 #[cfg(feature = "arbitrary_precision")]
109 Some(KeyClass::Number) => {
110 let number: NumberFromString = visitor.next_value()?;
111 Ok(Value::Number(number.value))
112 }
113 #[cfg(feature = "raw_value")]
114 Some(KeyClass::RawValue) => {
115 let value = visitor.next_value_seed(::raw::BoxedFromString)?;
116 ::from_str(value.get()).map_err(de::Error::custom)
117 }
118 Some(KeyClass::Map(first_key)) => {
119 let mut values = Map::new();
120
121 values.insert(first_key, try!(visitor.next_value()));
122 while let Some((key, value)) = try!(visitor.next_entry()) {
123 values.insert(key, value);
124 }
125
126 Ok(Value::Object(values))
127 }
128 None => Ok(Value::Object(Map::new())),
129 }
130 }
131 }
132
133 deserializer.deserialize_any(ValueVisitor)
134 }
135}
136
137impl str::FromStr for Value {
138 type Err = Error;
139 fn from_str(s: &str) -> Result<Value, Error> {
140 super::super::de::from_str(s)
141 }
142}
143
144macro_rules! deserialize_prim_number {
145 ($method:ident) => {
146 #[cfg(not(feature = "arbitrary_precision"))]
147 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
148 where
149 V: Visitor<'de>,
150 {
151 match self {
152 Value::Number(n) => n.deserialize_any(visitor),
153 _ => Err(self.invalid_type(&visitor)),
154 }
155 }
156
157 #[cfg(feature = "arbitrary_precision")]
158 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
159 where
160 V: Visitor<'de>,
161 {
162 match self {
163 Value::Number(n) => n.$method(visitor),
164 _ => self.deserialize_any(visitor),
165 }
166 }
167 }
168}
169
170fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error>
171where
172 V: Visitor<'de>,
173{
174 let len = array.len();
175 let mut deserializer = SeqDeserializer::new(array);
176 let seq = try!(visitor.visit_seq(&mut deserializer));
177 let remaining = deserializer.iter.len();
178 if remaining == 0 {
179 Ok(seq)
180 } else {
181 Err(serde::de::Error::invalid_length(
182 len,
183 &"fewer elements in array",
184 ))
185 }
186}
187
188fn visit_object<'de, V>(object: Map<String, Value>, visitor: V) -> Result<V::Value, Error>
189where
190 V: Visitor<'de>,
191{
192 let len = object.len();
193 let mut deserializer = MapDeserializer::new(object);
194 let map = try!(visitor.visit_map(&mut deserializer));
195 let remaining = deserializer.iter.len();
196 if remaining == 0 {
197 Ok(map)
198 } else {
199 Err(serde::de::Error::invalid_length(
200 len,
201 &"fewer elements in map",
202 ))
203 }
204}
205
206impl<'de> serde::Deserializer<'de> for Value {
207 type Error = Error;
208
209 #[inline]
210 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
211 where
212 V: Visitor<'de>,
213 {
214 match self {
215 Value::Null => visitor.visit_unit(),
216 Value::Bool(v) => visitor.visit_bool(v),
217 Value::Number(n) => n.deserialize_any(visitor),
218 Value::String(v) => visitor.visit_string(v),
219 Value::Array(v) => visit_array(v, visitor),
220 Value::Object(v) => visit_object(v, visitor),
221 }
222 }
223
224 deserialize_prim_number!(deserialize_i8);
225 deserialize_prim_number!(deserialize_i16);
226 deserialize_prim_number!(deserialize_i32);
227 deserialize_prim_number!(deserialize_i64);
228 deserialize_prim_number!(deserialize_u8);
229 deserialize_prim_number!(deserialize_u16);
230 deserialize_prim_number!(deserialize_u32);
231 deserialize_prim_number!(deserialize_u64);
232 deserialize_prim_number!(deserialize_f32);
233 deserialize_prim_number!(deserialize_f64);
234
235 serde_if_integer128! {
236 deserialize_prim_number!(deserialize_i128);
237 deserialize_prim_number!(deserialize_u128);
238 }
239
240 #[inline]
241 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
242 where
243 V: Visitor<'de>,
244 {
245 match self {
246 Value::Null => visitor.visit_none(),
247 _ => visitor.visit_some(self),
248 }
249 }
250
251 #[inline]
252 fn deserialize_enum<V>(
253 self,
254 _name: &str,
255 _variants: &'static [&'static str],
256 visitor: V,
257 ) -> Result<V::Value, Error>
258 where
259 V: Visitor<'de>,
260 {
261 let (variant, value) = match self {
262 Value::Object(value) => {
263 let mut iter = value.into_iter();
264 let (variant, value) = match iter.next() {
265 Some(v) => v,
266 None => {
267 return Err(serde::de::Error::invalid_value(
268 Unexpected::Map,
269 &"map with a single key",
270 ));
271 }
272 };
273 if iter.next().is_some() {
275 return Err(serde::de::Error::invalid_value(
276 Unexpected::Map,
277 &"map with a single key",
278 ));
279 }
280 (variant, Some(value))
281 }
282 Value::String(variant) => (variant, None),
283 other => {
284 return Err(serde::de::Error::invalid_type(
285 other.unexpected(),
286 &"string or map",
287 ));
288 }
289 };
290
291 visitor.visit_enum(EnumDeserializer {
292 variant: variant,
293 value: value,
294 })
295 }
296
297 #[inline]
298 fn deserialize_newtype_struct<V>(
299 self,
300 name: &'static str,
301 visitor: V,
302 ) -> Result<V::Value, Self::Error>
303 where
304 V: Visitor<'de>,
305 {
306 #[cfg(feature = "raw_value")]
307 {
308 if name == ::raw::TOKEN {
309 return visitor.visit_map(::raw::OwnedRawDeserializer {
310 raw_value: Some(self.to_string()),
311 });
312 }
313 }
314
315 let _ = name;
316 visitor.visit_newtype_struct(self)
317 }
318
319 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
320 where
321 V: Visitor<'de>,
322 {
323 match self {
324 Value::Bool(v) => visitor.visit_bool(v),
325 _ => Err(self.invalid_type(&visitor)),
326 }
327 }
328
329 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
330 where
331 V: Visitor<'de>,
332 {
333 self.deserialize_string(visitor)
334 }
335
336 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
337 where
338 V: Visitor<'de>,
339 {
340 self.deserialize_string(visitor)
341 }
342
343 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
344 where
345 V: Visitor<'de>,
346 {
347 match self {
348 Value::String(v) => visitor.visit_string(v),
349 _ => Err(self.invalid_type(&visitor)),
350 }
351 }
352
353 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
354 where
355 V: Visitor<'de>,
356 {
357 self.deserialize_byte_buf(visitor)
358 }
359
360 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
361 where
362 V: Visitor<'de>,
363 {
364 match self {
365 Value::String(v) => visitor.visit_string(v),
366 Value::Array(v) => visit_array(v, visitor),
367 _ => Err(self.invalid_type(&visitor)),
368 }
369 }
370
371 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
372 where
373 V: Visitor<'de>,
374 {
375 match self {
376 Value::Null => visitor.visit_unit(),
377 _ => Err(self.invalid_type(&visitor)),
378 }
379 }
380
381 fn deserialize_unit_struct<V>(
382 self,
383 _name: &'static str,
384 visitor: V,
385 ) -> Result<V::Value, Self::Error>
386 where
387 V: Visitor<'de>,
388 {
389 self.deserialize_unit(visitor)
390 }
391
392 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
393 where
394 V: Visitor<'de>,
395 {
396 match self {
397 Value::Array(v) => visit_array(v, visitor),
398 _ => Err(self.invalid_type(&visitor)),
399 }
400 }
401
402 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
403 where
404 V: Visitor<'de>,
405 {
406 self.deserialize_seq(visitor)
407 }
408
409 fn deserialize_tuple_struct<V>(
410 self,
411 _name: &'static str,
412 _len: usize,
413 visitor: V,
414 ) -> Result<V::Value, Self::Error>
415 where
416 V: Visitor<'de>,
417 {
418 self.deserialize_seq(visitor)
419 }
420
421 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
422 where
423 V: Visitor<'de>,
424 {
425 match self {
426 Value::Object(v) => visit_object(v, visitor),
427 _ => Err(self.invalid_type(&visitor)),
428 }
429 }
430
431 fn deserialize_struct<V>(
432 self,
433 _name: &'static str,
434 _fields: &'static [&'static str],
435 visitor: V,
436 ) -> Result<V::Value, Self::Error>
437 where
438 V: Visitor<'de>,
439 {
440 match self {
441 Value::Array(v) => visit_array(v, visitor),
442 Value::Object(v) => visit_object(v, visitor),
443 _ => Err(self.invalid_type(&visitor)),
444 }
445 }
446
447 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
448 where
449 V: Visitor<'de>,
450 {
451 self.deserialize_string(visitor)
452 }
453
454 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
455 where
456 V: Visitor<'de>,
457 {
458 drop(self);
459 visitor.visit_unit()
460 }
461}
462
463struct EnumDeserializer {
464 variant: String,
465 value: Option<Value>,
466}
467
468impl<'de> EnumAccess<'de> for EnumDeserializer {
469 type Error = Error;
470 type Variant = VariantDeserializer;
471
472 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
473 where
474 V: DeserializeSeed<'de>,
475 {
476 let variant = self.variant.into_deserializer();
477 let visitor = VariantDeserializer { value: self.value };
478 seed.deserialize(variant).map(|v| (v, visitor))
479 }
480}
481
482struct VariantDeserializer {
483 value: Option<Value>,
484}
485
486impl<'de> VariantAccess<'de> for VariantDeserializer {
487 type Error = Error;
488
489 fn unit_variant(self) -> Result<(), Error> {
490 match self.value {
491 Some(value) => Deserialize::deserialize(value),
492 None => Ok(()),
493 }
494 }
495
496 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
497 where
498 T: DeserializeSeed<'de>,
499 {
500 match self.value {
501 Some(value) => seed.deserialize(value),
502 None => Err(serde::de::Error::invalid_type(
503 Unexpected::UnitVariant,
504 &"newtype variant",
505 )),
506 }
507 }
508
509 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
510 where
511 V: Visitor<'de>,
512 {
513 match self.value {
514 Some(Value::Array(v)) => {
515 serde::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
516 }
517 Some(other) => Err(serde::de::Error::invalid_type(
518 other.unexpected(),
519 &"tuple variant",
520 )),
521 None => Err(serde::de::Error::invalid_type(
522 Unexpected::UnitVariant,
523 &"tuple variant",
524 )),
525 }
526 }
527
528 fn struct_variant<V>(
529 self,
530 _fields: &'static [&'static str],
531 visitor: V,
532 ) -> Result<V::Value, Error>
533 where
534 V: Visitor<'de>,
535 {
536 match self.value {
537 Some(Value::Object(v)) => {
538 serde::Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
539 }
540 Some(other) => Err(serde::de::Error::invalid_type(
541 other.unexpected(),
542 &"struct variant",
543 )),
544 _ => Err(serde::de::Error::invalid_type(
545 Unexpected::UnitVariant,
546 &"struct variant",
547 )),
548 }
549 }
550}
551
552struct SeqDeserializer {
553 iter: vec::IntoIter<Value>,
554}
555
556impl SeqDeserializer {
557 fn new(vec: Vec<Value>) -> Self {
558 SeqDeserializer {
559 iter: vec.into_iter(),
560 }
561 }
562}
563
564impl<'de> serde::Deserializer<'de> for SeqDeserializer {
565 type Error = Error;
566
567 #[inline]
568 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
569 where
570 V: Visitor<'de>,
571 {
572 let len = self.iter.len();
573 if len == 0 {
574 visitor.visit_unit()
575 } else {
576 let ret = try!(visitor.visit_seq(&mut self));
577 let remaining = self.iter.len();
578 if remaining == 0 {
579 Ok(ret)
580 } else {
581 Err(serde::de::Error::invalid_length(
582 len,
583 &"fewer elements in array",
584 ))
585 }
586 }
587 }
588
589 forward_to_deserialize_any! {
590 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
591 bytes byte_buf option unit unit_struct newtype_struct seq tuple
592 tuple_struct map struct enum identifier ignored_any
593 }
594}
595
596impl<'de> SeqAccess<'de> for SeqDeserializer {
597 type Error = Error;
598
599 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
600 where
601 T: DeserializeSeed<'de>,
602 {
603 match self.iter.next() {
604 Some(value) => seed.deserialize(value).map(Some),
605 None => Ok(None),
606 }
607 }
608
609 fn size_hint(&self) -> Option<usize> {
610 match self.iter.size_hint() {
611 (lower, Some(upper)) if lower == upper => Some(upper),
612 _ => None,
613 }
614 }
615}
616
617struct MapDeserializer {
618 iter: <Map<String, Value> as IntoIterator>::IntoIter,
619 value: Option<Value>,
620}
621
622impl MapDeserializer {
623 fn new(map: Map<String, Value>) -> Self {
624 MapDeserializer {
625 iter: map.into_iter(),
626 value: None,
627 }
628 }
629}
630
631impl<'de> MapAccess<'de> for MapDeserializer {
632 type Error = Error;
633
634 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
635 where
636 T: DeserializeSeed<'de>,
637 {
638 match self.iter.next() {
639 Some((key, value)) => {
640 self.value = Some(value);
641 let key_de = MapKeyDeserializer {
642 key: Cow::Owned(key),
643 };
644 seed.deserialize(key_de).map(Some)
645 }
646 None => Ok(None),
647 }
648 }
649
650 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
651 where
652 T: DeserializeSeed<'de>,
653 {
654 match self.value.take() {
655 Some(value) => seed.deserialize(value),
656 None => Err(serde::de::Error::custom("value is missing")),
657 }
658 }
659
660 fn size_hint(&self) -> Option<usize> {
661 match self.iter.size_hint() {
662 (lower, Some(upper)) if lower == upper => Some(upper),
663 _ => None,
664 }
665 }
666}
667
668impl<'de> serde::Deserializer<'de> for MapDeserializer {
669 type Error = Error;
670
671 #[inline]
672 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
673 where
674 V: Visitor<'de>,
675 {
676 visitor.visit_map(self)
677 }
678
679 forward_to_deserialize_any! {
680 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
681 bytes byte_buf option unit unit_struct newtype_struct seq tuple
682 tuple_struct map struct enum identifier ignored_any
683 }
684}
685
686macro_rules! deserialize_value_ref_number {
687 ($method:ident) => {
688 #[cfg(not(feature = "arbitrary_precision"))]
689 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
690 where
691 V: Visitor<'de>,
692 {
693 match *self {
694 Value::Number(ref n) => n.deserialize_any(visitor),
695 _ => Err(self.invalid_type(&visitor)),
696 }
697 }
698
699 #[cfg(feature = "arbitrary_precision")]
700 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
701 where
702 V: Visitor<'de>,
703 {
704 match *self {
705 Value::Number(ref n) => n.$method(visitor),
706 _ => self.deserialize_any(visitor),
707 }
708 }
709 }
710}
711
712fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error>
713where
714 V: Visitor<'de>,
715{
716 let len = array.len();
717 let mut deserializer = SeqRefDeserializer::new(array);
718 let seq = try!(visitor.visit_seq(&mut deserializer));
719 let remaining = deserializer.iter.len();
720 if remaining == 0 {
721 Ok(seq)
722 } else {
723 Err(serde::de::Error::invalid_length(
724 len,
725 &"fewer elements in array",
726 ))
727 }
728}
729
730fn visit_object_ref<'de, V>(object: &'de Map<String, Value>, visitor: V) -> Result<V::Value, Error>
731where
732 V: Visitor<'de>,
733{
734 let len = object.len();
735 let mut deserializer = MapRefDeserializer::new(object);
736 let map = try!(visitor.visit_map(&mut deserializer));
737 let remaining = deserializer.iter.len();
738 if remaining == 0 {
739 Ok(map)
740 } else {
741 Err(serde::de::Error::invalid_length(
742 len,
743 &"fewer elements in map",
744 ))
745 }
746}
747
748impl<'de> serde::Deserializer<'de> for &'de Value {
749 type Error = Error;
750
751 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
752 where
753 V: Visitor<'de>,
754 {
755 match *self {
756 Value::Null => visitor.visit_unit(),
757 Value::Bool(v) => visitor.visit_bool(v),
758 Value::Number(ref n) => n.deserialize_any(visitor),
759 Value::String(ref v) => visitor.visit_borrowed_str(v),
760 Value::Array(ref v) => visit_array_ref(v, visitor),
761 Value::Object(ref v) => visit_object_ref(v, visitor),
762 }
763 }
764
765 deserialize_value_ref_number!(deserialize_i8);
766 deserialize_value_ref_number!(deserialize_i16);
767 deserialize_value_ref_number!(deserialize_i32);
768 deserialize_value_ref_number!(deserialize_i64);
769 deserialize_value_ref_number!(deserialize_u8);
770 deserialize_value_ref_number!(deserialize_u16);
771 deserialize_value_ref_number!(deserialize_u32);
772 deserialize_value_ref_number!(deserialize_u64);
773 deserialize_value_ref_number!(deserialize_f32);
774 deserialize_value_ref_number!(deserialize_f64);
775
776 serde_if_integer128! {
777 deserialize_prim_number!(deserialize_i128);
778 deserialize_prim_number!(deserialize_u128);
779 }
780
781 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
782 where
783 V: Visitor<'de>,
784 {
785 match *self {
786 Value::Null => visitor.visit_none(),
787 _ => visitor.visit_some(self),
788 }
789 }
790
791 fn deserialize_enum<V>(
792 self,
793 _name: &str,
794 _variants: &'static [&'static str],
795 visitor: V,
796 ) -> Result<V::Value, Error>
797 where
798 V: Visitor<'de>,
799 {
800 let (variant, value) = match *self {
801 Value::Object(ref value) => {
802 let mut iter = value.into_iter();
803 let (variant, value) = match iter.next() {
804 Some(v) => v,
805 None => {
806 return Err(serde::de::Error::invalid_value(
807 Unexpected::Map,
808 &"map with a single key",
809 ));
810 }
811 };
812 if iter.next().is_some() {
814 return Err(serde::de::Error::invalid_value(
815 Unexpected::Map,
816 &"map with a single key",
817 ));
818 }
819 (variant, Some(value))
820 }
821 Value::String(ref variant) => (variant, None),
822 ref other => {
823 return Err(serde::de::Error::invalid_type(
824 other.unexpected(),
825 &"string or map",
826 ));
827 }
828 };
829
830 visitor.visit_enum(EnumRefDeserializer {
831 variant: variant,
832 value: value,
833 })
834 }
835
836 #[inline]
837 fn deserialize_newtype_struct<V>(
838 self,
839 name: &'static str,
840 visitor: V,
841 ) -> Result<V::Value, Self::Error>
842 where
843 V: Visitor<'de>,
844 {
845 #[cfg(feature = "raw_value")]
846 {
847 if name == ::raw::TOKEN {
848 return visitor.visit_map(::raw::OwnedRawDeserializer {
849 raw_value: Some(self.to_string()),
850 });
851 }
852 }
853
854 let _ = name;
855 visitor.visit_newtype_struct(self)
856 }
857
858 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
859 where
860 V: Visitor<'de>,
861 {
862 match *self {
863 Value::Bool(v) => visitor.visit_bool(v),
864 _ => Err(self.invalid_type(&visitor)),
865 }
866 }
867
868 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
869 where
870 V: Visitor<'de>,
871 {
872 self.deserialize_str(visitor)
873 }
874
875 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
876 where
877 V: Visitor<'de>,
878 {
879 match *self {
880 Value::String(ref v) => visitor.visit_borrowed_str(v),
881 _ => Err(self.invalid_type(&visitor)),
882 }
883 }
884
885 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
886 where
887 V: Visitor<'de>,
888 {
889 self.deserialize_str(visitor)
890 }
891
892 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
893 where
894 V: Visitor<'de>,
895 {
896 match *self {
897 Value::String(ref v) => visitor.visit_borrowed_str(v),
898 Value::Array(ref v) => visit_array_ref(v, visitor),
899 _ => Err(self.invalid_type(&visitor)),
900 }
901 }
902
903 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
904 where
905 V: Visitor<'de>,
906 {
907 self.deserialize_bytes(visitor)
908 }
909
910 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
911 where
912 V: Visitor<'de>,
913 {
914 match *self {
915 Value::Null => visitor.visit_unit(),
916 _ => Err(self.invalid_type(&visitor)),
917 }
918 }
919
920 fn deserialize_unit_struct<V>(
921 self,
922 _name: &'static str,
923 visitor: V,
924 ) -> Result<V::Value, Self::Error>
925 where
926 V: Visitor<'de>,
927 {
928 self.deserialize_unit(visitor)
929 }
930
931 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
932 where
933 V: Visitor<'de>,
934 {
935 match *self {
936 Value::Array(ref v) => visit_array_ref(v, visitor),
937 _ => Err(self.invalid_type(&visitor)),
938 }
939 }
940
941 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
942 where
943 V: Visitor<'de>,
944 {
945 self.deserialize_seq(visitor)
946 }
947
948 fn deserialize_tuple_struct<V>(
949 self,
950 _name: &'static str,
951 _len: usize,
952 visitor: V,
953 ) -> Result<V::Value, Self::Error>
954 where
955 V: Visitor<'de>,
956 {
957 self.deserialize_seq(visitor)
958 }
959
960 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
961 where
962 V: Visitor<'de>,
963 {
964 match *self {
965 Value::Object(ref v) => visit_object_ref(v, visitor),
966 _ => Err(self.invalid_type(&visitor)),
967 }
968 }
969
970 fn deserialize_struct<V>(
971 self,
972 _name: &'static str,
973 _fields: &'static [&'static str],
974 visitor: V,
975 ) -> Result<V::Value, Self::Error>
976 where
977 V: Visitor<'de>,
978 {
979 match *self {
980 Value::Array(ref v) => visit_array_ref(v, visitor),
981 Value::Object(ref v) => visit_object_ref(v, visitor),
982 _ => Err(self.invalid_type(&visitor)),
983 }
984 }
985
986 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
987 where
988 V: Visitor<'de>,
989 {
990 self.deserialize_str(visitor)
991 }
992
993 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
994 where
995 V: Visitor<'de>,
996 {
997 visitor.visit_unit()
998 }
999}
1000
1001struct EnumRefDeserializer<'de> {
1002 variant: &'de str,
1003 value: Option<&'de Value>,
1004}
1005
1006impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
1007 type Error = Error;
1008 type Variant = VariantRefDeserializer<'de>;
1009
1010 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
1011 where
1012 V: DeserializeSeed<'de>,
1013 {
1014 let variant = self.variant.into_deserializer();
1015 let visitor = VariantRefDeserializer { value: self.value };
1016 seed.deserialize(variant).map(|v| (v, visitor))
1017 }
1018}
1019
1020struct VariantRefDeserializer<'de> {
1021 value: Option<&'de Value>,
1022}
1023
1024impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
1025 type Error = Error;
1026
1027 fn unit_variant(self) -> Result<(), Error> {
1028 match self.value {
1029 Some(value) => Deserialize::deserialize(value),
1030 None => Ok(()),
1031 }
1032 }
1033
1034 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
1035 where
1036 T: DeserializeSeed<'de>,
1037 {
1038 match self.value {
1039 Some(value) => seed.deserialize(value),
1040 None => Err(serde::de::Error::invalid_type(
1041 Unexpected::UnitVariant,
1042 &"newtype variant",
1043 )),
1044 }
1045 }
1046
1047 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
1048 where
1049 V: Visitor<'de>,
1050 {
1051 match self.value {
1052 Some(&Value::Array(ref v)) => {
1053 serde::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
1054 }
1055 Some(other) => Err(serde::de::Error::invalid_type(
1056 other.unexpected(),
1057 &"tuple variant",
1058 )),
1059 None => Err(serde::de::Error::invalid_type(
1060 Unexpected::UnitVariant,
1061 &"tuple variant",
1062 )),
1063 }
1064 }
1065
1066 fn struct_variant<V>(
1067 self,
1068 _fields: &'static [&'static str],
1069 visitor: V,
1070 ) -> Result<V::Value, Error>
1071 where
1072 V: Visitor<'de>,
1073 {
1074 match self.value {
1075 Some(&Value::Object(ref v)) => {
1076 serde::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
1077 }
1078 Some(other) => Err(serde::de::Error::invalid_type(
1079 other.unexpected(),
1080 &"struct variant",
1081 )),
1082 _ => Err(serde::de::Error::invalid_type(
1083 Unexpected::UnitVariant,
1084 &"struct variant",
1085 )),
1086 }
1087 }
1088}
1089
1090struct SeqRefDeserializer<'de> {
1091 iter: slice::Iter<'de, Value>,
1092}
1093
1094impl<'de> SeqRefDeserializer<'de> {
1095 fn new(slice: &'de [Value]) -> Self {
1096 SeqRefDeserializer { iter: slice.iter() }
1097 }
1098}
1099
1100impl<'de> serde::Deserializer<'de> for SeqRefDeserializer<'de> {
1101 type Error = Error;
1102
1103 #[inline]
1104 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
1105 where
1106 V: Visitor<'de>,
1107 {
1108 let len = self.iter.len();
1109 if len == 0 {
1110 visitor.visit_unit()
1111 } else {
1112 let ret = try!(visitor.visit_seq(&mut self));
1113 let remaining = self.iter.len();
1114 if remaining == 0 {
1115 Ok(ret)
1116 } else {
1117 Err(serde::de::Error::invalid_length(
1118 len,
1119 &"fewer elements in array",
1120 ))
1121 }
1122 }
1123 }
1124
1125 forward_to_deserialize_any! {
1126 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1127 bytes byte_buf option unit unit_struct newtype_struct seq tuple
1128 tuple_struct map struct enum identifier ignored_any
1129 }
1130}
1131
1132impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
1133 type Error = Error;
1134
1135 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1136 where
1137 T: DeserializeSeed<'de>,
1138 {
1139 match self.iter.next() {
1140 Some(value) => seed.deserialize(value).map(Some),
1141 None => Ok(None),
1142 }
1143 }
1144
1145 fn size_hint(&self) -> Option<usize> {
1146 match self.iter.size_hint() {
1147 (lower, Some(upper)) if lower == upper => Some(upper),
1148 _ => None,
1149 }
1150 }
1151}
1152
1153struct MapRefDeserializer<'de> {
1154 iter: <&'de Map<String, Value> as IntoIterator>::IntoIter,
1155 value: Option<&'de Value>,
1156}
1157
1158impl<'de> MapRefDeserializer<'de> {
1159 fn new(map: &'de Map<String, Value>) -> Self {
1160 MapRefDeserializer {
1161 iter: map.into_iter(),
1162 value: None,
1163 }
1164 }
1165}
1166
1167impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
1168 type Error = Error;
1169
1170 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1171 where
1172 T: DeserializeSeed<'de>,
1173 {
1174 match self.iter.next() {
1175 Some((key, value)) => {
1176 self.value = Some(value);
1177 let key_de = MapKeyDeserializer {
1178 key: Cow::Borrowed(&**key),
1179 };
1180 seed.deserialize(key_de).map(Some)
1181 }
1182 None => Ok(None),
1183 }
1184 }
1185
1186 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
1187 where
1188 T: DeserializeSeed<'de>,
1189 {
1190 match self.value.take() {
1191 Some(value) => seed.deserialize(value),
1192 None => Err(serde::de::Error::custom("value is missing")),
1193 }
1194 }
1195
1196 fn size_hint(&self) -> Option<usize> {
1197 match self.iter.size_hint() {
1198 (lower, Some(upper)) if lower == upper => Some(upper),
1199 _ => None,
1200 }
1201 }
1202}
1203
1204impl<'de> serde::Deserializer<'de> for MapRefDeserializer<'de> {
1205 type Error = Error;
1206
1207 #[inline]
1208 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1209 where
1210 V: Visitor<'de>,
1211 {
1212 visitor.visit_map(self)
1213 }
1214
1215 forward_to_deserialize_any! {
1216 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1217 bytes byte_buf option unit unit_struct newtype_struct seq tuple
1218 tuple_struct map struct enum identifier ignored_any
1219 }
1220}
1221
1222struct MapKeyDeserializer<'de> {
1223 key: Cow<'de, str>,
1224}
1225
1226macro_rules! deserialize_integer_key {
1227 ($method:ident => $visit:ident) => {
1228 fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
1229 where
1230 V: Visitor<'de>,
1231 {
1232 match (self.key.parse(), self.key) {
1233 (Ok(integer), _) => visitor.$visit(integer),
1234 (Err(_), Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
1235 (Err(_), Cow::Owned(s)) => visitor.visit_string(s),
1236 }
1237 }
1238 }
1239}
1240
1241impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
1242 type Error = Error;
1243
1244 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1245 where
1246 V: Visitor<'de>,
1247 {
1248 BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor)
1249 }
1250
1251 deserialize_integer_key!(deserialize_i8 => visit_i8);
1252 deserialize_integer_key!(deserialize_i16 => visit_i16);
1253 deserialize_integer_key!(deserialize_i32 => visit_i32);
1254 deserialize_integer_key!(deserialize_i64 => visit_i64);
1255 deserialize_integer_key!(deserialize_u8 => visit_u8);
1256 deserialize_integer_key!(deserialize_u16 => visit_u16);
1257 deserialize_integer_key!(deserialize_u32 => visit_u32);
1258 deserialize_integer_key!(deserialize_u64 => visit_u64);
1259
1260 serde_if_integer128! {
1261 deserialize_integer_key!(deserialize_i128 => visit_i128);
1262 deserialize_integer_key!(deserialize_u128 => visit_u128);
1263 }
1264
1265 #[inline]
1266 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
1267 where
1268 V: Visitor<'de>,
1269 {
1270 visitor.visit_some(self)
1272 }
1273
1274 #[inline]
1275 fn deserialize_newtype_struct<V>(
1276 self,
1277 _name: &'static str,
1278 visitor: V,
1279 ) -> Result<V::Value, Error>
1280 where
1281 V: Visitor<'de>,
1282 {
1283 visitor.visit_newtype_struct(self)
1284 }
1285
1286 fn deserialize_enum<V>(
1287 self,
1288 name: &'static str,
1289 variants: &'static [&'static str],
1290 visitor: V,
1291 ) -> Result<V::Value, Error>
1292 where
1293 V: Visitor<'de>,
1294 {
1295 self.key
1296 .into_deserializer()
1297 .deserialize_enum(name, variants, visitor)
1298 }
1299
1300 forward_to_deserialize_any! {
1301 bool f32 f64 char str string bytes byte_buf unit unit_struct seq tuple
1302 tuple_struct map struct identifier ignored_any
1303 }
1304}
1305
1306struct KeyClassifier;
1307
1308enum KeyClass {
1309 Map(String),
1310 #[cfg(feature = "arbitrary_precision")]
1311 Number,
1312 #[cfg(feature = "raw_value")]
1313 RawValue,
1314}
1315
1316impl<'de> DeserializeSeed<'de> for KeyClassifier {
1317 type Value = KeyClass;
1318
1319 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1320 where
1321 D: serde::Deserializer<'de>,
1322 {
1323 deserializer.deserialize_str(self)
1324 }
1325}
1326
1327impl<'de> Visitor<'de> for KeyClassifier {
1328 type Value = KeyClass;
1329
1330 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1331 formatter.write_str("a string key")
1332 }
1333
1334 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1335 where
1336 E: de::Error,
1337 {
1338 match s {
1339 #[cfg(feature = "arbitrary_precision")]
1340 ::number::TOKEN => Ok(KeyClass::Number),
1341 #[cfg(feature = "raw_value")]
1342 ::raw::TOKEN => Ok(KeyClass::RawValue),
1343 _ => Ok(KeyClass::Map(s.to_owned())),
1344 }
1345 }
1346
1347 fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
1348 where
1349 E: de::Error,
1350 {
1351 match s.as_str() {
1352 #[cfg(feature = "arbitrary_precision")]
1353 ::number::TOKEN => Ok(KeyClass::Number),
1354 #[cfg(feature = "raw_value")]
1355 ::raw::TOKEN => Ok(KeyClass::RawValue),
1356 _ => Ok(KeyClass::Map(s)),
1357 }
1358 }
1359}
1360
1361impl Value {
1362 #[cold]
1363 fn invalid_type<E>(&self, exp: &Expected) -> E
1364 where
1365 E: serde::de::Error,
1366 {
1367 serde::de::Error::invalid_type(self.unexpected(), exp)
1368 }
1369
1370 #[cold]
1371 fn unexpected(&self) -> Unexpected {
1372 match *self {
1373 Value::Null => Unexpected::Unit,
1374 Value::Bool(b) => Unexpected::Bool(b),
1375 Value::Number(ref n) => n.unexpected(),
1376 Value::String(ref s) => Unexpected::Str(s),
1377 Value::Array(_) => Unexpected::Seq,
1378 Value::Object(_) => Unexpected::Map,
1379 }
1380 }
1381}
1382
1383struct BorrowedCowStrDeserializer<'de> {
1384 value: Cow<'de, str>,
1385}
1386
1387impl<'de> BorrowedCowStrDeserializer<'de> {
1388 fn new(value: Cow<'de, str>) -> Self {
1389 BorrowedCowStrDeserializer { value: value }
1390 }
1391}
1392
1393impl<'de> de::Deserializer<'de> for BorrowedCowStrDeserializer<'de> {
1394 type Error = Error;
1395
1396 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1397 where
1398 V: de::Visitor<'de>,
1399 {
1400 match self.value {
1401 Cow::Borrowed(string) => visitor.visit_borrowed_str(string),
1402 Cow::Owned(string) => visitor.visit_string(string),
1403 }
1404 }
1405
1406 fn deserialize_enum<V>(
1407 self,
1408 _name: &str,
1409 _variants: &'static [&'static str],
1410 visitor: V,
1411 ) -> Result<V::Value, Self::Error>
1412 where
1413 V: de::Visitor<'de>,
1414 {
1415 visitor.visit_enum(self)
1416 }
1417
1418 forward_to_deserialize_any! {
1419 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1420 bytes byte_buf option unit unit_struct newtype_struct seq tuple
1421 tuple_struct map struct identifier ignored_any
1422 }
1423}
1424
1425impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> {
1426 type Error = Error;
1427 type Variant = UnitOnly;
1428
1429 fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
1430 where
1431 T: de::DeserializeSeed<'de>,
1432 {
1433 let value = seed.deserialize(self)?;
1434 Ok((value, UnitOnly))
1435 }
1436}
1437
1438struct UnitOnly;
1439
1440impl<'de> de::VariantAccess<'de> for UnitOnly {
1441 type Error = Error;
1442
1443 fn unit_variant(self) -> Result<(), Self::Error> {
1444 Ok(())
1445 }
1446
1447 fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
1448 where
1449 T: de::DeserializeSeed<'de>,
1450 {
1451 Err(de::Error::invalid_type(
1452 Unexpected::UnitVariant,
1453 &"newtype variant",
1454 ))
1455 }
1456
1457 fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
1458 where
1459 V: de::Visitor<'de>,
1460 {
1461 Err(de::Error::invalid_type(
1462 Unexpected::UnitVariant,
1463 &"tuple variant",
1464 ))
1465 }
1466
1467 fn struct_variant<V>(
1468 self,
1469 _fields: &'static [&'static str],
1470 _visitor: V,
1471 ) -> Result<V::Value, Self::Error>
1472 where
1473 V: de::Visitor<'de>,
1474 {
1475 Err(de::Error::invalid_type(
1476 Unexpected::UnitVariant,
1477 &"struct variant",
1478 ))
1479 }
1480}