avro_rs/
ser.rs

1//! Logic for serde-compatible serialization.
2use crate::{types::Value, Error};
3use serde::{ser, Serialize};
4use std::{collections::HashMap, iter::once};
5
6#[derive(Clone, Default)]
7pub struct Serializer {}
8
9pub struct SeqSerializer {
10    items: Vec<Value>,
11}
12
13pub struct SeqVariantSerializer<'a> {
14    index: u32,
15    variant: &'a str,
16    items: Vec<Value>,
17}
18
19pub struct MapSerializer {
20    indices: HashMap<String, usize>,
21    values: Vec<Value>,
22}
23
24pub struct StructSerializer {
25    fields: Vec<(String, Value)>,
26}
27
28pub struct StructVariantSerializer<'a> {
29    index: u32,
30    variant: &'a str,
31    fields: Vec<(String, Value)>,
32}
33
34impl SeqSerializer {
35    pub fn new(len: Option<usize>) -> SeqSerializer {
36        let items = match len {
37            Some(len) => Vec::with_capacity(len),
38            None => Vec::new(),
39        };
40
41        SeqSerializer { items }
42    }
43}
44
45impl<'a> SeqVariantSerializer<'a> {
46    pub fn new(index: u32, variant: &'a str, len: Option<usize>) -> SeqVariantSerializer {
47        let items = match len {
48            Some(len) => Vec::with_capacity(len),
49            None => Vec::new(),
50        };
51        SeqVariantSerializer {
52            index,
53            variant,
54            items,
55        }
56    }
57}
58
59impl MapSerializer {
60    pub fn new(len: Option<usize>) -> MapSerializer {
61        let (indices, values) = match len {
62            Some(len) => (HashMap::with_capacity(len), Vec::with_capacity(len)),
63            None => (HashMap::new(), Vec::new()),
64        };
65
66        MapSerializer { indices, values }
67    }
68}
69
70impl StructSerializer {
71    pub fn new(len: usize) -> StructSerializer {
72        StructSerializer {
73            fields: Vec::with_capacity(len),
74        }
75    }
76}
77
78impl<'a> StructVariantSerializer<'a> {
79    pub fn new(index: u32, variant: &'a str, len: usize) -> StructVariantSerializer {
80        StructVariantSerializer {
81            index,
82            variant,
83            fields: Vec::with_capacity(len),
84        }
85    }
86}
87
88impl<'b> ser::Serializer for &'b mut Serializer {
89    type Ok = Value;
90    type Error = Error;
91    type SerializeSeq = SeqSerializer;
92    type SerializeTuple = SeqSerializer;
93    type SerializeTupleStruct = SeqSerializer;
94    type SerializeTupleVariant = SeqVariantSerializer<'b>;
95    type SerializeMap = MapSerializer;
96    type SerializeStruct = StructSerializer;
97    type SerializeStructVariant = StructVariantSerializer<'b>;
98
99    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
100        Ok(Value::Boolean(v))
101    }
102
103    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
104        self.serialize_i32(i32::from(v))
105    }
106
107    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
108        self.serialize_i32(i32::from(v))
109    }
110
111    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
112        Ok(Value::Int(v))
113    }
114
115    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
116        Ok(Value::Long(v))
117    }
118
119    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
120        self.serialize_i32(i32::from(v))
121    }
122
123    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
124        self.serialize_i32(i32::from(v))
125    }
126
127    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
128        if v <= i32::max_value() as u32 {
129            self.serialize_i32(v as i32)
130        } else {
131            self.serialize_i64(i64::from(v))
132        }
133    }
134
135    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
136        if v <= i64::max_value() as u64 {
137            self.serialize_i64(v as i64)
138        } else {
139            Err(ser::Error::custom("u64 is too large"))
140        }
141    }
142
143    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
144        Ok(Value::Float(v))
145    }
146
147    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
148        Ok(Value::Double(v))
149    }
150
151    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
152        self.serialize_str(&once(v).collect::<String>())
153    }
154
155    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
156        Ok(Value::String(v.to_owned()))
157    }
158
159    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
160        Ok(Value::Bytes(v.to_owned()))
161    }
162
163    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
164        Ok(Value::from(None::<Self::Ok>))
165    }
166
167    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
168    where
169        T: Serialize,
170    {
171        let v = value.serialize(&mut Serializer::default())?;
172        Ok(Value::from(Some(v)))
173    }
174
175    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
176        Ok(Value::Null)
177    }
178
179    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
180        self.serialize_unit()
181    }
182
183    fn serialize_unit_variant(
184        self,
185        _: &'static str,
186        index: u32,
187        variant: &'static str,
188    ) -> Result<Self::Ok, Self::Error> {
189        Ok(Value::Enum(index as i32, variant.to_string()))
190    }
191
192    fn serialize_newtype_struct<T: ?Sized>(
193        self,
194        _: &'static str,
195        value: &T,
196    ) -> Result<Self::Ok, Self::Error>
197    where
198        T: Serialize,
199    {
200        value.serialize(self)
201    }
202
203    fn serialize_newtype_variant<T: ?Sized>(
204        self,
205        _: &'static str,
206        index: u32,
207        variant: &'static str,
208        value: &T,
209    ) -> Result<Self::Ok, Self::Error>
210    where
211        T: Serialize,
212    {
213        Ok(Value::Record(vec![
214            (
215                "type".to_owned(),
216                Value::Enum(index as i32, variant.to_owned()),
217            ),
218            (
219                "value".to_owned(),
220                Value::Union(Box::new(value.serialize(self)?)),
221            ),
222        ]))
223    }
224
225    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
226        Ok(SeqSerializer::new(len))
227    }
228
229    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
230        self.serialize_seq(Some(len))
231    }
232
233    fn serialize_tuple_struct(
234        self,
235        _: &'static str,
236        len: usize,
237    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
238        self.serialize_seq(Some(len))
239    }
240
241    fn serialize_tuple_variant(
242        self,
243        _: &'static str,
244        index: u32,
245        variant: &'static str,
246        len: usize,
247    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
248        Ok(SeqVariantSerializer::new(index, variant, Some(len)))
249    }
250
251    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
252        Ok(MapSerializer::new(len))
253    }
254
255    fn serialize_struct(
256        self,
257        _: &'static str,
258        len: usize,
259    ) -> Result<Self::SerializeStruct, Self::Error> {
260        Ok(StructSerializer::new(len))
261    }
262
263    fn serialize_struct_variant(
264        self,
265        _: &'static str,
266        index: u32,
267        variant: &'static str,
268        len: usize,
269    ) -> Result<Self::SerializeStructVariant, Self::Error> {
270        Ok(StructVariantSerializer::new(index, variant, len))
271    }
272}
273
274impl<'a> ser::SerializeSeq for SeqSerializer {
275    type Ok = Value;
276    type Error = Error;
277
278    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
279    where
280        T: Serialize,
281    {
282        self.items
283            .push(value.serialize(&mut Serializer::default())?);
284        Ok(())
285    }
286
287    fn end(self) -> Result<Self::Ok, Self::Error> {
288        Ok(Value::Array(self.items))
289    }
290}
291
292impl<'a> ser::SerializeTuple for SeqSerializer {
293    type Ok = Value;
294    type Error = Error;
295
296    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
297    where
298        T: Serialize,
299    {
300        ser::SerializeSeq::serialize_element(self, value)
301    }
302
303    fn end(self) -> Result<Self::Ok, Self::Error> {
304        ser::SerializeSeq::end(self)
305    }
306}
307
308impl ser::SerializeTupleStruct for SeqSerializer {
309    type Ok = Value;
310    type Error = Error;
311
312    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
313    where
314        T: Serialize,
315    {
316        ser::SerializeSeq::serialize_element(self, value)
317    }
318
319    fn end(self) -> Result<Self::Ok, Self::Error> {
320        ser::SerializeSeq::end(self)
321    }
322}
323
324impl<'a> ser::SerializeSeq for SeqVariantSerializer<'a> {
325    type Ok = Value;
326    type Error = Error;
327
328    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
329    where
330        T: Serialize,
331    {
332        self.items.push(Value::Union(Box::new(
333            value.serialize(&mut Serializer::default())?,
334        )));
335        Ok(())
336    }
337
338    fn end(self) -> Result<Self::Ok, Self::Error> {
339        Ok(Value::Record(vec![
340            (
341                "type".to_owned(),
342                Value::Enum(self.index as i32, self.variant.to_owned()),
343            ),
344            ("value".to_owned(), Value::Array(self.items)),
345        ]))
346    }
347}
348
349impl<'a> ser::SerializeTupleVariant for SeqVariantSerializer<'a> {
350    type Ok = Value;
351    type Error = Error;
352
353    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
354    where
355        T: Serialize,
356    {
357        ser::SerializeSeq::serialize_element(self, value)
358    }
359
360    fn end(self) -> Result<Self::Ok, Self::Error> {
361        Ok(ser::SerializeSeq::end(self)?)
362    }
363}
364
365impl ser::SerializeMap for MapSerializer {
366    type Ok = Value;
367    type Error = Error;
368
369    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
370    where
371        T: Serialize,
372    {
373        let key = key.serialize(&mut Serializer::default())?;
374
375        if let Value::String(key) = key {
376            self.indices.insert(key, self.values.len());
377            Ok(())
378        } else {
379            Err(ser::Error::custom("map key is not a string"))
380        }
381    }
382
383    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
384    where
385        T: Serialize,
386    {
387        self.values
388            .push(value.serialize(&mut Serializer::default())?);
389        Ok(())
390    }
391
392    fn end(self) -> Result<Self::Ok, Self::Error> {
393        let mut items = HashMap::new();
394        for (key, index) in self.indices {
395            if let Some(value) = self.values.get(index) {
396                items.insert(key, value.clone());
397            }
398        }
399
400        Ok(Value::Map(items))
401    }
402}
403
404impl ser::SerializeStruct for StructSerializer {
405    type Ok = Value;
406    type Error = Error;
407
408    fn serialize_field<T: ?Sized>(
409        &mut self,
410        name: &'static str,
411        value: &T,
412    ) -> Result<(), Self::Error>
413    where
414        T: Serialize,
415    {
416        self.fields.push((
417            name.to_owned(),
418            value.serialize(&mut Serializer::default())?,
419        ));
420        Ok(())
421    }
422
423    fn end(self) -> Result<Self::Ok, Self::Error> {
424        Ok(Value::Record(self.fields))
425    }
426}
427
428impl<'a> ser::SerializeStructVariant for StructVariantSerializer<'a> {
429    type Ok = Value;
430    type Error = Error;
431
432    fn serialize_field<T: ?Sized>(
433        &mut self,
434        name: &'static str,
435        value: &T,
436    ) -> Result<(), Self::Error>
437    where
438        T: Serialize,
439    {
440        self.fields.push((
441            name.to_owned(),
442            value.serialize(&mut Serializer::default())?,
443        ));
444        Ok(())
445    }
446
447    fn end(self) -> Result<Self::Ok, Self::Error> {
448        Ok(Value::Record(vec![
449            (
450                "type".to_owned(),
451                Value::Enum(self.index as i32, self.variant.to_owned()),
452            ),
453            (
454                "value".to_owned(),
455                Value::Union(Box::new(Value::Record(self.fields))),
456            ),
457        ]))
458    }
459}
460
461/// Interpret a serializeable instance as a `Value`.
462///
463/// This conversion can fail if the value is not valid as per the Avro specification.
464/// e.g: HashMap with non-string keys
465pub fn to_value<S: Serialize>(value: S) -> Result<Value, Error> {
466    let mut serializer = Serializer::default();
467    value.serialize(&mut serializer)
468}
469
470#[cfg(test)]
471mod tests {
472    use super::*;
473    use serde::{Deserialize, Serialize};
474
475    #[derive(Debug, Deserialize, Serialize, Clone)]
476    struct Test {
477        a: i64,
478        b: String,
479    }
480
481    #[derive(Debug, Deserialize, Serialize)]
482    struct TestInner {
483        a: Test,
484        b: i32,
485    }
486
487    #[derive(Debug, Deserialize, Serialize)]
488    struct TestUnitExternalEnum {
489        a: UnitExternalEnum,
490    }
491
492    #[derive(Debug, Deserialize, Serialize)]
493    enum UnitExternalEnum {
494        Val1,
495        Val2,
496    }
497
498    #[derive(Debug, Deserialize, Serialize)]
499    struct TestUnitInternalEnum {
500        a: UnitInternalEnum,
501    }
502
503    #[derive(Debug, Deserialize, Serialize)]
504    #[serde(tag = "t")]
505    enum UnitInternalEnum {
506        Val1,
507        Val2,
508    }
509
510    #[derive(Debug, Deserialize, Serialize)]
511    struct TestUnitAdjacentEnum {
512        a: UnitAdjacentEnum,
513    }
514
515    #[derive(Debug, Deserialize, Serialize)]
516    #[serde(tag = "t", content = "v")]
517    enum UnitAdjacentEnum {
518        Val1,
519        Val2,
520    }
521
522    #[derive(Debug, Deserialize, Serialize)]
523    struct TestUnitUntaggedEnum {
524        a: UnitUntaggedEnum,
525    }
526
527    #[derive(Debug, Deserialize, Serialize)]
528    #[serde(untagged)]
529    enum UnitUntaggedEnum {
530        Val1,
531        Val2,
532    }
533
534    #[derive(Debug, Serialize, Deserialize)]
535    struct TestSingleValueExternalEnum {
536        a: SingleValueExternalEnum,
537    }
538
539    #[derive(Debug, Serialize, Deserialize)]
540    enum SingleValueExternalEnum {
541        Double(f64),
542        String(String),
543    }
544
545    #[derive(Debug, Serialize, Deserialize)]
546    struct TestSingleValueInternalEnum {
547        a: SingleValueInternalEnum,
548    }
549
550    #[derive(Debug, Serialize, Deserialize)]
551    #[serde(tag = "t")]
552    enum SingleValueInternalEnum {
553        Double(f64),
554        String(String),
555    }
556
557    #[derive(Debug, Serialize, Deserialize)]
558    struct TestSingleValueAdjacentEnum {
559        a: SingleValueAdjacentEnum,
560    }
561    #[derive(Debug, Serialize, Deserialize)]
562    #[serde(tag = "t", content = "v")]
563    enum SingleValueAdjacentEnum {
564        Double(f64),
565        String(String),
566    }
567
568    #[derive(Debug, Serialize, Deserialize)]
569    struct TestSingleValueUntaggedEnum {
570        a: SingleValueUntaggedEnum,
571    }
572
573    #[derive(Debug, Serialize, Deserialize)]
574    #[serde(untagged)]
575    enum SingleValueUntaggedEnum {
576        Double(f64),
577        String(String),
578    }
579
580    #[derive(Debug, Serialize, Deserialize)]
581    struct TestStructExternalEnum {
582        a: StructExternalEnum,
583    }
584
585    #[derive(Debug, Serialize, Deserialize)]
586    enum StructExternalEnum {
587        Val1 { x: f32, y: f32 },
588        Val2 { x: f32, y: f32 },
589    }
590
591    #[derive(Debug, Serialize, Deserialize)]
592    struct TestStructInternalEnum {
593        a: StructInternalEnum,
594    }
595
596    #[derive(Debug, Serialize, Deserialize)]
597    #[serde(tag = "type")]
598    enum StructInternalEnum {
599        Val1 { x: f32, y: f32 },
600        Val2 { x: f32, y: f32 },
601    }
602
603    #[derive(Debug, Serialize, Deserialize)]
604    struct TestStructAdjacentEnum {
605        a: StructAdjacentEnum,
606    }
607
608    #[derive(Debug, Serialize, Deserialize)]
609    #[serde(tag = "t", content = "v")]
610    enum StructAdjacentEnum {
611        Val1 { x: f32, y: f32 },
612        Val2 { x: f32, y: f32 },
613    }
614
615    #[derive(Debug, Serialize, Deserialize)]
616    struct TestStructUntaggedEnum {
617        a: StructUntaggedEnum,
618    }
619
620    #[derive(Debug, Serialize, Deserialize)]
621    #[serde(untagged)]
622    enum StructUntaggedEnum {
623        Val1 { x: f32, y: f32 },
624        Val2 { x: f32, y: f32, z: f32 },
625    }
626
627    #[derive(Debug, Serialize, Deserialize)]
628    struct TestTupleExternalEnum {
629        a: TupleExternalEnum,
630    }
631
632    #[derive(Debug, Serialize, Deserialize)]
633    enum TupleExternalEnum {
634        Val1(f32, f32),
635        Val2(f32, f32, f32),
636    }
637
638    // Tuple Internal Enum cannot be instantiated
639
640    #[derive(Debug, Serialize, Deserialize)]
641    struct TestTupleAdjacentEnum {
642        a: TupleAdjacentEnum,
643    }
644
645    #[derive(Debug, Serialize, Deserialize)]
646    #[serde(tag = "t", content = "v")]
647    enum TupleAdjacentEnum {
648        Val1(f32, f32),
649        Val2(f32, f32, f32),
650    }
651
652    #[derive(Debug, Serialize, Deserialize)]
653    struct TestTupleUntaggedEnum {
654        a: TupleUntaggedEnum,
655    }
656
657    #[derive(Debug, Serialize, Deserialize)]
658    #[serde(untagged)]
659    enum TupleUntaggedEnum {
660        Val1(f32, f32),
661        Val2(f32, f32, f32),
662    }
663
664    #[test]
665    fn test_to_value() {
666        let test = Test {
667            a: 27,
668            b: "foo".to_owned(),
669        };
670        let expected = Value::Record(vec![
671            ("a".to_owned(), Value::Long(27)),
672            ("b".to_owned(), Value::String("foo".to_owned())),
673        ]);
674
675        assert_eq!(to_value(test.clone()).unwrap(), expected);
676
677        let test_inner = TestInner { a: test, b: 35 };
678
679        let expected_inner = Value::Record(vec![
680            (
681                "a".to_owned(),
682                Value::Record(vec![
683                    ("a".to_owned(), Value::Long(27)),
684                    ("b".to_owned(), Value::String("foo".to_owned())),
685                ]),
686            ),
687            ("b".to_owned(), Value::Int(35)),
688        ]);
689
690        assert_eq!(to_value(test_inner).unwrap(), expected_inner);
691    }
692
693    #[test]
694    fn test_to_value_unit_enum() {
695        let test = TestUnitExternalEnum {
696            a: UnitExternalEnum::Val1,
697        };
698
699        let expected = Value::Record(vec![("a".to_owned(), Value::Enum(0, "Val1".to_owned()))]);
700
701        assert_eq!(
702            to_value(test).unwrap(),
703            expected,
704            "Error serializing unit external enum"
705        );
706
707        let test = TestUnitInternalEnum {
708            a: UnitInternalEnum::Val1,
709        };
710
711        let expected = Value::Record(vec![(
712            "a".to_owned(),
713            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
714        )]);
715
716        assert_eq!(
717            to_value(test).unwrap(),
718            expected,
719            "Error serializing unit internal enum"
720        );
721
722        let test = TestUnitAdjacentEnum {
723            a: UnitAdjacentEnum::Val1,
724        };
725
726        let expected = Value::Record(vec![(
727            "a".to_owned(),
728            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
729        )]);
730
731        assert_eq!(
732            to_value(test).unwrap(),
733            expected,
734            "Error serializing unit adjacent enum"
735        );
736
737        let test = TestUnitUntaggedEnum {
738            a: UnitUntaggedEnum::Val1,
739        };
740
741        let expected = Value::Record(vec![("a".to_owned(), Value::Null)]);
742
743        assert_eq!(
744            to_value(test).unwrap(),
745            expected,
746            "Error serializing unit untagged enum"
747        );
748    }
749
750    #[test]
751    fn test_to_value_single_value_enum() {
752        let test = TestSingleValueExternalEnum {
753            a: SingleValueExternalEnum::Double(64.0),
754        };
755
756        let expected = Value::Record(vec![(
757            "a".to_owned(),
758            Value::Record(vec![
759                ("type".to_owned(), Value::Enum(0, "Double".to_owned())),
760                (
761                    "value".to_owned(),
762                    Value::Union(Box::new(Value::Double(64.0))),
763                ),
764            ]),
765        )]);
766
767        assert_eq!(
768            to_value(test).unwrap(),
769            expected,
770            "Error serializing single value external enum"
771        );
772
773        // It is not possible to serialize an internal Single Value enum...
774        let test = TestSingleValueInternalEnum {
775            a: SingleValueInternalEnum::Double(64.0),
776        };
777
778        assert_eq!(to_value(test).is_err(), true);
779
780        let test = TestSingleValueAdjacentEnum {
781            a: SingleValueAdjacentEnum::Double(64.0),
782        };
783
784        let expected = Value::Record(vec![(
785            "a".to_owned(),
786            Value::Record(vec![
787                ("t".to_owned(), Value::String("Double".to_owned())),
788                ("v".to_owned(), Value::Double(64.0)),
789            ]),
790        )]);
791
792        assert_eq!(
793            to_value(test).unwrap(),
794            expected,
795            "Error serializing single value adjacent enum"
796        );
797
798        let test = TestSingleValueUntaggedEnum {
799            a: SingleValueUntaggedEnum::Double(64.0),
800        };
801
802        let expected = Value::Record(vec![("a".to_owned(), Value::Double(64.0))]);
803
804        assert_eq!(
805            to_value(test).unwrap(),
806            expected,
807            "Error serializing single value untagged enum"
808        );
809    }
810
811    #[test]
812    fn test_to_value_struct_enum() {
813        let test = TestStructExternalEnum {
814            a: StructExternalEnum::Val1 { x: 1.0, y: 2.0 },
815        };
816        let expected = Value::Record(vec![(
817            "a".to_owned(),
818            Value::Record(vec![
819                ("type".to_owned(), Value::Enum(0, "Val1".to_owned())),
820                (
821                    "value".to_owned(),
822                    Value::Union(Box::new(Value::Record(vec![
823                        ("x".to_owned(), Value::Float(1.0)),
824                        ("y".to_owned(), Value::Float(2.0)),
825                    ]))),
826                ),
827            ]),
828        )]);
829
830        assert_eq!(
831            to_value(test).unwrap(),
832            expected,
833            "error serializing struct external enum"
834        );
835
836        // I don't think that this is feasible in avro
837
838        let test = TestStructInternalEnum {
839            a: StructInternalEnum::Val1 { x: 1.0, y: 2.0 },
840        };
841        let expected = Value::Record(vec![(
842            "a".to_owned(),
843            Value::Record(vec![
844                ("type".to_owned(), Value::String("Val1".to_owned())),
845                ("x".to_owned(), Value::Float(1.0)),
846                ("y".to_owned(), Value::Float(2.0)),
847            ]),
848        )]);
849
850        assert_eq!(
851            to_value(test).unwrap(),
852            expected,
853            "error serializing struct internal enum"
854        );
855
856        let test = TestStructAdjacentEnum {
857            a: StructAdjacentEnum::Val1 { x: 1.0, y: 2.0 },
858        };
859        let expected = Value::Record(vec![(
860            "a".to_owned(),
861            Value::Record(vec![
862                ("t".to_owned(), Value::String("Val1".to_owned())),
863                (
864                    "v".to_owned(),
865                    Value::Record(vec![
866                        ("x".to_owned(), Value::Float(1.0)),
867                        ("y".to_owned(), Value::Float(2.0)),
868                    ]),
869                ),
870            ]),
871        )]);
872
873        assert_eq!(
874            to_value(test).unwrap(),
875            expected,
876            "error serializing struct adjacent enum"
877        );
878
879        let test = TestStructUntaggedEnum {
880            a: StructUntaggedEnum::Val1 { x: 1.0, y: 2.0 },
881        };
882        let expected = Value::Record(vec![(
883            "a".to_owned(),
884            Value::Record(vec![
885                ("x".to_owned(), Value::Float(1.0)),
886                ("y".to_owned(), Value::Float(2.0)),
887            ]),
888        )]);
889
890        assert_eq!(
891            to_value(test).unwrap(),
892            expected,
893            "error serializing struct untagged enum"
894        );
895
896        let test = TestStructUntaggedEnum {
897            a: StructUntaggedEnum::Val2 {
898                x: 1.0,
899                y: 2.0,
900                z: 3.0,
901            },
902        };
903        let expected = Value::Record(vec![(
904            "a".to_owned(),
905            Value::Record(vec![
906                ("x".to_owned(), Value::Float(1.0)),
907                ("y".to_owned(), Value::Float(2.0)),
908                ("z".to_owned(), Value::Float(3.0)),
909            ]),
910        )]);
911
912        assert_eq!(
913            to_value(test).unwrap(),
914            expected,
915            "error serializing struct untagged enum variant"
916        );
917    }
918
919    #[test]
920    fn test_to_value_tuple_enum() {
921        let test = TestTupleExternalEnum {
922            a: TupleExternalEnum::Val2(1.0, 2.0, 3.0),
923        };
924
925        let expected = Value::Record(vec![(
926            "a".to_owned(),
927            Value::Record(vec![
928                ("type".to_owned(), Value::Enum(1, "Val2".to_owned())),
929                (
930                    "value".to_owned(),
931                    Value::Array(vec![
932                        Value::Union(Box::new(Value::Float(1.0))),
933                        Value::Union(Box::new(Value::Float(2.0))),
934                        Value::Union(Box::new(Value::Float(3.0))),
935                    ]),
936                ),
937            ]),
938        )]);
939
940        assert_eq!(
941            to_value(test).unwrap(),
942            expected,
943            "error serializing tuple external enum"
944        );
945
946        let test = TestTupleAdjacentEnum {
947            a: TupleAdjacentEnum::Val1(1.0, 2.0),
948        };
949
950        let expected = Value::Record(vec![(
951            "a".to_owned(),
952            Value::Record(vec![
953                ("t".to_owned(), Value::String("Val1".to_owned())),
954                (
955                    "v".to_owned(),
956                    Value::Array(vec![Value::Float(1.0), Value::Float(2.0)]),
957                ),
958            ]),
959        )]);
960
961        assert_eq!(
962            to_value(test).unwrap(),
963            expected,
964            "error serializing tuple adjacent enum"
965        );
966
967        let test = TestTupleUntaggedEnum {
968            a: TupleUntaggedEnum::Val1(1.0, 2.0),
969        };
970
971        let expected = Value::Record(vec![(
972            "a".to_owned(),
973            Value::Array(vec![Value::Float(1.0), Value::Float(2.0)]),
974        )]);
975
976        assert_eq!(
977            to_value(test).unwrap(),
978            expected,
979            "error serializing tuple untagged enum"
980        );
981    }
982}
avro_rs/ser.rs

avro_rs/
ser.rs
