datex_core/dif/
mod.rs

1use serde::{Deserialize, Serialize};
2
3pub mod interface;
4pub mod reference;
5pub mod representation;
6pub mod r#type;
7pub mod update;
8pub mod value;
9
10pub trait DIFConvertible: Serialize + for<'de> Deserialize<'de> {
11    fn to_json(self) -> String {
12        self.as_json()
13    }
14    fn to_json_pretty(self) -> String {
15        self.as_json_pretty()
16    }
17    fn from_json(json: &str) -> Self {
18        serde_json::from_str(json).unwrap()
19    }
20    fn as_json(&self) -> String {
21        serde_json::to_string(self).unwrap()
22    }
23    fn as_json_pretty(&self) -> String {
24        serde_json::to_string_pretty(self).unwrap()
25    }
26}
27
28#[cfg(test)]
29mod tests {
30    use crate::dif::DIFConvertible;
31    use crate::dif::update::DIFUpdateData;
32    use crate::dif::value::DIFValueContainer;
33    use crate::runtime::memory::Memory;
34    use crate::{
35        dif::{
36            representation::DIFValueRepresentation,
37            r#type::{DIFType, DIFTypeContainer},
38            value::DIFValue,
39        },
40        libs::core::CoreLibPointerId,
41        values::{
42            core_values::integer::typed_integer::IntegerTypeVariant,
43            value_container::ValueContainer,
44        },
45    };
46    use datex_core::dif::r#type::DIFTypeDefinition;
47    use datex_core::values::core_values::endpoint::Endpoint;
48    use std::cell::RefCell;
49
50    fn dif_value_circle(value_container: ValueContainer) -> DIFValueContainer {
51        let memory = RefCell::new(Memory::new(Endpoint::default()));
52        let dif_value_container: DIFValueContainer =
53            DIFValueContainer::from_value_container(&value_container, &memory);
54        let serialized = dif_value_container.as_json();
55        let deserialized: DIFValueContainer =
56            DIFValueContainer::from_json(&serialized);
57        assert_eq!(dif_value_container, deserialized);
58        dif_value_container
59    }
60
61    #[test]
62    fn serde() {
63        // replace
64        let dif_update =
65            DIFUpdateData::replace(DIFValueContainer::Value(DIFValue {
66                value: DIFValueRepresentation::String("Hello".to_string()),
67                r#type: None,
68            }));
69        let serialized = dif_update.as_json();
70        println!("Serialized DIFUpdate: {}", serialized);
71        let deserialized: DIFUpdateData = DIFUpdateData::from_json(&serialized);
72        assert_eq!(dif_update, deserialized);
73
74        // update property
75        let dif_update = DIFUpdateData::set(
76            "name",
77            DIFValueContainer::Value(DIFValue {
78                value: DIFValueRepresentation::Number(42.0),
79                r#type: None,
80            }),
81        );
82        let serialized = dif_update.as_json();
83        println!("Serialized DIFUpdate: {}", serialized);
84        let deserialized: DIFUpdateData = DIFUpdateData::from_json(&serialized);
85        assert_eq!(dif_update, deserialized);
86    }
87
88    #[test]
89    fn dif_value_serialization() {
90        let value = DIFValue {
91            value: DIFValueRepresentation::Null,
92            r#type: Some(
93                DIFType {
94                    mutability: None,
95                    name: None,
96                    type_definition: DIFTypeDefinition::Unit,
97                }
98                .as_container(),
99            ),
100        };
101        let serialized = value.as_json();
102        println!("Serialized DIFValue: {}", serialized);
103        let deserialized = DIFValue::from_json(&serialized);
104        assert_eq!(value, deserialized);
105    }
106
107    #[test]
108    fn from_value_container_i32() {
109        let dif_value_container = dif_value_circle(ValueContainer::from(42i32));
110        if let DIFValueContainer::Value(dif_value) = &dif_value_container {
111            assert_eq!(dif_value.value, DIFValueRepresentation::Number(42f64));
112            assert_eq!(
113                dif_value.r#type,
114                Some(DIFTypeContainer::Reference(
115                    CoreLibPointerId::Integer(Some(IntegerTypeVariant::I32))
116                        .into()
117                ))
118            );
119        } else {
120            panic!("Expected DIFValueContainer::Value variant");
121        }
122    }
123
124    #[test]
125    fn from_value_container_text() {
126        let dif_value_container =
127            dif_value_circle(ValueContainer::from("Hello, World!"));
128        if let DIFValueContainer::Value(dif_value) = &dif_value_container {
129            assert_eq!(
130                dif_value.value,
131                DIFValueRepresentation::String("Hello, World!".to_string())
132            );
133            assert_eq!(dif_value.r#type, None);
134        } else {
135            panic!("Expected DIFValueContainer::Value variant");
136        }
137    }
138}
datex_core/dif/mod.rs

datex_core/dif/
mod.rs
