autosar_data_abstraction/arpackage.rs
1use autosar_data::{AutosarModel, Element, ElementName};
2
3use crate::{
4 AbstractionElement, AutosarAbstractionError, ByteOrder, IdentifiableAbstractionElement, System, SystemCategory,
5 abstraction_element,
6 communication::{
7 DataTransformationSet, RequestResponseDelay, SomeipSdClientEventGroupTimingConfig,
8 SomeipSdClientServiceInstanceConfig, SomeipSdServerEventGroupTimingConfig, SomeipSdServerServiceInstanceConfig,
9 SystemSignal, SystemSignalGroup,
10 },
11 datatype::{
12 ApplicationArrayDataType, ApplicationArraySize, ApplicationDataType, ApplicationPrimitiveCategory,
13 ApplicationPrimitiveDataType, ApplicationRecordDataType, BaseTypeEncoding, CompuMethod, CompuMethodContent,
14 ConstantSpecification, DataConstr, DataTypeMappingSet, ImplementationDataType, ImplementationDataTypeSettings,
15 SwBaseType, Unit, ValueSpecification,
16 },
17 ecu_configuration::{
18 EcucDefinitionCollection, EcucDestinationUriDefSet, EcucModuleConfigurationValues, EcucModuleDef,
19 EcucValueCollection,
20 },
21 software_component::{
22 ApplicationSwComponentType, ClientServerInterface, ComplexDeviceDriverSwComponentType,
23 CompositionSwComponentType, EcuAbstractionSwComponentType, ModeDeclarationGroup, ModeDeclarationGroupCategory,
24 ModeSwitchInterface, NvDataInterface, ParameterInterface, SenderReceiverInterface,
25 SensorActuatorSwComponentType, ServiceSwComponentType, TriggerInterface,
26 },
27};
28
29/// An `ArPackage` is an Autosar package, which can contain other packages or elements
30#[derive(Debug, Clone, PartialEq, Eq, Hash)]
31pub struct ArPackage(Element);
32abstraction_element!(ArPackage, ArPackage);
33impl IdentifiableAbstractionElement for ArPackage {}
34
35impl ArPackage {
36 /// Get or create an autosar package for the given path
37 ///
38 /// # Example
39 ///
40 /// ```
41 /// # use autosar_data::*;
42 /// # use autosar_data_abstraction::*;
43 /// # fn main() -> Result<(), AutosarAbstractionError> {
44 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
45 /// let package = model.get_or_create_package("/pkg1")?;
46 /// # Ok(())}
47 /// ```
48 ///
49 /// # Errors
50 ///
51 /// - [`AutosarAbstractionError::InvalidPath`] The value in `package_path` was not an Autosar path
52 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model
53 pub(crate) fn get_or_create(model: &AutosarModel, package_path: &str) -> Result<Self, AutosarAbstractionError> {
54 if let Some(pkg_elem) = model.get_element_by_path(package_path) {
55 pkg_elem.try_into()
56 } else {
57 let mut parts_iter = package_path.split('/');
58 if !parts_iter.next().unwrap_or("-").is_empty() {
59 return Err(AutosarAbstractionError::InvalidPath(package_path.to_string()));
60 }
61 let mut pkg_elem = model.root_element();
62 for part in parts_iter {
63 pkg_elem = pkg_elem
64 .get_or_create_sub_element(ElementName::ArPackages)?
65 .get_or_create_named_sub_element(ElementName::ArPackage, part)?;
66 }
67 pkg_elem.try_into()
68 }
69 }
70
71 /// create a new `ApplicationArrayDataType` in the package
72 ///
73 /// # Example
74 ///
75 /// ```
76 /// # use autosar_data::*;
77 /// # use autosar_data_abstraction::{*, datatype::*};
78 /// # fn main() -> Result<(), AutosarAbstractionError> {
79 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
80 /// let package = model.get_or_create_package("/some/package")?;
81 /// let element_type = package.create_application_primitive_data_type("ElementType", ApplicationPrimitiveCategory::Value, None, None, None)?;
82 /// let data_type = package.create_application_array_data_type("ArrayDataType", &element_type, ApplicationArraySize::Fixed(4))?;
83 /// assert!(model.get_element_by_path("/some/package/ArrayDataType").is_some());
84 /// # Ok(())}
85 /// ```
86 ///
87 /// # Errors
88 ///
89 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the APPLICATION-ARRAY-DATA-TYPE element
90 pub fn create_application_array_data_type<T: Into<ApplicationDataType> + AbstractionElement>(
91 &self,
92 name: &str,
93 element_type: &T,
94 size: ApplicationArraySize,
95 ) -> Result<ApplicationArrayDataType, AutosarAbstractionError> {
96 ApplicationArrayDataType::new(name, self, element_type, size)
97 }
98
99 /// create a new `ApplicationPrimitiveDataType` in the package
100 ///
101 /// # Example
102 ///
103 /// ```
104 /// # use autosar_data::*;
105 /// # use autosar_data_abstraction::{*, datatype::*};
106 /// # fn main() -> Result<(), AutosarAbstractionError> {
107 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
108 /// let package = model.get_or_create_package("/some/package")?;
109 /// let data_type = package.create_application_primitive_data_type("ApplicationPrimitiveDataType", ApplicationPrimitiveCategory::Value, None, None, None)?;
110 /// assert!(model.get_element_by_path("/some/package/ApplicationPrimitiveDataType").is_some());
111 /// # Ok(())}
112 /// ```
113 ///
114 /// # Errors
115 ///
116 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the APPLICATION-PRIMITIVE-DATA-TYPE element
117 pub fn create_application_primitive_data_type(
118 &self,
119 name: &str,
120 category: ApplicationPrimitiveCategory,
121 compu_method: Option<&CompuMethod>,
122 unit: Option<&Unit>,
123 data_constraint: Option<&DataConstr>,
124 ) -> Result<ApplicationPrimitiveDataType, AutosarAbstractionError> {
125 ApplicationPrimitiveDataType::new(name, self, category, compu_method, unit, data_constraint)
126 }
127
128 /// create a new `ApplicationRecordDataType` in the package
129 ///
130 /// # Example
131 ///
132 /// ```
133 /// # use autosar_data::*;
134 /// # use autosar_data_abstraction::{*, datatype::*};
135 /// # fn main() -> Result<(), AutosarAbstractionError> {
136 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
137 /// let package = model.get_or_create_package("/some/package")?;
138 /// let data_type = package.create_application_record_data_type("ApplicationRecordDataType")?;
139 /// assert!(model.get_element_by_path("/some/package/ApplicationRecordDataType").is_some());
140 /// # Ok(())}
141 /// ```
142 ///
143 /// # Errors
144 ///
145 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the APPLICATION-RECORD-DATA-TYPE element
146 pub fn create_application_record_data_type(
147 &self,
148 name: &str,
149 ) -> Result<ApplicationRecordDataType, AutosarAbstractionError> {
150 ApplicationRecordDataType::new(name, self)
151 }
152
153 /// create a new `ApplicationSwComponentType` in the package
154 ///
155 /// # Example
156 ///
157 /// ```
158 /// # use autosar_data::*;
159 /// # use autosar_data_abstraction::*;
160 /// # fn main() -> Result<(), AutosarAbstractionError> {
161 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
162 /// let package = model.get_or_create_package("/some/package")?;
163 /// let component = package.create_application_sw_component_type("MyComponent")?;
164 /// assert!(model.get_element_by_path("/some/package/MyComponent").is_some());
165 /// # Ok(())}
166 /// ```
167 ///
168 /// # Errors
169 ///
170 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the APPLICATION-SW-COMPONENT-TYPE element
171 pub fn create_application_sw_component_type(
172 &self,
173 name: &str,
174 ) -> Result<ApplicationSwComponentType, AutosarAbstractionError> {
175 ApplicationSwComponentType::new(name, self)
176 }
177
178 /// create a new `ClientServerInterface` in the package
179 ///
180 /// # Example
181 ///
182 /// ```
183 /// # use autosar_data::*;
184 /// # use autosar_data_abstraction::*;
185 /// # fn main() -> Result<(), AutosarAbstractionError> {
186 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
187 /// let package = model.get_or_create_package("/some/package")?;
188 /// let interface = package.create_client_server_interface("ClientServerInterface")?;
189 /// assert!(model.get_element_by_path("/some/package/ClientServerInterface").is_some());
190 /// # Ok(())}
191 /// ```
192 ///
193 /// # Errors
194 ///
195 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the CLIENT-SERVER-INTERFACE element
196 pub fn create_client_server_interface(&self, name: &str) -> Result<ClientServerInterface, AutosarAbstractionError> {
197 ClientServerInterface::new(name, self)
198 }
199
200 /// create a new `ComplexDeviceDriverSwComponentType` in the package
201 ///
202 /// # Example
203 ///
204 /// ```
205 /// # use autosar_data::*;
206 /// # use autosar_data_abstraction::*;
207 /// # fn main() -> Result<(), AutosarAbstractionError> {
208 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
209 /// let package = model.get_or_create_package("/some/package")?;
210 /// let component = package.create_complex_device_driver_sw_component_type("ComplexDeviceDriverSwComponentType")?;
211 /// assert!(model.get_element_by_path("/some/package/ComplexDeviceDriverSwComponentType").is_some());
212 /// # Ok(())}
213 /// ```
214 ///
215 /// # Errors
216 ///
217 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the COMPLEX-DEVICE-DRIVER-SW-COMPONENT-TYPE element
218 pub fn create_complex_device_driver_sw_component_type(
219 &self,
220 name: &str,
221 ) -> Result<ComplexDeviceDriverSwComponentType, AutosarAbstractionError> {
222 ComplexDeviceDriverSwComponentType::new(name, self)
223 }
224
225 /// create a new `CompositionSwComponentType` in the package
226 ///
227 /// # Example
228 ///
229 /// ```
230 /// # use autosar_data::*;
231 /// # use autosar_data_abstraction::*;
232 /// # fn main() -> Result<(), AutosarAbstractionError> {
233 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
234 /// let package = model.get_or_create_package("/some/package")?;
235 /// let component = package.create_composition_sw_component_type("CompositionSwComponentType")?;
236 /// assert!(model.get_element_by_path("/some/package/CompositionSwComponentType").is_some());
237 /// # Ok(())}
238 /// ```
239 ///
240 /// # Errors
241 ///
242 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the COMPOSITION-SW-COMPONENT-TYPE element
243 pub fn create_composition_sw_component_type(
244 &self,
245 name: &str,
246 ) -> Result<CompositionSwComponentType, AutosarAbstractionError> {
247 CompositionSwComponentType::new(name, self)
248 }
249
250 /// create a new `CompuMethod` in the package
251 ///
252 /// # Example
253 ///
254 /// ```
255 /// # use autosar_data::*;
256 /// # use autosar_data_abstraction::{*, datatype::*};
257 /// # fn main() -> Result<(), AutosarAbstractionError> {
258 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
259 /// let package = model.get_or_create_package("/some/package")?;
260 /// let compu_content = CompuMethodContent::Linear(CompuMethodLinearContent {
261 /// direction: CompuScaleDirection::IntToPhys,
262 /// offset: 0.0,
263 /// factor: 1.0,
264 /// divisor: 1.0,
265 /// lower_limit: None,
266 /// upper_limit: None,
267 /// });
268 /// let compu_method = package.create_compu_method("CompuMethod", compu_content)?;
269 /// assert!(model.get_element_by_path("/some/package/CompuMethod").is_some());
270 /// # Ok(())}
271 /// ```
272 ///
273 /// # Errors
274 ///
275 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the COMPU-METHOD element
276 pub fn create_compu_method(
277 &self,
278 name: &str,
279 content: CompuMethodContent,
280 ) -> Result<CompuMethod, AutosarAbstractionError> {
281 CompuMethod::new(name, self, content)
282 }
283
284 /// create a new `ConstantSpecification` in the package
285 ///
286 /// # Example
287 ///
288 /// ```
289 /// # use autosar_data::*;
290 /// # use autosar_data_abstraction::{*, datatype::*};
291 /// # fn main() -> Result<(), AutosarAbstractionError> {
292 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
293 /// let package = model.get_or_create_package("/some/package")?;
294 /// let value = NumericalValueSpecification {
295 /// label: None,
296 /// value: 42.0,
297 /// };
298 /// let compu_method = package.create_constant_specification("CompuMethod", value)?;
299 /// assert!(model.get_element_by_path("/some/package/CompuMethod").is_some());
300 /// # Ok(())}
301 /// ```
302 ///
303 /// # Errors
304 ///
305 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the CONSTANT-SPECIFICATION element
306 pub fn create_constant_specification<T: Into<ValueSpecification>>(
307 &self,
308 name: &str,
309 value: T,
310 ) -> Result<ConstantSpecification, AutosarAbstractionError> {
311 ConstantSpecification::new(name, self, value.into())
312 }
313
314 /// create a new `DataConstr` in the package
315 ///
316 /// # Example
317 ///
318 /// ```
319 /// # use autosar_data::*;
320 /// # use autosar_data_abstraction::{*, datatype::*};
321 /// # fn main() -> Result<(), AutosarAbstractionError> {
322 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
323 /// let package = model.get_or_create_package("/some/package")?;
324 /// let data_constr = package.create_data_constr("DataConstr")?;
325 /// assert!(model.get_element_by_path("/some/package/DataConstr").is_some());
326 /// # Ok(())}
327 /// ```
328 ///
329 /// # Errors
330 ///
331 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the DATA-CONSTR element
332 pub fn create_data_constr(&self, name: &str) -> Result<DataConstr, AutosarAbstractionError> {
333 DataConstr::new(name, self)
334 }
335
336 /// create a new `DataTransformationSet` in the package
337 ///
338 /// # Example
339 ///
340 /// ```
341 /// # use autosar_data::*;
342 /// # use autosar_data_abstraction::*;
343 /// # fn main() -> Result<(), AutosarAbstractionError> {
344 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
345 /// let package = model.get_or_create_package("/some/package")?;
346 /// let transformation_set = package.create_data_transformation_set("DataTransformationSet")?;
347 /// assert!(model.get_element_by_path("/some/package/DataTransformationSet").is_some());
348 /// # Ok(())}
349 /// ```
350 ///
351 /// # Errors
352 ///
353 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the DATA-TRANSFORMATION-SET element
354 pub fn create_data_transformation_set(&self, name: &str) -> Result<DataTransformationSet, AutosarAbstractionError> {
355 DataTransformationSet::new(name, self)
356 }
357
358 /// create a new `DataTypeMappingSet` in the package
359 ///
360 /// # Example
361 ///
362 /// ```
363 /// # use autosar_data::*;
364 /// # use autosar_data_abstraction::*;
365 /// # fn main() -> Result<(), AutosarAbstractionError> {
366 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
367 /// let package = model.get_or_create_package("/some/package")?;
368 /// let mapping_set = package.create_data_type_mapping_set("DataTypeMappingSet")?;
369 /// assert!(model.get_element_by_path("/some/package/DataTypeMappingSet").is_some());
370 /// # Ok(())}
371 /// ```
372 ///
373 /// # Errors
374 ///
375 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the DATA-TYPE-MAPPING-SET element
376 pub fn create_data_type_mapping_set(&self, name: &str) -> Result<DataTypeMappingSet, AutosarAbstractionError> {
377 DataTypeMappingSet::new(name, self)
378 }
379
380 /// create a new `EcuAbstractionSwComponentType` in the package
381 ///
382 /// # Example
383 ///
384 /// ```
385 /// # use autosar_data::*;
386 /// # use autosar_data_abstraction::*;
387 /// # fn main() -> Result<(), AutosarAbstractionError> {
388 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
389 /// let package = model.get_or_create_package("/some/package")?;
390 /// let component = package.create_ecu_abstraction_sw_component_type("EcuAbstractionSwComponentType")?;
391 /// assert!(model.get_element_by_path("/some/package/EcuAbstractionSwComponentType").is_some());
392 /// # Ok(())}
393 /// ```
394 ///
395 /// # Errors
396 ///
397 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the ECU-ABSTRACTION-SW-COMPONENT-TYPE element
398 pub fn create_ecu_abstraction_sw_component_type(
399 &self,
400 name: &str,
401 ) -> Result<EcuAbstractionSwComponentType, AutosarAbstractionError> {
402 EcuAbstractionSwComponentType::new(name, self)
403 }
404
405 /// create a new `EcucDefinitionCollection` in the package
406 ///
407 /// # Example
408 ///
409 /// ```
410 /// # use autosar_data::*;
411 /// # use autosar_data_abstraction::*;
412 /// # fn main() -> Result<(), AutosarAbstractionError> {
413 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::LATEST);
414 /// let package = model.get_or_create_package("/pkg")?;
415 /// let definition_collection = package.create_ecuc_definition_collection("DefinitionCollection")?;
416 /// assert!(model.get_element_by_path("/pkg/DefinitionCollection").is_some());
417 /// # Ok(())}
418 /// ```
419 ///
420 /// # Errors
421 ///
422 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model
423 pub fn create_ecuc_definition_collection(
424 &self,
425 name: &str,
426 ) -> Result<EcucDefinitionCollection, AutosarAbstractionError> {
427 EcucDefinitionCollection::new(name, self)
428 }
429
430 /// create a new `EcucDestinationUriDefSet` in the package
431 ///
432 /// # Example
433 ///
434 /// ```
435 /// # use autosar_data::*;
436 /// # use autosar_data_abstraction::*;
437 /// # fn main() -> Result<(), AutosarAbstractionError> {
438 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::LATEST);
439 /// let package = model.get_or_create_package("/pkg")?;
440 /// let uri_def_set = package.create_ecuc_destination_uri_def_set("DestinationUriDefSet")?;
441 /// assert!(model.get_element_by_path("/pkg/DestinationUriDefSet").is_some());
442 /// # Ok(())}
443 /// ```
444 ///
445 /// # Errors
446 ///
447 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model
448 pub fn create_ecuc_destination_uri_def_set(
449 &self,
450 name: &str,
451 ) -> Result<EcucDestinationUriDefSet, AutosarAbstractionError> {
452 EcucDestinationUriDefSet::new(name, self)
453 }
454
455 /// create a new `EcucModuleConfigurationValues` in the package
456 ///
457 /// # Example
458 ///
459 /// ```
460 /// # use autosar_data::*;
461 /// # use autosar_data_abstraction::*;
462 /// # fn main() -> Result<(), AutosarAbstractionError> {
463 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::LATEST);
464 /// let package = model.get_or_create_package("/pkg")?;
465 /// # let module_definition = package.create_ecuc_module_def("ModuleDef")?;
466 /// let module_config = package.create_ecuc_module_configuration_values("ModuleConfig", &module_definition)?;
467 /// assert!(model.get_element_by_path("/pkg/ModuleConfig").is_some());
468 /// # Ok(())}
469 /// ```
470 ///
471 /// # Errors
472 ///
473 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model
474 pub fn create_ecuc_module_configuration_values(
475 &self,
476 name: &str,
477 definition: &EcucModuleDef,
478 ) -> Result<EcucModuleConfigurationValues, AutosarAbstractionError> {
479 EcucModuleConfigurationValues::new(name, self, definition)
480 }
481
482 /// create a new `EcucModuleDef` in the package
483 ///
484 /// # Example
485 ///
486 /// ```
487 /// # use autosar_data::*;
488 /// # use autosar_data_abstraction::*;
489 /// # fn main() -> Result<(), AutosarAbstractionError> {
490 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::LATEST);
491 /// let package = model.get_or_create_package("/pkg")?;
492 /// let bsw_module = package.create_ecuc_module_def("BswModule")?;
493 /// assert!(model.get_element_by_path("/pkg/BswModule").is_some());
494 /// # Ok(())}
495 /// ```
496 ///
497 /// # Errors
498 ///
499 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model
500 pub fn create_ecuc_module_def(&self, name: &str) -> Result<EcucModuleDef, AutosarAbstractionError> {
501 EcucModuleDef::new(name, self)
502 }
503
504 /// create a new `EcucValueCollection` in the package
505 ///
506 /// # Example
507 ///
508 /// ```
509 /// # use autosar_data::*;
510 /// # use autosar_data_abstraction::*;
511 /// # fn main() -> Result<(), AutosarAbstractionError> {
512 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::LATEST);
513 /// let package = model.get_or_create_package("/pkg")?;
514 /// let value_collection = package.create_ecuc_value_collection("ValueCollection")?;
515 /// assert!(model.get_element_by_path("/pkg/ValueCollection").is_some());
516 /// # Ok(())}
517 /// ```
518 ///
519 /// # Errors
520 ///
521 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model
522 pub fn create_ecuc_value_collection(&self, name: &str) -> Result<EcucValueCollection, AutosarAbstractionError> {
523 EcucValueCollection::new(name, self)
524 }
525
526 /// create a new `ImplementationDataType` in the package
527 ///
528 /// # Example
529 ///
530 /// ```
531 /// # use autosar_data::*;
532 /// # use autosar_data_abstraction::{*, datatype::*};
533 /// # fn main() -> Result<(), AutosarAbstractionError> {
534 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
535 /// let package = model.get_or_create_package("/some/package")?;
536 /// let sw_base_type = package.create_sw_base_type("uint8", 8, BaseTypeEncoding::None, None, None, None)?;
537 /// let settings = ImplementationDataTypeSettings::Value {
538 /// name: "ImplementationDataType_Value".to_string(),
539 /// base_type: sw_base_type,
540 /// compu_method: None,
541 /// data_constraint: None,
542 /// };
543 /// let data_type = package.create_implementation_data_type(&settings)?;
544 /// assert!(model.get_element_by_path("/some/package/ImplementationDataType_Value").is_some());
545 /// # Ok(())}
546 /// ```
547 ///
548 /// # Errors
549 ///
550 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the IMPLEMENTATION-DATA-TYPE element
551 pub fn create_implementation_data_type(
552 &self,
553 settings: &ImplementationDataTypeSettings,
554 ) -> Result<ImplementationDataType, AutosarAbstractionError> {
555 ImplementationDataType::new(self, settings)
556 }
557
558 /// create a new `ModeDeclarationGroup` in the package
559 ///
560 /// # Example
561 ///
562 /// ```
563 /// # use autosar_data::*;
564 /// # use autosar_data_abstraction::*;
565 /// # fn main() -> Result<(), AutosarAbstractionError> {
566 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::LATEST);
567 /// let package = model.get_or_create_package("/some/package")?;
568 /// let mode_declaration_group = package.create_mode_declaration_group("ModeDeclarationGroup", None)?;
569 /// assert!(model.get_element_by_path("/some/package/ModeDeclarationGroup").is_some());
570 /// # Ok(())}
571 /// ```
572 ///
573 /// # Errors
574 ///
575 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the MODE-DECLARATION-GROUP element
576 pub fn create_mode_declaration_group(
577 &self,
578 name: &str,
579 category: Option<ModeDeclarationGroupCategory>,
580 ) -> Result<ModeDeclarationGroup, AutosarAbstractionError> {
581 ModeDeclarationGroup::new(name, self, category)
582 }
583
584 /// create a new `ModeSwitchInterface` in the package
585 ///
586 /// # Example
587 ///
588 /// ```
589 /// # use autosar_data::*;
590 /// # use autosar_data_abstraction::*;
591 /// # fn main() -> Result<(), AutosarAbstractionError> {
592 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
593 /// let package = model.get_or_create_package("/some/package")?;
594 /// let interface = package.create_mode_switch_interface("ModeSwitchInterface")?;
595 /// assert!(model.get_element_by_path("/some/package/ModeSwitchInterface").is_some());
596 /// # Ok(())}
597 /// ```
598 ///
599 /// # Errors
600 ///
601 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the MODE-SWITCH-INTERFACE element
602 pub fn create_mode_switch_interface(&self, name: &str) -> Result<ModeSwitchInterface, AutosarAbstractionError> {
603 ModeSwitchInterface::new(name, self)
604 }
605
606 /// create a new `NvDataInterface` in the package
607 ///
608 /// # Example
609 ///
610 /// ```
611 /// # use autosar_data::*;
612 /// # use autosar_data_abstraction::*;
613 /// # fn main() -> Result<(), AutosarAbstractionError> {
614 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
615 /// let package = model.get_or_create_package("/some/package")?;
616 /// let interface = package.create_nv_data_interface("NvDataInterface")?;
617 /// assert!(model.get_element_by_path("/some/package/NvDataInterface").is_some());
618 /// # Ok(())}
619 /// ```
620 ///
621 /// # Errors
622 ///
623 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the NV-DATA-INTERFACE element
624 pub fn create_nv_data_interface(&self, name: &str) -> Result<NvDataInterface, AutosarAbstractionError> {
625 NvDataInterface::new(name, self)
626 }
627
628 /// create a new `ParameterInterface` in the package
629 ///
630 /// # Example
631 ///
632 /// ```
633 /// # use autosar_data::*;
634 /// # use autosar_data_abstraction::*;
635 /// # fn main() -> Result<(), AutosarAbstractionError> {
636 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
637 /// let package = model.get_or_create_package("/some/package")?;
638 /// let interface = package.create_parameter_interface("ParameterInterface")?;
639 /// assert!(model.get_element_by_path("/some/package/ParameterInterface").is_some());
640 /// # Ok(())}
641 /// ```
642 ///
643 /// # Errors
644 ///
645 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the PARAMETER-INTERFACE element
646 pub fn create_parameter_interface(&self, name: &str) -> Result<ParameterInterface, AutosarAbstractionError> {
647 ParameterInterface::new(name, self)
648 }
649
650 /// create a new `SenderReceiverInterface` in the package
651 ///
652 /// # Example
653 ///
654 /// ```
655 /// # use autosar_data::*;
656 /// # use autosar_data_abstraction::*;
657 /// # fn main() -> Result<(), AutosarAbstractionError> {
658 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
659 /// let package = model.get_or_create_package("/some/package")?;
660 /// let interface = package.create_sender_receiver_interface("SenderReceiverInterface")?;
661 /// assert!(model.get_element_by_path("/some/package/SenderReceiverInterface").is_some());
662 /// # Ok(())}
663 /// ```
664 ///
665 /// # Errors
666 ///
667 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SENDER-RECEIVER-INTERFACE element
668 pub fn create_sender_receiver_interface(
669 &self,
670 name: &str,
671 ) -> Result<SenderReceiverInterface, AutosarAbstractionError> {
672 SenderReceiverInterface::new(name, self)
673 }
674
675 /// create a new `SensorActuatorSwComponentType` in the package
676 ///
677 /// # Example
678 ///
679 /// ```
680 /// # use autosar_data::*;
681 /// # use autosar_data_abstraction::{*, communication::*};
682 /// # fn main() -> Result<(), AutosarAbstractionError> {
683 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
684 /// let package = model.get_or_create_package("/some/package")?;
685 /// let component = package.create_sensor_actuator_sw_component_type("SensorActuatorSwComponentType")?;
686 /// assert!(model.get_element_by_path("/some/package/SensorActuatorSwComponentType").is_some());
687 /// # Ok(())}
688 /// ```
689 ///
690 /// # Errors
691 ///
692 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SENSOR-ACTUATOR-SW-COMPONENT-TYPE element
693 pub fn create_sensor_actuator_sw_component_type(
694 &self,
695 name: &str,
696 ) -> Result<SensorActuatorSwComponentType, AutosarAbstractionError> {
697 SensorActuatorSwComponentType::new(name, self)
698 }
699
700 /// create a new `ServiceSwComponentType` in the package
701 ///
702 /// # Example
703 ///
704 /// ```
705 /// # use autosar_data::*;
706 /// # use autosar_data_abstraction::*;
707 /// # fn main() -> Result<(), AutosarAbstractionError> {
708 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
709 /// let package = model.get_or_create_package("/some/package")?;
710 /// let component = package.create_service_sw_component_type("ServiceSwComponentType")?;
711 /// assert!(model.get_element_by_path("/some/package/ServiceSwComponentType").is_some());
712 /// # Ok(())}
713 /// ```
714 ///
715 /// # Errors
716 ///
717 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SERVICE-SW-COMPONENT-TYPE element
718 pub fn create_service_sw_component_type(
719 &self,
720 name: &str,
721 ) -> Result<ServiceSwComponentType, AutosarAbstractionError> {
722 ServiceSwComponentType::new(name, self)
723 }
724
725 /// create a new `SomeipSdClientEventGroupTimingConfig` in the package
726 ///
727 /// # Example
728 ///
729 /// ```
730 /// # use autosar_data::*;
731 /// # use autosar_data_abstraction::{*, communication::*};
732 /// # fn main() -> Result<(), AutosarAbstractionError> {
733 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
734 /// let package = model.get_or_create_package("/some/package")?;
735 /// let client_config = package.create_someip_sd_client_event_group_timing_config("SomeipSdClientEventGroupTimingConfig", 10)?;
736 /// assert!(model.get_element_by_path("/some/package/SomeipSdClientEventGroupTimingConfig").is_some());
737 /// # Ok(())}
738 /// ```
739 ///
740 /// # Errors
741 ///
742 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SOMEIP-SD-CLIENT-EVENT-GROUP-TIMING-CONFIG element
743 pub fn create_someip_sd_client_event_group_timing_config(
744 &self,
745 name: &str,
746 time_to_live: u32,
747 ) -> Result<SomeipSdClientEventGroupTimingConfig, AutosarAbstractionError> {
748 SomeipSdClientEventGroupTimingConfig::new(name, self, time_to_live)
749 }
750
751 /// create a new `SomeipSdClientServiceInstanceConfig` in the package
752 ///
753 /// # Example
754 ///
755 /// ```
756 /// # use autosar_data::*;
757 /// # use autosar_data_abstraction::*;
758 /// # fn main() -> Result<(), AutosarAbstractionError> {
759 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
760 /// let package = model.get_or_create_package("/some/package")?;
761 /// let service_instance = package.create_someip_sd_client_service_instance_config("SomeipSdClientServiceInstanceConfig")?;
762 /// assert!(model.get_element_by_path("/some/package/SomeipSdClientServiceInstanceConfig").is_some());
763 /// # Ok(())}
764 /// ```
765 ///
766 /// # Errors
767 ///
768 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SOMEIP-SD-CLIENT-SERVICE-INSTANCE-CONFIG element
769 pub fn create_someip_sd_client_service_instance_config(
770 &self,
771 name: &str,
772 ) -> Result<SomeipSdClientServiceInstanceConfig, AutosarAbstractionError> {
773 SomeipSdClientServiceInstanceConfig::new(name, self)
774 }
775
776 /// create a new `SomeipSdServerEventGroupTimingConfig` in the package
777 ///
778 /// # Example
779 ///
780 /// ```
781 /// # use autosar_data::*;
782 /// # use autosar_data_abstraction::{*, communication::*};
783 /// # fn main() -> Result<(), AutosarAbstractionError> {
784 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
785 /// let package = model.get_or_create_package("/some/package")?;
786 /// let request_response_delay = RequestResponseDelay {
787 /// min_value: 0.1,
788 /// max_value: 0.2,
789 /// };
790 /// let timing_config = package.create_someip_sd_server_event_group_timing_config("SomeipSdServerEventGroupTimingConfig", &request_response_delay)?;
791 /// assert!(model.get_element_by_path("/some/package/SomeipSdServerEventGroupTimingConfig").is_some());
792 /// # Ok(())}
793 /// ```
794 ///
795 /// # Errors
796 ///
797 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SOMEIP-SD-SERVER-EVENT-GROUP-TIMING-CONFIG element
798 pub fn create_someip_sd_server_event_group_timing_config(
799 &self,
800 name: &str,
801 request_response_delay: &RequestResponseDelay,
802 ) -> Result<SomeipSdServerEventGroupTimingConfig, AutosarAbstractionError> {
803 SomeipSdServerEventGroupTimingConfig::new(name, self, request_response_delay)
804 }
805
806 /// create a new `SomeipSdServerServiceInstanceConfig` in the package
807 ///
808 /// # Example
809 ///
810 /// ```
811 /// # use autosar_data::*;
812 /// # use autosar_data_abstraction::*;
813 /// # fn main() -> Result<(), AutosarAbstractionError> {
814 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
815 /// let package = model.get_or_create_package("/some/package")?;
816 /// let service_instance = package.create_someip_sd_server_service_instance_config("SomeipSdServerServiceInstanceConfig", 10)?;
817 /// assert!(model.get_element_by_path("/some/package/SomeipSdServerServiceInstanceConfig").is_some());
818 /// # Ok(())}
819 /// ```
820 ///
821 /// # Errors
822 ///
823 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SOMEIP-SD-SERVER-SERVICE-INSTANCE-CONFIG element
824 pub fn create_someip_sd_server_service_instance_config(
825 &self,
826 name: &str,
827 ttl: u32,
828 ) -> Result<SomeipSdServerServiceInstanceConfig, AutosarAbstractionError> {
829 SomeipSdServerServiceInstanceConfig::new(name, self, ttl)
830 }
831
832 /// create a new `SwBaseType` in the package
833 ///
834 /// # Example
835 ///
836 /// ```
837 /// # use autosar_data::*;
838 /// # use autosar_data_abstraction::{*, datatype::*};
839 /// # fn main() -> Result<(), AutosarAbstractionError> {
840 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
841 /// let package = model.get_or_create_package("/some/package")?;
842 /// let base_type = package.create_sw_base_type("MyBaseType", 8, BaseTypeEncoding::None, None, None, None)?;
843 /// assert!(model.get_element_by_path("/some/package/MyBaseType").is_some());
844 /// # Ok(())}
845 /// ```
846 ///
847 /// # Errors
848 ///
849 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SW-BASE-TYPE element
850 pub fn create_sw_base_type(
851 &self,
852 name: &str,
853 bit_length: u32,
854 base_type_encoding: BaseTypeEncoding,
855 byte_order: Option<ByteOrder>,
856 mem_alignment: Option<u32>,
857 native_declaration: Option<&str>,
858 ) -> Result<SwBaseType, AutosarAbstractionError> {
859 SwBaseType::new(
860 name,
861 self,
862 bit_length,
863 base_type_encoding,
864 byte_order,
865 mem_alignment,
866 native_declaration,
867 )
868 }
869
870 /// create a new System in the package
871 ///
872 /// Note that an Autosar model should ony contain one SYSTEM. This is not checked here.
873 ///
874 /// # Example
875 ///
876 /// ```
877 /// # use autosar_data::*;
878 /// # use autosar_data_abstraction::*;
879 /// # fn main() -> Result<(), AutosarAbstractionError> {
880 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
881 /// let package = model.get_or_create_package("/some/package")?;
882 /// let system = package.create_system("System", SystemCategory::SystemExtract)?;
883 /// assert!(model.get_element_by_path("/some/package/System").is_some());
884 /// # Ok(())}
885 /// ```
886 ///
887 /// # Errors
888 ///
889 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SYSTEM element
890 pub fn create_system(&self, name: &str, category: SystemCategory) -> Result<System, AutosarAbstractionError> {
891 System::new(name, self, category)
892 }
893
894 /// create a new `SystemSignal` in the package
895 ///
896 /// # Example
897 ///
898 /// ```
899 /// # use autosar_data::*;
900 /// # use autosar_data_abstraction::*;
901 /// # fn main() -> Result<(), AutosarAbstractionError> {
902 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
903 /// let package = model.get_or_create_package("/some/package")?;
904 /// let signal = package.create_system_signal("MySignal")?;
905 /// assert!(model.get_element_by_path("/some/package/MySignal").is_some());
906 /// # Ok(())}
907 /// ```
908 ///
909 /// # Errors
910 ///
911 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SYSTEM-SIGNAL element
912 pub fn create_system_signal(&self, name: &str) -> Result<SystemSignal, AutosarAbstractionError> {
913 SystemSignal::new(name, self)
914 }
915
916 /// create a new `SystemSignalGroup` in the package
917 ///
918 /// # Example
919 ///
920 /// ```
921 /// # use autosar_data::*;
922 /// # use autosar_data_abstraction::*;
923 /// # fn main() -> Result<(), AutosarAbstractionError> {
924 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
925 /// let package = model.get_or_create_package("/some/package")?;
926 /// let signal_group = package.create_system_signal_group("MySignalGroup")?;
927 /// assert!(model.get_element_by_path("/some/package/MySignalGroup").is_some());
928 /// # Ok(())}
929 /// ```
930 ///
931 /// # Errors
932 ///
933 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the SYSTEM-SIGNAL-GROUP element
934 pub fn create_system_signal_group(&self, name: &str) -> Result<SystemSignalGroup, AutosarAbstractionError> {
935 SystemSignalGroup::new(name, self)
936 }
937
938 /// create a new `TriggerInterface` in the package
939 ///
940 /// # Example
941 ///
942 /// ```
943 /// # use autosar_data::*;
944 /// # use autosar_data_abstraction::*;
945 /// # fn main() -> Result<(), AutosarAbstractionError> {
946 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
947 /// let package = model.get_or_create_package("/some/package")?;
948 /// let interface = package.create_trigger_interface("TriggerInterface")?;
949 /// assert!(model.get_element_by_path("/some/package/TriggerInterface").is_some());
950 /// # Ok(())}
951 /// ```
952 ///
953 /// # Errors
954 ///
955 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the TRIGGER-INTERFACE element
956 pub fn create_trigger_interface(&self, name: &str) -> Result<TriggerInterface, AutosarAbstractionError> {
957 TriggerInterface::new(name, self)
958 }
959
960 /// create a new `Unit` in the package
961 ///
962 /// # Example
963 ///
964 /// ```
965 /// # use autosar_data::*;
966 /// # use autosar_data_abstraction::*;
967 /// # fn main() -> Result<(), AutosarAbstractionError> {
968 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
969 /// let package = model.get_or_create_package("/some/package")?;
970 /// let unit = package.create_unit("Unit", Some("UnitDisplayName"))?;
971 /// assert!(model.get_element_by_path("/some/package/Unit").is_some());
972 /// # Ok(())}
973 /// ```
974 ///
975 /// # Errors
976 ///
977 /// - [`AutosarAbstractionError::ModelError`] An error occurred in the Autosar model while trying to create the UNIT element
978 pub fn create_unit(&self, name: &str, display_name: Option<&str>) -> Result<Unit, AutosarAbstractionError> {
979 Unit::new(name, self, display_name)
980 }
981
982 /// iterate over all elements in the package
983 ///
984 /// # Example
985 ///
986 /// ```
987 /// # use autosar_data::*;
988 /// # use autosar_data_abstraction::*;
989 /// # fn main() -> Result<(), AutosarAbstractionError> {
990 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
991 /// let package = model.get_or_create_package("/some/package")?;
992 /// for element in package.elements() {
993 /// println!("{:?}", element);
994 /// }
995 /// # Ok(())}
996 /// ```
997 pub fn elements(&self) -> impl Iterator<Item = Element> + Send + 'static {
998 self.0
999 .get_sub_element(ElementName::Elements)
1000 .into_iter()
1001 .flat_map(|element| element.sub_elements())
1002 }
1003
1004 /// create a new `ArPackage` as a sub-package of the package
1005 ///
1006 /// # Example
1007 ///
1008 /// ```
1009 /// # use autosar_data::*;
1010 /// # use autosar_data_abstraction::*;
1011 /// # fn main() -> Result<(), AutosarAbstractionError> {
1012 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
1013 /// let package = model.get_or_create_package("/some/package")?;
1014 /// let sub_package = package.create_sub_package("SubPackage")?;
1015 /// assert!(model.get_element_by_path("/some/package/SubPackage").is_some());
1016 /// # Ok(())}
1017 /// ```
1018 pub fn create_sub_package(&self, name: &str) -> Result<ArPackage, AutosarAbstractionError> {
1019 let sub_package_elem = self
1020 .0
1021 .get_or_create_sub_element(ElementName::ArPackages)
1022 .and_then(|elem| elem.create_named_sub_element(ElementName::ArPackage, name))?;
1023 Ok(Self(sub_package_elem))
1024 }
1025
1026 /// iterate over all sub-packages in the package
1027 ///
1028 /// # Example
1029 ///
1030 /// ```
1031 /// # use autosar_data::*;
1032 /// # use autosar_data_abstraction::*;
1033 /// # fn main() -> Result<(), AutosarAbstractionError> {
1034 /// # let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
1035 /// let package = model.get_or_create_package("/some/package")?;
1036 /// for sub_package in package.sub_packages() {
1037 /// println!("{:?}", sub_package);
1038 /// }
1039 /// # Ok(())}
1040 /// ```
1041 pub fn sub_packages(&self) -> impl Iterator<Item = ArPackage> + Send + 'static {
1042 self.0
1043 .get_sub_element(ElementName::ArPackages)
1044 .into_iter()
1045 .flat_map(|element| element.sub_elements())
1046 .filter_map(|element| ArPackage::try_from(element).ok())
1047 }
1048}
1049
1050//##################################################################
1051
1052#[cfg(test)]
1053mod test {
1054 use super::*;
1055 use crate::{AutosarModelAbstraction, datatype::*};
1056 use crate::{System, SystemCategory};
1057 use autosar_data::AutosarVersion;
1058
1059 #[test]
1060 fn package() {
1061 let model = AutosarModel::new();
1062 // can't do anything in an incomplete model: it has no files
1063 let result = ArPackage::get_or_create(&model, "/bad");
1064 assert!(result.is_err());
1065
1066 model.create_file("filename", AutosarVersion::Autosar_00048).unwrap();
1067
1068 // create a new package
1069 let result = ArPackage::get_or_create(&model, "/pkg1");
1070 assert!(result.is_ok());
1071 let package = result.unwrap();
1072 assert_eq!(package.name().unwrap(), "pkg1");
1073 // get the existing package
1074 let result = ArPackage::get_or_create(&model, "/pkg1");
1075 assert!(result.is_ok());
1076 // create multiple levels
1077 let result = ArPackage::get_or_create(&model, "/level1/level2/level3");
1078 assert!(result.is_ok());
1079 let package = result.unwrap();
1080 assert_eq!(package.name().unwrap(), "level3");
1081
1082 // can't create a package due to an element name conflict
1083 let pkg = ArPackage::get_or_create(&model, "/test").unwrap();
1084 System::new("system", &pkg, SystemCategory::EcuExtract).unwrap();
1085 let result = ArPackage::get_or_create(&model, "/test/system");
1086 assert!(result.is_err());
1087 let result = ArPackage::get_or_create(&model, "/test/system/sub");
1088 assert!(result.is_err());
1089
1090 // invalid path: does not start with '/'
1091 let result = ArPackage::get_or_create(&model, "hello world");
1092 assert!(result.is_err());
1093
1094 // conversions
1095 let element: Element = pkg.into();
1096 let result = ArPackage::try_from(element);
1097 assert!(result.is_ok());
1098 let result = ArPackage::try_from(model.root_element());
1099 assert!(result.is_err());
1100 }
1101
1102 #[test]
1103 fn create_package_items() {
1104 let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
1105 let package = model.get_or_create_package("/some/package").unwrap();
1106
1107 // create a new application primitive data type
1108 let primitive_data_type = package
1109 .create_application_primitive_data_type(
1110 "ApplicationPrimitiveDataType",
1111 ApplicationPrimitiveCategory::Value,
1112 None,
1113 None,
1114 None,
1115 )
1116 .unwrap();
1117 assert_eq!(primitive_data_type.name().unwrap(), "ApplicationPrimitiveDataType");
1118
1119 // create a new application array data type
1120 let array_data_type = package
1121 .create_application_array_data_type(
1122 "ApplicationArrayDataType",
1123 &primitive_data_type,
1124 ApplicationArraySize::Fixed(4),
1125 )
1126 .unwrap();
1127 assert_eq!(array_data_type.name().unwrap(), "ApplicationArrayDataType");
1128
1129 // create a new application record data type
1130 let data_type = package
1131 .create_application_record_data_type("ApplicationRecordDataType")
1132 .unwrap();
1133 assert_eq!(data_type.name().unwrap(), "ApplicationRecordDataType");
1134
1135 // create a new application sw component type
1136 let component = package.create_application_sw_component_type("MyComponent").unwrap();
1137 assert_eq!(component.name().unwrap(), "MyComponent");
1138
1139 // create a new client server interface
1140 let interface = package.create_client_server_interface("ClientServerInterface").unwrap();
1141 assert_eq!(interface.name().unwrap(), "ClientServerInterface");
1142
1143 // create a new complex device driver sw component type
1144 let component = package
1145 .create_complex_device_driver_sw_component_type("ComplexDeviceDriverSwComponentType")
1146 .unwrap();
1147 assert_eq!(component.name().unwrap(), "ComplexDeviceDriverSwComponentType");
1148
1149 // create a new composition sw component type
1150 let component = package
1151 .create_composition_sw_component_type("CompositionSwComponentType")
1152 .unwrap();
1153 assert_eq!(component.name().unwrap(), "CompositionSwComponentType");
1154
1155 // create a new compu method
1156 let compu_content = CompuMethodContent::Linear(CompuMethodLinearContent {
1157 direction: CompuScaleDirection::IntToPhys,
1158 offset: 0.0,
1159 factor: 1.0,
1160 divisor: 1.0,
1161 lower_limit: None,
1162 upper_limit: None,
1163 });
1164 let compu_method = package.create_compu_method("CompuMethod", compu_content).unwrap();
1165 assert_eq!(compu_method.name().unwrap(), "CompuMethod");
1166
1167 // create a new data constr
1168 let data_constr = package.create_data_constr("DataConstr").unwrap();
1169 assert_eq!(data_constr.name().unwrap(), "DataConstr");
1170
1171 // create a new data transformation set
1172 let transformation_set = package.create_data_transformation_set("DataTransformationSet").unwrap();
1173 assert_eq!(transformation_set.name().unwrap(), "DataTransformationSet");
1174
1175 // create a new data type mapping set
1176 let mapping_set = package.create_data_type_mapping_set("DataTypeMappingSet").unwrap();
1177 assert_eq!(mapping_set.name().unwrap(), "DataTypeMappingSet");
1178
1179 // create a new ecu abstraction sw component type
1180 let component = package
1181 .create_ecu_abstraction_sw_component_type("EcuAbstractionSwComponentType")
1182 .unwrap();
1183 assert_eq!(component.name().unwrap(), "EcuAbstractionSwComponentType");
1184
1185 // create a new ecuc definition collection
1186 let ecuc_definition_collection = package
1187 .create_ecuc_definition_collection("EcucDefinitionCollection")
1188 .unwrap();
1189 assert_eq!(ecuc_definition_collection.name().unwrap(), "EcucDefinitionCollection");
1190
1191 // create a new ecuc value collection
1192 let ecuc_value_collection = package.create_ecuc_value_collection("EcucValueCollection").unwrap();
1193 assert_eq!(ecuc_value_collection.name().unwrap(), "EcucValueCollection");
1194
1195 // create a new ecuc destination uri def set
1196 let uri_def_set = package
1197 .create_ecuc_destination_uri_def_set("EcucDestinationUriDefSet")
1198 .unwrap();
1199 assert_eq!(uri_def_set.name().unwrap(), "EcucDestinationUriDefSet");
1200
1201 // create a new ecuc module def
1202 let ecuc_module_def = package.create_ecuc_module_def("EcucModuleDef").unwrap();
1203 assert_eq!(ecuc_module_def.name().unwrap(), "EcucModuleDef");
1204
1205 // create a new ecuc module configuration values
1206 let ecuc_module_configuration_values = package
1207 .create_ecuc_module_configuration_values("EcucModuleConfigurationValues", &ecuc_module_def)
1208 .unwrap();
1209 assert_eq!(
1210 ecuc_module_configuration_values.name().unwrap(),
1211 "EcucModuleConfigurationValues"
1212 );
1213
1214 // create a new implementation data type
1215 let sw_base_type = package
1216 .create_sw_base_type("uint8", 8, BaseTypeEncoding::None, None, None, None)
1217 .unwrap();
1218 let settings = ImplementationDataTypeSettings::Value {
1219 name: "ImplementationDataType_Value".to_string(),
1220 base_type: sw_base_type,
1221 compu_method: None,
1222 data_constraint: None,
1223 };
1224 let data_type = package.create_implementation_data_type(&settings).unwrap();
1225 assert_eq!(data_type.name().unwrap(), "ImplementationDataType_Value");
1226
1227 // create a new mode switch interface
1228 let interface = package.create_mode_switch_interface("ModeSwitchInterface").unwrap();
1229 assert_eq!(interface.name().unwrap(), "ModeSwitchInterface");
1230
1231 // create a new nv data interface
1232 let interface = package.create_nv_data_interface("NvDataInterface").unwrap();
1233 assert_eq!(interface.name().unwrap(), "NvDataInterface");
1234
1235 // create a new parameter interface
1236 let interface = package.create_parameter_interface("ParameterInterface").unwrap();
1237 assert_eq!(interface.name().unwrap(), "ParameterInterface");
1238
1239 // create a new sender receiver interface
1240 let interface = package
1241 .create_sender_receiver_interface("SenderReceiverInterface")
1242 .unwrap();
1243 assert_eq!(interface.name().unwrap(), "SenderReceiverInterface");
1244
1245 // create a new sensor actuator sw component type
1246 let component = package
1247 .create_sensor_actuator_sw_component_type("SensorActuatorSwComponentType")
1248 .unwrap();
1249 assert_eq!(component.name().unwrap(), "SensorActuatorSwComponentType");
1250
1251 // create a new service sw component type
1252 let component = package
1253 .create_service_sw_component_type("ServiceSwComponentType")
1254 .unwrap();
1255 assert_eq!(component.name().unwrap(), "ServiceSwComponentType");
1256
1257 // create a new someip sd client event group timing config
1258 let client_config = package
1259 .create_someip_sd_client_event_group_timing_config("SomeipSdClientEventGroupTimingConfig", 10)
1260 .unwrap();
1261 assert_eq!(client_config.name().unwrap(), "SomeipSdClientEventGroupTimingConfig");
1262
1263 // create a new someip sd client service instance config
1264 let service_instance = package
1265 .create_someip_sd_client_service_instance_config("SomeipSdClientServiceInstanceConfig")
1266 .unwrap();
1267 assert_eq!(service_instance.name().unwrap(), "SomeipSdClientServiceInstanceConfig");
1268
1269 // create a new someip sd server event group timing config
1270 let request_response_delay = RequestResponseDelay {
1271 min_value: 0.1,
1272 max_value: 0.2,
1273 };
1274 let timing_config = package
1275 .create_someip_sd_server_event_group_timing_config(
1276 "SomeipSdServerEventGroupTimingConfig",
1277 &request_response_delay,
1278 )
1279 .unwrap();
1280 assert_eq!(timing_config.name().unwrap(), "SomeipSdServerEventGroupTimingConfig");
1281
1282 // create a new someip sd server service instance config
1283 let service_instance = package
1284 .create_someip_sd_server_service_instance_config("SomeipSdServerServiceInstanceConfig", 10)
1285 .unwrap();
1286 assert_eq!(service_instance.name().unwrap(), "SomeipSdServerServiceInstanceConfig");
1287
1288 // create a new sw base type
1289 let sw_base_type = package
1290 .create_sw_base_type("SwBaseType", 8, BaseTypeEncoding::None, None, None, None)
1291 .unwrap();
1292 assert_eq!(sw_base_type.name().unwrap(), "SwBaseType");
1293
1294 // create a new system
1295 let system = package.create_system("System", SystemCategory::SystemExtract).unwrap();
1296 assert_eq!(system.name().unwrap(), "System");
1297
1298 // create a new system signal
1299 let signal = package.create_system_signal("SystemSignal").unwrap();
1300 assert_eq!(signal.name().unwrap(), "SystemSignal");
1301
1302 // create a new system signal group
1303 let signal_group = package.create_system_signal_group("SystemSignalGroup").unwrap();
1304 assert_eq!(signal_group.name().unwrap(), "SystemSignalGroup");
1305
1306 // create a new trigger interface
1307 let interface = package.create_trigger_interface("TriggerInterface").unwrap();
1308 assert_eq!(interface.name().unwrap(), "TriggerInterface");
1309
1310 // create a new unit
1311 let unit = package.create_unit("Unit", Some("UnitDisplayName")).unwrap();
1312 assert_eq!(unit.name().unwrap(), "Unit");
1313 }
1314
1315 #[test]
1316 fn test_elements_iter() {
1317 let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
1318 let package = model.get_or_create_package("/some/package").unwrap();
1319
1320 package
1321 .create_application_record_data_type("ApplicationRecordDataType")
1322 .unwrap();
1323 package
1324 .create_application_sw_component_type("ApplicationSwComponentType")
1325 .unwrap();
1326 package.create_client_server_interface("ClientServerInterface").unwrap();
1327 package
1328 .create_complex_device_driver_sw_component_type("ComplexDeviceDriverSwComponentType")
1329 .unwrap();
1330 package
1331 .create_composition_sw_component_type("CompositionSwComponentType")
1332 .unwrap();
1333 package
1334 .create_compu_method(
1335 "CompuMethod",
1336 CompuMethodContent::Linear(CompuMethodLinearContent {
1337 direction: CompuScaleDirection::IntToPhys,
1338 offset: 0.0,
1339 factor: 1.0,
1340 divisor: 1.0,
1341 lower_limit: None,
1342 upper_limit: None,
1343 }),
1344 )
1345 .unwrap();
1346 package.create_data_constr("DataConstr").unwrap();
1347 package.create_data_transformation_set("DataTransformationSet").unwrap();
1348 package.create_data_type_mapping_set("DataTypeMappingSet").unwrap();
1349 package
1350 .create_ecu_abstraction_sw_component_type("EcuAbstractionSwComponentType")
1351 .unwrap();
1352 let sw_base_type = package
1353 .create_sw_base_type("uint8", 8, BaseTypeEncoding::None, None, None, None)
1354 .unwrap();
1355 let settings = ImplementationDataTypeSettings::Value {
1356 name: "ImplementationDataType_Value".to_string(),
1357 base_type: sw_base_type,
1358 compu_method: None,
1359 data_constraint: None,
1360 };
1361 package.create_implementation_data_type(&settings).unwrap();
1362 package.create_mode_switch_interface("ModeSwitchInterface").unwrap();
1363 package.create_nv_data_interface("NvDataInterface").unwrap();
1364 package.create_parameter_interface("ParameterInterface").unwrap();
1365 package
1366 .create_sender_receiver_interface("SenderReceiverInterface")
1367 .unwrap();
1368 package
1369 .create_sensor_actuator_sw_component_type("SensorActuatorSwComponentType")
1370 .unwrap();
1371 package
1372 .create_service_sw_component_type("ServiceSwComponentType")
1373 .unwrap();
1374 package
1375 .create_someip_sd_client_event_group_timing_config("SomeipSdClientEventGroupTimingConfig", 10)
1376 .unwrap();
1377 package
1378 .create_someip_sd_client_service_instance_config("SomeipSdClientServiceInstanceConfig")
1379 .unwrap();
1380 let request_response_delay = RequestResponseDelay {
1381 min_value: 0.1,
1382 max_value: 0.2,
1383 };
1384 package
1385 .create_someip_sd_server_event_group_timing_config(
1386 "SomeipSdServerEventGroupTimingConfig",
1387 &request_response_delay,
1388 )
1389 .unwrap();
1390 package
1391 .create_someip_sd_server_service_instance_config("SomeipSdServerServiceInstanceConfig", 10)
1392 .unwrap();
1393 // package
1394 // .create_sw_base_type("SwBaseType", 8, BaseTypeEncoding::None, None, None, None)
1395 // .unwrap();
1396 package.create_system("System", SystemCategory::SystemExtract).unwrap();
1397 package.create_system_signal("SystemSignal").unwrap();
1398 package.create_system_signal_group("SystemSignalGroup").unwrap();
1399 package.create_trigger_interface("TriggerInterface").unwrap();
1400 package.create_unit("Unit", Some("UnitDisplayName")).unwrap();
1401
1402 let mut elements = package.elements();
1403 let item = elements.next().unwrap();
1404 assert_eq!(item.element_name(), ElementName::ApplicationRecordDataType);
1405
1406 let item = elements.next().unwrap();
1407 assert_eq!(item.element_name(), ElementName::ApplicationSwComponentType);
1408
1409 let item = elements.next().unwrap();
1410 assert_eq!(item.element_name(), ElementName::ClientServerInterface);
1411
1412 let item = elements.next().unwrap();
1413 assert_eq!(item.element_name(), ElementName::ComplexDeviceDriverSwComponentType);
1414
1415 let item = elements.next().unwrap();
1416 assert_eq!(item.element_name(), ElementName::CompositionSwComponentType);
1417
1418 let item = elements.next().unwrap();
1419 assert_eq!(item.element_name(), ElementName::CompuMethod);
1420
1421 let item = elements.next().unwrap();
1422 assert_eq!(item.element_name(), ElementName::DataConstr);
1423
1424 let item = elements.next().unwrap();
1425 assert_eq!(item.element_name(), ElementName::DataTransformationSet);
1426
1427 let item = elements.next().unwrap();
1428 assert_eq!(item.element_name(), ElementName::DataTypeMappingSet);
1429
1430 let item = elements.next().unwrap();
1431 assert_eq!(item.element_name(), ElementName::EcuAbstractionSwComponentType);
1432
1433 let item = elements.next().unwrap();
1434 assert_eq!(item.element_name(), ElementName::SwBaseType);
1435
1436 let item = elements.next().unwrap();
1437 assert_eq!(item.element_name(), ElementName::ImplementationDataType);
1438
1439 let item = elements.next().unwrap();
1440 assert_eq!(item.element_name(), ElementName::ModeSwitchInterface);
1441
1442 let item = elements.next().unwrap();
1443 assert_eq!(item.element_name(), ElementName::NvDataInterface);
1444
1445 let item = elements.next().unwrap();
1446 assert_eq!(item.element_name(), ElementName::ParameterInterface);
1447
1448 let item = elements.next().unwrap();
1449 assert_eq!(item.element_name(), ElementName::SenderReceiverInterface);
1450
1451 let item = elements.next().unwrap();
1452 assert_eq!(item.element_name(), ElementName::SensorActuatorSwComponentType);
1453
1454 let item = elements.next().unwrap();
1455 assert_eq!(item.element_name(), ElementName::ServiceSwComponentType);
1456
1457 let item = elements.next().unwrap();
1458 assert_eq!(item.element_name(), ElementName::SomeipSdClientEventGroupTimingConfig);
1459
1460 let item = elements.next().unwrap();
1461 assert_eq!(item.element_name(), ElementName::SomeipSdClientServiceInstanceConfig);
1462
1463 let item = elements.next().unwrap();
1464 assert_eq!(item.element_name(), ElementName::SomeipSdServerEventGroupTimingConfig);
1465
1466 let item = elements.next().unwrap();
1467 assert_eq!(item.element_name(), ElementName::SomeipSdServerServiceInstanceConfig);
1468
1469 let item = elements.next().unwrap();
1470 assert_eq!(item.element_name(), ElementName::System);
1471
1472 let item = elements.next().unwrap();
1473 assert_eq!(item.element_name(), ElementName::SystemSignal);
1474
1475 let item = elements.next().unwrap();
1476 assert_eq!(item.element_name(), ElementName::SystemSignalGroup);
1477
1478 let item = elements.next().unwrap();
1479 assert_eq!(item.element_name(), ElementName::TriggerInterface);
1480
1481 let item = elements.next().unwrap();
1482 assert_eq!(item.element_name(), ElementName::Unit);
1483 }
1484
1485 #[test]
1486 fn sub_packages() {
1487 let model = AutosarModelAbstraction::create("filename", AutosarVersion::Autosar_00048);
1488 let package = model.get_or_create_package("/package").unwrap();
1489
1490 // create sub-packages
1491 package.create_sub_package("sub1").unwrap();
1492 package.create_sub_package("sub2").unwrap();
1493
1494 // name conflict: can't create a sub-package with the same name
1495 let result = package.create_sub_package("sub2");
1496 assert!(result.is_err());
1497
1498 // iterate over sub-packages
1499 assert_eq!(package.sub_packages().count(), 2);
1500 }
1501}