serde_value/
de.rs

1use serde::{forward_to_deserialize_any, de};
2use std::collections::BTreeMap;
3use std::error::Error;
4use std::fmt;
5use std::marker::PhantomData;
6
7use crate::Value;
8
9#[derive(Debug)]
10pub enum Unexpected {
11    Bool(bool),
12    Unsigned(u64),
13    Signed(i64),
14    Float(f64),
15    Char(char),
16    Str(String),
17    Bytes(Vec<u8>),
18    Unit,
19    Option,
20    NewtypeStruct,
21    Seq,
22    Map,
23    Enum,
24    UnitVariant,
25    NewtypeVariant,
26    TupleVariant,
27    StructVariant,
28    Other(String),
29}
30
31impl<'a> From<de::Unexpected<'a>> for Unexpected {
32    fn from(unexp: de::Unexpected) -> Unexpected {
33        match unexp {
34            de::Unexpected::Bool(v) => Unexpected::Bool(v),
35            de::Unexpected::Unsigned(v) => Unexpected::Unsigned(v),
36            de::Unexpected::Signed(v) => Unexpected::Signed(v),
37            de::Unexpected::Float(v) => Unexpected::Float(v),
38            de::Unexpected::Char(v) => Unexpected::Char(v),
39            de::Unexpected::Str(v) => Unexpected::Str(v.to_owned()),
40            de::Unexpected::Bytes(v) => Unexpected::Bytes(v.to_owned()),
41            de::Unexpected::Unit => Unexpected::Unit,
42            de::Unexpected::Option => Unexpected::Option,
43            de::Unexpected::NewtypeStruct => Unexpected::NewtypeStruct,
44            de::Unexpected::Seq => Unexpected::Seq,
45            de::Unexpected::Map => Unexpected::Map,
46            de::Unexpected::Enum => Unexpected::Enum,
47            de::Unexpected::UnitVariant => Unexpected::UnitVariant,
48            de::Unexpected::NewtypeVariant => Unexpected::NewtypeVariant,
49            de::Unexpected::TupleVariant => Unexpected::TupleVariant,
50            de::Unexpected::StructVariant => Unexpected::StructVariant,
51            de::Unexpected::Other(v) => Unexpected::Other(v.to_owned()),
52        }
53    }
54}
55
56impl Unexpected {
57    pub fn to_unexpected<'a>(&'a self) -> de::Unexpected<'a> {
58        match *self {
59            Unexpected::Bool(v) => de::Unexpected::Bool(v),
60            Unexpected::Unsigned(v) => de::Unexpected::Unsigned(v),
61            Unexpected::Signed(v) => de::Unexpected::Signed(v),
62            Unexpected::Float(v) => de::Unexpected::Float(v),
63            Unexpected::Char(v) => de::Unexpected::Char(v),
64            Unexpected::Str(ref v) => de::Unexpected::Str(v),
65            Unexpected::Bytes(ref v) => de::Unexpected::Bytes(v),
66            Unexpected::Unit => de::Unexpected::Unit,
67            Unexpected::Option => de::Unexpected::Option,
68            Unexpected::NewtypeStruct => de::Unexpected::NewtypeStruct,
69            Unexpected::Seq => de::Unexpected::Seq,
70            Unexpected::Map => de::Unexpected::Map,
71            Unexpected::Enum => de::Unexpected::Enum,
72            Unexpected::UnitVariant => de::Unexpected::UnitVariant,
73            Unexpected::NewtypeVariant => de::Unexpected::NewtypeVariant,
74            Unexpected::TupleVariant => de::Unexpected::TupleVariant,
75            Unexpected::StructVariant => de::Unexpected::StructVariant,
76            Unexpected::Other(ref v) => de::Unexpected::Other(v),
77        }
78    }
79
80}
81
82#[derive(Debug)]
83pub enum DeserializerError {
84    Custom(String),
85    InvalidType(Unexpected, String),
86    InvalidValue(Unexpected, String),
87    InvalidLength(usize, String),
88    UnknownVariant(String, &'static [&'static str]),
89    UnknownField(String, &'static [&'static str]),
90    MissingField(&'static str),
91    DuplicateField(&'static str),
92}
93
94impl de::Error for DeserializerError {
95    fn custom<T: fmt::Display>(msg: T) -> Self {
96        DeserializerError::Custom(msg.to_string())
97    }
98
99    fn invalid_type(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self {
100        DeserializerError::InvalidType(unexp.into(), exp.to_string())
101    }
102
103    fn invalid_value(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self {
104        DeserializerError::InvalidValue(unexp.into(), exp.to_string())
105    }
106
107    fn invalid_length(len: usize, exp: &dyn de::Expected) -> Self {
108        DeserializerError::InvalidLength(len, exp.to_string())
109    }
110
111    fn unknown_variant(field: &str, expected: &'static [&'static str]) -> Self {
112        DeserializerError::UnknownVariant(field.into(), expected)
113    }
114
115    fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
116        DeserializerError::UnknownField(field.into(), expected)
117    }
118
119    fn missing_field(field: &'static str) -> Self {
120        DeserializerError::MissingField(field)
121    }
122
123    fn duplicate_field(field: &'static str) -> Self {
124        DeserializerError::DuplicateField(field)
125    }
126}
127
128impl DeserializerError {
129    pub fn to_error<E: de::Error>(&self) -> E {
130        match *self {
131            DeserializerError::Custom(ref msg) => E::custom(msg.clone()),
132            DeserializerError::InvalidType(ref unexp, ref exp) => {
133                E::invalid_type(unexp.to_unexpected(), &&**exp)
134            }
135            DeserializerError::InvalidValue(ref unexp, ref exp) => {
136                E::invalid_value(unexp.to_unexpected(), &&**exp)
137            }
138            DeserializerError::InvalidLength(len, ref exp) => E::invalid_length(len, &&**exp),
139            DeserializerError::UnknownVariant(ref field, exp) => E::unknown_variant(field, exp),
140            DeserializerError::UnknownField(ref field, exp) => E::unknown_field(field, exp),
141            DeserializerError::MissingField(field) => E::missing_field(field),
142            DeserializerError::DuplicateField(field) => E::missing_field(field),
143        }
144    }
145
146    pub fn into_error<E: de::Error>(self) -> E {
147        self.to_error()
148    }
149}
150
151impl Error for DeserializerError {
152    fn description(&self) -> &str {
153        "Value deserializer error"
154    }
155}
156
157impl fmt::Display for DeserializerError {
158    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
159        match *self {
160            DeserializerError::Custom(ref msg) => write!(f, "{}", msg),
161            DeserializerError::InvalidType(ref unexp, ref exp) => {
162                write!(f, "Invalid type {}. Expected {}", unexp.to_unexpected(), exp)
163            }
164            DeserializerError::InvalidValue(ref unexp, ref exp) => {
165                write!(f, "Invalid value {}. Expected {}", unexp.to_unexpected(), exp)
166            }
167            DeserializerError::InvalidLength(len, ref exp) => {
168                write!(f, "Invalid length {}. Expected {}", len, exp)
169            }
170            DeserializerError::UnknownVariant(ref field, exp) => {
171                write!(f, "Unknown variant {}. Expected one of {}", field, exp.join(", "))
172            },
173            DeserializerError::UnknownField(ref field, exp) => {
174                write!(f, "Unknown field {}. Expected one of {}", field, exp.join(", "))
175            }
176            DeserializerError::MissingField(field) => write!(f, "Missing field {}", field),
177            DeserializerError::DuplicateField(field) => write!(f, "Duplicate field {}", field),
178        }
179    }
180}
181
182impl From<de::value::Error> for DeserializerError {
183    fn from(e: de::value::Error) -> DeserializerError {
184        DeserializerError::Custom(e.to_string())
185    }
186}
187
188pub struct ValueVisitor;
189
190impl<'de> de::Visitor<'de> for ValueVisitor {
191    type Value = Value;
192
193    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
194        fmt.write_str("any value")
195    }
196
197    fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
198        Ok(Value::Bool(value))
199    }
200
201    fn visit_i8<E>(self, value: i8) -> Result<Value, E> {
202        Ok(Value::I8(value))
203    }
204
205    fn visit_i16<E>(self, value: i16) -> Result<Value, E> {
206        Ok(Value::I16(value))
207    }
208
209    fn visit_i32<E>(self, value: i32) -> Result<Value, E> {
210        Ok(Value::I32(value))
211    }
212
213    fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
214        Ok(Value::I64(value))
215    }
216
217    fn visit_u8<E>(self, value: u8) -> Result<Value, E> {
218        Ok(Value::U8(value))
219    }
220
221    fn visit_u16<E>(self, value: u16) -> Result<Value, E> {
222        Ok(Value::U16(value))
223    }
224
225    fn visit_u32<E>(self, value: u32) -> Result<Value, E> {
226        Ok(Value::U32(value))
227    }
228
229    fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
230        Ok(Value::U64(value))
231    }
232
233    fn visit_f32<E>(self, value: f32) -> Result<Value, E> {
234        Ok(Value::F32(value))
235    }
236
237    fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
238        Ok(Value::F64(value))
239    }
240
241    fn visit_char<E>(self, value: char) -> Result<Value, E> {
242        Ok(Value::Char(value))
243    }
244
245    fn visit_str<E>(self, value: &str) -> Result<Value, E> {
246        Ok(Value::String(value.into()))
247    }
248
249    fn visit_string<E>(self, value: String) -> Result<Value, E> {
250        Ok(Value::String(value))
251    }
252
253    fn visit_unit<E>(self) -> Result<Value, E> {
254        Ok(Value::Unit)
255    }
256
257    fn visit_none<E>(self) -> Result<Value, E> {
258        Ok(Value::Option(None))
259    }
260
261    fn visit_some<D: de::Deserializer<'de>>(self, d: D) -> Result<Value, D::Error> {
262        d.deserialize_any(ValueVisitor).map(|v| Value::Option(Some(Box::new(v))))
263    }
264
265    fn visit_newtype_struct<D: de::Deserializer<'de>>(self, d: D) -> Result<Value, D::Error> {
266        d.deserialize_any(ValueVisitor).map(|v| Value::Newtype(Box::new(v)))
267    }
268
269    fn visit_seq<V: de::SeqAccess<'de>>(self, mut visitor: V) -> Result<Value, V::Error> {
270        let mut values = Vec::new();
271        while let Some(elem) = visitor.next_element()? {
272            values.push(elem);
273        }
274        Ok(Value::Seq(values))
275    }
276
277    fn visit_map<V: de::MapAccess<'de>>(self, mut visitor: V) -> Result<Value, V::Error> {
278        let mut values = BTreeMap::new();
279        while let Some((key, value)) = visitor.next_entry()? {
280            values.insert(key, value);
281        }
282        Ok(Value::Map(values))
283    }
284
285    fn visit_bytes<E>(self, v: &[u8]) -> Result<Value, E> {
286        Ok(Value::Bytes(v.into()))
287    }
288
289    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Value, E> {
290        Ok(Value::Bytes(v))
291    }
292}
293
294impl<'de> de::Deserialize<'de> for Value {
295    fn deserialize<D: de::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
296        d.deserialize_any(ValueVisitor)
297    }
298}
299
300impl<'de> de::IntoDeserializer<'de, DeserializerError> for Value {
301    type Deserializer = Value;
302
303    fn into_deserializer(self) -> Value {
304        self
305    }
306}
307
308pub struct ValueDeserializer<E> {
309    value: Value,
310    error: PhantomData<fn() -> E>,
311}
312
313impl<E> ValueDeserializer<E> {
314    pub fn new(value: Value) -> Self {
315        ValueDeserializer {
316            value: value,
317            error: Default::default(),
318        }
319    }
320
321    pub fn into_value(self) -> Value {
322        self.value
323    }
324}
325
326impl<'de, E> de::Deserializer<'de> for ValueDeserializer<E> where E: de::Error {
327    type Error = E;
328
329    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
330        match self.value {
331            Value::Bool(v) => visitor.visit_bool(v),
332            Value::U8(v) => visitor.visit_u8(v),
333            Value::U16(v) => visitor.visit_u16(v),
334            Value::U32(v) => visitor.visit_u32(v),
335            Value::U64(v) => visitor.visit_u64(v),
336            Value::I8(v) => visitor.visit_i8(v),
337            Value::I16(v) => visitor.visit_i16(v),
338            Value::I32(v) => visitor.visit_i32(v),
339            Value::I64(v) => visitor.visit_i64(v),
340            Value::F32(v) => visitor.visit_f32(v),
341            Value::F64(v) => visitor.visit_f64(v),
342            Value::Char(v) => visitor.visit_char(v),
343            Value::String(v) => visitor.visit_string(v),
344            Value::Unit => visitor.visit_unit(),
345            Value::Option(None) => visitor.visit_none(),
346            Value::Option(Some(v)) => visitor.visit_some(ValueDeserializer::new(*v)),
347            Value::Newtype(v) => visitor.visit_newtype_struct(ValueDeserializer::new(*v)),
348            Value::Seq(v) => {
349                visitor.visit_seq(de::value::SeqDeserializer::new(v.into_iter().map(ValueDeserializer::new)))
350            },
351            Value::Map(v) => {
352                visitor.visit_map(de::value::MapDeserializer::new(v.into_iter().map(|(k, v)| (
353                    ValueDeserializer::new(k),
354                    ValueDeserializer::new(v),
355                ))))
356            },
357            Value::Bytes(v) => visitor.visit_byte_buf(v),
358        }
359    }
360
361    fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
362        match self.value {
363            Value::Option(..) => self.deserialize_any(visitor),
364            Value::Unit => visitor.visit_unit(),
365            _ => visitor.visit_some(self)
366        }
367    }
368
369    fn deserialize_enum<V: de::Visitor<'de>>(self,
370                                             _name: &'static str,
371                                             _variants: &'static [&'static str],
372                                             visitor: V)
373                                             -> Result<V::Value, Self::Error> {
374        let (variant, value) = match self.value {
375            Value::Map(value) => {
376                let mut iter = value.into_iter();
377                let (variant, value) = match iter.next() {
378                    Some(v) => v,
379                    None => {
380                        return Err(de::Error::invalid_value(de::Unexpected::Map,
381                                                            &"map with a single key"));
382                    }
383                };
384                // enums are encoded as maps with a single key:value pair
385                if iter.next().is_some() {
386                    return Err(de::Error::invalid_value(de::Unexpected::Map,
387                                                        &"map with a single key"));
388                }
389                (variant, Some(value))
390            }
391            Value::String(variant) => (Value::String(variant), None),
392            other => {
393                return Err(de::Error::invalid_type(other.unexpected(), &"string or map"));
394            }
395        };
396
397        let d = EnumDeserializer {
398            variant: variant,
399            value: value,
400            error: Default::default(),
401        };
402        visitor.visit_enum(d)
403    }
404
405    fn deserialize_newtype_struct<V: de::Visitor<'de>>(self,
406                                                       _name: &'static str,
407                                                       visitor: V)
408                                                       -> Result<V::Value, Self::Error> {
409        match self.value {
410            Value::Newtype(v) => visitor.visit_newtype_struct(ValueDeserializer::new(*v)),
411            _ => visitor.visit_newtype_struct(self),
412        }
413    }
414
415    forward_to_deserialize_any! {
416        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit
417        seq bytes byte_buf map unit_struct
418        tuple_struct struct tuple ignored_any identifier
419    }
420}
421
422impl<'de, E> de::IntoDeserializer<'de, E> for ValueDeserializer<E> where E: de::Error {
423    type Deserializer = Self;
424
425    fn into_deserializer(self) -> Self::Deserializer {
426        self
427    }
428}
429
430impl<'de> de::Deserializer<'de> for Value {
431    type Error = DeserializerError;
432
433    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
434        ValueDeserializer::new(self).deserialize_any(visitor)
435    }
436
437    fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
438        ValueDeserializer::new(self).deserialize_option(visitor)
439    }
440
441    fn deserialize_enum<V: de::Visitor<'de>>(self,
442                                             name: &'static str,
443                                             variants: &'static [&'static str],
444                                             visitor: V)
445                                             -> Result<V::Value, Self::Error> {
446        ValueDeserializer::new(self).deserialize_enum(name, variants, visitor)
447    }
448
449    fn deserialize_newtype_struct<V: de::Visitor<'de>>(self,
450                                                       name: &'static str,
451                                                       visitor: V)
452                                                       -> Result<V::Value, Self::Error> {
453        ValueDeserializer::new(self).deserialize_newtype_struct(name, visitor)
454    }
455
456    forward_to_deserialize_any! {
457        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit
458        seq bytes byte_buf map unit_struct
459        tuple_struct struct tuple ignored_any identifier
460    }
461}
462
463struct EnumDeserializer<E> {
464    variant: Value,
465    value: Option<Value>,
466    error: PhantomData<fn() -> E>,
467}
468
469impl<'de, E> de::EnumAccess<'de> for EnumDeserializer<E> where E: de::Error {
470    type Error = E;
471    type Variant = VariantDeserializer<Self::Error>;
472
473    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer<Self::Error>), Self::Error>
474        where V: de::DeserializeSeed<'de>
475    {
476        let visitor = VariantDeserializer {
477            value: self.value,
478            error: Default::default(),
479        };
480        seed.deserialize(ValueDeserializer::new(self.variant)).map(|v| (v, visitor))
481    }
482}
483
484struct VariantDeserializer<E> {
485    value: Option<Value>,
486    error: PhantomData<fn() -> E>,
487}
488
489impl<'de, E> de::VariantAccess<'de> for VariantDeserializer<E> where E: de::Error {
490    type Error = E;
491
492    fn unit_variant(self) -> Result<(), Self::Error> {
493        match self.value {
494            Some(value) => de::Deserialize::deserialize(ValueDeserializer::new(value)),
495            None => Ok(()),
496        }
497    }
498
499    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
500        where T: de::DeserializeSeed<'de>
501    {
502        match self.value {
503            Some(value) => seed.deserialize(ValueDeserializer::new(value)),
504            None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"newtype variant")),
505        }
506    }
507
508    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
509        where V: de::Visitor<'de>
510    {
511        match self.value {
512            Some(Value::Seq(v)) => {
513                de::Deserializer::deserialize_any(
514                    de::value::SeqDeserializer::new(v.into_iter().map(ValueDeserializer::new)),
515                    visitor)
516            }
517            Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")),
518            None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant")),
519        }
520    }
521
522    fn struct_variant<V>(self,
523                       _fields: &'static [&'static str],
524                       visitor: V)
525                       -> Result<V::Value, Self::Error>
526        where V: de::Visitor<'de>
527    {
528        match self.value {
529            Some(Value::Map(v)) => {
530                de::Deserializer::deserialize_any(
531                    de::value::MapDeserializer::new(v.into_iter().map(|(k, v)| (
532                        ValueDeserializer::new(k),
533                        ValueDeserializer::new(v),
534                    ))),
535                    visitor)
536            }
537            Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")),
538            None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant")),
539        }
540    }
541}
serde_value/de.rs

serde_value/
de.rs
