datex_core/serde/
serializer.rs

1use crate::compiler::compile_value;
2use crate::runtime::execution::{
3    ExecutionInput, ExecutionOptions, execute_dxb_sync,
4};
5use crate::serde::error::SerializationError;
6use crate::values::core_value::CoreValue;
7use crate::values::core_values::list::List;
8use crate::values::core_values::map::Map;
9use crate::values::value_container::ValueContainer;
10use serde::ser::{
11    Serialize, SerializeMap, SerializeSeq, SerializeStruct,
12    SerializeStructVariant, SerializeTuple, SerializeTupleStruct,
13    SerializeTupleVariant, Serializer,
14};
15use std::vec;
16pub struct DatexSerializer {}
17
18impl Default for DatexSerializer {
19    fn default() -> Self {
20        Self::new()
21    }
22}
23
24impl DatexSerializer {
25    pub fn new() -> Self {
26        DatexSerializer {}
27    }
28}
29
30pub fn to_bytes<T>(value: &T) -> Result<Vec<u8>, SerializationError>
31where
32    T: Serialize,
33{
34    let value_container = to_value_container(value)?;
35    compile_value(&value_container).map_err(|e| e.into())
36}
37pub fn to_value_container<T>(
38    value: &T,
39) -> Result<ValueContainer, SerializationError>
40where
41    T: Serialize,
42{
43    let mut serializer = DatexSerializer::new();
44    let container = value.serialize(&mut serializer)?;
45    Ok(container)
46}
47
48/// Serializer for structs
49/// For example:
50/// struct MyStruct {
51///     field1: String,
52///     field2: i32,
53/// }
54/// will be serialized as:
55/// {"field1": String, "field2": i32}
56#[derive(Default)]
57pub struct StructSerializer {
58    fields: Vec<(String, ValueContainer)>,
59}
60impl StructSerializer {
61    pub fn new() -> Self {
62        Self::default()
63    }
64}
65impl SerializeStruct for StructSerializer {
66    type Ok = ValueContainer;
67    type Error = SerializationError;
68
69    fn serialize_field<T: ?Sized>(
70        &mut self,
71        key: &'static str,
72        value: &T,
73    ) -> Result<(), Self::Error>
74    where
75        T: serde::Serialize,
76    {
77        let vc = value.serialize(&mut DatexSerializer::new())?;
78        self.fields.push((key.to_string(), vc));
79        Ok(())
80    }
81
82    fn end(self) -> Result<Self::Ok, Self::Error> {
83        Ok(Map::Structural(self.fields).into())
84    }
85}
86
87/// Serializer for tuples
88/// For example:
89/// (i32, String)
90/// will be serialized as:
91/// [i32, String]
92#[derive(Default)]
93pub struct TupleSerializer {
94    elements: Vec<ValueContainer>,
95}
96impl TupleSerializer {
97    pub fn new() -> Self {
98        Self {
99            elements: Vec::new(),
100        }
101    }
102}
103impl SerializeTuple for TupleSerializer {
104    type Ok = ValueContainer;
105    type Error = SerializationError;
106
107    fn serialize_element<T: ?Sized>(
108        &mut self,
109        value: &T,
110    ) -> Result<(), Self::Error>
111    where
112        T: serde::Serialize,
113    {
114        let vc = value.serialize(&mut DatexSerializer::new())?;
115        self.elements.push(vc);
116        Ok(())
117    }
118
119    fn end(self) -> Result<Self::Ok, Self::Error> {
120        let mut list = List::default();
121        for element in self.elements.into_iter() {
122            list.push(element);
123        }
124        Ok(ValueContainer::from(CoreValue::List(list)))
125    }
126}
127
128/// Serializer for tuple structs
129/// For example:
130/// struct MyStruct(i32, String);
131/// will be serialized as:
132/// [i32, String]
133pub struct TupleStructSerializer {
134    _name: &'static str,
135    fields: List,
136}
137impl TupleStructSerializer {
138    pub fn new(name: &'static str) -> Self {
139        Self {
140            _name: name,
141            fields: List::default(),
142        }
143    }
144}
145impl SerializeTupleStruct for TupleStructSerializer {
146    type Ok = ValueContainer;
147    type Error = SerializationError;
148
149    fn serialize_field<T: ?Sized>(
150        &mut self,
151        value: &T,
152    ) -> Result<(), Self::Error>
153    where
154        T: Serialize,
155    {
156        let field = value.serialize(&mut DatexSerializer::new())?;
157        self.fields.push(field);
158        Ok(())
159    }
160
161    fn end(self) -> Result<Self::Ok, Self::Error> {
162        Ok(ValueContainer::from(self.fields))
163    }
164}
165
166/// Serializer for enum variants with tuple fields
167/// For example:
168/// enum MyEnum {
169///     Variant1(i32, String),
170///     Variant2(bool),
171/// }
172/// will be serialized as:
173/// {"Variant1": [i32, String]}
174pub struct TupleVariantSerializer {
175    variant: &'static str,
176    fields: List,
177}
178impl TupleVariantSerializer {
179    pub fn new(variant: &'static str) -> Self {
180        Self {
181            variant,
182            fields: List::default(),
183        }
184    }
185}
186impl SerializeTupleVariant for TupleVariantSerializer {
187    type Ok = ValueContainer;
188    type Error = SerializationError;
189
190    fn serialize_field<T: ?Sized>(
191        &mut self,
192        value: &T,
193    ) -> Result<(), Self::Error>
194    where
195        T: Serialize,
196    {
197        let field = value.serialize(&mut DatexSerializer::new())?;
198        self.fields.push(field);
199        Ok(())
200    }
201
202    fn end(self) -> Result<Self::Ok, Self::Error> {
203        Ok(ValueContainer::from(CoreValue::Map(Map::from(vec![(
204            self.variant.to_string(),
205            self.fields.into(),
206        )]))))
207    }
208}
209
210/// Serializer for enum variants with struct fields
211/// For example:
212/// enum MyEnum {
213///     Variant1 { x: i32, y: String },
214///     Variant2 { a: bool },
215/// }
216/// will be serialized as:
217/// {"Variant1": {"x": i32, "y": String}}
218pub struct StructVariantSerializer {
219    variant: &'static str,
220    fields: Vec<(String, ValueContainer)>,
221}
222impl StructVariantSerializer {
223    pub fn new(variant: &'static str) -> Self {
224        Self {
225            variant,
226            fields: Vec::new(),
227        }
228    }
229}
230impl SerializeStructVariant for StructVariantSerializer {
231    type Ok = ValueContainer;
232    type Error = SerializationError;
233
234    fn serialize_field<T: ?Sized>(
235        &mut self,
236        key: &'static str,
237        value: &T,
238    ) -> Result<(), Self::Error>
239    where
240        T: serde::Serialize,
241    {
242        let field = value.serialize(&mut DatexSerializer::new())?;
243        self.fields.push((key.to_string(), field));
244        Ok(())
245    }
246
247    fn end(self) -> Result<Self::Ok, Self::Error> {
248        Ok(Map::from(vec![(
249            self.variant.to_string(),
250            Map::from(self.fields).into(),
251        )])
252        .into())
253    }
254}
255
256/// Serializer for sequences
257/// For example:
258/// vec![1, 2, 3]
259/// will be serialized as:
260/// [1, 2, 3]
261#[derive(Default)]
262pub struct SeqSerializer {
263    elements: List,
264}
265impl SeqSerializer {
266    pub fn new() -> Self {
267        Self {
268            elements: List::default(),
269        }
270    }
271}
272impl SerializeSeq for SeqSerializer {
273    type Ok = ValueContainer;
274    type Error = SerializationError;
275
276    fn serialize_element<T: ?Sized>(
277        &mut self,
278        value: &T,
279    ) -> Result<(), Self::Error>
280    where
281        T: serde::Serialize,
282    {
283        let vc = value.serialize(&mut DatexSerializer::new())?;
284        self.elements.push(vc);
285        Ok(())
286    }
287
288    fn end(self) -> Result<Self::Ok, Self::Error> {
289        Ok(ValueContainer::from(self.elements))
290    }
291}
292
293/// Serializer for maps
294/// For example:
295///     HashMap<String, i32>
296/// will be serialized as:
297///     {"key": 1, "key2": 2, "key3": 3}
298#[derive(Default)]
299pub struct MapSerializer {
300    entries: Vec<(ValueContainer, Option<ValueContainer>)>,
301}
302impl MapSerializer {
303    pub fn new() -> Self {
304        Self {
305            entries: Vec::new(),
306        }
307    }
308}
309
310impl SerializeMap for MapSerializer {
311    type Ok = ValueContainer;
312    type Error = SerializationError;
313
314    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
315    where
316        T: serde::Serialize,
317    {
318        let key = key.serialize(&mut DatexSerializer::new())?;
319        self.entries.push((key, None));
320        Ok(())
321    }
322
323    fn serialize_value<T: ?Sized>(
324        &mut self,
325        value: &T,
326    ) -> Result<(), Self::Error>
327    where
328        T: serde::Serialize,
329    {
330        let vc = value.serialize(&mut DatexSerializer::new())?;
331        if let Some(last) = self.entries.last_mut() {
332            last.1 = Some(vc);
333            Ok(())
334        } else {
335            Err(SerializationError::Custom(
336                "serialize_value called before serialize_key".to_string(),
337            ))
338        }
339    }
340
341    fn end(self) -> Result<Self::Ok, Self::Error> {
342        let mut map = Map::default();
343        for (key, value) in self.entries.into_iter() {
344            if let Some(value) = value {
345                map.set(key, value);
346            } else {
347                return Err(SerializationError::Custom(
348                    "Map entry without value".to_string(),
349                ));
350            }
351        }
352        Ok(map.into())
353    }
354}
355
356/// Main serializer implementation
357impl Serializer for &mut DatexSerializer {
358    type Ok = ValueContainer;
359    type Error = SerializationError;
360
361    type SerializeStruct = StructSerializer;
362    type SerializeTuple = TupleSerializer;
363    type SerializeTupleStruct = TupleStructSerializer;
364    type SerializeTupleVariant = TupleVariantSerializer;
365    type SerializeStructVariant = StructVariantSerializer;
366    type SerializeSeq = SeqSerializer;
367    type SerializeMap = MapSerializer;
368
369    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
370        Ok(ValueContainer::from(v))
371    }
372
373    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
374        Ok(ValueContainer::from(v))
375    }
376
377    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
378        Ok(ValueContainer::from(v))
379    }
380
381    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
382        Ok(ValueContainer::from(v))
383    }
384
385    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
386        Ok(ValueContainer::from(v))
387    }
388
389    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
390        Ok(ValueContainer::from(v))
391    }
392
393    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
394        Ok(ValueContainer::from(v))
395    }
396
397    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
398        Ok(ValueContainer::from(v))
399    }
400
401    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
402        Ok(ValueContainer::from(v))
403    }
404
405    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
406        Ok(ValueContainer::from(v))
407    }
408
409    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
410        Ok(ValueContainer::from(v))
411    }
412
413    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
414        Ok(ValueContainer::from(v))
415    }
416
417    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
418        Ok(ValueContainer::from(v))
419    }
420
421    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
422        Ok(ValueContainer::from(v.to_string()))
423    }
424
425    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
426        Ok(ValueContainer::from(v))
427    }
428
429    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
430        todo!("#134 Undescribed by author.")
431    }
432
433    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
434        Ok(CoreValue::Null.into())
435    }
436
437    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
438    where
439        T: ?Sized + serde::Serialize,
440    {
441        value.serialize(&mut *self).map_err(|e| {
442            SerializationError::CanNotSerialize(format!(
443                "Failed to serialize Some value: {e}"
444            ))
445        })
446    }
447
448    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
449        Ok(Map::default().into())
450    }
451
452    fn serialize_struct(
453        self,
454        _name: &'static str,
455        _len: usize,
456    ) -> Result<Self::SerializeStruct, Self::Error> {
457        Ok(StructSerializer::new())
458    }
459
460    fn serialize_unit_struct(
461        self,
462        _name: &'static str,
463    ) -> Result<Self::Ok, Self::Error> {
464        Ok(Map::default().into())
465    }
466
467    fn serialize_unit_variant(
468        self,
469        _name: &'static str,
470        _variant_index: u32,
471        variant: &'static str,
472    ) -> Result<Self::Ok, Self::Error> {
473        Ok(ValueContainer::from(variant))
474    }
475
476    fn serialize_newtype_struct<T>(
477        self,
478        name: &'static str,
479        value: &T,
480    ) -> Result<Self::Ok, Self::Error>
481    where
482        T: ?Sized + serde::Serialize,
483    {
484        if name == "datex::endpoint" {
485            let endpoint = value
486                .serialize(&mut *self)?
487                .to_value()
488                .borrow()
489                .cast_to_endpoint()
490                .unwrap();
491            Ok(ValueContainer::from(endpoint))
492        } else if name == "datex::value" {
493            // unsafe cast value to ValueContainer
494            let bytes = unsafe { &*(value as *const T as *const Vec<u8>) };
495            Ok(execute_dxb_sync(ExecutionInput::new_with_dxb_and_options(
496                bytes,
497                ExecutionOptions::default(),
498            ))
499            .unwrap()
500            .unwrap())
501        } else if name.starts_with("datex::") {
502            // Serialize internal new type structs as normal structs
503            // {"datex::field": value}
504            // instead of
505            // value
506            let mut struct_serializer = StructSerializer::new();
507            struct_serializer.serialize_field(name, value)?;
508            struct_serializer.end()
509        } else {
510            Ok(value.serialize(&mut *self)?)
511        }
512    }
513
514    /// Serialize newtype enum variants as structs with one field
515    /// For example:
516    /// enum MyEnum {
517    ///     Variant1(String),
518    ///     Variant2(i32, String),
519    /// }
520    /// is serialized as
521    /// {"Variant2": [100, "hello"]}
522    fn serialize_newtype_variant<T>(
523        self,
524        _name: &'static str,
525        _variant_index: u32,
526        variant: &'static str,
527        value: &T,
528    ) -> Result<Self::Ok, Self::Error>
529    where
530        T: ?Sized + serde::Serialize,
531    {
532        let field = value.serialize(&mut *self)?;
533        Ok(ValueContainer::from(CoreValue::Map(Map::from(vec![(
534            variant.to_string(),
535            field,
536        )]))))
537    }
538
539    fn serialize_seq(
540        self,
541        _len: Option<usize>,
542    ) -> Result<Self::SerializeSeq, Self::Error> {
543        Ok(SeqSerializer::new())
544    }
545
546    fn serialize_tuple(
547        self,
548        _len: usize,
549    ) -> Result<Self::SerializeTuple, Self::Error> {
550        Ok(TupleSerializer::new())
551    }
552
553    fn serialize_tuple_struct(
554        self,
555        name: &'static str,
556        _len: usize,
557    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
558        Ok(TupleStructSerializer::new(name))
559    }
560
561    fn serialize_tuple_variant(
562        self,
563        _name: &'static str,
564        _variant_index: u32,
565        variant: &'static str,
566        _len: usize,
567    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
568        Ok(TupleVariantSerializer::new(variant))
569    }
570
571    fn serialize_map(
572        self,
573        _len: Option<usize>,
574    ) -> Result<Self::SerializeMap, Self::Error> {
575        Ok(MapSerializer::new())
576    }
577
578    fn serialize_struct_variant(
579        self,
580        _name: &'static str,
581        _variant_index: u32,
582        variant: &'static str,
583        _len: usize,
584    ) -> Result<Self::SerializeStructVariant, Self::Error> {
585        Ok(StructVariantSerializer::new(variant))
586    }
587
588    fn is_human_readable(&self) -> bool {
589        true
590    }
591}
592
593#[cfg(test)]
594mod tests {
595    use crate::assert_structural_eq;
596    use crate::serde::serializer::{
597        DatexSerializer, to_bytes, to_value_container,
598    };
599    use crate::traits::structural_eq::StructuralEq;
600    use crate::values::core_values::endpoint::Endpoint;
601    use crate::values::core_values::map::Map;
602
603    use crate::values::{
604        core_value::CoreValue, value::Value, value_container::ValueContainer,
605    };
606    use serde::{Deserialize, Serialize};
607    use std::assert_matches::assert_matches;
608
609    #[derive(Serialize)]
610    struct TestStruct {
611        field1: String,
612        field2: i32,
613    }
614
615    #[derive(Serialize)]
616    struct TestTupleStruct(String, i32);
617
618    #[derive(Serialize)]
619    struct UnitStruct;
620
621    #[derive(Serialize)]
622    enum TestEnum {
623        Unit,
624        Tuple(i32, String),
625        Struct { x: bool, y: f64 },
626    }
627
628    #[derive(Serialize)]
629    struct NestedStruct {
630        nested: TestStruct,
631        value: i32,
632    }
633
634    #[derive(Serialize)]
635    struct StructWithOption {
636        value: Option<i32>,
637    }
638
639    #[derive(Serialize)]
640    struct StructWithVec {
641        values: Vec<i32>,
642    }
643
644    #[derive(Serialize)]
645    struct TestStructWithEndpoint {
646        endpoint: Endpoint,
647    }
648
649    #[derive(Serialize, Deserialize, Debug)]
650    pub struct StructWithUSize {
651        pub usize: Option<usize>,
652    }
653
654    #[test]
655    fn datex_serializer() {
656        let mut serializer = DatexSerializer::new();
657        let test_struct = TestStruct {
658            field1: "Hello".to_string(),
659            field2: 42,
660        };
661        let value_container = test_struct.serialize(&mut serializer).unwrap();
662        assert_matches!(
663            value_container,
664            ValueContainer::Value(Value {
665                inner: CoreValue::Map(_),
666                ..
667            })
668        );
669    }
670
671    #[test]
672    fn r#struct() {
673        let test_struct = TestStruct {
674            field1: "Hello".to_string(),
675            field2: 42,
676        };
677        let result = to_value_container(&test_struct).unwrap();
678        assert_eq!(result.to_string(), r#"{"field1": "Hello", "field2": 42}"#);
679    }
680
681    #[test]
682    fn tuple_struct() {
683        let ts = TestTupleStruct("hi".to_string(), 99);
684        let result = to_value_container(&ts).unwrap();
685        assert_eq!(result.to_string(), r#"["hi", 99]"#);
686    }
687
688    #[test]
689    fn unit_struct() {
690        let us = UnitStruct;
691        let result = to_value_container(&us).unwrap();
692        assert_eq!(result.to_string(), r#"{}"#);
693    }
694
695    #[test]
696    fn enum_unit_variant() {
697        let e = TestEnum::Unit;
698        let result = to_value_container(&e).unwrap();
699        assert_eq!(result.to_string(), r#""Unit""#);
700    }
701
702    #[test]
703    fn enum_tuple_variant() {
704        let e = TestEnum::Tuple(42, "hello".to_string());
705        let result = to_value_container(&e).unwrap();
706        assert_eq!(result.to_string(), r#"{"Tuple": [42, "hello"]}"#);
707    }
708
709    #[test]
710    fn enum_struct_variant() {
711        let e = TestEnum::Struct { x: true, y: 3.5 };
712        let result = to_value_container(&e).unwrap();
713        assert_eq!(result.to_string(), r#"{"Struct": {"x": true, "y": 3.5}}"#);
714    }
715
716    #[test]
717    fn vec() {
718        let data = vec![10, 20, 30];
719        let result = to_value_container(&data).unwrap();
720        assert_eq!(result.to_string(), "[10, 20, 30]");
721    }
722
723    #[test]
724    fn tuple_array() {
725        let data = [1, 2, 3, 4];
726        let result = to_value_container(&data).unwrap();
727        assert_eq!(result.to_string(), "[1, 2, 3, 4]");
728    }
729
730    #[test]
731    fn nested_struct() {
732        let nested = NestedStruct {
733            nested: TestStruct {
734                field1: "A".to_string(),
735                field2: 1,
736            },
737            value: 99,
738        };
739        let result = to_value_container(&nested).unwrap();
740        assert_eq!(
741            result.to_string(),
742            r#"{"nested": {"field1": "A", "field2": 1}, "value": 99}"#
743        );
744    }
745
746    #[test]
747    fn struct_with_option_some() {
748        let s = StructWithOption { value: Some(42) };
749        let result = to_value_container(&s).unwrap();
750        assert_eq!(result.to_string(), r#"{"value": 42}"#);
751    }
752
753    #[test]
754    fn struct_with_option_none() {
755        let s = StructWithOption { value: None };
756        let result = to_value_container(&s).unwrap();
757        // None can serialize as null
758        assert_eq!(result.to_string(), r#"{"value": null}"#);
759    }
760
761    #[test]
762    fn struct_with_vec() {
763        let s = StructWithVec {
764            values: vec![1, 2, 3],
765        };
766        let result = to_value_container(&s).unwrap();
767        assert_eq!(result.to_string(), r#"{"values": [1, 2, 3]}"#);
768    }
769
770    #[test]
771    fn primitive_values() {
772        // integer
773        let i = 42;
774        let vc = to_value_container(&i).unwrap();
775        assert_eq!(vc.to_string(), "42");
776
777        // float
778        let f = 3.4;
779        let vc = to_value_container(&f).unwrap();
780        assert_eq!(vc.to_string(), "3.4");
781
782        // boolean
783        let b = true;
784        let vc = to_value_container(&b).unwrap();
785        assert_eq!(vc.to_string(), "true");
786
787        // string
788        let s = "test";
789        let vc = to_value_container(&s).unwrap();
790        assert_eq!(vc.to_string(), r#""test""#);
791    }
792
793    #[test]
794    fn array_serialization() {
795        let arr = vec![1, 2, 3];
796        let vc = to_value_container(&arr).unwrap();
797        assert_eq!(vc.to_string(), "[1, 2, 3]");
798    }
799
800    #[test]
801    fn serializer_into_inner_map() {
802        let mut serializer = DatexSerializer::new();
803        let s = TestStruct {
804            field1: "Hello".to_string(),
805            field2: 42,
806        };
807        let value_container = s.serialize(&mut serializer).unwrap();
808        assert_matches!(
809            value_container,
810            ValueContainer::Value(Value {
811                inner: CoreValue::Map(_),
812                ..
813            })
814        );
815    }
816
817    #[test]
818    fn struct_to_bytes() {
819        let test_struct = TestStruct {
820            field1: "Hello".to_string(),
821            field2: 42,
822        };
823        let result = to_bytes(&test_struct);
824        assert!(result.is_ok());
825        assert!(!result.unwrap().is_empty());
826    }
827
828    #[test]
829    fn to_bytes_with_struct_with_usize() {
830        let test_struct = StructWithUSize { usize: Some(42) };
831        let result = to_value_container(&test_struct);
832        assert!(result.is_ok());
833        let result = result.unwrap();
834        assert_structural_eq!(
835            result
836                .to_value()
837                .borrow()
838                .cast_to_map()
839                .unwrap()
840                .get_text("usize")
841                .unwrap(),
842            ValueContainer::from(42)
843        );
844    }
845
846    #[test]
847    fn endpoint() {
848        let script = "@test";
849        let result = to_value_container(&script).unwrap();
850        assert_eq!(result.to_string(), "\"@test\"");
851
852        let test_struct = TestStructWithEndpoint {
853            endpoint: Endpoint::new("@test"),
854        };
855
856        let result = to_value_container(&test_struct);
857        assert!(result.is_ok());
858        let result = result.unwrap();
859        let map = Map::Structural(vec![(
860            "endpoint".to_string(),
861            ValueContainer::from(Endpoint::new("@test")),
862        )]);
863        assert_eq!(result, ValueContainer::from(map));
864    }
865
866    #[derive(Serialize)]
867    struct MyNewtype(i32);
868
869    #[test]
870    fn newtype_struct() {
871        let my_newtype = MyNewtype(100);
872        let result = to_value_container(&my_newtype).unwrap();
873        assert_eq!(result.to_string(), r#"100"#);
874    }
875
876    #[derive(Serialize)]
877    struct StructType(i32, String, bool);
878    #[test]
879    fn newtype_struct_multiple_fields() {
880        let s = StructType(1, "test".to_string(), true);
881        let result = to_value_container(&s).unwrap();
882        assert_eq!(result.to_string(), r#"[1, "test", true]"#);
883    }
884
885    #[derive(Serialize)]
886    enum MyTaggedEnum {
887        Variant1 { x: i32, y: String },
888        Variant2(i32, String),
889        Empty,
890    }
891
892    #[test]
893    fn tagged_enum() {
894        let e = MyTaggedEnum::Variant1 {
895            x: 42,
896            y: "test".to_string(),
897        };
898        let result = to_value_container(&e).unwrap();
899        assert_eq!(
900            result.to_string(),
901            r#"{"Variant1": {"x": 42, "y": "test"}}"#
902        );
903
904        let e = MyTaggedEnum::Variant2(100, "hello".to_string());
905        let result = to_value_container(&e).unwrap();
906        assert_eq!(result.to_string(), r#"{"Variant2": [100, "hello"]}"#);
907
908        let e = MyTaggedEnum::Empty;
909        let result = to_value_container(&e).unwrap();
910        assert_eq!(result.to_string(), r#""Empty""#);
911    }
912}
datex_core/serde/serializer.rs

datex_core/serde/
serializer.rs
