cu29_value/
de.rs

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

cu29_value/
de.rs
