datex_core/dif/
mod.rs

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

datex_core/dif/
mod.rs
