armodel 1.7.9__py3-none-any.whl → 1.8.0__py3-none-any.whl

armodel/tests/test_armodel/models/test_datatype.py

@@ -1,20 +1,16 @@
 import pytest
 
-from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType, AutosarDataType, DataTypeMap
-
-from ....models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpType
-
 from ....models.M2.MSR.AsamHdo.BaseTypes import BaseType, BaseTypeDirectDefinition
-
+from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType
+from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationDataType, ApplicationPrimitiveDataType
+from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationRecordDataType, AutosarDataType, DataTypeMap
+from ....models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpType
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import PackageableElement
-
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import CollectableElement
-
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable, Referrable
-
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-
-from ....models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import AbstractImplementationDataType, ImplementationDataType, ImplementationDataTypeElement
+from ....models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import AbstractImplementationDataType, ImplementationDataType
+from ....models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataTypeElement
 from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Components import SymbolProps
 from ....models.M2.AUTOSARTemplates.CommonStructure.Implementation import ImplementationProps
 from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationRecordElement
@@ -22,27 +18,30 @@ from ....models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes impor
 from ....models.M2.MSR.AsamHdo.BaseTypes import SwBaseType
 from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
 from .... import AUTOSAR
+
+
 class Test_M2_AUTOSARTemplates_CommonStructure_Implementation:
     def test_ImplementationProps(self):
         with pytest.raises(NotImplementedError) as err:
             document = AUTOSAR.getInstance()
             ar_root = document.createARPackage("AUTOSAR")
             ImplementationProps(ar_root, "ImplementationProps")
