bramble_data/object/
de.rs

1//! BDF object deserialization
2
3use super::Object;
4use crate::{Error, Map, Result};
5use serde::{
6    de::{
7        self, DeserializeOwned, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess,
8        SeqAccess, VariantAccess, Visitor,
9    },
10    forward_to_deserialize_any, Deserialize,
11};
12use std::{convert::TryFrom, fmt, result, vec};
13
14/// Parses a value from a BDF [`Object`].
15pub fn from_object<T>(object: Object) -> Result<T>
16where
17    T: DeserializeOwned,
18{
19    T::deserialize(object)
20}
21
22impl<'de> Deserialize<'de> for Object {
23    fn deserialize<D>(deserializer: D) -> result::Result<Object, D::Error>
24    where
25        D: de::Deserializer<'de>,
26    {
27        struct ObjectVisitor;
28
29        impl<'de> Visitor<'de> for ObjectVisitor {
30            type Value = Object;
31
32            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
33                formatter.write_str("any valid BDF object")
34            }
35
36            fn visit_bool<E>(self, value: bool) -> result::Result<Object, E>
37            where
38                E: de::Error,
39            {
40                Ok(Object::Boolean(value))
41            }
42
43            fn visit_i64<E>(self, value: i64) -> result::Result<Object, E>
44            where
45                E: de::Error,
46            {
47                Ok(Object::Integer(value))
48            }
49
50            fn visit_u64<E>(self, value: u64) -> result::Result<Object, E>
51            where
52                E: de::Error,
53            {
54                let value = i64::try_from(value).map_err(|_| {
55                    de::Error::invalid_value(de::Unexpected::Unsigned(value), &self)
56                })?;
57                self.visit_i64(value)
58            }
59
60            fn visit_f64<E>(self, value: f64) -> result::Result<Object, E>
61            where
62                E: de::Error,
63            {
64                Ok(Object::Float(value))
65            }
66
67            fn visit_str<E>(self, value: &str) -> result::Result<Object, E>
68            where
69                E: de::Error,
70            {
71                self.visit_string(String::from(value))
72            }
73
74            fn visit_string<E>(self, value: String) -> result::Result<Object, E>
75            where
76                E: de::Error,
77            {
78                Ok(Object::String(value))
79            }
80
81            fn visit_bytes<E>(self, value: &[u8]) -> result::Result<Object, E>
82            where
83                E: de::Error,
84            {
85                self.visit_byte_buf(Vec::from(value))
86            }
87
88            fn visit_byte_buf<E>(self, value: Vec<u8>) -> result::Result<Object, E>
89            where
90                E: de::Error,
91            {
92                Ok(Object::Raw(value))
93            }
94
95            fn visit_none<E>(self) -> result::Result<Object, E>
96            where
97                E: de::Error,
98            {
99                Ok(Object::Null)
100            }
101
102            fn visit_some<D>(self, deserializer: D) -> result::Result<Object, D::Error>
103            where
104                D: de::Deserializer<'de>,
105            {
106                Deserialize::deserialize(deserializer)
107            }
108
109            fn visit_unit<E>(self) -> result::Result<Object, E>
110            where
111                E: de::Error,
112            {
113                Ok(Object::Null)
114            }
115
116            fn visit_seq<V>(self, mut visitor: V) -> result::Result<Object, V::Error>
117            where
118                V: SeqAccess<'de>,
119            {
120                let mut list = Vec::new();
121
122                while let Some(elem) = visitor.next_element()? {
123                    list.push(elem);
124                }
125
126                Ok(Object::List(list))
127            }
128
129            fn visit_map<V>(self, mut visitor: V) -> result::Result<Object, V::Error>
130            where
131                V: MapAccess<'de>,
132            {
133                let mut map = Map::new();
134                while let Some((key, value)) = visitor.next_entry()? {
135                    map.insert(key, value);
136                }
137                Ok(Object::Map(map))
138            }
139        }
140
141        deserializer.deserialize_any(ObjectVisitor)
142    }
143}
144
145impl<'de> de::Deserializer<'de> for Object {
146    type Error = Error;
147
148    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
149    where
150        V: Visitor<'de>,
151    {
152        match self {
153            Object::Null => visitor.visit_unit(),
154            Object::Boolean(value) => visitor.visit_bool(value),
155            Object::Integer(value) => visitor.visit_i64(value),
156            Object::Float(value) => visitor.visit_f64(value),
157            Object::String(value) => visitor.visit_string(value),
158            Object::Raw(value) => visitor.visit_byte_buf(value),
159            Object::List(value) => visit_list(value, visitor),
160            Object::Map(value) => visit_map(value, visitor),
161        }
162    }
163
164    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
165    where
166        V: Visitor<'de>,
167    {
168        visitor.visit_bool(self.as_boolean()?)
169    }
170
171    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
172    where
173        V: Visitor<'de>,
174    {
175        match self {
176            Object::Integer(value) => visitor.visit_i8(i8::try_from(value)?),
177            _ => Err(Error::WrongType),
178        }
179    }
180
181    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
182    where
183        V: Visitor<'de>,
184    {
185        match self {
186            Object::Integer(value) => visitor.visit_i16(i16::try_from(value)?),
187            _ => Err(Error::WrongType),
188        }
189    }
190
191    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
192    where
193        V: Visitor<'de>,
194    {
195        match self {
196            Object::Integer(value) => visitor.visit_i32(i32::try_from(value)?),
197            _ => Err(Error::WrongType),
198        }
199    }
200
201    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
202    where
203        V: Visitor<'de>,
204    {
205        match self {
206            Object::Integer(value) => visitor.visit_i64(value),
207            _ => Err(Error::WrongType),
208        }
209    }
210
211    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
212    where
213        V: Visitor<'de>,
214    {
215        match self {
216            Object::Integer(value) => visitor.visit_u8(u8::try_from(value)?),
217            _ => Err(Error::WrongType),
218        }
219    }
220
221    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
222    where
223        V: Visitor<'de>,
224    {
225        match self {
226            Object::Integer(value) => visitor.visit_u16(u16::try_from(value)?),
227            _ => Err(Error::WrongType),
228        }
229    }
230
231    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
232    where
233        V: Visitor<'de>,
234    {
235        match self {
236            Object::Integer(value) => visitor.visit_u32(u32::try_from(value)?),
237            _ => Err(Error::WrongType),
238        }
239    }
240
241    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
242    where
243        V: Visitor<'de>,
244    {
245        match self {
246            Object::Integer(value) => visitor.visit_u64(u64::try_from(value)?),
247            _ => Err(Error::WrongType),
248        }
249    }
250
251    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
252    where
253        V: Visitor<'de>,
254    {
255        match self {
256            Object::Float(value) => visitor.visit_f32(value as f32),
257            _ => Err(Error::WrongType),
258        }
259    }
260
261    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
262    where
263        V: Visitor<'de>,
264    {
265        match self {
266            Object::Float(value) => visitor.visit_f64(value),
267            _ => Err(Error::WrongType),
268        }
269    }
270
271    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
272    where
273        V: Visitor<'de>,
274    {
275        match self {
276            Object::Integer(value) => visitor.visit_char(char::try_from(u32::try_from(value)?)?),
277            _ => Err(Error::WrongType),
278        }
279    }
280
281    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
282    where
283        V: Visitor<'de>,
284    {
285        self.deserialize_string(visitor)
286    }
287
288    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
289    where
290        V: Visitor<'de>,
291    {
292        match self {
293            Object::String(value) => visitor.visit_string(value),
294            _ => Err(Error::WrongType),
295        }
296    }
297
298    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
299    where
300        V: Visitor<'de>,
301    {
302        self.deserialize_byte_buf(visitor)
303    }
304
305    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
306    where
307        V: Visitor<'de>,
308    {
309        match self {
310            Object::Raw(value) => visitor.visit_byte_buf(value),
311            _ => Err(Error::WrongType),
312        }
313    }
314
315    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
316    where
317        V: Visitor<'de>,
318    {
319        match &self {
320            Object::Null => visitor.visit_none(),
321            _ => visitor.visit_some(self),
322        }
323    }
324
325    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
326    where
327        V: Visitor<'de>,
328    {
329        match self {
330            Object::Null => visitor.visit_unit(),
331            _ => Err(Error::WrongType),
332        }
333    }
334
335    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
336    where
337        V: Visitor<'de>,
338    {
339        self.deserialize_unit(visitor)
340    }
341
342    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
343    where
344        V: Visitor<'de>,
345    {
346        visitor.visit_newtype_struct(self)
347    }
348
349    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
350    where
351        V: Visitor<'de>,
352    {
353        match self {
354            Object::List(value) => visit_list(value, visitor),
355            _ => Err(Error::WrongType),
356        }
357    }
358
359    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
360    where
361        V: Visitor<'de>,
362    {
363        self.deserialize_seq(visitor)
364    }
365
366    fn deserialize_tuple_struct<V>(
367        self,
368        _name: &'static str,
369        _len: usize,
370        visitor: V,
371    ) -> Result<V::Value>
372    where
373        V: Visitor<'de>,
374    {
375        self.deserialize_seq(visitor)
376    }
377
378    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
379    where
380        V: Visitor<'de>,
381    {
382        match self {
383            Object::Map(value) => visit_map(value, visitor),
384            _ => Err(Error::WrongType),
385        }
386    }
387
388    fn deserialize_struct<V>(
389        self,
390        _name: &'static str,
391        fields: &'static [&'static str],
392        visitor: V,
393    ) -> Result<V::Value>
394    where
395        V: Visitor<'de>,
396    {
397        self.deserialize_tuple(fields.len(), visitor)
398    }
399
400    fn deserialize_enum<V>(
401        self,
402        _name: &'static str,
403        _variants: &'static [&'static str],
404        visitor: V,
405    ) -> Result<V::Value>
406    where
407        V: Visitor<'de>,
408    {
409        visitor.visit_enum(self)
410    }
411
412    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
413    where
414        V: Visitor<'de>,
415    {
416        self.deserialize_string(visitor)
417    }
418
419    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
420    where
421        V: Visitor<'de>,
422    {
423        self.deserialize_any(visitor)
424    }
425}
426
427impl<'de> EnumAccess<'de> for Object {
428    type Error = Error;
429    type Variant = Self;
430
431    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
432    where
433        V: DeserializeSeed<'de>,
434    {
435        match self {
436            Object::Integer(value) => {
437                let variant_index = u32::try_from(value)?;
438                let value: Result<_> = seed.deserialize(variant_index.into_deserializer());
439                Ok((value?, self))
440            }
441            Object::List(mut list) => {
442                if list.is_empty() {
443                    return Err(Error::InvalidValue);
444                }
445                let variant_index = u32::try_from(list[0].as_integer()?)?;
446                let value: Result<_> = seed.deserialize(variant_index.into_deserializer());
447                Ok((value?, list.remove(1)))
448            }
449            _ => Err(Error::WrongType),
450        }
451    }
452}
453
454impl<'de> VariantAccess<'de> for Object {
455    type Error = Error;
456
457    fn unit_variant(self) -> Result<()> {
458        Ok(())
459    }
460
461    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
462    where
463        T: DeserializeSeed<'de>,
464    {
465        seed.deserialize(self)
466    }
467
468    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
469    where
470        V: Visitor<'de>,
471    {
472        de::Deserializer::deserialize_tuple(self, len, visitor)
473    }
474
475    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
476    where
477        V: Visitor<'de>,
478    {
479        de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
480    }
481}
482
483fn visit_list<'de, V>(list: Vec<Object>, visitor: V) -> Result<V::Value>
484where
485    V: Visitor<'de>,
486{
487    let mut deserializer = SeqDeserializer::new(list);
488    let seq = visitor.visit_seq(&mut deserializer)?;
489    let remaining = deserializer.iter.len();
490    if remaining == 0 {
491        Ok(seq)
492    } else {
493        Err(Error::InvalidLength)
494    }
495}
496
497fn visit_map<'de, V>(map: Map, visitor: V) -> Result<V::Value>
498where
499    V: Visitor<'de>,
500{
501    let mut deserializer = MapDeserializer::new(map);
502    let map = visitor.visit_map(&mut deserializer)?;
503    let remaining = deserializer.iter.len();
504    if remaining == 0 {
505        Ok(map)
506    } else {
507        Err(Error::InvalidLength)
508    }
509}
510
511struct SeqDeserializer {
512    iter: vec::IntoIter<Object>,
513}
514
515impl SeqDeserializer {
516    fn new(vec: Vec<Object>) -> Self {
517        SeqDeserializer {
518            iter: vec.into_iter(),
519        }
520    }
521}
522
523impl<'de> de::Deserializer<'de> for SeqDeserializer {
524    type Error = Error;
525
526    #[inline]
527    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value>
528    where
529        V: Visitor<'de>,
530    {
531        let ret = visitor.visit_seq(&mut self)?;
532        let remaining = self.iter.len();
533        if remaining == 0 {
534            Ok(ret)
535        } else {
536            Err(Error::InvalidLength)
537        }
538    }
539
540    forward_to_deserialize_any! {
541        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
542        bytes byte_buf option unit unit_struct newtype_struct seq tuple
543        tuple_struct map struct enum identifier ignored_any
544    }
545}
546
547impl<'de> SeqAccess<'de> for SeqDeserializer {
548    type Error = Error;
549
550    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
551    where
552        T: DeserializeSeed<'de>,
553    {
554        match self.iter.next() {
555            Some(value) => seed.deserialize(value).map(Some),
556            None => Ok(None),
557        }
558    }
559
560    fn size_hint(&self) -> Option<usize> {
561        match self.iter.size_hint() {
562            (lower, Some(upper)) if lower == upper => Some(upper),
563            _ => None,
564        }
565    }
566}
567
568struct MapDeserializer {
569    iter: <Map as IntoIterator>::IntoIter,
570    value: Option<Object>,
571}
572
573impl MapDeserializer {
574    fn new(map: Map) -> Self {
575        MapDeserializer {
576            iter: map.into_iter(),
577            value: None,
578        }
579    }
580}
581
582impl<'de> de::Deserializer<'de> for MapDeserializer {
583    type Error = Error;
584
585    #[inline]
586    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
587    where
588        V: Visitor<'de>,
589    {
590        visitor.visit_map(self)
591    }
592
593    forward_to_deserialize_any! {
594        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
595        bytes byte_buf option unit unit_struct newtype_struct seq tuple
596        tuple_struct map struct enum identifier ignored_any
597    }
598}
599
600impl<'de> MapAccess<'de> for MapDeserializer {
601    type Error = Error;
602
603    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
604    where
605        T: DeserializeSeed<'de>,
606    {
607        match self.iter.next() {
608            Some((key, value)) => {
609                self.value = Some(value);
610                let key_de = key.into_deserializer();
611                seed.deserialize(key_de).map(Some)
612            }
613            None => Ok(None),
614        }
615    }
616
617    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value>
618    where
619        T: DeserializeSeed<'de>,
620    {
621        match self.value.take() {
622            Some(value) => seed.deserialize(value),
623            None => Err(Error::InvalidValue),
624        }
625    }
626
627    fn size_hint(&self) -> Option<usize> {
628        match self.iter.size_hint() {
629            (lower, Some(upper)) if lower == upper => Some(upper),
630            _ => None,
631        }
632    }
633}
634
635#[cfg(test)]
636mod test {
637    use super::*;
638    use serde::Deserialize;
639    use std::collections::HashMap;
640
641    #[test]
642    fn from_object_maps() {
643        let mut map = Map::new();
644        map.insert("foo".to_string(), Object::Integer(123));
645        map.insert("bar".to_string(), Object::Integer(456));
646        let obj = Object::Map(map);
647        let map = from_object(obj).unwrap();
648
649        let mut expected = HashMap::new();
650        expected.insert("foo".to_string(), 123u32);
651        expected.insert("bar".to_string(), 456u32);
652
653        assert_eq!(expected, map);
654    }
655
656    #[test]
657    fn from_object_structs() {
658        #[derive(Deserialize, Debug, PartialEq, Eq)]
659        struct Test {
660            x: bool,
661            y: u32,
662            z: Vec<String>,
663        }
664
665        let obj = Object::List(vec![
666            Object::Boolean(true),
667            Object::Integer(17),
668            Object::List(vec![
669                Object::String("foo".into()),
670                Object::String("bar".into()),
671            ]),
672        ]);
673        let s = from_object(obj).unwrap();
674        let expected = Test {
675            x: true,
676            y: 17,
677            z: vec!["foo".into(), "bar".into()],
678        };
679        assert_eq!(expected, s);
680    }
681
682    #[test]
683    fn from_object_enums() {
684        #[derive(Deserialize, Debug, PartialEq, Eq)]
685        enum Test {
686            UnitVariant,
687            NewTypeVariant(u32),
688            TupleVariant(bool, u32),
689            StructVariant { x: bool, y: u32 },
690        }
691
692        let obj = Object::Integer(0);
693        let e = from_object(obj).unwrap();
694        let expected = Test::UnitVariant;
695        assert_eq!(expected, e);
696
697        let obj = Object::List(vec![Object::Integer(1), Object::Integer(17)]);
698        let e = from_object(obj).unwrap();
699        let expected = Test::NewTypeVariant(17);
700        assert_eq!(expected, e);
701
702        let obj = Object::List(vec![
703            Object::Integer(2),
704            Object::List(vec![Object::Boolean(true), Object::Integer(17)]),
705        ]);
706        let e = from_object(obj).unwrap();
707        let expected = Test::TupleVariant(true, 17);
708        assert_eq!(expected, e);
709
710        let obj = Object::List(vec![
711            Object::Integer(3),
712            Object::List(vec![Object::Boolean(true), Object::Integer(17)]),
713        ]);
714        let e = from_object(obj).unwrap();
715        let expected = Test::StructVariant { x: true, y: 17 };
716        assert_eq!(expected, e);
717    }
718
719    #[test]
720    fn from_object_options() {
721        let obj = Object::Null;
722        let e = from_object(obj).unwrap();
723        let expected: Option<u32> = None;
724        assert_eq!(expected, e);
725
726        let obj = Object::Integer(17);
727        let e = from_object(obj).unwrap();
728        let expected = Some(17);
729        assert_eq!(expected, e);
730    }
731}
bramble_data/object/de.rs

bramble_data/object/
de.rs
