fmi_schema/fmi3/variable/
model_variables.rs

1use super::{
2    AbstractVariableTrait, FmiBinary, FmiBoolean, FmiClock, FmiFloat32, FmiFloat64, FmiInt8,
3    FmiInt16, FmiInt32, FmiInt64, FmiString, FmiUInt8, FmiUInt16, FmiUInt32, FmiUInt64,
4    TypedArrayableVariableTrait,
5};
6
7#[derive(hard_xml::XmlRead, hard_xml::XmlWrite, Debug, PartialEq)]
8pub enum Variable {
9    #[xml(tag = "Int8")]
10    Int8(FmiInt8),
11    #[xml(tag = "UInt8")]
12    UInt8(FmiUInt8),
13    #[xml(tag = "Int16")]
14    Int16(FmiInt16),
15    #[xml(tag = "UInt16")]
16    UInt16(FmiUInt16),
17    #[xml(tag = "Int32")]
18    Int32(FmiInt32),
19    #[xml(tag = "UInt32")]
20    UInt32(FmiUInt32),
21    #[xml(tag = "Int64")]
22    Int64(FmiInt64),
23    #[xml(tag = "UInt64")]
24    UInt64(FmiUInt64),
25    #[xml(tag = "Float32")]
26    Float32(FmiFloat32),
27    #[xml(tag = "Float64")]
28    Float64(FmiFloat64),
29    #[xml(tag = "Boolean")]
30    Boolean(FmiBoolean),
31    #[xml(tag = "String")]
32    String(FmiString),
33    #[xml(tag = "Binary")]
34    Binary(FmiBinary),
35    #[xml(tag = "Clock")]
36    Clock(FmiClock),
37}
38
39#[derive(Debug, PartialEq, Default, hard_xml::XmlRead, hard_xml::XmlWrite)]
40#[xml(tag = "ModelVariables")]
41pub struct ModelVariables {
42    #[xml(
43        child = "Int8",
44        child = "UInt8",
45        child = "Int16",
46        child = "UInt16",
47        child = "Int32",
48        child = "UInt32",
49        child = "Int64",
50        child = "UInt64",
51        child = "Float32",
52        child = "Float64",
53        child = "Boolean",
54        child = "String",
55        child = "Binary",
56        child = "Clock"
57    )]
58    pub variables: Vec<Variable>,
59}
60
61impl ModelVariables {
62    /// Returns the total number of variables in the model description
63    pub fn len(&self) -> usize {
64        self.iter_abstract().count()
65    }
66
67    pub fn is_empty(&self) -> bool {
68        self.len() == 0
69    }
70
71    /// Returns an iterator over all the AbstractVariables in the model description
72    pub fn iter_abstract(&self) -> impl Iterator<Item = &dyn AbstractVariableTrait> {
73        self.variables.iter().map(|v| match v {
74            Variable::Int8(var) => var as &dyn AbstractVariableTrait,
75            Variable::UInt8(var) => var as &dyn AbstractVariableTrait,
76            Variable::Int16(var) => var as &dyn AbstractVariableTrait,
77            Variable::UInt16(var) => var as &dyn AbstractVariableTrait,
78            Variable::Int32(var) => var as &dyn AbstractVariableTrait,
79            Variable::UInt32(var) => var as &dyn AbstractVariableTrait,
80            Variable::Int64(var) => var as &dyn AbstractVariableTrait,
81            Variable::UInt64(var) => var as &dyn AbstractVariableTrait,
82            Variable::Float32(var) => var as &dyn AbstractVariableTrait,
83            Variable::Float64(var) => var as &dyn AbstractVariableTrait,
84            Variable::Boolean(var) => var as &dyn AbstractVariableTrait,
85            Variable::String(var) => var as &dyn AbstractVariableTrait,
86            Variable::Binary(var) => var as &dyn AbstractVariableTrait,
87            Variable::Clock(var) => var as &dyn AbstractVariableTrait,
88        })
89    }
90
91    /// Returns an iterator over all the float32 and float64 variables in the model description
92    pub fn iter_floating(&self) -> impl Iterator<Item = &dyn TypedArrayableVariableTrait> {
93        self.variables.iter().filter_map(|v| match v {
94            Variable::Float32(var) => Some(var as &dyn TypedArrayableVariableTrait),
95            Variable::Float64(var) => Some(var as &dyn TypedArrayableVariableTrait),
96            _ => None,
97        })
98    }
99
100    /// Finds a variable by its name.
101    pub fn find_by_name(&self, name: &str) -> Option<&dyn AbstractVariableTrait> {
102        self.iter_abstract().find(|v| v.name() == name)
103    }
104
105    /// Returns a vector of all Float32 variables
106    pub fn float32(&self) -> Vec<&FmiFloat32> {
107        self.variables
108            .iter()
109            .filter_map(|v| match v {
110                Variable::Float32(var) => Some(var),
111                _ => None,
112            })
113            .collect()
114    }
115
116    /// Returns a vector of all Float64 variables
117    pub fn float64(&self) -> Vec<&FmiFloat64> {
118        self.variables
119            .iter()
120            .filter_map(|v| match v {
121                Variable::Float64(var) => Some(var),
122                _ => None,
123            })
124            .collect()
125    }
126
127    /// Returns a vector of all Int8 variables
128    pub fn int8(&self) -> Vec<&FmiInt8> {
129        self.variables
130            .iter()
131            .filter_map(|v| match v {
132                Variable::Int8(var) => Some(var),
133                _ => None,
134            })
135            .collect()
136    }
137
138    /// Returns a vector of all UInt8 variables
139    pub fn uint8(&self) -> Vec<&FmiUInt8> {
140        self.variables
141            .iter()
142            .filter_map(|v| match v {
143                Variable::UInt8(var) => Some(var),
144                _ => None,
145            })
146            .collect()
147    }
148
149    /// Returns a vector of all Int16 variables
150    pub fn int16(&self) -> Vec<&FmiInt16> {
151        self.variables
152            .iter()
153            .filter_map(|v| match v {
154                Variable::Int16(var) => Some(var),
155                _ => None,
156            })
157            .collect()
158    }
159
160    /// Returns a vector of all UInt16 variables
161    pub fn uint16(&self) -> Vec<&FmiUInt16> {
162        self.variables
163            .iter()
164            .filter_map(|v| match v {
165                Variable::UInt16(var) => Some(var),
166                _ => None,
167            })
168            .collect()
169    }
170
171    /// Returns a vector of all Int32 variables
172    pub fn int32(&self) -> Vec<&FmiInt32> {
173        self.variables
174            .iter()
175            .filter_map(|v| match v {
176                Variable::Int32(var) => Some(var),
177                _ => None,
178            })
179            .collect()
180    }
181
182    /// Returns a vector of all UInt32 variables
183    pub fn uint32(&self) -> Vec<&FmiUInt32> {
184        self.variables
185            .iter()
186            .filter_map(|v| match v {
187                Variable::UInt32(var) => Some(var),
188                _ => None,
189            })
190            .collect()
191    }
192
193    /// Returns a vector of all Int64 variables
194    pub fn int64(&self) -> Vec<&FmiInt64> {
195        self.variables
196            .iter()
197            .filter_map(|v| match v {
198                Variable::Int64(var) => Some(var),
199                _ => None,
200            })
201            .collect()
202    }
203
204    /// Returns a vector of all UInt64 variables
205    pub fn uint64(&self) -> Vec<&FmiUInt64> {
206        self.variables
207            .iter()
208            .filter_map(|v| match v {
209                Variable::UInt64(var) => Some(var),
210                _ => None,
211            })
212            .collect()
213    }
214
215    /// Returns a vector of all Boolean variables
216    pub fn boolean(&self) -> Vec<&FmiBoolean> {
217        self.variables
218            .iter()
219            .filter_map(|v| match v {
220                Variable::Boolean(var) => Some(var),
221                _ => None,
222            })
223            .collect()
224    }
225
226    /// Returns a vector of all String variables
227    pub fn string(&self) -> Vec<&FmiString> {
228        self.variables
229            .iter()
230            .filter_map(|v| match v {
231                Variable::String(var) => Some(var),
232                _ => None,
233            })
234            .collect()
235    }
236
237    /// Returns a vector of all Binary variables
238    pub fn binary(&self) -> Vec<&FmiBinary> {
239        self.variables
240            .iter()
241            .filter_map(|v| match v {
242                Variable::Binary(var) => Some(var),
243                _ => None,
244            })
245            .collect()
246    }
247}
248
249/// Append a variable to the given `ModelVariables` struct
250pub trait AppendToModelVariables {
251    fn append_to_variables(self, variables: &mut ModelVariables);
252}
253
254impl AppendToModelVariables for FmiFloat32 {
255    fn append_to_variables(self, variables: &mut ModelVariables) {
256        variables.variables.push(Variable::Float32(self));
257    }
258}
259
260impl AppendToModelVariables for FmiFloat64 {
261    fn append_to_variables(self, variables: &mut ModelVariables) {
262        variables.variables.push(Variable::Float64(self));
263    }
264}
265
266impl AppendToModelVariables for FmiInt8 {
267    fn append_to_variables(self, variables: &mut ModelVariables) {
268        variables.variables.push(Variable::Int8(self));
269    }
270}
271
272impl AppendToModelVariables for FmiInt16 {
273    fn append_to_variables(self, variables: &mut ModelVariables) {
274        variables.variables.push(Variable::Int16(self));
275    }
276}
277
278impl AppendToModelVariables for FmiInt32 {
279    fn append_to_variables(self, variables: &mut ModelVariables) {
280        variables.variables.push(Variable::Int32(self));
281    }
282}
283
284impl AppendToModelVariables for FmiInt64 {
285    fn append_to_variables(self, variables: &mut ModelVariables) {
286        variables.variables.push(Variable::Int64(self));
287    }
288}
289
290impl AppendToModelVariables for FmiUInt8 {
291    fn append_to_variables(self, variables: &mut ModelVariables) {
292        variables.variables.push(Variable::UInt8(self));
293    }
294}
295
296impl AppendToModelVariables for FmiUInt16 {
297    fn append_to_variables(self, variables: &mut ModelVariables) {
298        variables.variables.push(Variable::UInt16(self));
299    }
300}
301
302impl AppendToModelVariables for FmiUInt32 {
303    fn append_to_variables(self, variables: &mut ModelVariables) {
304        variables.variables.push(Variable::UInt32(self));
305    }
306}
307
308impl AppendToModelVariables for FmiUInt64 {
309    fn append_to_variables(self, variables: &mut ModelVariables) {
310        variables.variables.push(Variable::UInt64(self));
311    }
312}
313
314impl AppendToModelVariables for FmiBoolean {
315    fn append_to_variables(self, variables: &mut ModelVariables) {
316        variables.variables.push(Variable::Boolean(self));
317    }
318}
319
320impl AppendToModelVariables for FmiString {
321    fn append_to_variables(self, variables: &mut ModelVariables) {
322        variables.variables.push(Variable::String(self));
323    }
324}
325
326impl AppendToModelVariables for FmiBinary {
327    fn append_to_variables(self, variables: &mut ModelVariables) {
328        variables.variables.push(Variable::Binary(self));
329    }
330}
331
332impl AppendToModelVariables for FmiClock {
333    fn append_to_variables(self, variables: &mut ModelVariables) {
334        variables.variables.push(Variable::Clock(self));
335    }
336}
fmi_schema/fmi3/variable/model_variables.rs

fmi_schema/fmi3/variable/
model_variables.rs
