serde_intermediate/de/
object.rs

1use crate::{error::*, value::object::*};
2use serde::{
3    de::{
4        DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess, VariantAccess, Visitor,
5    },
6    forward_to_deserialize_any, Deserialize,
7};
8
9pub fn deserialize<'a, T>(value: &'a Object) -> Result<T>
10where
11    T: Deserialize<'a>,
12{
13    T::deserialize(Deserializer::from_object(value))
14}
15
16#[derive(Debug)]
17pub struct Deserializer<'de> {
18    input: &'de Object,
19}
20
21impl<'de> Deserializer<'de> {
22    pub fn from_object(input: &'de Object) -> Self {
23        Self { input }
24    }
25}
26
27impl<'de> serde::de::Deserializer<'de> for Deserializer<'de> {
28    type Error = Error;
29
30    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
31    where
32        V: Visitor<'de>,
33    {
34        match self.input {
35            Object::Unit => visitor.visit_unit(),
36            Object::Bool(v) => visitor.visit_bool(*v),
37            Object::Number(v) => match v {
38                Number::SignedInteger(v) => visitor.visit_i64(*v),
39                Number::UnsignedInteger(v) => visitor.visit_u64(*v),
40                Number::Float(v) => visitor.visit_f64(*v),
41            },
42            Object::String(v) => visitor.visit_borrowed_str(v),
43            Object::Wrapper(v) => visitor.visit_newtype_struct(Self::from_object(v)),
44            Object::Array(v) => visitor.visit_seq(SeqDeserializer {
45                values: v.as_slice(),
46                index: 0,
47            }),
48            Object::Map(v) => visitor.visit_map(MapDeserializer {
49                values: v.as_slice(),
50                index: 0,
51            }),
52            Object::Option(v) => match v {
53                Some(v) => visitor.visit_some(Self::from_object(v)),
54                None => visitor.visit_none(),
55            },
56            Object::Variant { name, value } => match &**value {
57                Variant::Unit => visitor.visit_enum(EnumDeserializer::Unit { name }),
58                Variant::Wrapper(v) => {
59                    visitor.visit_enum(EnumDeserializer::NewType { name, content: v })
60                }
61                Variant::Array(v) => {
62                    visitor.visit_enum(EnumDeserializer::Tuple { name, content: v })
63                }
64                Variant::Map(v) => {
65                    visitor.visit_enum(EnumDeserializer::Struct { name, content: v })
66                }
67            },
68        }
69    }
70
71    forward_to_deserialize_any! {
72        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
73        bytes byte_buf option unit unit_struct seq tuple
74        tuple_struct map struct identifier ignored_any newtype_struct enum
75    }
76}
77
78#[derive(Debug)]
79pub struct SeqDeserializer<'de> {
80    values: &'de [Object],
81    index: usize,
82}
83
84impl<'de> SeqAccess<'de> for SeqDeserializer<'de> {
85    type Error = Error;
86
87    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
88    where
89        T: DeserializeSeed<'de>,
90    {
91        if let Some(value) = self.values.get(self.index) {
92            self.index += 1;
93            return seed.deserialize(Deserializer::from_object(value)).map(Some);
94        }
95        Ok(None)
96    }
97}
98
99#[derive(Debug)]
100pub struct MapDeserializer<'de> {
101    values: &'de [(Object, Object)],
102    index: usize,
103}
104
105impl<'de> MapAccess<'de> for MapDeserializer<'de> {
106    type Error = Error;
107
108    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
109    where
110        K: DeserializeSeed<'de>,
111    {
112        if let Some((key, _)) = self.values.get(self.index) {
113            return seed.deserialize(Deserializer::from_object(key)).map(Some);
114        }
115        Ok(None)
116    }
117
118    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
119    where
120        V: DeserializeSeed<'de>,
121    {
122        if let Some((_, value)) = self.values.get(self.index) {
123            self.index += 1;
124            return seed.deserialize(Deserializer::from_object(value));
125        }
126        Err(Error::ExpectedMapEntry)
127    }
128
129    fn next_entry_seed<K, V>(&mut self, kseed: K, vseed: V) -> Result<Option<(K::Value, V::Value)>>
130    where
131        K: DeserializeSeed<'de>,
132        V: DeserializeSeed<'de>,
133    {
134        if let Some((key, value)) = self.values.get(self.index) {
135            self.index += 1;
136            let key = kseed.deserialize(Deserializer::from_object(key))?;
137            let value = vseed.deserialize(Deserializer::from_object(value))?;
138            return Ok(Some((key, value)));
139        }
140        Ok(None)
141    }
142}
143
144#[derive(Debug)]
145pub struct StructDeserializer<'de> {
146    values: &'de [(String, Object)],
147    index: usize,
148}
149
150impl<'de> MapAccess<'de> for StructDeserializer<'de> {
151    type Error = Error;
152
153    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
154    where
155        K: DeserializeSeed<'de>,
156    {
157        if let Some((key, _)) = self.values.get(self.index) {
158            return seed.deserialize(key.as_str().into_deserializer()).map(Some);
159        }
160        Ok(None)
161    }
162
163    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
164    where
165        V: DeserializeSeed<'de>,
166    {
167        if let Some((_, value)) = self.values.get(self.index) {
168            self.index += 1;
169            return seed.deserialize(Deserializer::from_object(value));
170        }
171        Err(Error::ExpectedStructField)
172    }
173
174    fn next_entry_seed<K, V>(&mut self, kseed: K, vseed: V) -> Result<Option<(K::Value, V::Value)>>
175    where
176        K: DeserializeSeed<'de>,
177        V: DeserializeSeed<'de>,
178    {
179        if let Some((key, value)) = self.values.get(self.index) {
180            self.index += 1;
181            let key = kseed.deserialize(key.as_str().into_deserializer())?;
182            let value = vseed.deserialize(Deserializer::from_object(value))?;
183            return Ok(Some((key, value)));
184        }
185        Ok(None)
186    }
187}
188
189#[derive(Debug)]
190enum EnumDeserializer<'de> {
191    Unit {
192        name: &'de str,
193    },
194    NewType {
195        name: &'de str,
196        content: &'de Object,
197    },
198    Tuple {
199        name: &'de str,
200        content: &'de [Object],
201    },
202    Struct {
203        name: &'de str,
204        content: &'de [(String, Object)],
205    },
206}
207
208impl<'de> EnumDeserializer<'de> {
209    fn name(&self) -> &'de str {
210        match self {
211            Self::Unit { name }
212            | Self::NewType { name, .. }
213            | Self::Tuple { name, .. }
214            | Self::Struct { name, .. } => name,
215        }
216    }
217}
218
219impl<'de> EnumAccess<'de> for EnumDeserializer<'de> {
220    type Error = Error;
221    type Variant = Self;
222
223    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
224    where
225        V: DeserializeSeed<'de>,
226    {
227        let name = seed.deserialize(self.name().into_deserializer())?;
228        Ok((name, self))
229    }
230}
231
232impl<'de> VariantAccess<'de> for EnumDeserializer<'de> {
233    type Error = Error;
234
235    fn unit_variant(self) -> Result<()> {
236        if let EnumDeserializer::Unit { .. } = self {
237            return Ok(());
238        }
239        Err(Error::ExpectedUnitVariant)
240    }
241
242    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
243    where
244        T: DeserializeSeed<'de>,
245    {
246        if let EnumDeserializer::NewType { content, .. } = self {
247            return seed.deserialize(Deserializer::from_object(content));
248        }
249        Err(Error::ExpectedNewTypeVariant)
250    }
251
252    fn tuple_variant<V>(self, _: usize, visitor: V) -> Result<V::Value>
253    where
254        V: Visitor<'de>,
255    {
256        if let EnumDeserializer::Tuple { content, .. } = self {
257            return visitor.visit_seq(SeqDeserializer {
258                values: content,
259                index: 0,
260            });
261        }
262        Err(Error::ExpectedNewTypeVariant)
263    }
264
265    fn struct_variant<V>(self, _: &'static [&'static str], visitor: V) -> Result<V::Value>
266    where
267        V: Visitor<'de>,
268    {
269        if let EnumDeserializer::Struct { content, .. } = self {
270            return visitor.visit_map(StructDeserializer {
271                values: content,
272                index: 0,
273            });
274        }
275        Err(Error::ExpectedStructVariant)
276    }
277}
278
279#[derive(Copy, Clone)]
280pub struct ObjectVisitor;
281
282impl<'de> Visitor<'de> for ObjectVisitor {
283    type Value = Object;
284
285    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
286        formatter.write_str("object data representation")
287    }
288
289    fn visit_bool<E>(self, value: bool) -> std::result::Result<Self::Value, E>
290    where
291        E: serde::de::Error,
292    {
293        Ok(Object::Bool(value))
294    }
295
296    fn visit_i8<E>(self, value: i8) -> std::result::Result<Self::Value, E>
297    where
298        E: serde::de::Error,
299    {
300        Ok(Object::Number(Number::SignedInteger(value as _)))
301    }
302
303    fn visit_i16<E>(self, value: i16) -> std::result::Result<Self::Value, E>
304    where
305        E: serde::de::Error,
306    {
307        Ok(Object::Number(Number::SignedInteger(value as _)))
308    }
309
310    fn visit_i32<E>(self, value: i32) -> std::result::Result<Self::Value, E>
311    where
312        E: serde::de::Error,
313    {
314        Ok(Object::Number(Number::SignedInteger(value as _)))
315    }
316
317    fn visit_i64<E>(self, value: i64) -> std::result::Result<Self::Value, E>
318    where
319        E: serde::de::Error,
320    {
321        Ok(Object::Number(Number::SignedInteger(value)))
322    }
323
324    fn visit_u8<E>(self, value: u8) -> std::result::Result<Self::Value, E>
325    where
326        E: serde::de::Error,
327    {
328        Ok(Object::Number(Number::UnsignedInteger(value as _)))
329    }
330
331    fn visit_u16<E>(self, value: u16) -> std::result::Result<Self::Value, E>
332    where
333        E: serde::de::Error,
334    {
335        Ok(Object::Number(Number::UnsignedInteger(value as _)))
336    }
337
338    fn visit_u32<E>(self, value: u32) -> std::result::Result<Self::Value, E>
339    where
340        E: serde::de::Error,
341    {
342        Ok(Object::Number(Number::UnsignedInteger(value as _)))
343    }
344
345    fn visit_u64<E>(self, value: u64) -> std::result::Result<Self::Value, E>
346    where
347        E: serde::de::Error,
348    {
349        Ok(Object::Number(Number::UnsignedInteger(value)))
350    }
351
352    fn visit_f32<E>(self, value: f32) -> std::result::Result<Self::Value, E>
353    where
354        E: serde::de::Error,
355    {
356        Ok(Object::Number(Number::Float(value as _)))
357    }
358
359    fn visit_f64<E>(self, value: f64) -> std::result::Result<Self::Value, E>
360    where
361        E: serde::de::Error,
362    {
363        Ok(Object::Number(Number::Float(value)))
364    }
365
366    fn visit_char<E>(self, value: char) -> std::result::Result<Self::Value, E>
367    where
368        E: serde::de::Error,
369    {
370        Ok(Object::String(value.to_string()))
371    }
372
373    fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
374    where
375        E: serde::de::Error,
376    {
377        Ok(Object::String(value.to_owned()))
378    }
379
380    fn visit_borrowed_str<E>(self, value: &'de str) -> std::result::Result<Self::Value, E>
381    where
382        E: serde::de::Error,
383    {
384        Ok(Object::String(value.to_owned()))
385    }
386
387    fn visit_string<E>(self, value: String) -> std::result::Result<Self::Value, E>
388    where
389        E: serde::de::Error,
390    {
391        Ok(Object::String(value))
392    }
393
394    fn visit_bytes<E>(self, value: &[u8]) -> std::result::Result<Self::Value, E>
395    where
396        E: serde::de::Error,
397    {
398        Ok(Object::Array(
399            value
400                .iter()
401                .map(|value| Object::Number(Number::UnsignedInteger(*value as _)))
402                .collect(),
403        ))
404    }
405
406    fn visit_borrowed_bytes<E>(self, value: &'de [u8]) -> std::result::Result<Self::Value, E>
407    where
408        E: serde::de::Error,
409    {
410        Ok(Object::Array(
411            value
412                .iter()
413                .map(|value| Object::Number(Number::UnsignedInteger(*value as _)))
414                .collect(),
415        ))
416    }
417
418    fn visit_byte_buf<E>(self, value: Vec<u8>) -> std::result::Result<Self::Value, E>
419    where
420        E: serde::de::Error,
421    {
422        Ok(Object::Array(
423            value
424                .into_iter()
425                .map(|value| Object::Number(Number::UnsignedInteger(value as _)))
426                .collect(),
427        ))
428    }
429
430    fn visit_none<E>(self) -> std::result::Result<Self::Value, E>
431    where
432        E: serde::de::Error,
433    {
434        Ok(Object::Option(None))
435    }
436
437    fn visit_some<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
438    where
439        D: serde::de::Deserializer<'de>,
440    {
441        Ok(Object::Option(Some(Box::new(
442            deserializer.deserialize_any(ObjectVisitor)?,
443        ))))
444    }
445
446    fn visit_unit<E>(self) -> std::result::Result<Self::Value, E>
447    where
448        E: serde::de::Error,
449    {
450        Ok(Object::Unit)
451    }
452
453    fn visit_newtype_struct<D>(self, deserializer: D) -> std::result::Result<Self::Value, D::Error>
454    where
455        D: serde::de::Deserializer<'de>,
456    {
457        Ok(Object::Wrapper(Box::new(
458            deserializer.deserialize_any(ObjectVisitor)?,
459        )))
460    }
461
462    fn visit_seq<A>(self, mut access: A) -> std::result::Result<Self::Value, A::Error>
463    where
464        A: SeqAccess<'de>,
465    {
466        let mut result = Vec::with_capacity(access.size_hint().unwrap_or_default());
467        while let Some(v) = access.next_element()? {
468            result.push(v);
469        }
470        Ok(Object::Array(result))
471    }
472
473    fn visit_map<A>(self, mut access: A) -> std::result::Result<Self::Value, A::Error>
474    where
475        A: MapAccess<'de>,
476    {
477        let mut result = Vec::with_capacity(access.size_hint().unwrap_or_default());
478        while let Some((k, v)) = access.next_entry()? {
479            result.push((k, v));
480        }
481        Ok(Object::Map(result))
482    }
483
484    // TODO: what do we do with this? this obviously can be called, but at least JSON tests don't
485    // do it, have to ask smart ppl what should i do to make it work, since neither serde docs nor
486    // book shows how this works for self-describing types.
487    // fn visit_enum<A>(self, mut access: A) -> std::result::Result<Self::Value, A::Error>
488    // where
489    //     A: EnumAccess<'de>,
490    // {
491    //     Err(serde::de::Error::invalid_type(Unexpected::Enum, &self))
492    // }
493}
serde_intermediate/de/object.rs

serde_intermediate/de/
object.rs
