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

cu29_value/
de.rs
