fmi-schema 0.7.0

XML schema support for FMI 2.0 and 3.0
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use super::attribute_groups::{IntegerAttributes, RealAttributes};

#[derive(Debug, PartialEq, hard_xml::XmlRead, hard_xml::XmlWrite)]
pub enum SimpleTypeElement {
    #[xml(tag = "Real")]
    Real(RealAttributes),
    #[xml(tag = "Integer")]
    Integer(IntegerAttributes),
    #[xml(tag = "Boolean")]
    Boolean,
    #[xml(tag = "String")]
    String,
    #[xml(tag = "Enumeration")]
    Enumeration,
}

impl Default for SimpleTypeElement {
    fn default() -> Self {
        Self::Real(RealAttributes::default())
    }
}

#[derive(Default, Debug, PartialEq, hard_xml::XmlRead, hard_xml::XmlWrite)]
#[xml(tag = "SimpleType", strict(unknown_attribute, unknown_element))]
/// Type attributes of a scalar variable
pub struct SimpleType {
    /// Name of SimpleType element. "name" must be unique with respect to all other elements of the
    /// TypeDefinitions list. Furthermore, "name" of a SimpleType must be different to all
    /// "name"s of ScalarVariable.
    #[xml(attr = "name")]
    pub name: String,

    /// Description of the SimpleType
    #[xml(attr = "description")]
    pub description: Option<String>,

    #[xml(
        child = "Real",
        child = "Integer",
        child = "Boolean",
        child = "String",
        child = "Enumeration"
    )]
    pub elem: SimpleTypeElement,
}

#[cfg(test)]
mod tests {
    use hard_xml::XmlRead;

    use crate::fmi2::{RealAttributes, SimpleTypeElement};

    use super::SimpleType;

    #[test]
    fn test_simple_type() {
        let xml = r#"
        <SimpleType name="Acceleration">
            <Real quantity="Acceleration" unit="m/s2"/>
        </SimpleType>"#;

        let simple_type = SimpleType::from_str(xml).unwrap();
        assert_eq!(simple_type.name, "Acceleration");
        assert_eq!(simple_type.description, None);
        assert_eq!(
            simple_type.elem,
            SimpleTypeElement::Real(RealAttributes {
                quantity: Some("Acceleration".to_owned()),
                unit: Some("m/s2".to_owned()),
                ..Default::default()
            })
        );
    }
}