cu29_value/
de.rs

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

cu29_value/
de.rs
