cu29_value/
de.rs

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

cu29_value/
de.rs
