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

armodel/parser/arxml_parser.py

@@ -2,9 +2,7 @@ from typing import List
 import xml.etree.ElementTree as ET
 import os
 
-from armodel.models.M2.MSR.Documentation.TextModel.BlockElements.PaginationAndView import DocumentViewSelectable, Paginateable
-
-from ..models.M2.MSR.AsamHdo.AdminData import AdminData
+from ..models.M2.MSR.AsamHdo.AdminData import AdminData, DocRevision, Modification
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition, SwBaseType
 from ..models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstrRule, InternalConstrs, PhysConstrs, DataConstr
 from ..models.M2.MSR.AsamHdo.ComputationMethod import CompuConstContent, CompuConstFormulaContent, CompuConstNumericContent, CompuMethod, Compu
@@ -29,6 +27,7 @@ from ..models.M2.MSR.Documentation.TextModel.BlockElements.ListElements import A
 from ..models.M2.MSR.Documentation.TextModel.LanguageDataModel import LLongName, LOverviewParagraph, LParagraph, LanguageSpecific
 from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultiLanguagePlainText
 from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultilanguageLongName
+from ..models.M2.MSR.Documentation.TextModel.BlockElements.PaginationAndView import DocumentViewSelectable, Paginateable
 
 from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswApiOptions, BswAsynchronousServerCallPoint, BswBackgroundEvent
@@ -48,7 +47,8 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.Filter import DataFilter
 from ..models.M2.AUTOSARTemplates.CommonStructure.FlatMap import FlatInstanceDescriptor, FlatMap
 from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import ImplementationProps, Code
 from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity, InternalBehavior
-from ..models.M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroup, ModeRequestTypeMap, ModeDeclarationGroupPrototype
+from ..models.M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroup, ModeDeclarationGroupPrototypeMapping
+from ..models.M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeRequestTypeMap, ModeDeclarationGroupPrototype
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import ResourceConsumption
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.MemorySectionUsage import MemorySection
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import RoughEstimateStackUsage, StackUsage
@@ -67,11 +67,22 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.Execut
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingExtensions import SwcTiming, TimingExtension
 from ..models.M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger
 from ..models.M2.AUTOSARTemplates.DiagnosticExtract.DiagnosticContribution import DiagnosticServiceTable
-from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue
+from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucDefinitionElement
+from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucModuleDef, EcucInstanceReferenceValue
 from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue
 from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
 from ..models.M2.AUTOSARTemplates.EcuResourceTemplate import HwDescriptionEntity, HwElement, HwPinGroup
 from ..models.M2.AUTOSARTemplates.EcuResourceTemplate.HwElementCategory import HwAttributeDef, HwCategory, HwType
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucAbstractConfigurationClass, EcucAbstractInternalReferenceDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucFunctionNameDef, EcucReferenceDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucAbstractReferenceDef, EcucSymbolicNameReferenceDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucAbstractStringParamDef, EcucBooleanParamDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucValueConfigurationClass
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucCommonAttributes, EcucEnumerationLiteralDef, EcucEnumerationParamDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucFloatParamDef, EcucIntegerParamDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucChoiceContainerDef, EcucStringParamDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucContainerDef, EcucParameterDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucMultiplicityConfigurationClass, EcucParamConfContainerDef
 from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ElementCollection import Collection
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Describable, Identifiable
@@ -112,6 +123,8 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes im
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationRecordElement, AutosarDataPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import DataPrototype, ParameterDataPrototype, VariableDataPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ArgumentDataPrototype, ClientServerInterface, ClientServerInterfaceMapping
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ModeDeclarationMapping
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ModeDeclarationMappingSet, ModeInterfaceMapping
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ClientServerOperation, ClientServerOperationMapping
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import DataPrototypeMapping, InvalidationPolicy, ModeSwitchInterface
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ParameterInterface, PortInterface, PortInterfaceMappingSet
@@ -248,13 +261,45 @@ class ARXMLParser(AbstractARXMLParser):
         self.readSdgSdxRefs(element, sdg)
         return sdg
 
