rmpv/ext/
de.rs

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
672/// Deserializer for Ext (expecting sequence)
673impl<'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
690/// Deserializer for Ext SeqAccess elements
691impl<'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        // Can accept only [u32].
874        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        // Can accept both [u32, T...] and [u32, [T]] cases.
890        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        // Can accept [u32, [T...]].
920        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        // Can accept only [u32].
1043        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        // Can accept both [u32, T...] and [u32, [T]] cases.
1060        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        // Can accept [u32, [T...]].
1088        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
1113// TODO: Ugly hack. Needed for avoiding copy-pasting similar code, but I don't like it.
1114trait 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}