fmi-rs 0.1.0

Functional Mock-up Interface (FMI) for Rust
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals)]

mod file;
pub mod fmi2;
pub mod fmi3;
pub mod validation;

use std::{ops::Range, path::Path};
use thiserror::Error;

/// Represents a problem found during model description validation.
#[derive(Debug)]
pub struct ValidationError {
    pub range: Vec<Range<usize>>,
    pub message: String,
}

#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
pub enum FMIMajorVersion {
    V2 = 2,
    V3 = 3,
}

#[derive(Error, Debug)]
pub enum ModelDescriptionError {
    #[error("Failed to open the file")]
    Io(#[from] std::io::Error),

    #[error("{0}")]
    Parse(String),

    #[error("Missing attribute '{0}'")]
    MissingAttribute(String),

    #[error("Unsupported FMI version '{0}'")]
    UnsupportedVersion(String),

    #[error("Unknown FMI version '{0}'")]
    UnknownVersion(String),

    #[error("Illegal value reference: {0}")]
    ValueReference(u32),

    #[error("Illegal variable index: {0}")]
    VariableIndex(u32),

    #[error("Illegal variable name: {0}")]
    VariableName(String),
}

#[derive(Debug)]
pub struct Unit {
    pub name: String,
    pub baseUnit: Option<BaseUnit>,
    pub displayUnits: Vec<DisplayUnit>,
    pub range: Range<usize>,
}

#[derive(Debug)]
pub struct DisplayUnit {
    pub name: String,
    pub factor: f64,
    pub offset: f64,
    pub inverse: bool,
    pub range: Range<usize>,
}

#[derive(Debug)]
pub struct BaseUnit {
    pub kg: i32,
    pub m: i32,
    pub s: i32,
    pub A: i32,
    pub K: i32,
    pub mol: i32,
    pub cd: i32,
    pub rad: i32,
    pub factor: f64,
    pub offset: f64,
    pub range: Range<usize>,
}

#[derive(Debug)]
pub struct Category {
    pub name: String,
    pub description: Option<String>,
}

#[derive(Debug)]
pub struct DefaultExperiment {
    pub startTime: Option<String>,
    pub stopTime: Option<String>,
    pub tolerance: Option<String>,
    pub stepSize: Option<String>,
    pub range: Range<usize>,
}

pub fn peek_fmi_version(path: &Path) -> Result<String, ModelDescriptionError> {
    let text = std::fs::read_to_string(path)?;

    let opt = roxmltree::ParsingOptions {
        allow_dtd: true,
        ..roxmltree::ParsingOptions::default()
    };

    let doc = roxmltree::Document::parse_with_options(&text, opt)
        .map_err(|err| ModelDescriptionError::Parse(err.to_string()))?;

    let root = doc.root_element();

    if let Some(fmi_version) = root.attribute("fmiVersion") {
        Ok(fmi_version.to_string())
    } else {
        Err(ModelDescriptionError::MissingAttribute(
            "fmiVersion".to_string(),
        ))
    }
}

pub fn peek_fmi_major_version(path: &Path) -> Result<FMIMajorVersion, ModelDescriptionError> {
    let fmi_version = peek_fmi_version(path)?;

    if fmi_version == "1.0" {
        Err(ModelDescriptionError::UnsupportedVersion(fmi_version))
    } else if fmi_version == "2.0" {
        Ok(FMIMajorVersion::V2)
    } else if fmi_version.starts_with("3.") {
        Ok(FMIMajorVersion::V3)
    } else {
        Err(ModelDescriptionError::UnknownVersion(fmi_version))
    }
}