-    def readSdgs(self, element: ET.Element, admin_data: AdminData):
+    def readAdminDataSdgs(self, element: ET.Element, admin_data: AdminData):
         for child_element in self.findall(element, "SDGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "SDG":
                 admin_data.addSdg(self.getSdg(child_element))
             else:
                 self.notImplemented("Unsupported SDG <%s>" % tag_name)
+
+    def readModification(self, element: ET.Element, modification: Modification):
+        modification.setChange(self.getMultiLanguageOverviewParagraph(element, "CHANGE")) \
+                    .setReason(self.getMultiLanguageOverviewParagraph(element, "REASON"))
+
+    def readDocRevisionModifications(self, element: ET.Element, revision: DocRevision):
+        for child_element in self.findall(element, "MODIFICATIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "MODIFICATION":
+                modification = Modification()
+                self.readModification(child_element, modification)
+                revision.addModification(modification)
+            else:
+                self.notImplemented("Unsupported Modification <%s>" % tag_name)
+
+    def readDocRevision(self, element: ET.Element, revision: DocRevision):
+        revision.setDate(self.getChildElementOptionalDataTime(element, "DATE")) \
+                .setIssuedBy(self.getChildElementOptionalLiteral(element, "ISSUED-BY")) \
+                .setRevisionLabel(self.getChildElementOptionalRevisionLabelString(element, "REVISION-LABEL")) \
+                .setState(self.getChildElementOptionalLiteral(element, "STATE"))
+        
+        self.readDocRevisionModifications(element, revision)
+
+    def readAdminDataDocRevisions(self, element: ET.Element, admin_data: AdminData):
+        for child_element in self.findall(element, "DOC-REVISIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DOC-REVISION":
+                revision = DocRevision()
+                self.readDocRevision(child_element, revision)
+                admin_data.addDocRevision(revision)
+            else:
+                self.notImplemented("Unsupported DocRevision <%s>" % tag_name)
     
     def getAdminData(self, element: ET.Element, key: str) -> AdminData:
         admin_data = None
@@ -265,7 +310,8 @@ class ARXMLParser(AbstractARXMLParser):
             admin_data.setLanguage(self.getChildElementOptionalLiteral(child_element, "LANGUAGE")) \
                       .setUsedLanguages(self.getMultiLanguagePlainText(child_element, "USED-LANGUAGES"))
 
-            self.readSdgs(child_element, admin_data)
+            self.readAdminDataSdgs(child_element, admin_data)
+            self.readAdminDataDocRevisions(child_element, admin_data)
         return admin_data
     
     def readReferrable(self, element: ET.Element, referrable: Referrable):
@@ -4247,6 +4293,253 @@ class ARXMLParser(AbstractARXMLParser):
         self.readARElement(element, blueprint)
         blueprint.setInterfaceRef(self.getChildElementOptionalRefType(element, "INTERFACE-REF"))
 
+    def readModeDeclarationMappingFirstModeRefs(self, element: ET.Element, mapping: ModeDeclarationMapping):
+        for ref_link in self.getChildElementRefTypeList(element, "FIRST-MODE-REFS/FIRST-MODE-REF"):
+            mapping.addFirstModeRef(ref_link)
+
+    def readModeDeclarationMapping(self, element: ET.Element, mapping: ModeDeclarationMapping):
+        # self.logger.debug("Read ModeDeclarationMapping <%s>" % mapping.getShortName())
+        self.readIdentifiable(element, mapping)
+        self.readModeDeclarationMappingFirstModeRefs(element, mapping)
+        mapping.setSecondModeRef(self.getChildElementOptionalRefType(element, "SECOND-MODE-REF"))
+
+    def readModeDeclarationMappingSetModeDeclarationMappings(self, element: ET.Element, mapping_set: ModeDeclarationMappingSet):
+        for child_element in self.findall(element, "MODE-DECLARATION-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "MODE-DECLARATION-MAPPING":
+                mapping = mapping_set.createModeDeclarationMapping(self.getShortName(child_element))
+                self.readModeDeclarationMapping(child_element, mapping)
+            else:
+                self.notImplemented("Unsupported ModeDeclarationMapping <%s>" % tag_name)
+
+    def readModeDeclarationMappingSet(self, element: ET.Element, mapping_set: ModeDeclarationMappingSet):
+        self.logger.debug("Read ModeDeclarationMappingSet <%s>" % mapping_set.getShortName())
+        self.readARElement(element, mapping_set)
+        self.readModeDeclarationMappingSetModeDeclarationMappings(element, mapping_set)
+
+    def readEcucDefinitionElement(self, element: ET.Element, def_element: EcucDefinitionElement):
+        self.readIdentifiable(element, def_element)
+        def_element.setLowerMultiplicity(self.getChildElementOptionalPositiveInteger(element, "LOWER-MULTIPLICITY"))
+        def_element.setUpperMultiplicity(self.getChildElementOptionalPositiveInteger(element, "UPPER-MULTIPLICITY"))
+        def_element.setScope(self.getChildElementOptionalLiteral(element, "SCOPE"))
+        
+    def readEcucModuleDefSupportedConfigVariants(self, element: ET.Element, module_def: EcucModuleDef):
+        for variant in self.getChildElementLiteralValueList(element, "SUPPORTED-CONFIG-VARIANTS/SUPPORTED-CONFIG-VARIANT"):
+            module_def.addSupportedConfigVariant(variant)
+
+    def readEcucAbstractConfigurationClass(self, element: ET.Element, cfg_class: EcucAbstractConfigurationClass):
+        self.readARObjectAttributes(element, cfg_class)
+        cfg_class.setConfigClass(self.getChildElementOptionalLiteral(element, "CONFIG-CLASS"))
+        cfg_class.setConfigVariant(self.getChildElementOptionalLiteral(element, "CONFIG-VARIANT"))
+
+    def readEcucMultiplicityConfigurationClass(self, element: ET.Element, cfg_class: EcucMultiplicityConfigurationClass):
+        self.readEcucAbstractConfigurationClass(element, cfg_class)
+
+    def getEcucMultiplicityConfigurationClasses(self, element: ET.Element) -> List[EcucMultiplicityConfigurationClass]:
+        cfg_classes = []
+        for child_element in self.findall(element, "MULTIPLICITY-CONFIG-CLASSES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-MULTIPLICITY-CONFIGURATION-CLASS":
+                cfg_class = EcucMultiplicityConfigurationClass()
+                self.readEcucMultiplicityConfigurationClass(child_element, cfg_class)
+                cfg_classes.append(cfg_class)
+            else:
+                self.notImplemented("Unsupported MultiplicityConfigClass <%s>" % tag_name)
+        return cfg_classes
+
+    def readEcucContainerDef(self, element: ET.Element, container_def: EcucContainerDef):
+        self.readEcucDefinitionElement(element, container_def)
+        for cfg_class in self.getEcucMultiplicityConfigurationClasses(element):
+            container_def.addMultiplicityConfigClass(cfg_class)
+        container_def.setPostBuildVariantMultiplicity(self.getChildElementOptionalBooleanValue(element, "POST-BUILD-VARIANT-MULTIPLICITY"))
+        container_def.setRequiresIndex(self.getChildElementOptionalBooleanValue(element, "REQUIRES-INDEX"))
+        container_def.setMultipleConfigurationContainer(self.getChildElementOptionalBooleanValue(element, "MULTIPLE-CONFIGURATION-CONTAINER"))
+
+    def readEcucValueConfigurationClass(self, element: ET.Element, cfg_class: EcucValueConfigurationClass):
+        self.readEcucAbstractConfigurationClass(element, cfg_class)
+
+    def getEcucValueConfigurationClasses(self, element: ET.Element) -> List[EcucValueConfigurationClass]:
+        cfg_classes = []
+        for child_element in self.findall(element, "VALUE-CONFIG-CLASSES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-VALUE-CONFIGURATION-CLASS":
+                cfg_class = EcucValueConfigurationClass()
+                self.readEcucValueConfigurationClass(child_element, cfg_class)
+                cfg_classes.append(cfg_class)
+            else:
+                self.notImplemented("Unsupported ValueConfigClass <%s>" % tag_name)
+        return cfg_classes
+        
+    def readEcucCommonAttributes(self, element: ET.Element, common_attrs: EcucCommonAttributes):
+        self.readEcucDefinitionElement(element, common_attrs)
+        for cfg_class in self.getEcucMultiplicityConfigurationClasses(element):
+            common_attrs.addMultiplicityConfigClass(cfg_class)
+        common_attrs.setOrigin(self.getChildElementOptionalLiteral(element, "ORIGIN"))
+        common_attrs.setPostBuildVariantMultiplicity(self.getChildElementOptionalBooleanValue(element, "POST-BUILD-VARIANT-MULTIPLICITY"))
+        common_attrs.setPostBuildVariantValue(self.getChildElementOptionalBooleanValue(element, "POST-BUILD-VARIANT-VALUE"))
+        common_attrs.setRequiresIndex(self.getChildElementOptionalBooleanValue(element, "REQUIRES-INDEX"))
+        for cfg_class in self.getEcucValueConfigurationClasses(element):
+            common_attrs.addValueConfigClass(cfg_class)
+        
+    def readEcucParameterDef(self, element: ET.Element, param_def: EcucParameterDef):
+        self.readEcucCommonAttributes(element, param_def)
+        param_def.setDerivation(self.getChildElementOptionalLiteral(element, "DERIVATION"))
+        param_def.setSymbolicNameValue(self.getChildElementOptionalBooleanValue(element, "SYMBOLIC-NAME-VALUE"))
+        param_def.setWithAuto(self.getChildElementOptionalBooleanValue(element, "WITH-AUTO"))
+        
+    def readEcucBooleanParamDef(self, element: ET.Element, param_def: EcucBooleanParamDef):
+        self.readEcucParameterDef(element, param_def)
+        param_def.setDefaultValue(self.getChildElementOptionalBooleanValue(element, "DEFAULT-VALUE"))
+
+    def readEcucAbstractStringParamDef(self, element: ET.Element, param_def: EcucAbstractStringParamDef):
+        self.readEcucParameterDef(element, param_def)
+        param_def.setDefaultValue(self.getChildElementOptionalLiteral(element, "DEFAULT-VALUE"))
+        param_def.setMaxLength(self.getChildElementOptionalIntegerValue(element, "MAX-LENGTH"))
+        param_def.setMinLength(self.getChildElementOptionalIntegerValue(element, "MIN-LENGTH"))
+        param_def.setRegularExpression(self.getChildElementOptionalLiteral(element, "REGULAR-EXPRESSION"))
+
+    def readEcucStringParamDef(self, element: ET.Element, param_def: EcucStringParamDef):
+        self.readEcucAbstractStringParamDef(element, param_def)
+
+    def readEcucIntegerParamDef(self, element: ET.Element, param_def: EcucIntegerParamDef):
+        self.readEcucParameterDef(element, param_def)
+        param_def.setDefaultValue(self.getChildElementOptionalIntegerValue(element, "DEFAULT-VALUE"))
+        param_def.setMax(self.getChildElementOptionalIntegerValue(element, "MAX"))
+        param_def.setMin(self.getChildElementOptionalIntegerValue(element, "MIN"))
+
+    def readEcucFloatParamDef(self, element: ET.Element, param_def: EcucFloatParamDef):
+        self.readEcucParameterDef(element, param_def)
+        param_def.setDefaultValue(self.getChildElementOptionalFloatValue(element, "DEFAULT-VALUE"))
+        param_def.setMax(self.getChildLimitElement(element, "MAX"))
+        param_def.setMin(self.getChildLimitElement(element, "MIN"))
+
+    def readEcucEnumerationLiteral(self, element: ET.Element, literal: EcucEnumerationLiteralDef):
+        self.readIdentifiable(element, literal)
+        literal.setOrigin(self.getChildElementOptionalLiteral(element, "ORIGIN"))
+
+    def readEcucEnumerationParamDefLiterals(self, element: ET.Element, literal_def: EcucEnumerationParamDef):
+        for child_element in self.findall(element, "LITERALS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-ENUMERATION-LITERAL-DEF":
+                literal = literal_def.createLiteral(self.getShortName(child_element))
+                self.readEcucEnumerationLiteral(child_element, literal)
+            else:
+                self.notImplemented("Unsupported EnumerationLiteral <%s>" % tag_name)
+
+    def readEcucEnumerationParamDef(self, element: ET.Element, param_def: EcucEnumerationParamDef):
+        self.readEcucParameterDef(element, param_def)
+        param_def.setDefaultValue(self.getChildElementOptionalLiteral(element, "DEFAULT-VALUE"))
+        self.readEcucEnumerationParamDefLiterals(element, param_def)
+
+    def readEcucFunctionNameDef(self, element: ET.Element, ref_def: EcucFunctionNameDef):
+        self.readEcucAbstractStringParamDef(element, ref_def)
+        child_element = self.find(element, "ECUC-FUNCTION-NAME-DEF-VARIANTS/ECUC-FUNCTION-NAME-DEF-CONDITIONAL")
+        if child_element is not None:
+            ref_def.setDefaultValue(self.getChildElementOptionalLiteral(child_element, "DEFAULT-VALUE"))
+            ref_def.setMinLength(self.getChildElementOptionalIntegerValue(child_element, "MIN-LENGTH"))
+            ref_def.setMaxLength(self.getChildElementOptionalIntegerValue(child_element, "MAX-LENGTH"))
+
+    def readEcucContainerDefParameters(self, element: ET.Element, container_def: EcucParamConfContainerDef):
+        for child_element in self.findall(element, "PARAMETERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-BOOLEAN-PARAM-DEF":
+                param_def = container_def.createEcucBooleanParamDef(self.getShortName(child_element))
+                self.readEcucBooleanParamDef(child_element, param_def)
+            elif tag_name == "ECUC-STRING-PARAM-DEF":
+                param_def = container_def.createEcucStringParamDef(self.getShortName(child_element))
+                self.readEcucStringParamDef(child_element, param_def)
+            elif tag_name == "ECUC-INTEGER-PARAM-DEF":
+                param_def = container_def.createEcucIntegerParamDef(self.getShortName(child_element))
+                self.readEcucIntegerParamDef(child_element, param_def)
+            elif tag_name == "ECUC-FLOAT-PARAM-DEF":
+                param_def = container_def.createEcucFloatParamDef(self.getShortName(child_element))
+                self.readEcucFloatParamDef(child_element, param_def)
+            elif tag_name == "ECUC-ENUMERATION-PARAM-DEF":
+                param_def = container_def.createEcucEnumerationParamDef(self.getShortName(child_element))
+                self.readEcucEnumerationParamDef(child_element, param_def)
+            elif tag_name == "ECUC-FUNCTION-NAME-DEF":
+                param_def = container_def.createEcucFunctionNameDef(self.getShortName(child_element))
+                self.readEcucFunctionNameDef(child_element, param_def)
+            else:
+                self.notImplemented("Unsupported Parameter <%s>" % tag_name)
+
+    def readEcucAbstractReferenceDef(self, element: ET.Element, ref_def: EcucAbstractReferenceDef):
+        self.readEcucCommonAttributes(element, ref_def)
+        ref_def.setWithAuto(self.getChildElementOptionalBooleanValue(element, "WITH-AUTO"))
+
+    def readEcucAbstractInternalReferenceDef(self, element: ET.Element, ref_def: EcucAbstractInternalReferenceDef):
+        self.readEcucAbstractReferenceDef(element, ref_def)
+
+    def readEcucSymbolicNameReferenceDef(self, element: ET.Element, ref_def: EcucSymbolicNameReferenceDef):
+        self.readEcucAbstractInternalReferenceDef(element, ref_def)
+        ref_def.setDestinationRef(self.getChildElementOptionalRefType(element, "DESTINATION-REF"))
+
+    def readEcucReferenceDef(self, element: ET.Element, ref_def: EcucReferenceDef):
+        self.readEcucAbstractInternalReferenceDef(element, ref_def)
+        ref_def.setDestinationRef(self.getChildElementOptionalRefType(element, "DESTINATION-REF"))
+
+    def readEcucContainerDefReferences(self, element: ET.Element, container_def: EcucParamConfContainerDef):
+        for child_element in self.findall(element, "REFERENCES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-SYMBOLIC-NAME-REFERENCE-DEF":
+                ref_def = container_def.createEcucSymbolicNameReferenceDef(self.getShortName(child_element))
+                self.readEcucSymbolicNameReferenceDef(child_element, ref_def)
+            elif tag_name == "ECUC-REFERENCE-DEF":
+                ref_def = container_def.createEcucReferenceDef(self.getShortName(child_element))
+                self.readEcucReferenceDef(child_element, ref_def)
+            else:
+                self.notImplemented("Unsupported EcucReferenceDef <%s>" % tag_name)
+
+    def readEcucContainerDefSubContainers(self, element: ET.Element, container_def: EcucParamConfContainerDef):
+        for child_element in self.findall(element, "SUB-CONTAINERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-PARAM-CONF-CONTAINER-DEF":
+                sub_container_def = container_def.createEcucParamConfContainerDef(self.getShortName(child_element))
+                self.readEcucParamConfContainerDef(child_element, sub_container_def)
+            elif tag_name == "ECUC-CHOICE-CONTAINER-DEF":
+                sub_container_def = container_def.createEcucChoiceContainerDef(self.getShortName(child_element))
+                self.readEcucChoiceContainerDef(child_element, sub_container_def)
+            else:
+                self.notImplemented("Unsupported SubContainer <%s>" % tag_name)
+
+    def readEcucParamConfContainerDef(self, element: ET.Element, container_def: EcucParamConfContainerDef):
+        self.readEcucContainerDef(element, container_def)
+        self.readEcucContainerDefParameters(element, container_def)
+        self.readEcucContainerDefReferences(element, container_def)
+        self.readEcucContainerDefSubContainers(element, container_def)
+
+    def readEcucChoiceContainerDefChoices(self, element: ET.Element, container_def: EcucChoiceContainerDef):
+        for child_element in self.findall(element, "CHOICES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-PARAM-CONF-CONTAINER-DEF":
+                ref_def = container_def.createEcucParamConfContainerDef(self.getShortName(child_element))
+                self.readEcucParamConfContainerDef(child_element, ref_def)
+            else:
+                self.notImplemented("Unsupported Choice <%s>" % tag_name)
+
+    def readEcucChoiceContainerDef(self, element: ET.Element, container_def: EcucChoiceContainerDef):
+        self.readEcucContainerDef(element, container_def)
+        self.readEcucChoiceContainerDefChoices(element, container_def)
+
+    def readEcucModuleDefContainers(self, element: ET.Element, module_def: EcucModuleDef):
+        for child_element in self.findall(element, "CONTAINERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-PARAM-CONF-CONTAINER-DEF":
+                container_def = module_def.createEcucParamConfContainerDef(self.getShortName(child_element))
+                self.readEcucParamConfContainerDef(child_element, container_def)
+            elif tag_name == "ECUC-CHOICE-CONTAINER-DEF":
+                container_def = module_def.createEcucChoiceContainerDef(self.getShortName(child_element))
+                self.readEcucChoiceContainerDef(child_element, container_def)
+            else:
+                self.notImplemented("Unsupported Container <%s>" % tag_name)
+
+    def readEcucModuleDef(self, element: ET.Element, module_def: EcucModuleDef):
+        self.logger.debug("Read EcucModuleDef <%s>" % module_def.getShortName())
+        self.readEcucDefinitionElement(element, module_def)
+        module_def.setPostBuildVariantSupport(self.getChildElementOptionalBooleanValue(element, "POST-BUILD-VARIANT-SUPPORT"))
+        self.readEcucModuleDefSupportedConfigVariants(element, module_def)
+        self.readEcucModuleDefContainers(element, module_def)
+
     def readCommunicationController(self, element: ET.Element, controller: CommunicationController):
         controller.setWakeUpByControllerSupported(self.getChildElementOptionalBooleanValue(element, "WAKE-UP-BY-CONTROLLER-SUPPORTED"))
 
@@ -4696,13 +4989,13 @@ class ARXMLParser(AbstractARXMLParser):
     def readPhysicalDimension(self, element: ET.Element, dimension: PhysicalDimension):
         self.logger.debug("Read PhysicalDimension <%s>" % dimension.getShortName())
         self.readIdentifiable(element, dimension)
-        dimension.setLengthExp(self.getChildElementOptionalNumericalValue(element, "LENGTH-EXP")) \
-                 .setLuminousIntensityExp(self.getChildElementOptionalNumericalValue(element, "LUMINOUS-INTENSITY-EXP")) \
-                 .setMassExp(self.getChildElementOptionalNumericalValue(element, "MASS-EXP")) \
-                 .setMolarAmountExp(self.getChildElementOptionalNumericalValue(element, "MOLAR-AMOUNT-EXP")) \
-                 .setTemperatureExp(self.getChildElementOptionalNumericalValue(element, "TEMPERATURE-EXP")) \
-                 .setTimeExp(self.getChildElementOptionalNumericalValue(element, "TIME-EXP")) \
-                 .setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP"))
+        dimension.setLengthExp(self.getChildElementOptionalNumericalValue(element, "LENGTH-EXP"))
+        dimension.setLuminousIntensityExp(self.getChildElementOptionalNumericalValue(element, "LUMINOUS-INTENSITY-EXP"))
+        dimension.setMassExp(self.getChildElementOptionalNumericalValue(element, "MASS-EXP"))
+        dimension.setMolarAmountExp(self.getChildElementOptionalNumericalValue(element, "MOLAR-AMOUNT-EXP"))
+        dimension.setTemperatureExp(self.getChildElementOptionalNumericalValue(element, "TEMPERATURE-EXP"))
+        dimension.setTimeExp(self.getChildElementOptionalNumericalValue(element, "TIME-EXP"))
+        dimension.setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP"))
 
     def readISignalGroupISignalRef(self, element: ET.Element, group: ISignalGroup):
         for ref_type in self.getChildElementRefTypeList(element, "I-SIGNAL-REFS/I-SIGNAL-REF"):
@@ -5111,6 +5404,20 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, mapping)
         self.readClientServerInterfaceMappingOperationMappings(element, mapping)
 
+    def readModeInterfaceMappingModeMapping(self, element: ET.Element, mapping: ModeInterfaceMapping):
+        child_element = self.find(element, "MODE-MAPPING")
+        if child_element is not None:
+            mode_mapping = ModeDeclarationGroupPrototypeMapping()
+            mode_mapping.setFirstModeGroupRef(self.getChildElementOptionalRefType(child_element, "FIRST-MODE-GROUP-REF")) \
+                        .setModeDeclarationMappingSetRef(self.getChildElementOptionalRefType(child_element, "MODE-DECLARATION-MAPPING-SET-REF")) \
+                        .setSecondModeGroupRef(self.getChildElementOptionalRefType(child_element, "SECOND-MODE-GROUP-REF"))
+            mapping.setModeMapping(mode_mapping)
+
+    def readModeInterfaceMapping(self, element: ET.Element, mapping: ModeInterfaceMapping):
+        # self.logger.debug("Read ModeInterfaceMapping %s" % mapping.getShortName())
+        self.readIdentifiable(element, mapping)
+        self.readModeInterfaceMappingModeMapping(element, mapping)
+
     def readPortInterfaceMappings(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
         for child_element in self.findall(element, "PORT-INTERFACE-MAPPINGS/*"):
             tag_name = self.getTagName(child_element)
@@ -5120,6 +5427,9 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "CLIENT-SERVER-INTERFACE-MAPPING":
                 mapping = mapping_set.createClientServerInterfaceMapping(self.getShortName(child_element))
                 self.readClientServerInterfaceMapping(child_element, mapping)
+            elif tag_name == "MODE-INTERFACE-MAPPING":
+                mapping = mapping_set.createModeInterfaceMapping(self.getShortName(child_element))
+                self.readModeInterfaceMapping(child_element, mapping)
             else:
                 self.notImplemented("Unsupported PortInterfaceMapping <%s>" % tag_name)
 
@@ -5363,8 +5673,14 @@ class ARXMLParser(AbstractARXMLParser):
                 keyword_set = parent.createKeywordSet(self.getShortName(child_element))
                 self.readKeywordSet(child_element, keyword_set)
             elif tag_name == "PORT-PROTOTYPE-BLUEPRINT":
-                keyword_set = parent.createPortPrototypeBlueprint(self.getShortName(child_element))
-                self.readPortPrototypeBlueprint(child_element, keyword_set)
+                blueprint = parent.createPortPrototypeBlueprint(self.getShortName(child_element))
+                self.readPortPrototypeBlueprint(child_element, blueprint)
+            elif tag_name == "MODE-DECLARATION-MAPPING-SET":
+                mapping_set = parent.createModeDeclarationMappingSet(self.getShortName(child_element))
+                self.readModeDeclarationMappingSet(child_element, mapping_set)
+            elif tag_name == "ECUC-MODULE-DEF":
+                module_def = parent.createEcucModuleDef(self.getShortName(child_element))
+                self.readEcucModuleDef(child_element, module_def)
             else:
                 self.notImplemented("Unsupported Element type of ARPackage <%s>" % tag_name)
 

armodel/tests/test_armodel/models/test_ECUCParameterDefTemplate.py

@@ -0,0 +1,116 @@
+import pytest
+
+from ....models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
+from ....models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucChoiceContainerDef, EcucFloatParamDef, EcucParamConfContainerDef
+from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+# filepath: src/armodel/models/M2/AUTOSARTemplates/test_ECUCParameterDefTemplate.py
+
+
+class TestEcucChoiceContainerDef:
+    def test_initialization(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        short_name = "TestChoiceContainer"
+        choice_container = EcucChoiceContainerDef(parent, short_name)
+
+        assert choice_container.getShortName() == short_name
+        assert choice_container.getChoices() == []
+
+    def test_createEcucParamConfContainerDef(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        short_name = "TestChoiceContainer"
+        choice_container = EcucChoiceContainerDef(parent, short_name)
+
+        param_conf_container = choice_container.createEcucParamConfContainerDef("TestParamConfContainer")
+        assert param_conf_container.getShortName() == "TestParamConfContainer"
+        assert isinstance(param_conf_container, EcucParamConfContainerDef)
+        assert param_conf_container in choice_container.getChoices()
+
+    def test_createEcucParamConfContainerDef_duplicate(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        short_name = "TestChoiceContainer"
+        choice_container = EcucChoiceContainerDef(parent, short_name)
+
+        choice_container.createEcucParamConfContainerDef("TestParamConfContainer")
+        param_conf_container_duplicate = choice_container.createEcucParamConfContainerDef("TestParamConfContainer")
+
+        assert len(choice_container.getChoices()) == 1
+        assert param_conf_container_duplicate.getShortName() == "TestParamConfContainer"
+
+    def test_getChoices(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        short_name = "TestChoiceContainer"
+        choice_container = EcucChoiceContainerDef(parent, short_name)
+
+        choice_container.createEcucParamConfContainerDef("Choice1")
+        choice_container.createEcucParamConfContainerDef("Choice2")
+
+        choices = choice_container.getChoices()
+        assert len(choices) == 2
+        assert choices[0].getShortName() == "Choice1"
+        assert choices[1].getShortName() == "Choice2"
+
+        
+class TestEcucFloatParamDef:
+    def test_initialization(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        short_name = "TestFloatParam"
+        float_param = EcucFloatParamDef(parent, short_name)
+
+        assert float_param.getShortName() == short_name
+        assert float_param.getDefaultValue() is None
+        assert float_param.getMax() is None
+        assert float_param.getMin() is None
+
+    def test_set_and_get_default_value(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        float_param = EcucFloatParamDef(parent, "TestFloatParam")
+
+        default_value = 3.14
+        float_param.setDefaultValue(default_value)
+
+        assert float_param.getDefaultValue() == default_value
+
+    def test_set_and_get_max_value(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        float_param = EcucFloatParamDef(parent, "TestFloatParam")
+
+        max_value = 100.0
+        float_param.setMax(max_value)
+
+        assert float_param.getMax() == max_value
+
+    def test_set_and_get_min_value(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        float_param = EcucFloatParamDef(parent, "TestFloatParam")
+
+        min_value = 0.0
+        float_param.setMin(min_value)
+
+        assert float_param.getMin() == min_value
+
+    def test_set_max_to_none(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        float_param = EcucFloatParamDef(parent, "TestFloatParam")
+
+        float_param.setMax(None)
+
+        assert float_param.getMax() is None
+
+    def test_set_min_to_none(self):
+        document = AUTOSAR.getInstance()
+        parent = document.createARPackage("AUTOSAR")
+        float_param = EcucFloatParamDef(parent, "TestFloatParam")
+
+        float_param.setMin(None)
+
+        assert float_param.getMin() is None

armodel/tests/test_armodel/models/test_Identifiable.py

@@ -0,0 +1,85 @@
+import pytest
+
+from ....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import CollectableElement, Referrable
+
+
+class MockReferrable1(Referrable):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+
+class MockReferrable2(Referrable):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+
+class MockCollectableElement(CollectableElement):
+    def __init__(self):
+        super().__init__()
+
+
+class TestCollectableElement:
+
+    def setup_method(self):
+        '''
+            CollectableElement instance for testing.
+        '''
+        self.collectable_element = MockCollectableElement()
+        self.mock_referrable1 = MockReferrable1(None, "referrable")
+        self.mock_referrable2 = MockReferrable2(None, "referrable")
+
+    def test_getTotalElement(self):
+        assert self.collectable_element.getTotalElement() == 0
+        self.collectable_element.addElement(self.mock_referrable1)
+        assert self.collectable_element.getTotalElement() == 1
+
+    def test_addElement(self):
+        self.collectable_element.addElement(self.mock_referrable1)
+        assert self.collectable_element.getTotalElement() == 1
+        assert self.collectable_element.getElement("referrable", MockReferrable1) == self.mock_referrable1
+        self.collectable_element.addElement(self.mock_referrable2)
+        assert self.collectable_element.getTotalElement() == 2
+        assert self.collectable_element.getElement("referrable", MockReferrable2) == self.mock_referrable2
+
+    def test_removeElement(self):
+        self.collectable_element.addElement(self.mock_referrable1)
+        assert self.collectable_element.getTotalElement() == 1
+        self.collectable_element.addElement(self.mock_referrable2)
+        assert self.collectable_element.getTotalElement() == 2
+        self.collectable_element.removeElement("referrable", MockReferrable2)
+        assert self.collectable_element.getTotalElement() == 1
+        self.collectable_element.removeElement("referrable", MockReferrable1)
+        assert self.collectable_element.getTotalElement() == 0
+
+    def test_removeElement_non_existent_key(self):
+        self.collectable_element.addElement(self.mock_referrable1)
+        assert self.collectable_element.getTotalElement() == 1
+        try:
+            self.collectable_element.removeElement("non_existent", MockReferrable1)
+        except KeyError as ex:
+            assert str(ex) == "'Invalid key <non_existent> for removing element'"
+        assert self.collectable_element.getTotalElement() == 1
+
+    def test_getElements(self):
+        self.collectable_element.addElement(self.mock_referrable1)
+        self.collectable_element.addElement(self.mock_referrable1)
+        self.collectable_element.addElement(self.mock_referrable2)
+        elements = list(self.collectable_element.getElements())
+        assert len(elements) == 2
+        assert elements[0] == self.mock_referrable1
+        assert elements[1] == self.mock_referrable2
+
+    def test_getElement(self):
+        self.collectable_element.addElement(self.mock_referrable1)
+        element = self.collectable_element.getElement("referrable", MockReferrable1)
+        assert element == self.mock_referrable1
+        assert self.collectable_element.getElement("referrable", MockReferrable2) is None
+        assert self.collectable_element.getElement("non_existent", MockReferrable1) is None
+
+    def test_IsElementExists(self):
+        assert not self.collectable_element.IsElementExists("test_element")
+        self.collectable_element.addElement(self.mock_referrable1)
+        assert not self.collectable_element.IsElementExists("test_element")
+        assert self.collectable_element.IsElementExists("referrable")
+        assert self.collectable_element.IsElementExists("referrable", MockReferrable1)
+        assert not self.collectable_element.IsElementExists("referrable", MockReferrable2)