1use std::fmt::{self, Display, Formatter};
2use std::iter::ExactSizeIterator;
3use std::slice::Iter;
4use std::vec::IntoIter;
5use std::borrow::Cow;
6
7use serde::{self, Deserialize, Deserializer};
8use serde::de::{self, DeserializeSeed, IntoDeserializer, SeqAccess, Unexpected, Visitor};
9
10use crate::{Integer, IntPriv, Utf8String, Utf8StringRef, Value, ValueRef};
11
12use super::{Error, ValueExt};
13use crate::MSGPACK_EXT_STRUCT_NAME;
14
15pub fn from_value<T>(val: Value) -> Result<T, Error>
16 where T: for<'de> Deserialize<'de>
17{
18 deserialize_from(val)
19}
20
21pub fn deserialize_from<'de, T, D>(val: D) -> Result<T, Error>
22 where T: Deserialize<'de>,
23 D: Deserializer<'de, Error = Error>
24{
25 Deserialize::deserialize(val)
26}
27
28impl de::Error for Error {
29 fn custom<T: Display>(msg: T) -> Self {
30 Error::Syntax(format!("{}", msg))
31 }
32}
33
34impl<'de> Deserialize<'de> for Value {
35 #[inline]
36 fn deserialize<D>(de: D) -> Result<Self, D::Error>
37 where D: de::Deserializer<'de>
38 {
39 struct ValueVisitor;
40
41 impl<'de> serde::de::Visitor<'de> for ValueVisitor {
42 type Value = Value;
43
44 fn expecting(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
45 "any valid MessagePack value".fmt(fmt)
46 }
47
48 #[inline]
49 fn visit_some<D>(self, de: D) -> Result<Value, D::Error>
50 where D: de::Deserializer<'de>
51 {
52 Deserialize::deserialize(de)
53 }
54
55 #[inline]
56 fn visit_none<E>(self) -> Result<Value, E> {
57 Ok(Value::Nil)
58 }
59
60 #[inline]
61 fn visit_unit<E>(self) -> Result<Value, E> {
62 Ok(Value::Nil)
63 }
64
65 #[inline]
66 fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
67 Ok(Value::Boolean(value))
68 }
69
70 #[inline]
71 fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
72 Ok(Value::from(value))
73 }
74
75 #[inline]
76 fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
77 Ok(Value::from(value))
78 }
79
80 #[inline]
81 fn visit_f32<E>(self, value: f32) -> Result<Value, E> {
82 Ok(Value::F32(value))
83 }
84
85 #[inline]
86 fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
87 Ok(Value::F64(value))
88 }
89
90 #[inline]
91 fn visit_string<E>(self, value: String) -> Result<Value, E> {
92 Ok(Value::String(Utf8String::from(value)))
93 }
94
95 #[inline]
96 fn visit_str<E>(self, value: &str) -> Result<Value, E>
97 where E: de::Error
98 {
99 self.visit_string(String::from(value))
100 }
101
102 #[inline]
103 fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
104 where V: SeqAccess<'de>
105 {
106 let mut vec = Vec::new();
107 while let Some(elem) = visitor.next_element()? {
108 vec.push(elem);
109 }
110 Ok(Value::Array(vec))
111 }
112
113 #[inline]
114 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
115 where E: de::Error
116 {
117 Ok(Value::Binary(v.to_owned()))
118 }
119
120 #[inline]
121 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
122 where E: de::Error
123 {
124 Ok(Value::Binary(v))
125 }
126
127 #[inline]
128 fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
129 where V: de::MapAccess<'de>
130 {
131 let mut pairs = vec![];
132
133 loop {
134 if let Some(key) = visitor.next_key()? {
135 let val = visitor.next_value()?;
136 pairs.push((key, val));
137 } else {
138 break;
139 }
140 }
141
142 Ok(Value::Map(pairs))
143 }
144
145 #[inline]
146 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
147 where D: Deserializer<'de>,
148 {
149 struct ExtValueVisitor;
150 impl<'de> serde::de::Visitor<'de> for ExtValueVisitor {
151 type Value = Value;
152
153 fn expecting(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
154 "a valid MessagePack Ext".fmt(fmt)
155 }
156
157 #[inline]
158 fn visit_seq<V>(self, mut seq: V) -> Result<Value, V::Error>
159 where V: SeqAccess<'de>
160 {
161 let tag = seq.next_element()?
162 .ok_or_else(|| de::Error::invalid_length(0, &self))?;
163 let bytes: serde_bytes::ByteBuf = seq.next_element()?
164 .ok_or_else(|| de::Error::invalid_length(1, &self))?;
165
166 Ok(Value::Ext(tag, bytes.to_vec()))
167 }
168 }
169
170 deserializer.deserialize_tuple(2, ExtValueVisitor)
171 }
172 }
173
174 de.deserialize_any(ValueVisitor)
175 }
176}
177
178impl<'de> Deserialize<'de> for ValueRef<'de> {
179 #[inline]
180 fn deserialize<D>(de: D) -> Result<Self, D::Error>
181 where D: Deserializer<'de>
182 {
183 struct ValueVisitor;
184
185 impl<'de> de::Visitor<'de> for ValueVisitor {
186 type Value = ValueRef<'de>;
187
188 fn expecting(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
189 "any valid MessagePack value".fmt(fmt)
190 }
191
192 #[inline]
193 fn visit_some<D>(self, de: D) -> Result<Self::Value, D::Error>
194 where D: Deserializer<'de>
195 {
196 Deserialize::deserialize(de)
197 }
198
199 #[inline]
200 fn visit_none<E>(self) -> Result<Self::Value, E> {
201 Ok(ValueRef::Nil)
202 }
203
204 #[inline]
205 fn visit_unit<E>(self) -> Result<Self::Value, E> {
206 Ok(ValueRef::Nil)
207 }
208
209 #[inline]
210 fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E> {
211 Ok(ValueRef::Boolean(value))
212 }
213
214 #[inline]
215 fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> {
216 Ok(ValueRef::from(value))
217 }
218
219 #[inline]
220 fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> {
221 Ok(ValueRef::from(value))
222 }
223
224 #[inline]
225 fn visit_f32<E>(self, value: f32) -> Result<Self::Value, E> {
226 Ok(ValueRef::F32(value))
227 }
228
229 #[inline]
230 fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E> {
231 Ok(ValueRef::F64(value))
232 }
233
234 #[inline]
235 fn visit_borrowed_str<E>(self, value: &'de str) -> Result<Self::Value, E>
236 where E: de::Error
237 {
238 Ok(ValueRef::String(Utf8StringRef::from(value)))
239 }
240
241 #[inline]
242 fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
243 where V: SeqAccess<'de>
244 {
245 let mut vec = Vec::new();
246
247 while let Some(elem) = visitor.next_element()? {
248 vec.push(elem);
249 }
250
251 Ok(ValueRef::Array(vec))
252 }
253
254 #[inline]
255 fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
256 where E: de::Error
257 {
258 Ok(ValueRef::Binary(v))
259 }
260
261 #[inline]
262 fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
263 where V: de::MapAccess<'de>
264 {
265 let mut vec = Vec::new();
266
267 while let Some(key) = visitor.next_key()? {
268 let val = visitor.next_value()?;
269 vec.push((key, val));
270 }
271
272 Ok(ValueRef::Map(vec))
273 }
274
275 #[inline]
276 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
277 where D: Deserializer<'de>,
278 {
279 struct ExtValueRefVisitor;
280 impl<'de> serde::de::Visitor<'de> for ExtValueRefVisitor {
281 type Value = ValueRef<'de>;
282
283 fn expecting(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
284 "a valid MessagePack Ext".fmt(fmt)
285 }
286
287 #[inline]
288 fn visit_seq<V>(self, mut seq: V) -> Result<ValueRef<'de>, V::Error>
289 where V: SeqAccess<'de>
290 {
291 let tag = seq.next_element()?
292 .ok_or_else(|| de::Error::invalid_length(0, &"invalid ext sequence"))?;
293 let bytes: &[u8] = seq.next_element()?
294 .ok_or_else(|| de::Error::invalid_length(1, &"invalid ext sequence"))?;
295
296 Ok(ValueRef::Ext(tag, bytes))
297 }
298 }
299
300 deserializer.deserialize_tuple(2, ExtValueRefVisitor)
301 }
302 }
303
304 de.deserialize_any(ValueVisitor)
305 }
306}
307
308impl<'de> Deserializer<'de> for Value {
309 type Error = Error;
310
311 #[inline]
312 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
313 where V: Visitor<'de>
314 {
315 match self {
316 Value::Nil => visitor.visit_unit(),
317 Value::Boolean(v) => visitor.visit_bool(v),
318 Value::Integer(Integer { n }) => {
319 match n {
320 IntPriv::PosInt(v) => visitor.visit_u64(v),
321 IntPriv::NegInt(v) => visitor.visit_i64(v)
322 }
323 }
324 Value::F32(v) => visitor.visit_f32(v),
325 Value::F64(v) => visitor.visit_f64(v),
326 Value::String(v) => {
327 match v.s {
328 Ok(v) => visitor.visit_string(v),
329 Err(v) => visitor.visit_byte_buf(v.0),
330 }
331 }
332 Value::Binary(v) => visitor.visit_byte_buf(v),
333 Value::Array(v) => {
334 let len = v.len();
335 let mut de = SeqDeserializer::new(v.into_iter());
336 let seq = visitor.visit_seq(&mut de)?;
337 if de.iter.len() == 0 {
338 Ok(seq)
339 } else {
340 Err(de::Error::invalid_length(len, &"fewer elements in array"))
341 }
342 }
343 Value::Map(v) => {
344 let len = v.len();
345 let mut de = MapDeserializer::new(v.into_iter());
346 let map = visitor.visit_map(&mut de)?;
347 if de.iter.len() == 0 {
348 Ok(map)
349 } else {
350 Err(de::Error::invalid_length(len, &"fewer elements in map"))
351 }
352 }
353 Value::Ext(tag, data) => {
354 let de = ExtDeserializer::new_owned(tag, data);
355 visitor.visit_newtype_struct(de)
356 }
357 }
358 }
359
360 #[inline]
361 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
362 where V: Visitor<'de>
363 {
364 ValueBase::deserialize_option(self, visitor)
365 }
366
367 #[inline]
368 fn deserialize_enum<V>(self, _name: &str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
369 where V: Visitor<'de>
370 {
371 ValueBase::deserialize_enum(self, visitor)
372 }
373
374 #[inline]
375 fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
376 where V: Visitor<'de>
377 {
378 if name == MSGPACK_EXT_STRUCT_NAME {
379 match self {
380 Value::Ext(tag, data) => {
381 let ext_de = ExtDeserializer::new_owned(tag, data);
382 return visitor.visit_newtype_struct(ext_de);
383 }
384 other => {
385 return Err(de::Error::invalid_type(other.unexpected(), &"expected Ext"))
386 }
387 }
388 }
389
390 visitor.visit_newtype_struct(self)
391 }
392
393 #[inline]
394 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
395 where V: Visitor<'de>
396 {
397 ValueBase::deserialize_unit_struct(self, visitor)
398 }
399
400 forward_to_deserialize_any! {
401 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
402 bytes byte_buf map tuple_struct struct
403 identifier tuple ignored_any
404 }
405}
406
407impl<'de> Deserializer<'de> for ValueRef<'de> {
408 type Error = Error;
409
410 #[inline]
411 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
412 where V: Visitor<'de>
413 {
414 match self {
415 ValueRef::Nil => visitor.visit_unit(),
416 ValueRef::Boolean(v) => visitor.visit_bool(v),
417 ValueRef::Integer(Integer { n }) => {
418 match n {
419 IntPriv::PosInt(v) => visitor.visit_u64(v),
420 IntPriv::NegInt(v) => visitor.visit_i64(v)
421 }
422 }
423 ValueRef::F32(v) => visitor.visit_f32(v),
424 ValueRef::F64(v) => visitor.visit_f64(v),
425 ValueRef::String(v) => {
426 match v.s {
427 Ok(v) => visitor.visit_borrowed_str(v),
428 Err(v) => visitor.visit_borrowed_bytes(v.0),
429 }
430 }
431 ValueRef::Binary(v) => visitor.visit_borrowed_bytes(v),
432 ValueRef::Array(v) => {
433 let len = v.len();
434 let mut de = SeqDeserializer::new(v.into_iter());
435 let seq = visitor.visit_seq(&mut de)?;
436 if de.iter.len() == 0 {
437 Ok(seq)
438 } else {
439 Err(de::Error::invalid_length(len, &"fewer elements in array"))
440 }
441 }
442 ValueRef::Map(v) => {
443 let len = v.len();
444 let mut de = MapDeserializer::new(v.into_iter());
445 let map = visitor.visit_map(&mut de)?;
446 if de.iter.len() == 0 {
447 Ok(map)
448 } else {
449 Err(de::Error::invalid_length(len, &"fewer elements in map"))
450 }
451 }
452 ValueRef::Ext(tag, data) => {
453 let de = ExtDeserializer::new_ref(tag, data);
454 visitor.visit_newtype_struct(de)
455 }
456 }
457 }
458
459 #[inline]
460 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
461 where V: Visitor<'de>
462 {
463 ValueBase::deserialize_option(self, visitor)
464 }
465
466 #[inline]
467 fn deserialize_enum<V>(self, _name: &str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
468 where V: Visitor<'de>
469 {
470 ValueBase::deserialize_enum(self, visitor)
471 }
472
473 #[inline]
474 fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
475 where V: Visitor<'de>
476 {
477 if name == MSGPACK_EXT_STRUCT_NAME {
478 match self {
479 ValueRef::Ext(tag, data) => {
480 let ext_de = ExtDeserializer::new_ref(tag, data);
481 return visitor.visit_newtype_struct(ext_de);
482 }
483 other => {
484 return Err(de::Error::invalid_type(other.unexpected(), &"expected Ext"))
485 }
486 }
487 }
488
489 visitor.visit_newtype_struct(self)
490 }
491
492 #[inline]
493 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
494 where V: Visitor<'de>
495 {
496 ValueBase::deserialize_unit_struct(self, visitor)
497 }
498
499 forward_to_deserialize_any! {
500 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
501 bytes byte_buf map tuple_struct struct
502 identifier tuple ignored_any
503 }
504}
505
506impl<'de> Deserializer<'de> for &'de ValueRef<'de> {
507 type Error = Error;
508
509 #[inline]
510 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
511 where V: Visitor<'de>
512 {
513 match *self {
514 ValueRef::Nil => visitor.visit_unit(),
515 ValueRef::Boolean(v) => visitor.visit_bool(v),
516 ValueRef::Integer(Integer { n }) => {
517 match n {
518 IntPriv::PosInt(v) => visitor.visit_u64(v),
519 IntPriv::NegInt(v) => visitor.visit_i64(v)
520 }
521 }
522 ValueRef::F32(v) => visitor.visit_f32(v),
523 ValueRef::F64(v) => visitor.visit_f64(v),
524 ValueRef::String(v) => {
525 match v.s {
526 Ok(v) => visitor.visit_borrowed_str(v),
527 Err(v) => visitor.visit_borrowed_bytes(v.0),
528 }
529 }
530 ValueRef::Binary(v) => visitor.visit_borrowed_bytes(v),
531 ValueRef::Array(ref v) => {
532 let len = v.len();
533 let mut de = SeqDeserializer::new(v.into_iter());
534 let seq = visitor.visit_seq(&mut de)?;
535 if de.iter.len() == 0 {
536 Ok(seq)
537 } else {
538 Err(de::Error::invalid_length(len, &"fewer elements in array"))
539 }
540 }
541 ValueRef::Map(ref v) => {
542 let len = v.len();
543 let mut de = MapRefDeserializer::new(v.into_iter());
544 let map = visitor.visit_map(&mut de)?;
545 if de.iter.len() == 0 {
546 Ok(map)
547 } else {
548 Err(de::Error::invalid_length(len, &"fewer elements in map"))
549 }
550 }
551 ValueRef::Ext(tag, data) => {
552 let de = ExtDeserializer::new_ref(tag, data);
553 visitor.visit_newtype_struct(de)
554 }
555 }
556 }
557
558 #[inline]
559 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
560 where V: Visitor<'de>
561 {
562 if let &ValueRef::Nil = self {
563 visitor.visit_none()
564 } else {
565 visitor.visit_some(self)
566 }
567 }
568
569 #[inline]
570 fn deserialize_enum<V>(self, _name: &str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
571 where V: Visitor<'de>
572 {
573 match self {
574 &ValueRef::Array(ref v) => {
575 let len = v.len();
576 let mut iter = v.into_iter();
577 if !(len == 1 || len == 2) {
578 return Err(de::Error::invalid_length(len, &"array with one or two elements"));
579 }
580
581 let id = match iter.next() {
582 Some(id) => deserialize_from(id)?,
583 None => {
584 return Err(de::Error::invalid_length(len, &"array with one or two elements"));
585 }
586 };
587
588 visitor.visit_enum(EnumRefDeserializer::new(id, iter.next()))
589 }
590 other => Err(de::Error::invalid_type(other.unexpected(), &"array, map or int")),
591 }
592 }
593
594 #[inline]
595 fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
596 where V: Visitor<'de>
597 {
598 if name == MSGPACK_EXT_STRUCT_NAME {
599 match self {
600 ValueRef::Ext(tag, data) => {
601 let ext_de = ExtDeserializer::new_ref(*tag, data);
602 return visitor.visit_newtype_struct(ext_de);
603 }
604 other => {
605 return Err(de::Error::invalid_type(other.unexpected(), &"expected Ext"))
606 }
607 }
608 }
609
610 visitor.visit_newtype_struct(self)
611 }
612
613 #[inline]
614 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
615 where V: Visitor<'de>
616 {
617 match self {
618 &ValueRef::Array(ref v) => {
619 if v.len() == 0 {
620 visitor.visit_unit()
621 } else {
622 Err(de::Error::invalid_length(v.len(), &"empty array"))
623 }
624 }
625 other => Err(de::Error::invalid_type(other.unexpected(), &"empty array")),
626 }
627 }
628
629 forward_to_deserialize_any! {
630 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
631 bytes byte_buf map tuple_struct struct
632 identifier tuple ignored_any
633 }
634}
635
636struct ExtDeserializer<'de> {
637 tag: Option<i8>,
638 data: Option<Cow<'de, [u8]>>,
639}
640
641impl<'de> ExtDeserializer<'de> {
642 fn new_owned(tag: i8, data: Vec<u8>) -> Self {
643 ExtDeserializer {
644 tag: Some(tag),
645 data: Some(Cow::Owned(data)),
646 }
647 }
648
649 fn new_ref(tag: i8, data: &'de [u8]) -> Self {
650 ExtDeserializer {
651 tag: Some(tag),
652 data: Some(Cow::Borrowed(data)),
653 }
654 }
655}
656
657impl<'de> SeqAccess<'de> for ExtDeserializer<'de> {
658 type Error = Error;
659
660 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
661 where
662 T: DeserializeSeed<'de>,
663 {
664 if self.tag.is_some() || self.data.is_some() {
665 return Ok(Some(seed.deserialize(self)?));
666 }
667
668 Ok(None)
669 }
670}
671
672impl<'a, 'de: 'a> Deserializer<'de> for ExtDeserializer<'de> {
674 type Error = Error;
675
676 #[inline]
677 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
678 where V: Visitor<'de>
679 {
680 visitor.visit_seq(self)
681 }
682
683 forward_to_deserialize_any! {
684 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
685 seq bytes byte_buf map unit_struct newtype_struct
686 struct identifier tuple enum ignored_any tuple_struct
687 }
688}
689
690impl<'a, 'de: 'a> Deserializer<'de> for &'a mut ExtDeserializer<'de> {
692 type Error = Error;
693
694 #[inline]
695 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
696 where V: Visitor<'de>
697 {
698 if self.tag.is_some() {
699 let tag = self.tag.take().unwrap();
700 visitor.visit_i8(tag)
701 } else if self.data.is_some() {
702 let data = self.data.take().unwrap();
703 match data {
704 Cow::Owned(data) => visitor.visit_byte_buf(data),
705 Cow::Borrowed(data) => visitor.visit_borrowed_bytes(data)
706 }
707 } else {
708 unreachable!("ext seq only has two elements");
709 }
710 }
711
712 forward_to_deserialize_any! {
713 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
714 seq bytes byte_buf map unit_struct newtype_struct
715 tuple_struct struct identifier tuple enum ignored_any
716 }
717}
718
719struct SeqDeserializer<I> {
720 iter: I,
721}
722
723impl<I> SeqDeserializer<I> {
724 fn new(iter: I) -> Self {
725 Self { iter: iter }
726 }
727}
728
729impl<'de, I, U> SeqAccess<'de> for SeqDeserializer<I>
730 where I: Iterator<Item = U>,
731 U: Deserializer<'de, Error = Error>
732{
733 type Error = Error;
734
735 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
736 where T: de::DeserializeSeed<'de>
737 {
738 match self.iter.next() {
739 Some(val) => seed.deserialize(val).map(Some),
740 None => Ok(None),
741 }
742 }
743}
744
745impl<'de, I, U> Deserializer<'de> for SeqDeserializer<I>
746 where I: ExactSizeIterator<Item = U>,
747 U: Deserializer<'de, Error = Error>
748{
749 type Error = Error;
750
751 #[inline]
752 fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
753 where V: Visitor<'de>
754 {
755 let len = self.iter.len();
756 if len == 0 {
757 visitor.visit_unit()
758 } else {
759 let ret = visitor.visit_seq(&mut self)?;
760 let rem = self.iter.len();
761 if rem == 0 {
762 Ok(ret)
763 } else {
764 Err(de::Error::invalid_length(len, &"fewer elements in array"))
765 }
766 }
767 }
768
769 forward_to_deserialize_any! {
770 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
771 seq bytes byte_buf map unit_struct newtype_struct
772 tuple_struct struct identifier tuple enum ignored_any
773 }
774}
775
776struct MapDeserializer<I, U> {
777 val: Option<U>,
778 iter: I,
779}
780
781impl<I, U> MapDeserializer<I, U> {
782 fn new(iter: I) -> Self {
783 Self {
784 val: None,
785 iter: iter,
786 }
787 }
788}
789
790impl<'de, I, U> de::MapAccess<'de> for MapDeserializer<I, U>
791 where I: Iterator<Item = (U, U)>,
792 U: ValueBase<'de>
793{
794 type Error = Error;
795
796 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
797 where T: DeserializeSeed<'de>
798 {
799 match self.iter.next() {
800 Some((key, val)) => {
801 self.val = Some(val);
802 seed.deserialize(key).map(Some)
803 }
804 None => Ok(None),
805 }
806 }
807
808 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
809 where T: DeserializeSeed<'de>
810 {
811 match self.val.take() {
812 Some(val) => seed.deserialize(val),
813 None => Err(de::Error::custom("value is missing")),
814 }
815 }
816}
817
818impl<'de, I, U> Deserializer<'de> for MapDeserializer<I, U>
819 where I: Iterator<Item = (U, U)>,
820 U: ValueBase<'de>
821{
822 type Error = Error;
823
824 #[inline]
825 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
826 where V: Visitor<'de>
827 {
828 visitor.visit_map(self)
829 }
830
831 forward_to_deserialize_any! {
832 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
833 seq bytes byte_buf map unit_struct newtype_struct
834 tuple_struct struct identifier tuple enum ignored_any
835 }
836}
837
838struct EnumDeserializer<U> {
839 id: u32,
840 value: Option<U>,
841}
842
843impl<U> EnumDeserializer<U> {
844 pub fn new(id: u32, value: Option<U>) -> Self {
845 Self {
846 id: id,
847 value: value,
848 }
849 }
850}
851
852impl<'de, U: ValueBase<'de> + ValueExt> de::EnumAccess<'de> for EnumDeserializer<U> {
853 type Error = Error;
854 type Variant = VariantDeserializer<U>;
855
856 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
857 where V: de::DeserializeSeed<'de>
858 {
859 let variant = self.id.into_deserializer();
860 let visitor = VariantDeserializer { value: self.value };
861 seed.deserialize(variant).map(|v| (v, visitor))
862 }
863}
864
865struct VariantDeserializer<U> {
866 value: Option<U>,
867}
868
869impl<'de, U: ValueBase<'de> + ValueExt> de::VariantAccess<'de> for VariantDeserializer<U> {
870 type Error = Error;
871
872 fn unit_variant(self) -> Result<(), Error> {
873 match self.value {
875 Some(v) => {
876 match v.into_iter() {
877 Ok(ref v) if v.len() == 0 => Ok(()),
878 Ok(..) => Err(de::Error::invalid_value(Unexpected::Seq, &"empty array")),
879 Err(v) => Err(de::Error::invalid_value(v.unexpected(), &"empty array")),
880 }
881 }
882 None => Ok(()),
883 }
884 }
885
886 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
887 where T: de::DeserializeSeed<'de>
888 {
889 match self.value {
891 Some(v) => {
892 match v.into_iter() {
893 Ok(mut iter) => {
894 if iter.len() > 1 {
895 seed.deserialize(SeqDeserializer::new(iter))
896 } else {
897 let val = match iter.next() {
898 Some(val) => seed.deserialize(val),
899 None => return Err(de::Error::invalid_value(Unexpected::Seq, &"array with one element")),
900 };
901
902 if iter.next().is_some() {
903 Err(de::Error::invalid_value(Unexpected::Seq, &"array with one element"))
904 } else {
905 val
906 }
907 }
908 }
909 Err(v) => seed.deserialize(v),
910 }
911 }
912 None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant")),
913 }
914 }
915
916 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
917 where V: Visitor<'de>
918 {
919 match self.value {
921 Some(v) => {
922 match v.into_iter() {
923 Ok(v) => Deserializer::deserialize_any(SeqDeserializer::new(v), visitor),
924 Err(v) => Err(de::Error::invalid_type(v.unexpected(), &"tuple variant")),
925 }
926 }
927 None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"))
928 }
929 }
930
931 fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value, Error>
932 where V: Visitor<'de>,
933 {
934 match self.value {
935 Some(v) => {
936 match v.into_iter() {
937 Ok(iter) => Deserializer::deserialize_any(SeqDeserializer::new(iter), visitor),
938 Err(v) => {
939 match v.into_map_iter() {
940 Ok(iter) => Deserializer::deserialize_any(MapDeserializer::new(iter), visitor),
941 Err(v) => Err(de::Error::invalid_type(v.unexpected(), &"struct variant")),
942 }
943 }
944 }
945 }
946 None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"))
947 }
948 }
949}
950
951pub struct MapRefDeserializer<'de> {
952 val: Option<&'de ValueRef<'de>>,
953 iter: Iter<'de, (ValueRef<'de>, ValueRef<'de>)>,
954}
955
956impl<'de> MapRefDeserializer<'de> {
957 fn new(iter: Iter<'de, (ValueRef<'de>, ValueRef<'de>)>) -> Self {
958 Self {
959 val: None,
960 iter: iter,
961 }
962 }
963}
964
965impl<'de> de::MapAccess<'de> for MapRefDeserializer<'de> {
966 type Error = Error;
967
968 fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
969 where T: DeserializeSeed<'de>
970 {
971 match self.iter.next() {
972 Some(&(ref key, ref val)) => {
973 self.val = Some(val);
974 seed.deserialize(key).map(Some)
975 }
976 None => Ok(None),
977 }
978 }
979
980 fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
981 where T: DeserializeSeed<'de>
982 {
983 match self.val.take() {
984 Some(val) => seed.deserialize(val),
985 None => Err(de::Error::custom("value is missing")),
986 }
987 }
988}
989
990impl<'de> Deserializer<'de> for MapRefDeserializer<'de> {
991 type Error = Error;
992
993 #[inline]
994 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
995 where V: Visitor<'de>
996 {
997 visitor.visit_map(self)
998 }
999
1000 forward_to_deserialize_any! {
1001 bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
1002 seq bytes byte_buf map unit_struct newtype_struct
1003 tuple_struct struct identifier tuple enum ignored_any
1004 }
1005}
1006
1007pub struct EnumRefDeserializer<'de> {
1008 id: u32,
1009 value: Option<&'de ValueRef<'de>>,
1010}
1011
1012impl<'de> EnumRefDeserializer<'de> {
1013 pub fn new(id: u32, value: Option<&'de ValueRef<'de>>) -> Self {
1014 Self {
1015 id: id,
1016 value: value,
1017 }
1018 }
1019}
1020
1021impl<'de> de::EnumAccess<'de> for EnumRefDeserializer<'de> {
1022 type Error = Error;
1023 type Variant = VariantRefDeserializer<'de>;
1024
1025 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
1026 where V: de::DeserializeSeed<'de>
1027 {
1028 let variant = self.id.into_deserializer();
1029 let visitor = VariantRefDeserializer { value: self.value };
1030 seed.deserialize(variant).map(|v| (v, visitor))
1031 }
1032}
1033
1034pub struct VariantRefDeserializer<'de> {
1035 value: Option<&'de ValueRef<'de>>,
1036}
1037
1038impl<'de> de::VariantAccess<'de> for VariantRefDeserializer<'de> {
1039 type Error = Error;
1040
1041 fn unit_variant(self) -> Result<(), Error> {
1042 match self.value {
1044 Some(&ValueRef::Array(ref v)) => {
1045 if v.len() == 0 {
1046 Ok(())
1047 } else {
1048 Err(de::Error::invalid_value(Unexpected::Seq, &"empty array"))
1049 }
1050 }
1051 Some(v) => Err(de::Error::invalid_value(v.unexpected(), &"empty array")),
1052 None => Ok(()),
1053 }
1054 }
1055
1056 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
1057 where T: de::DeserializeSeed<'de>
1058 {
1059 match self.value {
1061 Some(&ValueRef::Array(ref v)) => {
1062 let len = v.len();
1063 let mut iter = v.into_iter();
1064 if len > 1 {
1065 seed.deserialize(SeqDeserializer::new(iter))
1066 } else {
1067 let val = match iter.next() {
1068 Some(val) => seed.deserialize(val),
1069 None => return Err(de::Error::invalid_length(len, &"array with one element")),
1070 };
1071
1072 if iter.next().is_some() {
1073 Err(de::Error::invalid_length(len, &"array with one element"))
1074 } else {
1075 val
1076 }
1077 }
1078 }
1079 Some(v) => seed.deserialize(v),
1080 None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant")),
1081 }
1082 }
1083
1084 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
1085 where V: Visitor<'de>
1086 {
1087 match self.value {
1089 Some(&ValueRef::Array(ref v)) => {
1090 Deserializer::deserialize_any(SeqDeserializer::new(v.into_iter()), visitor)
1091 }
1092 Some(v) => Err(de::Error::invalid_type(v.unexpected(), &"tuple variant")),
1093 None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"))
1094 }
1095 }
1096
1097 fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value, Error>
1098 where V: Visitor<'de>,
1099 {
1100 match self.value {
1101 Some(&ValueRef::Array(ref v)) => {
1102 Deserializer::deserialize_any(SeqDeserializer::new(v.into_iter()), visitor)
1103 }
1104 Some(&ValueRef::Map(ref v)) => {
1105 Deserializer::deserialize_any(MapRefDeserializer::new(v.into_iter()), visitor)
1106 }
1107 Some(v) => Err(de::Error::invalid_type(v.unexpected(), &"struct variant")),
1108 None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"))
1109 }
1110 }
1111}
1112
1113trait ValueBase<'de>: Deserializer<'de, Error = Error> + ValueExt {
1115 type Item: ValueBase<'de>;
1116 type Iter: ExactSizeIterator<Item = Self::Item>;
1117 type MapIter: Iterator<Item = (Self::Item, Self::Item)>;
1118 type MapDeserializer: Deserializer<'de>;
1119
1120 fn is_nil(&self) -> bool;
1121
1122 fn into_iter(self) -> Result<Self::Iter, Self::Item>;
1123 fn into_map_iter(self) -> Result<Self::MapIter, Self::Item>;
1124
1125 #[inline]
1126 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1127 where V: Visitor<'de>
1128 {
1129 if self.is_nil() {
1130 visitor.visit_none()
1131 } else {
1132 visitor.visit_some(self)
1133 }
1134 }
1135
1136 #[inline]
1137 fn deserialize_enum<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1138 where V: Visitor<'de>
1139 {
1140 match self.into_iter() {
1141 Ok(mut iter) => {
1142 if !(iter.len() == 1 || iter.len() == 2) {
1143 return Err(de::Error::invalid_length(iter.len(), &"array with one or two elements"));
1144 }
1145
1146 let id = match iter.next() {
1147 Some(id) => deserialize_from(id)?,
1148 None => {
1149 return Err(de::Error::invalid_value(Unexpected::Seq, &"array with one or two elements"));
1150 }
1151 };
1152
1153 visitor.visit_enum(EnumDeserializer::new(id, iter.next()))
1154 }
1155 Err(other) => {
1156 Err(de::Error::invalid_type(other.unexpected(), &"array, map or int"))
1157 }
1158 }
1159 }
1160
1161 #[inline]
1162 fn deserialize_newtype_struct<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1163 where V: Visitor<'de>
1164 {
1165 visitor.visit_newtype_struct(self)
1166 }
1167
1168 #[inline]
1169 fn deserialize_unit_struct<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1170 where V: Visitor<'de>
1171 {
1172 match self.into_iter() {
1173 Ok(iter) => {
1174 if iter.len() == 0 {
1175 visitor.visit_unit()
1176 } else {
1177 Err(de::Error::invalid_type(Unexpected::Seq, &"empty array"))
1178 }
1179 }
1180 Err(other) => Err(de::Error::invalid_type(other.unexpected(), &"empty array")),
1181 }
1182 }
1183}
1184
1185impl<'de> ValueBase<'de> for Value {
1186 type Item = Value;
1187 type Iter = IntoIter<Value>;
1188 type MapIter = IntoIter<(Value, Value)>;
1189 type MapDeserializer = MapDeserializer<Self::MapIter, Self::Item>;
1190
1191 #[inline]
1192 fn is_nil(&self) -> bool {
1193 if let &Value::Nil = self {
1194 true
1195 } else {
1196 false
1197 }
1198 }
1199
1200 #[inline]
1201 fn into_iter(self) -> Result<Self::Iter, Self::Item> {
1202 match self {
1203 Value::Array(v) => Ok(v.into_iter()),
1204 other => Err(other)
1205 }
1206 }
1207
1208 #[inline]
1209 fn into_map_iter(self) -> Result<Self::MapIter, Self::Item> {
1210 match self {
1211 Value::Map(v) => Ok(v.into_iter()),
1212 other => Err(other)
1213 }
1214 }
1215}
1216
1217impl<'de> ValueBase<'de> for ValueRef<'de> {
1218 type Item = ValueRef<'de>;
1219 type Iter = IntoIter<ValueRef<'de>>;
1220 type MapIter = IntoIter<(ValueRef<'de>, ValueRef<'de>)>;
1221 type MapDeserializer = MapDeserializer<Self::MapIter, Self::Item>;
1222
1223 #[inline]
1224 fn is_nil(&self) -> bool {
1225 if let &ValueRef::Nil = self {
1226 true
1227 } else {
1228 false
1229 }
1230 }
1231
1232 #[inline]
1233 fn into_iter(self) -> Result<Self::Iter, Self::Item> {
1234 match self {
1235 ValueRef::Array(v) => Ok(v.into_iter()),
1236 other => Err(other)
1237 }
1238 }
1239
1240 #[inline]
1241 fn into_map_iter(self) -> Result<Self::MapIter, Self::Item> {
1242 match self {
1243 ValueRef::Map(v) => Ok(v.into_iter()),
1244 other => Err(other)
1245 }
1246 }
1247}