bramble_data/object/
ser.rs

1//! BDF object serialization
2
3use crate::{Error, Map, Object, Result};
4use serde::{ser, Serialize};
5use std::result;
6
7/// Converts a value into a BDF [`Object`].
8pub fn to_object<T>(value: T) -> Result<Object>
9where
10    T: Serialize,
11{
12    value.serialize(Serializer)
13}
14
15impl Serialize for Object {
16    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
17    where
18        S: ser::Serializer,
19    {
20        match self {
21            Object::Null => serializer.serialize_unit(),
22            Object::Boolean(value) => serializer.serialize_bool(*value),
23            Object::Integer(value) => serializer.serialize_i64(*value),
24            Object::Float(value) => serializer.serialize_f64(*value),
25            Object::String(value) => serializer.serialize_str(value),
26            Object::Raw(value) => serializer.serialize_bytes(value),
27            Object::List(value) => value.serialize(serializer),
28            Object::Map(value) => value.serialize(serializer),
29        }
30    }
31}
32
33/// Serializer that serializes into an [`Object`]
34#[derive(Copy, Clone)]
35pub struct Serializer;
36
37impl ser::Serializer for Serializer {
38    type Ok = Object;
39    type Error = Error;
40
41    type SerializeSeq = SerializeList;
42    type SerializeTuple = SerializeList;
43    type SerializeTupleStruct = SerializeList;
44    type SerializeTupleVariant = SerializeListVariant;
45    type SerializeMap = SerializeMap;
46    type SerializeStruct = SerializeList;
47    type SerializeStructVariant = SerializeListVariant;
48
49    fn serialize_bool(self, value: bool) -> Result<Object> {
50        Ok(Object::Boolean(value))
51    }
52
53    fn serialize_i8(self, value: i8) -> Result<Object> {
54        self.serialize_i64(value as i64)
55    }
56
57    fn serialize_i16(self, value: i16) -> Result<Object> {
58        self.serialize_i64(value as i64)
59    }
60
61    fn serialize_i32(self, value: i32) -> Result<Object> {
62        self.serialize_i64(value as i64)
63    }
64
65    fn serialize_i64(self, value: i64) -> Result<Object> {
66        Ok(Object::Integer(value))
67    }
68
69    fn serialize_u8(self, value: u8) -> Result<Object> {
70        self.serialize_i64(value as i64)
71    }
72
73    fn serialize_u16(self, value: u16) -> Result<Object> {
74        self.serialize_i64(value as i64)
75    }
76
77    fn serialize_u32(self, value: u32) -> Result<Object> {
78        self.serialize_i64(value as i64)
79    }
80
81    fn serialize_u64(self, value: u64) -> Result<Object> {
82        if value <= i64::MAX as u64 {
83            self.serialize_i64(value as i64)
84        } else {
85            Err(Error::InvalidValue)
86        }
87    }
88
89    fn serialize_f32(self, value: f32) -> Result<Object> {
90        self.serialize_f64(value as f64)
91    }
92
93    fn serialize_f64(self, value: f64) -> Result<Object> {
94        Ok(Object::Float(value))
95    }
96
97    fn serialize_char(self, value: char) -> Result<Object> {
98        self.serialize_i64(value as i64)
99    }
100
101    fn serialize_str(self, value: &str) -> Result<Object> {
102        Ok(Object::String(value.into()))
103    }
104
105    fn serialize_bytes(self, value: &[u8]) -> Result<Object> {
106        Ok(Object::Raw(value.into()))
107    }
108
109    fn serialize_unit(self) -> Result<Object> {
110        Ok(Object::Null)
111    }
112
113    fn serialize_unit_struct(self, _name: &'static str) -> Result<Object> {
114        self.serialize_unit()
115    }
116
117    fn serialize_unit_variant(
118        self,
119        _name: &'static str,
120        variant_index: u32,
121        _variant: &'static str,
122    ) -> Result<Object> {
123        self.serialize_u32(variant_index)
124    }
125
126    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Object>
127    where
128        T: ?Sized + Serialize,
129    {
130        value.serialize(self)
131    }
132
133    fn serialize_newtype_variant<T>(
134        self,
135        _name: &'static str,
136        variant_index: u32,
137        _variant: &'static str,
138        value: &T,
139    ) -> Result<Object>
140    where
141        T: ?Sized + Serialize,
142    {
143        Ok(Object::List(vec![
144            Serializer.serialize_u32(variant_index)?,
145            value.serialize(self)?,
146        ]))
147    }
148
149    fn serialize_none(self) -> Result<Object> {
150        self.serialize_unit()
151    }
152
153    fn serialize_some<T>(self, value: &T) -> Result<Object>
154    where
155        T: ?Sized + Serialize,
156    {
157        value.serialize(self)
158    }
159
160    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
161        Ok(SerializeList {
162            list: Vec::with_capacity(len.unwrap_or(0)),
163        })
164    }
165
166    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
167        self.serialize_seq(Some(len))
168    }
169
170    fn serialize_tuple_struct(
171        self,
172        _name: &'static str,
173        len: usize,
174    ) -> Result<Self::SerializeTupleStruct> {
175        self.serialize_tuple(len)
176    }
177
178    fn serialize_tuple_variant(
179        self,
180        _name: &'static str,
181        variant_index: u32,
182        _variant: &'static str,
183        len: usize,
184    ) -> Result<Self::SerializeTupleVariant> {
185        use ser::SerializeTuple;
186        let mut outer = self.serialize_tuple(2)?;
187        outer.serialize_element(&variant_index)?;
188        let inner = self.serialize_tuple(len)?;
189        Ok(SerializeListVariant { outer, inner })
190    }
191
192    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
193        Ok(SerializeMap {
194            map: Map::new(),
195            next_key: None,
196        })
197    }
198
199    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
200        self.serialize_tuple(len)
201    }
202
203    fn serialize_struct_variant(
204        self,
205        name: &'static str,
206        variant_index: u32,
207        variant: &'static str,
208        len: usize,
209    ) -> Result<Self::SerializeStructVariant> {
210        self.serialize_tuple_variant(name, variant_index, variant, len)
211    }
212}
213
214pub struct SerializeList {
215    list: Vec<Object>,
216}
217
218impl ser::SerializeSeq for SerializeList {
219    type Ok = Object;
220    type Error = Error;
221
222    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
223    where
224        T: ?Sized + Serialize,
225    {
226        self.list.push(to_object(value)?);
227        Ok(())
228    }
229
230    fn end(self) -> Result<Object> {
231        Ok(Object::List(self.list))
232    }
233}
234
235impl ser::SerializeTuple for SerializeList {
236    type Ok = Object;
237    type Error = Error;
238
239    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
240    where
241        T: ?Sized + Serialize,
242    {
243        ser::SerializeSeq::serialize_element(self, value)
244    }
245
246    fn end(self) -> Result<Object> {
247        ser::SerializeSeq::end(self)
248    }
249}
250
251impl ser::SerializeTupleStruct for SerializeList {
252    type Ok = Object;
253    type Error = Error;
254
255    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
256    where
257        T: ?Sized + Serialize,
258    {
259        ser::SerializeSeq::serialize_element(self, value)
260    }
261
262    fn end(self) -> Result<Object> {
263        ser::SerializeSeq::end(self)
264    }
265}
266
267impl ser::SerializeStruct for SerializeList {
268    type Ok = Object;
269    type Error = Error;
270
271    fn serialize_field<T>(&mut self, _name: &'static str, value: &T) -> Result<()>
272    where
273        T: ?Sized + Serialize,
274    {
275        ser::SerializeSeq::serialize_element(self, value)
276    }
277
278    fn end(self) -> Result<Object> {
279        ser::SerializeSeq::end(self)
280    }
281}
282
283pub struct SerializeListVariant {
284    inner: SerializeList,
285    outer: SerializeList,
286}
287
288impl ser::SerializeTupleVariant for SerializeListVariant {
289    type Ok = Object;
290    type Error = Error;
291
292    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
293    where
294        T: ?Sized + Serialize,
295    {
296        ser::SerializeTuple::serialize_element(&mut self.inner, value)
297    }
298
299    fn end(mut self) -> Result<Object> {
300        let obj = ser::SerializeSeq::end(self.inner)?;
301        ser::SerializeTuple::serialize_element(&mut self.outer, &obj)?;
302        ser::SerializeSeq::end(self.outer)
303    }
304}
305
306impl ser::SerializeStructVariant for SerializeListVariant {
307    type Ok = Object;
308    type Error = Error;
309
310    fn serialize_field<T>(&mut self, _name: &'static str, value: &T) -> Result<()>
311    where
312        T: ?Sized + Serialize,
313    {
314        ser::SerializeTupleVariant::serialize_field(self, value)
315    }
316
317    fn end(self) -> Result<Object> {
318        ser::SerializeTupleVariant::end(self)
319    }
320}
321
322pub struct SerializeMap {
323    map: Map,
324    next_key: Option<String>,
325}
326
327impl ser::SerializeMap for SerializeMap {
328    type Ok = Object;
329    type Error = Error;
330
331    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
332    where
333        T: ?Sized + Serialize,
334    {
335        self.next_key = Some(key.serialize(KeySerializer)?);
336        Ok(())
337    }
338
339    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
340    where
341        T: ?Sized + Serialize,
342    {
343        // panic: this is a bug in the program, not an expected failure
344        let key = self
345            .next_key
346            .take()
347            .expect("serialize_value called before serialize_key");
348        self.map.insert(key, to_object(value)?);
349        Ok(())
350    }
351
352    fn end(self) -> Result<Object> {
353        Ok(Object::Map(self.map))
354    }
355}
356
357struct KeySerializer;
358
359impl ser::Serializer for KeySerializer {
360    type Ok = String;
361    type Error = Error;
362
363    type SerializeSeq = ser::Impossible<String, Error>;
364    type SerializeTuple = ser::Impossible<String, Error>;
365    type SerializeTupleStruct = ser::Impossible<String, Error>;
366    type SerializeTupleVariant = ser::Impossible<String, Error>;
367    type SerializeMap = ser::Impossible<String, Error>;
368    type SerializeStruct = ser::Impossible<String, Error>;
369    type SerializeStructVariant = ser::Impossible<String, Error>;
370
371    fn serialize_bool(self, _value: bool) -> Result<String> {
372        Err(Error::WrongType)
373    }
374
375    fn serialize_i8(self, _value: i8) -> Result<String> {
376        Err(Error::WrongType)
377    }
378
379    fn serialize_i16(self, _value: i16) -> Result<String> {
380        Err(Error::WrongType)
381    }
382
383    fn serialize_i32(self, _value: i32) -> Result<String> {
384        Err(Error::WrongType)
385    }
386
387    fn serialize_i64(self, _value: i64) -> Result<String> {
388        Err(Error::WrongType)
389    }
390
391    fn serialize_u8(self, _value: u8) -> Result<String> {
392        Err(Error::WrongType)
393    }
394
395    fn serialize_u16(self, _value: u16) -> Result<String> {
396        Err(Error::WrongType)
397    }
398
399    fn serialize_u32(self, _value: u32) -> Result<String> {
400        Err(Error::WrongType)
401    }
402
403    fn serialize_u64(self, _value: u64) -> Result<String> {
404        Err(Error::WrongType)
405    }
406
407    fn serialize_f32(self, _value: f32) -> Result<String> {
408        Err(Error::WrongType)
409    }
410
411    fn serialize_f64(self, _value: f64) -> Result<String> {
412        Err(Error::WrongType)
413    }
414
415    fn serialize_char(self, _value: char) -> Result<String> {
416        Err(Error::WrongType)
417    }
418
419    fn serialize_str(self, value: &str) -> Result<String> {
420        Ok(value.into())
421    }
422
423    fn serialize_bytes(self, _value: &[u8]) -> Result<String> {
424        Err(Error::WrongType)
425    }
426
427    fn serialize_unit(self) -> Result<String> {
428        Err(Error::WrongType)
429    }
430
431    fn serialize_unit_struct(self, _name: &'static str) -> Result<String> {
432        Err(Error::WrongType)
433    }
434
435    fn serialize_unit_variant(
436        self,
437        _name: &'static str,
438        _variant_index: u32,
439        _variant: &'static str,
440    ) -> Result<String> {
441        Err(Error::WrongType)
442    }
443
444    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<String>
445    where
446        T: ?Sized + Serialize,
447    {
448        Err(Error::WrongType)
449    }
450
451    fn serialize_newtype_variant<T>(
452        self,
453        _name: &'static str,
454        _variant_index: u32,
455        _variant: &'static str,
456        _value: &T,
457    ) -> Result<String>
458    where
459        T: ?Sized + Serialize,
460    {
461        Err(Error::WrongType)
462    }
463
464    fn serialize_none(self) -> Result<String> {
465        Err(Error::WrongType)
466    }
467
468    fn serialize_some<T>(self, _value: &T) -> Result<String>
469    where
470        T: ?Sized + Serialize,
471    {
472        Err(Error::WrongType)
473    }
474
475    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
476        Err(Error::WrongType)
477    }
478
479    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
480        Err(Error::WrongType)
481    }
482
483    fn serialize_tuple_struct(
484        self,
485        _name: &'static str,
486        _len: usize,
487    ) -> Result<Self::SerializeTupleStruct> {
488        Err(Error::WrongType)
489    }
490
491    fn serialize_tuple_variant(
492        self,
493        _name: &'static str,
494        _variant_index: u32,
495        _variant: &'static str,
496        _len: usize,
497    ) -> Result<Self::SerializeTupleVariant> {
498        Err(Error::WrongType)
499    }
500
501    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
502        Err(Error::WrongType)
503    }
504
505    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
506        Err(Error::WrongType)
507    }
508
509    fn serialize_struct_variant(
510        self,
511        _name: &'static str,
512        _variant_index: u32,
513        _variant: &'static str,
514        _len: usize,
515    ) -> Result<Self::SerializeStructVariant> {
516        Err(Error::WrongType)
517    }
518}
519
520#[cfg(test)]
521mod test {
522    use super::*;
523    use serde::Serialize;
524    use std::collections::HashMap;
525
526    #[test]
527    fn to_object_maps() {
528        let mut map = HashMap::new();
529        map.insert("foo", 123u32);
530        map.insert("bar", 456u32);
531        let obj = to_object(&map).unwrap();
532
533        let mut expected = Map::new();
534        expected.insert("foo".to_string(), Object::Integer(123));
535        expected.insert("bar".to_string(), Object::Integer(456));
536        assert_eq!(Object::Map(expected), obj);
537    }
538
539    #[test]
540    fn to_object_structs() {
541        #[derive(Serialize)]
542        struct Test {
543            x: bool,
544            y: u32,
545            z: Vec<String>,
546        }
547
548        let s = Test {
549            x: true,
550            y: 17,
551            z: vec!["foo".into(), "bar".into()],
552        };
553        let obj = to_object(&s).unwrap();
554        assert_eq!(
555            Object::List(vec![
556                Object::Boolean(true),
557                Object::Integer(17),
558                Object::List(vec![
559                    Object::String("foo".into()),
560                    Object::String("bar".into())
561                ])
562            ]),
563            obj
564        );
565    }
566
567    #[test]
568    fn to_object_enums() {
569        #[derive(Serialize)]
570        enum Test {
571            UnitVariant,
572            NewTypeVariant(u32),
573            TupleVariant(bool, u32),
574            StructVariant { x: bool, y: u32 },
575        }
576
577        let e = Test::UnitVariant;
578        let obj = to_object(&e).unwrap();
579        assert_eq!(Object::Integer(0), obj);
580
581        let e = Test::NewTypeVariant(17);
582        let obj = to_object(&e).unwrap();
583        assert_eq!(
584            Object::List(vec![Object::Integer(1), Object::Integer(17)]),
585            obj
586        );
587
588        let e = Test::TupleVariant(true, 17);
589        let obj = to_object(&e).unwrap();
590        assert_eq!(
591            Object::List(vec![
592                Object::Integer(2),
593                Object::List(vec![Object::Boolean(true), Object::Integer(17)])
594            ]),
595            obj
596        );
597
598        let e = Test::StructVariant { x: true, y: 17 };
599        let obj = to_object(&e).unwrap();
600        assert_eq!(
601            Object::List(vec![
602                Object::Integer(3),
603                Object::List(vec![Object::Boolean(true), Object::Integer(17)])
604            ]),
605            obj
606        );
607    }
608
609    #[test]
610    fn to_object_options() {
611        let o: Option<u32> = None;
612        let obj = to_object(&o).unwrap();
613        assert_eq!(Object::Null, obj);
614
615        let o = Some(17);
616        let obj = to_object(&o).unwrap();
617        assert_eq!(Object::Integer(17), obj);
618    }
619}
bramble_data/object/ser.rs

bramble_data/object/
ser.rs
