eva_common/value/
de.rs

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

eva_common/value/
de.rs