-        assert(str(err.value) == "ImplementationProps is an abstract class.")
+        assert (str(err.value) == "ImplementationProps is an abstract class.")
 
     def test_SymbolProps(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         prototype = SymbolProps(ar_root, "SymbolProps")
 
-        assert(isinstance(prototype, ARObject))
-        assert(isinstance(prototype, ImplementationProps))
-        assert(isinstance(prototype, Referrable))
-        assert(isinstance(prototype, SymbolProps))
+        assert (isinstance(prototype, ARObject))
+        assert (isinstance(prototype, ImplementationProps))
+        assert (isinstance(prototype, Referrable))
+        assert (isinstance(prototype, SymbolProps))
+
+        assert (prototype.parent == ar_root)
+        assert (prototype.short_name == "SymbolProps")
+        assert (prototype.symbol is None)
 
-        assert(prototype.parent == ar_root)
-        assert(prototype.short_name == "SymbolProps")
-        assert(prototype.symbol == None)
 
 class Test_M2_MSR_AsamHdo_BaseTypes:
     def test_BaseType(self):
@@ -50,25 +49,26 @@ class Test_M2_MSR_AsamHdo_BaseTypes:
             document = AUTOSAR.getInstance()
             ar_root = document.createARPackage("AUTOSAR")
             BaseType(ar_root, "BaseType")
-        assert(str(err.value) == "BaseType is an abstract class.")
+        assert (str(err.value) == "BaseType is an abstract class.")
 
     def test_SwBaseType(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         base_type = SwBaseType(ar_root, "SwBaseType")
 
-        assert(isinstance(base_type, ARElement))
-        assert(isinstance(base_type, ARObject))
-        assert(isinstance(base_type, CollectableElement))
-        assert(isinstance(base_type, Identifiable))
-        assert(isinstance(base_type, MultilanguageReferrable))
-        assert(isinstance(base_type, PackageableElement))
-        assert(isinstance(base_type, Referrable))
-        assert(isinstance(base_type, SwBaseType))
+        assert (isinstance(base_type, ARElement))
+        assert (isinstance(base_type, ARObject))
+        assert (isinstance(base_type, CollectableElement))
+        assert (isinstance(base_type, Identifiable))
+        assert (isinstance(base_type, MultilanguageReferrable))
+        assert (isinstance(base_type, PackageableElement))
+        assert (isinstance(base_type, Referrable))
+        assert (isinstance(base_type, SwBaseType))
+
+        assert (base_type.parent == ar_root)
+        assert (base_type.short_name == "SwBaseType")
+        assert (isinstance(base_type.baseTypeDefinition, BaseTypeDirectDefinition))
 
-        assert(base_type.parent == ar_root)
-        assert(base_type.short_name == "SwBaseType")
-        assert(isinstance(base_type.baseTypeDefinition, BaseTypeDirectDefinition))
 
 class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_Datatypes:
     def test_AtpType(self):
@@ -76,138 +76,137 @@ class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_Datatypes:
             document = AUTOSAR.getInstance()
             ar_root = document.createARPackage("AUTOSAR")
             AtpType(ar_root, "AtpType")
-        assert(str(err.value) == "AtpType is an abstract class.")
+        assert (str(err.value) == "AtpType is an abstract class.")
 
     def test_AutosarDataType(self):
         with pytest.raises(NotImplementedError) as err:
             document = AUTOSAR.getInstance()
             ar_root = document.createARPackage("AUTOSAR")
             AutosarDataType(ar_root, "AutosarDataType")
-        assert(str(err.value) == "AutosarDataType is an abstract class.")
+        assert (str(err.value) == "AutosarDataType is an abstract class.")
 
     def test_ApplicationDataType(self):
         with pytest.raises(NotImplementedError) as err:
             document = AUTOSAR.getInstance()
             ar_root = document.createARPackage("AUTOSAR")
             ApplicationDataType(ar_root, "ApplicationDataType")
-        assert(str(err.value) == "ApplicationDataType is an abstract class.")
+        assert (str(err.value) == "ApplicationDataType is an abstract class.")
 
     def test_ApplicationPrimitiveDataType(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         data_type = ApplicationPrimitiveDataType(ar_root, "ApplicationPrimitiveDataType")
 
-        assert(isinstance(data_type, ARElement))
-        assert(isinstance(data_type, ARObject))
-        # assert(isinstance(data_type, AtpBlueprint))
-        # assert(isinstance(data_type, AtpBlueprintable))
-        # assert(isinstance(data_type, AtpClassifier))
-        assert(isinstance(data_type, AtpType))
-        assert(isinstance(data_type, AutosarDataType))
-        assert(isinstance(data_type, CollectableElement))
-        assert(isinstance(data_type, Identifiable))
-        assert(isinstance(data_type, MultilanguageReferrable))
-        assert(isinstance(data_type, PackageableElement))
-        assert(isinstance(data_type, Referrable))
-        assert(isinstance(data_type, ApplicationPrimitiveDataType))
-
-        assert(data_type.parent == ar_root)
-        assert(data_type.short_name == "ApplicationPrimitiveDataType")
-        assert(data_type.swDataDefProps == None)
+        assert (isinstance(data_type, ARElement))
+        assert (isinstance(data_type, ARObject))
+        # assert (isinstance(data_type, AtpBlueprint))
+        # assert (isinstance(data_type, AtpBlueprintable))
+        # assert (isinstance(data_type, AtpClassifier))
+        assert (isinstance(data_type, AtpType))
+        assert (isinstance(data_type, AutosarDataType))
+        assert (isinstance(data_type, CollectableElement))
+        assert (isinstance(data_type, Identifiable))
+        assert (isinstance(data_type, MultilanguageReferrable))
+        assert (isinstance(data_type, PackageableElement))
+        assert (isinstance(data_type, Referrable))
+        assert (isinstance(data_type, ApplicationPrimitiveDataType))
+
+        assert (data_type.parent == ar_root)
+        assert (data_type.short_name == "ApplicationPrimitiveDataType")
+        assert (data_type.swDataDefProps is None)
 
     def test_ApplicationCompositeDataType(self):
         with pytest.raises(NotImplementedError) as err:
             document = AUTOSAR.getInstance()
             ar_root = document.createARPackage("AUTOSAR")
             ApplicationCompositeDataType(ar_root, "ApplicationCompositeDataType")
-        assert(str(err.value) == "ApplicationCompositeDataType is an abstract class.")
+        assert (str(err.value) == "ApplicationCompositeDataType is an abstract class.")
 
     def test_ApplicationArrayDataType(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         data_type = ApplicationArrayDataType(ar_root, "ApplicationArrayDataType")
 
-        assert(isinstance(data_type, ARElement))
-        assert(isinstance(data_type, ARObject))
-        assert(isinstance(data_type, ApplicationDataType))
-        # assert(isinstance(data_type, AtpBlueprint))
-        # assert(isinstance(data_type, AtpBlueprintable))
-        # assert(isinstance(data_type, AtpClassifier))
-        assert(isinstance(data_type, AtpType))
-        assert(isinstance(data_type, AutosarDataType))
-        assert(isinstance(data_type, CollectableElement))
-        assert(isinstance(data_type, Identifiable))
-        assert(isinstance(data_type, MultilanguageReferrable))
-        assert(isinstance(data_type, PackageableElement))
-        assert(isinstance(data_type, Referrable))
-        assert(isinstance(data_type, ApplicationArrayDataType))
-
-        assert(data_type.parent == ar_root)
-        assert(data_type.short_name == "ApplicationArrayDataType")
-        assert(data_type.dynamicArraySizeProfile == None)
-        assert(data_type.element == None)
+        assert (isinstance(data_type, ARElement))
+        assert (isinstance(data_type, ARObject))
+        assert (isinstance(data_type, ApplicationDataType))
+        # assert (isinstance(data_type, AtpBlueprint))
+        # assert (isinstance(data_type, AtpBlueprintable))
+        # assert (isinstance(data_type, AtpClassifier))
+        assert (isinstance(data_type, AtpType))
+        assert (isinstance(data_type, AutosarDataType))
+        assert (isinstance(data_type, CollectableElement))
+        assert (isinstance(data_type, Identifiable))
+        assert (isinstance(data_type, MultilanguageReferrable))
+        assert (isinstance(data_type, PackageableElement))
+        assert (isinstance(data_type, Referrable))
+        assert (isinstance(data_type, ApplicationArrayDataType))
+
+        assert (data_type.parent == ar_root)
+        assert (data_type.short_name == "ApplicationArrayDataType")
+        assert (data_type.dynamicArraySizeProfile is None)
+        assert (data_type.element is None)
 
     def test_ApplicationRecordDataType(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         data_type = ApplicationRecordDataType(ar_root, "ApplicationRecordDataType")
 
-        assert(isinstance(data_type, ARElement))
-        assert(isinstance(data_type, ARObject))
-        assert(isinstance(data_type, ApplicationDataType))
-        # assert(isinstance(data_type, AtpBlueprint))
-        # assert(isinstance(data_type, AtpBlueprintable))
-        # assert(isinstance(data_type, AtpClassifier))
-        assert(isinstance(data_type, AtpType))
-        assert(isinstance(data_type, AutosarDataType))
-        assert(isinstance(data_type, CollectableElement))
-        assert(isinstance(data_type, Identifiable))
-        assert(isinstance(data_type, MultilanguageReferrable))
-        assert(isinstance(data_type, PackageableElement))
-        assert(isinstance(data_type, Referrable))
-        assert(isinstance(data_type, ApplicationRecordDataType))
-
-        assert(data_type.parent == ar_root)
-        assert(data_type.short_name == "ApplicationRecordDataType")
+        assert (isinstance(data_type, ARElement))
+        assert (isinstance(data_type, ARObject))
+        assert (isinstance(data_type, ApplicationDataType))
+        # assert (isinstance(data_type, AtpBlueprint))
+        # assert (isinstance(data_type, AtpBlueprintable))
+        # assert (isinstance(data_type, AtpClassifier))
+        assert (isinstance(data_type, AtpType))
+        assert (isinstance(data_type, AutosarDataType))
+        assert (isinstance(data_type, CollectableElement))
+        assert (isinstance(data_type, Identifiable))
+        assert (isinstance(data_type, MultilanguageReferrable))
+        assert (isinstance(data_type, PackageableElement))
+        assert (isinstance(data_type, Referrable))
+        assert (isinstance(data_type, ApplicationRecordDataType))
+
+        assert (data_type.parent == ar_root)
+        assert (data_type.short_name == "ApplicationRecordDataType")
 
         element = data_type.createApplicationRecordElement("element")
-        assert(isinstance(element, ApplicationRecordElement))
-        assert(element.short_name == "element")
+        assert (isinstance(element, ApplicationRecordElement))
+        assert (element.short_name == "element")
 
     def test_DataTypeMap(self):
         data_type_map = DataTypeMap()
 
-        assert(isinstance(data_type_map, ARObject))
-        assert(isinstance(data_type_map, DataTypeMap))
+        assert (isinstance(data_type_map, ARObject))
+        assert (isinstance(data_type_map, DataTypeMap))
 
-        assert(data_type_map.applicationDataTypeRef == None)
-        assert(data_type_map.implementationDataTypeRef == None)
+        assert (data_type_map.applicationDataTypeRef is None)
+        assert (data_type_map.implementationDataTypeRef is None)
 
     def test_DataTypeMappingSet(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
         data_type_mapping_set = DataTypeMappingSet(ar_root, "DataTypeMappingSet")
 
-        assert(isinstance(data_type_mapping_set, ARElement))
-        assert(isinstance(data_type_mapping_set, ARObject))
-        # assert(isinstance(data_type_mapping_set, AtpBlueprint))
-        # assert(isinstance(data_type_mapping_set, AtpBlueprintable))
-        assert(isinstance(data_type_mapping_set, CollectableElement))
-        assert(isinstance(data_type_mapping_set, Identifiable))
-        assert(isinstance(data_type_mapping_set, MultilanguageReferrable))
-        assert(isinstance(data_type_mapping_set, PackageableElement))
-        assert(isinstance(data_type_mapping_set, Referrable))
-        assert(isinstance(data_type_mapping_set, DataTypeMappingSet))
-
-        assert(data_type_mapping_set.parent == ar_root)
-        assert(data_type_mapping_set.short_name == "DataTypeMappingSet")
-        assert(len(data_type_mapping_set.dataTypeMaps) == 0)
+        assert (isinstance(data_type_mapping_set, ARElement))
+        assert (isinstance(data_type_mapping_set, ARObject))
+        # assert (isinstance(data_type_mapping_set, AtpBlueprint))
+        # assert (isinstance(data_type_mapping_set, AtpBlueprintable))
+        assert (isinstance(data_type_mapping_set, CollectableElement))
+        assert (isinstance(data_type_mapping_set, Identifiable))
+        assert (isinstance(data_type_mapping_set, MultilanguageReferrable))
+        assert (isinstance(data_type_mapping_set, PackageableElement))
+        assert (isinstance(data_type_mapping_set, Referrable))
+        assert (isinstance(data_type_mapping_set, DataTypeMappingSet))
+
+        assert (data_type_mapping_set.parent == ar_root)
+        assert (data_type_mapping_set.short_name == "DataTypeMappingSet")
+        assert (len(data_type_mapping_set.dataTypeMaps) == 0)
 
         data_type_map = DataTypeMap()
         data_type_mapping_set.addDataTypeMap(data_type_map)
-        assert(len(data_type_mapping_set.getDataTypeMaps()) == 1)
-        assert(data_type_mapping_set.getDataTypeMaps()[0] == data_type_map)
-
+        assert (len(data_type_mapping_set.getDataTypeMaps()) == 1)
+        assert (data_type_mapping_set.getDataTypeMaps()[0] == data_type_map)
 
 
 class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
@@ -216,38 +215,37 @@ class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
             document = AUTOSAR.getInstance()
             ar_root = document.createARPackage("AUTOSAR")
             AbstractImplementationDataType(ar_root, "AbstractImplementationDataType")
-        assert(str(err.value) == "AbstractImplementationDataType is an abstract class.")
+        assert (str(err.value) == "AbstractImplementationDataType is an abstract class.")
 
     def test_ImplementationDataType(self):
         document = AUTOSAR.getInstance()
         ar_root = document.createARPackage("AUTOSAR")
-        data_type = ImplementationDataType(ar_root, "ImplementationDataType")
-
-        assert(isinstance(data_type, ARElement))
-        assert(isinstance(data_type, ARObject))
-        assert(isinstance(data_type, AbstractImplementationDataType,))
-        # assert(isinstance(data_type, AtpBlueprint))
-        # assert(isinstance(data_type, AtpBlueprintable))
-        # assert(isinstance(data_type, AtpClassifier))
-        assert(isinstance(data_type, AtpType))
-        assert(isinstance(data_type, AutosarDataType))
-        assert(isinstance(data_type, CollectableElement))
-        assert(isinstance(data_type, Identifiable))
-        assert(isinstance(data_type, MultilanguageReferrable))
-        assert(isinstance(data_type, PackageableElement))
-        assert(isinstance(data_type, Referrable))
-        assert(isinstance(data_type, ImplementationDataType))
-
-        assert(data_type.parent == ar_root)
-        assert(data_type.short_name == "ImplementationDataType")
-        assert(data_type.subElements == [])
-        assert(data_type.symbolProps == None)
-        assert(data_type.typeEmitter == None)
+        data_type = ar_root.createImplementationDataType("ImplementationDataType")
+
+        assert (isinstance(data_type, ARElement))
+        assert (isinstance(data_type, ARObject))
+        assert (isinstance(data_type, AbstractImplementationDataType,))
+        # assert (isinstance(data_type, AtpBlueprint))
+        # assert (isinstance(data_type, AtpBlueprintable))
+        # assert (isinstance(data_type, AtpClassifier))
+        assert (isinstance(data_type, AtpType))
+        assert (isinstance(data_type, AutosarDataType))
+        assert (isinstance(data_type, CollectableElement))
+        assert (isinstance(data_type, Identifiable))
+        assert (isinstance(data_type, MultilanguageReferrable))
+        assert (isinstance(data_type, PackageableElement))
+        assert (isinstance(data_type, Referrable))
+        assert (isinstance(data_type, ImplementationDataType))
+
+        assert (data_type.parent == ar_root)
+        assert (data_type.short_name == "ImplementationDataType")
+        assert (data_type.subElements == [])
+        assert (data_type.symbolProps is None)
+        assert (data_type.getTypeEmitter() is None)
 
         element = data_type.createImplementationDataTypeElement("ImplementationDataTypeElement")
-        assert(isinstance(element, ImplementationDataTypeElement))
-        assert(element.short_name == "ImplementationDataTypeElement")
+        assert (isinstance(element, ImplementationDataTypeElement))
+        assert (element.short_name == "ImplementationDataTypeElement")
 
-        assert(len(data_type.getImplementationDataTypeElements()) == 1)
-        assert(data_type.getImplementationDataTypeElements()[0] == element)
-        
+        assert (len(data_type.getSubElements()) == 1)
+        assert (data_type.getSubElements()[0] == element)

armodel/writer/arxml_writer.py

@@ -49,7 +49,7 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDec
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import ResourceConsumption
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import RoughEstimateStackUsage, StackUsage
 from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
-from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal, DltUserNeeds, ServiceNeeds
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticCapabilityElement, DtcStatusChangeNotificationNeeds
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds
@@ -1577,10 +1577,13 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Assigned Data <%s>" % type(data))
 
+    def writeServiceNeeds(self, element: ET.Element, needs: ServiceNeeds):
+        self.writeIdentifiable(element, needs)
+
     def writeNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
         child_element = ET.SubElement(element, "NV-BLOCK-NEEDS")
         self.logger.debug("write NvBlockNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeServiceNeeds(child_element, needs)
         self.setChildElementOptionalBooleanValue(child_element, "CALC-RAM-BLOCK-CRC", needs.getCalcRamBlockCrc())
         self.setChildElementOptionalBooleanValue(child_element, "CHECK-STATIC-BLOCK-ID", needs.getCheckStaticBlockId())
         self.setChildElementOptionalNumericalValue(child_element, "N-DATA-SETS", needs.getNDataSets())
@@ -1602,7 +1605,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(child_element, "WRITING-PRIORITY", needs.getWritingPriority())
 
     def writeDiagnosticCapabilityElement(self, element: ET.Element, needs: DiagnosticCapabilityElement):
-        self.writeIdentifiable(element, needs)
+        self.writeServiceNeeds(element, needs)
 
     def writeDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS")
@@ -1658,13 +1661,13 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
         # self.logger.debug("Write CryptoServiceNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "CRYPTO-SERVICE-NEEDS")
-        self.writeIdentifiable(child_element, needs)
+        self.writeServiceNeeds(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "MAXIMUM-KEY-LENGTH", needs.getMaximumKeyLength())
 
     def writeEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
         # self.logger.debug("write EcuStateMgrUserNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "ECU-STATE-MGR-USER-NEEDS")
-        self.writeIdentifiable(child_element, needs)
+        self.writeServiceNeeds(child_element, needs)
 
     def writeDtcStatusChangeNotificationNeeds(self, element: ET.Element, needs: DtcStatusChangeNotificationNeeds):
         # self.logger.debug("Write DtcStatusChangeNotificationNeeds %s" % needs.getShortName())
@@ -1672,31 +1675,38 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeDiagnosticCapabilityElement(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DTC-FORMAT-TYPE", needs.getDtcFormatType())
 
+    def writeDltUserNeeds(self, element: ET.Element, needs: DtcStatusChangeNotificationNeeds):
+        # self.logger.debug("Write DtcStatusChangeNotificationNeeds %s" % needs.getShortName())
+        child_element = ET.SubElement(element, "DLT-USER-NEEDS")
+        self.writeServiceNeeds(child_element, needs)
+
     def writeSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        needs = parent.getServiceNeeds()
-        if len(needs) > 0:
+        needs_list = parent.getServiceNeeds()
+        if len(needs_list) > 0:
             child_element = ET.SubElement(element, "SERVICE-NEEDS")
-            for need in needs:
-                if isinstance(need, NvBlockNeeds):
-                    self.writeNvBlockNeeds(child_element, need)
-                elif isinstance(need, DiagnosticCommunicationManagerNeeds):
-                    self.writeDiagnosticCommunicationManagerNeeds(child_element, need)
-                elif isinstance(need, DiagnosticRoutineNeeds):
-                    self.writeDiagnosticRoutineNeeds(child_element, need)
-                elif isinstance(need, DiagnosticValueNeeds):
-                    self.writeDiagnosticValueNeeds(child_element, need)
-                elif isinstance(need, DiagnosticEventNeeds):
-                    self.writeDiagnosticEventNeeds(child_element, need)
-                elif isinstance(need, DiagnosticEventInfoNeeds):
-                    self.writeDiagnosticEventInfoNeeds(child_element, need)
-                elif isinstance(need, CryptoServiceNeeds):
-                    self.writeCryptoServiceNeeds(child_element, need)
-                elif isinstance(need, EcuStateMgrUserNeeds):
-                    self.writeEcuStateMgrUserNeeds(child_element, need)
-                elif isinstance(need, DtcStatusChangeNotificationNeeds):
-                    self.writeDtcStatusChangeNotificationNeeds(child_element, need)
+            for needs in needs_list:
+                if isinstance(needs, NvBlockNeeds):
+                    self.writeNvBlockNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticCommunicationManagerNeeds):
+                    self.writeDiagnosticCommunicationManagerNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticRoutineNeeds):
+                    self.writeDiagnosticRoutineNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticValueNeeds):
+                    self.writeDiagnosticValueNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticEventNeeds):
+                    self.writeDiagnosticEventNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticEventInfoNeeds):
+                    self.writeDiagnosticEventInfoNeeds(child_element, needs)
+                elif isinstance(needs, CryptoServiceNeeds):
+                    self.writeCryptoServiceNeeds(child_element, needs)
+                elif isinstance(needs, EcuStateMgrUserNeeds):
+                    self.writeEcuStateMgrUserNeeds(child_element, needs)
+                elif isinstance(needs, DtcStatusChangeNotificationNeeds):
+                    self.writeDtcStatusChangeNotificationNeeds(child_element, needs)
+                elif isinstance(needs, DltUserNeeds):
+                    self.writeDltUserNeeds(child_element, needs)
                 else:
-                    self.notImplemented("Unsupported service needs <%s>" % type(need))
+                    self.notImplemented("Unsupported service needs <%s>" % type(needs))
 
     def writeSwcServiceDependency(self, element: ET.Element, dependency: SwcServiceDependency):
         child_element = ET.SubElement(element, "SWC-SERVICE-DEPENDENCY")
@@ -2471,7 +2481,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeBswImplementationVendorSpecificModuleDefRefs(child_element, impl)
 
     def writeImplementationDataTypeElements(self, element: ET.Element, parent: ImplementationDataType):
-        sub_elements = parent.getImplementationDataTypeElements()
+        sub_elements = parent.getSubElements()
         if len(sub_elements) > 0:
             sub_elements_tag = ET.SubElement(element, "SUB-ELEMENTS")
             for type_element in sub_elements:

{armodel-1.7.9.dist-info → armodel-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: armodel
-Version: 1.7.9
+Version: 1.8.0
 Summary: the python arxml parser
 Home-page: http://github.com/melodypapa/py-armodel
 Author: melodypapa
@@ -588,3 +588,17 @@ Fix the attribute intervalType of **Limit** is empty issue.
    * AUTOSAR::setARRelease()
 5. Fix the conversion for float number in scientific notation.
 
+**Version 1.8.0**
+
+1. To support the following AR Element:
+   * DLT-USER-NEEDS
+2. Improve the UUID check
+3. Improve the find method of class AbstractAUTOSAR to support the validation of dest
+4. Add the findXXX method of class AbstractAUTOSAR
+   * findAtomicSwComponentType
+   * findSystemSignal
+   * findSystemSignalGroup
+   * findPort
+   * findVariableDataPrototype
+   * findImplementationDataType
+