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