datex_core/serde/
serializer.rs

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

datex_core/serde/
serializer.rs
