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