cu29_value/
de.rs

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

cu29_value/
de.rs
