armodel 1.7.9__py3-none-any.whl → 1.8.1__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,12 +47,13 @@ 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
 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
@@ -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):
@@ -367,7 +413,7 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in self.findall(element, "%s/VARIABLE-ACCESS" % key):
             short_name = self.getShortName(child_element)
 
-            self.logger.debug("readVariableAccesses %s" % short_name)
+            # self.logger.debug("Read VariableAccesses %s" % short_name)
 
             if (key == "DATA-RECEIVE-POINT-BY-ARGUMENTS"):
                 variable_access = parent.createDataReceivePointByArgument(short_name)
@@ -400,7 +446,7 @@ class ARXMLParser(AbstractARXMLParser):
             ref = self.getChildElementOptionalRefType(child_element, "BSW-MODULE-ENTRY-REF")
             if (ref is not None):
                 parent.addImplementedEntryRef(ref)
-            self.logger.debug("ImplementedEntry <%s> of BswModuleDescription <%s> has been added", ref.value, parent.getShortName())
+            # self.logger.debug("ImplementedEntry <%s> of BswModuleDescription <%s> has been added", ref.value, parent.getShortName())
 
     def readModeDeclarationGroupPrototype(self, element: ET.Element, prototype: ModeDeclarationGroupPrototype):
         self.readIdentifiable(element, prototype)
@@ -429,7 +475,7 @@ class ARXMLParser(AbstractARXMLParser):
             entity.addCanEnterExclusiveAreaRef(ref)
 
     def readExecutableEntity(self, element: ET.Element, entity: ExecutableEntity):
-        self.logger.debug("readExecutableEntity %s" % entity.getShortName())
+        # self.logger.debug("Read ExecutableEntity %s" % entity.getShortName())
         self.readIdentifiable(element, entity)
         self.readCanEnterExclusiveAreaRefs(element, entity)
         entity.setMinimumStartInterval(self.getChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL")) \
@@ -448,7 +494,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBswEvent(element, event)
 
     def readBswModeSwitchEvent(self, element: ET.Element, event: BswModeSwitchEvent):
-        self.logger.debug("Read BswModeSwitchEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read BswModeSwitchEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
 
@@ -463,13 +509,13 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug(" Period: <%f, %s>" % (event.getPeriod().getValue(), event.getPeriod().getText()))
 
     def readBswDataReceivedEvent(self, element: ET.Element, event: BswDataReceivedEvent):
-        self.logger.debug("Read BswDataReceivedEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read BswDataReceivedEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setDataRef(self.getChildElementOptionalRefType(element, "DATA-REF"))
 
     def readBswInternalTriggerOccurredEvent(self, element: ET.Element, event: BswInternalTriggerOccurredEvent):
-        self.logger.debug("Read BswInternalTriggerOccurredEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read BswInternalTriggerOccurredEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
@@ -566,9 +612,12 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.raiseError("Unsupported assigned ports <%s>" % tag_name)
 
-    def readNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
-        self.logger.debug("Read NvBlockNeeds <%s>" % needs.getShortName())
+    def readServiceNeeds(self, element: ET.Element, needs: ServiceNeeds):
         self.readIdentifiable(element, needs)
+
+    def readNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
+        # self.logger.debug("Read NvBlockNeeds <%s>" % needs.getShortName())
+        self.readServiceNeeds(element, needs)
         needs.setCalcRamBlockCrc(self.getChildElementOptionalBooleanValue(element, "CALC-RAM-BLOCK-CRC")) \
              .setCheckStaticBlockId(self.getChildElementOptionalBooleanValue(element, "CHECK-STATIC-BLOCK-ID")) \
              .setNDataSets(self.getChildElementOptionalNumericalValue(element, "N-DATA-SETS")) \
@@ -590,21 +639,21 @@ class ARXMLParser(AbstractARXMLParser):
              .setWritingPriority(self.getChildElementOptionalLiteral(element, "WRITING-PRIORITY"))
         
     def readDiagnosticCapabilityElement(self, element: ET.Element, needs: DiagnosticCapabilityElement):
-        self.readIdentifiable(element, needs)
+        self.readServiceNeeds(element, needs)
         
     def readDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
-        self.logger.debug("Read DiagnosticCommunicationManagerNeeds <%s>" % needs.getShortName())
+        # self.logger.debug("Read DiagnosticCommunicationManagerNeeds <%s>" % needs.getShortName())
         self.readDiagnosticCapabilityElement(element, needs)
         needs.setServiceRequestCallbackType(self.getChildElementOptionalLiteral(element, "SERVICE-REQUEST-CALLBACK-TYPE"))
 
     def readDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
-        self.logger.debug("Read DiagnosticRoutineNeeds %s" % needs.getShortName())
+        # self.logger.debug("Read DiagnosticRoutineNeeds %s" % needs.getShortName())
         self.readDiagnosticCapabilityElement(element, needs)
         needs.setDiagRoutineType(self.getChildElementOptionalLiteral(element, "DIAG-ROUTINE-TYPE")) \
              .setRidNumber(self.getChildElementOptionalIntegerValue(element, "RID-NUMBER"))
 
     def readDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
-        self.logger.debug("Read DiagnosticValueNeeds %s" % needs.getShortName())
+        # self.logger.debug("Read DiagnosticValueNeeds %s" % needs.getShortName())
         self.readDiagnosticCapabilityElement(element, needs)
         needs.setDataLength(self.getChildElementOptionalPositiveInteger(element, "DATA-LENGTH")) \
              .setDiagnosticValueAccess(self.getChildElementOptionalLiteral(element, "DIAGNOSTIC-VALUE-ACCESS")) \
@@ -625,32 +674,36 @@ class ARXMLParser(AbstractARXMLParser):
                 self.notImplemented("Unsupported DiagEventDebounceAlgorithm <%s>" % tag_name)
     
     def readDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
-        self.logger.debug("Read DiagnosticEventNeeds <%s>" % needs.getShortName())
+        # self.logger.debug("Read DiagnosticEventNeeds <%s>" % needs.getShortName())
         self.readDiagnosticCapabilityElement(element, needs)
         self.readDiagEventDebounceAlgorithm(element, needs)
         needs.setDtcKind(self.getChildElementOptionalLiteral(element, "DTC-KIND")) \
              .setUdsDtcNumber(self.getChildElementOptionalIntegerValue(element, "UDS-DTC-NUMBER"))
         
     def readDiagnosticEventInfoNeeds(self, element: ET.Element, needs: DiagnosticEventInfoNeeds):
-        self.logger.debug("Read DiagnosticEventInfoNeeds <%s>" % needs.getShortName())
+        # self.logger.debug("Read DiagnosticEventInfoNeeds <%s>" % needs.getShortName())
         self.readDiagnosticCapabilityElement(element, needs)
         needs.setDtcKind(self.getChildElementOptionalLiteral(element, "DTC-KIND"))
         needs.setUdsDtcNumber(self.getChildElementOptionalPositiveInteger(element, "UDS-DTC-NUMBER"))
 
     def readCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
-        self.logger.debug("Read CryptoServiceNeeds <%s>" % needs.getShortName())
-        self.readIdentifiable(element, needs)
+        # self.logger.debug("Read CryptoServiceNeeds <%s>" % needs.getShortName())
+        self.readServiceNeeds(element, needs)
         needs.setMaximumKeyLength(self.getChildElementOptionalPositiveInteger(element, "MAXIMUM-KEY-LENGTH"))
 
     def readEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
-        self.logger.debug("Read EcuStateMgrUserNeeds %s" % needs.getShortName())
-        self.readIdentifiable(element, needs)
+        # self.logger.debug("Read EcuStateMgrUserNeeds %s" % needs.getShortName())
+        self.readServiceNeeds(element, needs)
 
     def readDtcStatusChangeNotificationNeeds(self, element: ET.Element, needs: DtcStatusChangeNotificationNeeds):
-        self.logger.debug("Read DtcStatusChangeNotificationNeeds %s" % needs.getShortName())
+        # self.logger.debug("Read DtcStatusChangeNotificationNeeds %s" % needs.getShortName())
         self.readDiagnosticCapabilityElement(element, needs)
         needs.setDtcFormatType(self.getChildElementOptionalLiteral(element, "DTC-FORMAT-TYPE"))
 
+    def readDltUserNeeds(self, element: ET.Element, needs: DltUserNeeds):
+        # self.logger.debug("Read DltUserNeeds %s" % needs.getShortName())
+        self.readServiceNeeds(element, needs)
+
     def readSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         for child_element in self.findall(element, "SERVICE-NEEDS/*"):
             tag_name = self.getTagName(child_element)
@@ -681,13 +734,16 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "DTC-STATUS-CHANGE-NOTIFICATION-NEEDS":
                 needs = parent.createDtcStatusChangeNotificationNeeds(self.getShortName(child_element))
                 self.readDtcStatusChangeNotificationNeeds(child_element, needs)
+            elif tag_name == "DLT-USER-NEEDS":
+                needs = parent.createDltUserNeeds(self.getShortName(child_element))
+                self.readDltUserNeeds(child_element, needs)
             else:
                 self.notImplemented("Unsupported service needs <%s>" % tag_name)
 
     def readSwcServiceDependency(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
         dependency = parent.createSwcServiceDependency(short_name)
-        self.logger.debug("read SwcServiceDependency %s" % short_name)
+        # self.logger.debug("Read SwcServiceDependency %s" % short_name)
         self.readServiceDependency(element, dependency)
         self.readSwcServiceDependencyAssignedData(element, dependency)
         self.readSwcServiceDependencyAssignedPorts(element, dependency)
@@ -831,15 +887,15 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBswModuleEntityIssuedTriggerRefs(element, entity)
     
     def readBswCalledEntity(self, element: ET.Element, entity: BswCalledEntity):
-        self.logger.debug("read BswCalledEntity %s" % entity.getShortName())
+        # self.logger.debug("Read BswCalledEntity %s" % entity.getShortName())
         self.readBswModuleEntity(element, entity)
 
     def readBswSchedulableEntity(self, element: ET.Element, entity: BswSchedulableEntity):
-        self.logger.debug("read BswSchedulableEntity %s" % entity.getShortName())
+        # self.logger.debug("Read BswSchedulableEntity %s" % entity.getShortName())
         self.readBswModuleEntity(element, entity)
 
     def readBswInterruptEntity(self, element: ET.Element, entity: BswInterruptEntity):
-        self.logger.debug("read BswSchedulableEntity %s" % entity.getShortName())
+        # self.logger.debug("Read BswSchedulableEntity %s" % entity.getShortName())
         self.readBswModuleEntity(element, entity)
         entity.setInterruptCategory(self.getChildElementOptionalLiteral(element, "INTERRUPT-CATEGORY")) \
               .setInterruptSource(self.getChildElementOptionalLiteral(element, "INTERRUPT-SOURCE"))
@@ -1056,8 +1112,6 @@ class ARXMLParser(AbstractARXMLParser):
              .setExecutionContext(self.getChildElementOptionalLiteral(element, "EXECUTION-CONTEXT")) \
              .setSwServiceImplPolicy(self.getChildElementOptionalLiteral(element, "SW-SERVICE-IMPL-POLICY"))
 
-        self.logger.debug("read BswModuleEntry %s" % entry.getShortName())
-
     def readEngineeringObject(self, element: ET.Element, engineering_obj: EngineeringObject):
         self.readARObjectAttributes(element, engineering_obj)
         engineering_obj.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
@@ -1066,7 +1120,7 @@ class ARXMLParser(AbstractARXMLParser):
     def getAutosarEngineeringObject(self, element: ET.Element) -> AutosarEngineeringObject:
         obj = AutosarEngineeringObject()
         self.readEngineeringObject(element, obj)
-        self.logger.debug("getAutosarEngineeringObject %s", obj.short_label)
+        # self.logger.debug("Get AutosarEngineeringObject %s", obj.short_label)
         return obj
 
     def readArtifactDescriptor(self, element: ET.Element, code_desc: Code):
@@ -1080,7 +1134,7 @@ class ARXMLParser(AbstractARXMLParser):
     def readCodeDescriptor(self, element: ET.Element, impl: Implementation):
         for child_element in self.findall(element, "CODE-DESCRIPTORS/CODE"):
             short_name = self.getShortName(child_element)
-            self.logger.debug("readCodeDescriptor %s" % short_name)
+            # self.logger.debug("Read CodeDescriptor %s" % short_name)
             code_desc = impl.createCodeDescriptor(short_name)
             self.readIdentifiable(child_element, code_desc)
             self.readArtifactDescriptor(child_element, code_desc)
@@ -1101,7 +1155,7 @@ class ARXMLParser(AbstractARXMLParser):
             memory_section.setSize(self.getChildElementOptionalNumericalValue(child_element, "SIZE")) \
                           .setSwAddrMethodRef(self.getChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF")) \
                           .setSymbol(self.getChildElementOptionalLiteral(child_element, "SYMBOL"))
-            self.logger.debug("read MemorySections %s" % memory_section.getShortName())
+            # self.logger.debug("read MemorySections %s" % memory_section.getShortName())
 
     def readStackUsage(self, element: ET.Element, usage: StackUsage):
         self.logger.debug("read StackUsage %s" % usage.getShortName())
@@ -1226,16 +1280,16 @@ class ARXMLParser(AbstractARXMLParser):
             parent.addModeIRef(mode_iref)
 
     def readSynchronousServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
+        # self.logger.debug("readSynchronousServerCallPoint %s" % short_name)
         short_name = self.getShortName(element)
-        self.logger.debug("readSynchronousServerCallPoint %s" % short_name)
         server_call_point = parent.createSynchronousServerCallPoint(short_name)
         self.readIdentifiable(element, server_call_point)
         server_call_point.setTimeout(self.getChildElementOptionalFloatValue(element, "TIMEOUT"))
         self.readROperationIRef(element, "OPERATION-IREF", server_call_point)
 
     def readAsynchronousServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
+        # self.logger.debug("readAsynchronousServerCallPoint %s" % short_name)
         short_name = self.getShortName(element)
-        self.logger.debug("readAsynchronousServerCallPoint %s" % short_name)
         server_call_point = parent.createAsynchronousServerCallPoint(short_name)
         self.readIdentifiable(element, server_call_point)
         server_call_point.setTimeout(self.getChildElementOptionalFloatValue(element, "TIMEOUT"))
@@ -1388,7 +1442,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.setOperationIRef(operation_iref)
 
     def readOperationInvokedEvent(self, element: ET.Element, event: OperationInvokedEvent):
-        self.logger.debug("Read OperationInvokedEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read OperationInvokedEvent <%s>" % event.getShortName())
         self.readPOperationIRef(element, "OPERATION-IREF", event)
         self.readRTEEvent(element, event)
 
@@ -1446,43 +1500,43 @@ class ARXMLParser(AbstractARXMLParser):
             behavior.addPortAPIOption(option)
             
     def readTimingEvent(self, element: ET.Element, event: TimingEvent):
-        self.logger.debug("Read TimingEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read TimingEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setOffset(self.getChildElementOptionalTimeValue(element, "OFFSET")) \
              .setPeriod(self.getChildElementOptionalTimeValue(element, "PERIOD"))
 
     def readDataReceivedEvent(self, element: ET.Element, event: DataReceivedEvent):
-        self.logger.debug("Read DataReceivedEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read DataReceivedEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         self.readRVariableInAtomicSwcInstanceRef(element, event)
 
     def readSwcModeSwitchEvent(self, element: ET.Element, event: SwcModeSwitchEvent):
-        self.logger.debug("Read SwcModeSwitchEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read SwcModeSwitchEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setActivation(self.getChildElementOptionalLiteral(element, "ACTIVATION"))
         self.readRModeInAtomicSwcInstanceRef(element, event)
 
     def readInternalTriggerOccurredEvent(self, element: ET.Element, event: InternalTriggerOccurredEvent):
-        self.logger.debug("Read InternalTriggerOccurredEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read InternalTriggerOccurredEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
     def readInitEvent(self, element, event: InitEvent):
-        self.logger.debug("Read InitEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read InitEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
 
     def readAsynchronousServerCallReturnsEvent(self, element, event: AsynchronousServerCallReturnsEvent):
-        self.logger.debug("Read AsynchronousServerCallReturnsEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read AsynchronousServerCallReturnsEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setActivationReasonRepresentationRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
     def readModeSwitchedAckEvent(self, element, event: ModeSwitchedAckEvent):
-        self.logger.debug("Read ModeSwitchedAckEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read ModeSwitchedAckEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
     def readBackgroundEvent(self, element, event: BackgroundEvent):
-        self.logger.debug("Read BackgroundEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read BackgroundEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
 
     def readSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
@@ -1749,7 +1803,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readAutosarDataType(element, data_type)
 
     def readApplicationRecordElement(self, element: ET.Element, record_element: ApplicationRecordElement):
-        self.logger.debug("read ApplicationRecordElement %s" % record_element.getShortName())
+        # self.logger.debug("Read ApplicationRecordElement %s" % record_element.getShortName())
         self.readApplicationCompositeElementDataPrototype(element, record_element)
 
     def readApplicationRecordDataTypeElements(self, element: ET.Element, parent: ApplicationRecordDataType):
@@ -1808,7 +1862,7 @@ class ARXMLParser(AbstractARXMLParser):
         return iref
 
     def getCompositeNetworkRepresentation(self, element: ET.Element) -> CompositeNetworkRepresentation:
-        self.logger.debug("getCompositeNetworkRepresentation")
+        # self.logger.debug("getCompositeNetworkRepresentation")
         representation = CompositeNetworkRepresentation()
         representation.setLeafElementIRef(self.getApplicationCompositeElementInPortInterfaceInstanceRef(element, "LEAF-ELEMENT-IREF")) \
                       .setNetworkRepresentation(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION"))
@@ -1839,7 +1893,7 @@ class ARXMLParser(AbstractARXMLParser):
         value_list = None
         child_element = self.find(element, key)
         if child_element is not None:
-            self.logger.debug("getValueList %s" % key)
+            # self.logger.debug("Get ValueList %s" % key)
             value_list = ValueList()
             self.readARObjectAttributes(child_element, value_list)
             value_list.setV(self.getChildElementOptionalFloatValue(child_element, "V"))
@@ -1849,7 +1903,7 @@ class ARXMLParser(AbstractARXMLParser):
         cont = None
         child_element = self.find(element, "SW-VALUE-CONT")
         if child_element is not None:
-            self.logger.debug("getSwValueCont")
+            # self.logger.debug("Get SwValueCont")
             cont = SwValueCont()
             self.readARObjectAttributes(child_element, cont)
             cont.setUnitRef(self.getChildElementOptionalRefType(child_element, "UNIT-REF")) \
@@ -1931,7 +1985,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readProvidedComSpec(element, prototype)
 
     def readPPortPrototype(self, element: ET.Element, prototype: PPortPrototype):
-        self.logger.debug("Read PPortPrototype %s" % prototype.getShortName())
+        # self.logger.debug("Read PPortPrototype %s" % prototype.getShortName())
         self.readIdentifiable(element, prototype)
         self.readAbstractRequiredPortPrototype(element, prototype)
         prototype.setProvidedInterfaceTRef(self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF"))
@@ -1940,13 +1994,13 @@ class ARXMLParser(AbstractARXMLParser):
         self.readRequiredComSpec(element, prototype)
 
     def readRPortPrototype(self, element: ET.Element, prototype: RPortPrototype):
-        self.logger.debug("Read RPortPrototype %s" % prototype.getShortName())
+        # self.logger.debug("Read RPortPrototype %s" % prototype.getShortName())
         self.readIdentifiable(element, prototype)
         self.readAbstractProvidedPortPrototype(element, prototype)
         prototype.setRequiredInterfaceTRef(self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF"))
 
     def readPRPortPrototype(self, element: ET.Element, prototype: PRPortPrototype):
-        self.logger.debug("Read PRPortPrototype %s" % prototype.getShortName())
+        # self.logger.debug("Read PRPortPrototype %s" % prototype.getShortName())
         self.readIdentifiable(element, prototype)
         self.readAbstractRequiredPortPrototype(element, prototype)
         self.readAbstractProvidedPortPrototype(element, prototype)
@@ -2093,6 +2147,7 @@ class ARXMLParser(AbstractARXMLParser):
         p_port_in_composition_instance_ref.setContextComponentRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")) \
                                           .setTargetPPortRef(self.getChildElementOptionalRefType(element, "TARGET-P-PORT-REF"))
         
+        '''
         self.logger.debug("PPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
                           % (p_port_in_composition_instance_ref.getContextComponentRef().getDest(),
@@ -2100,11 +2155,13 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s"
                           % (p_port_in_composition_instance_ref.getTargetPPortRef().getDest(),
                              p_port_in_composition_instance_ref.getTargetPPortRef().getValue()))
+        '''
 
     def readRPortInCompositionInstanceRef(self, element, r_port_in_composition_instance_ref: RPortInCompositionInstanceRef):
         r_port_in_composition_instance_ref.setContextComponentRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")) \
                                           .setTargetRPortRef(self.getChildElementOptionalRefType(element, "TARGET-R-PORT-REF"))
 
+        '''
         self.logger.debug("RPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
                           % (r_port_in_composition_instance_ref.getContextComponentRef().getDest(),
@@ -2112,6 +2169,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s"
                           % (r_port_in_composition_instance_ref.getTargetRPortRef().getDest(),
                              r_port_in_composition_instance_ref.getTargetRPortRef().getValue()))
+        '''
 
     def readAssemblySwConnectorProviderIRef(self, element: ET.Element, parent: AssemblySwConnector):
         child_element = self.find(element, "PROVIDER-IREF")
@@ -2134,7 +2192,7 @@ class ARXMLParser(AbstractARXMLParser):
         connector.setMappingRef(self.getChildElementOptionalRefType(element, "MAPPING-REF"))
 
     def readAssemblySwConnector(self, element: ET.Element, connector: AssemblySwConnector):
-        self.logger.debug("Read AssemblySwConnectors %s" % connector.getShortName())
+        # self.logger.debug("Read AssemblySwConnectors %s" % connector.getShortName())
         self.readSwConnector(element, connector)
         self.readAssemblySwConnectorProviderIRef(element, connector)
         self.readAssemblySwConnectorRequesterIRef(element, connector)
@@ -2171,7 +2229,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.raiseError("Unsupported child element of INNER-PORT-IREF")
 
     def readDelegationSwConnector(self, element, connector: DelegationSwConnector):
-        self.logger.debug("Read DelegationSwConnectors %s" % connector.getShortName())
+        # self.logger.debug("Read DelegationSwConnectors %s" % connector.getShortName())
         self.readSwConnector(element, connector)
         self.readDelegationSwConnectorInnerPortIRef(element, connector)
 
@@ -2179,7 +2237,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.raiseError("Invalid PortPrototype of DELEGATION-SW-CONNECTOR")
 
         connector.setOuterPortRef(self.getChildElementOptionalRefType(element, "OUTER-PORT-REF"))
-        self.logger.debug("OUTER-PORT-REF DEST: %s, %s" % (connector.getOuterPortRef().getDest(), connector.getOuterPortRef().getValue()))
+        # self.logger.debug("OUTER-PORT-REF DEST: %s, %s" % (connector.getOuterPortRef().getDest(), connector.getOuterPortRef().getValue()))
 
     def readSwComponentPrototype(self, element: ET.Element, prototype: SwComponentPrototype):
         self.logger.debug("Read SwComponentPrototypes <%s>" % prototype.getShortName())
@@ -2197,7 +2255,6 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readCompositionSwComponentTypeDataTypeMappingSet(self, element: ET.Element, parent: CompositionSwComponentType):
         child_element = self.find(element, "DATA-TYPE-MAPPING-REFS")
-        self.logger.debug("readDataTypeMappingSet")
         if child_element is not None:
             for ref in self.getChildElementRefTypeList(child_element, "DATA-TYPE-MAPPING-REF"):
                 parent.addDataTypeMapping(ref)
@@ -2331,7 +2388,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readParameterInterfaceParameters(element, interface)
 
     def readClientServerInterface(self, element: ET.Element, cs_interface: ClientServerInterface):
-        self.logger.debug("Read readClientServerInterface <%s>" % cs_interface.getShortName())
+        self.logger.debug("Read ClientServerInterface <%s>" % cs_interface.getShortName())
         self.readPortInterface(element, cs_interface)
         self.readClientServerInterfaceOperations(element, cs_interface)
         self.readPossibleErrors(element, cs_interface)
@@ -2366,7 +2423,7 @@ class ARXMLParser(AbstractARXMLParser):
     def readCompuConst(self, element: ET.Element, parent: CompuScale):
         child_element = self.find(element, "COMPU-CONST/VT")
         if (child_element is not None):
-            self.logger.debug("readCompuConst VT: %s" % child_element.text)
+            # self.logger.debug("Read CompuConst VT: %s" % child_element.text)
             contents = CompuScaleConstantContents()
             contents.compuConst = CompuConst()
             contents.compuConst.compuConstContentType = CompuConstTextContent()
@@ -2376,13 +2433,13 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readCompuNominatorDenominator(self, element: ET.Element, key: str, parent: CompuNominatorDenominator):
         for child_element in self.findall(element, "%s/V" % key):
-            self.logger.debug("readCompuNominatorDenominator - %s: %s" % (key, child_element.text))
+            # self.logger.debug("Read CompuNominatorDenominator - %s: %s" % (key, child_element.text))
             parent.add_v(child_element.text)
 
     def readCompuRationCoeffs(self, element: ET.Element, parent: CompuScale):
         child_element = self.find(element, "COMPU-RATIONAL-COEFFS")
         if (child_element is not None):
-            self.logger.debug("readCompuRationCoeffs")
+            # self.logger.debug("Read CompuRationCoeffs")
             contents = CompuScaleRationalFormula()
             contents.compuRationalCoeffs = CompuRationalCoeffs()
             contents.compuRationalCoeffs.compuDenominator = CompuNominatorDenominator()
@@ -2426,7 +2483,7 @@ class ARXMLParser(AbstractARXMLParser):
         return compu
 
     def readCompuMethod(self, element: ET.Element, compu_method: CompuMethod):
-        self.logger.debug("Read CompuMethods <%s>" % compu_method.getShortName())
+        self.logger.debug("Read CompuMethod <%s>" % compu_method.getShortName())
         self.readIdentifiable(element, compu_method)
         compu_method.setUnitRef(self.getChildElementOptionalRefType(element, "UNIT-REF")) \
                     .setCompuInternalToPhys(self.getCompu(element, "COMPU-INTERNAL-TO-PHYS")) \
@@ -2440,7 +2497,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.addRunnableMapping(mapping)
 
     def readSwcBswMapping(self, element: ET.Element, mapping: SwcBswMapping):
-        self.logger.debug("read SwcBswMappings %s" % mapping.getShortName())
+        self.logger.debug("Read SwcBswMapping <%s>" % mapping.getShortName())
         self.readIdentifiable(element, mapping)
         mapping.setBswBehaviorRef(self.getChildElementOptionalRefType(element, "BSW-BEHAVIOR-REF"))
         self.readSwcBswMappingSwcBswRunnableMappings(element, mapping)
@@ -2467,7 +2524,7 @@ class ARXMLParser(AbstractARXMLParser):
         return value_spec
     
     def getTextValueSpecification(self, element: ET.Element) -> TextValueSpecification:
-        self.logger.debug("getTextValueSpecification")
+        # self.logger.debug("Get TextValueSpecification")
         value_spec = TextValueSpecification()
         self.readValueSpecification(element, value_spec)
         value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
@@ -2475,7 +2532,7 @@ class ARXMLParser(AbstractARXMLParser):
         return value_spec
 
     def getArrayValueSpecification(self, element: ET.Element) -> ArrayValueSpecification:
-        self.logger.debug("getArrayValueSpecification")
+        # self.logger.debug("Get ArrayValueSpecification")
         value_spec = ArrayValueSpecification()
         self.readValueSpecification(element, value_spec)
         child_elements = element.findall("./xmlns:ELEMENTS/*", self.nsmap)
@@ -2484,7 +2541,7 @@ class ARXMLParser(AbstractARXMLParser):
         return value_spec
 
     def getConstantReference(self, element: ET.Element) -> ConstantReference:
-        self.logger.debug("getConstantReference")
+        # self.logger.debug("getConstantReference")
         value_spec = ConstantReference()
         self.readValueSpecification(element, value_spec)
         value_spec.setConstantRef(self.getChildElementOptionalRefType(element, "CONSTANT-REF"))
@@ -2518,7 +2575,7 @@ class ARXMLParser(AbstractARXMLParser):
         return value_spec
 
     def readConstantSpecification(self, element: ET.Element, spec: ConstantSpecification):
-        self.logger.debug("readConstantSpecification %s" % spec.getShortName())
+        self.logger.debug("Read ConstantSpecification <%s>" % spec.getShortName())
         self.readIdentifiable(element, spec)
         for child_element in self.findall(element, "VALUE-SPEC/*"):
             spec.setValueSpec(self.getValueSpecification(child_element, self.getTagName(child_element)))
@@ -2533,7 +2590,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.internalConstrs = constrs
 
     def readPhysConstrs(self, element: ET.Element, parent: DataConstrRule):
-        child_element = element.find("./xmlns:PHYS-CONSTRS", self.nsmap)
+        child_element = self.find(element, "PHYS-CONSTRS")
         if child_element is not None:
             constrs = PhysConstrs()
             self.readARObjectAttributes(child_element, constrs)
@@ -2543,8 +2600,8 @@ class ARXMLParser(AbstractARXMLParser):
             parent.physConstrs = constrs
                 
     def readDataConstrRule(self, element: ET.Element, parent: DataConstr):
-        for child_element in element.findall("./xmlns:DATA-CONSTR-RULES/xmlns:DATA-CONSTR-RULE", self.nsmap):
-            self.logger.debug("readDataConstrRule")
+        for child_element in self.findall(element, "DATA-CONSTR-RULES/DATA-CONSTR-RULE"):
+            # self.logger.debug("Read DataConstrRule")
             rule = DataConstrRule()
             self.readARObjectAttributes(child_element, rule)
             rule.constrLevel = self.getChildElementOptionalNumericalValue(child_element, "CONSTR-LEVEL")
@@ -2553,7 +2610,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.addDataConstrRule(rule)
                 
     def readDataConstr(self, element: ET.Element, constr: DataConstr):
-        self.logger.debug("Read DataConstr <%s>" % constr.getShortName())
+        # self.logger.debug("Read DataConstr <%s>" % constr.getShortName())
         self.readIdentifiable(element, constr)
         self.readDataConstrRule(element, constr)
 
@@ -4236,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"))
 
@@ -4685,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"):
@@ -4810,7 +5114,7 @@ class ARXMLParser(AbstractARXMLParser):
         timing = None
         child_element = self.find(element, key)
         if child_element is not None:
-            self.logger.debug("Get TransmissionModeTiming of <%s>" % key)
+            # self.logger.debug("Get TransmissionModeTiming of <%s>" % key)
             timing = TransmissionModeTiming()
             timing.setCyclicTiming(self.getCyclicTiming(child_element, "CYCLIC-TIMING")) \
                   .setEventControlledTiming(self.getEventControlledTiming(child_element, "EVENT-CONTROLLED-TIMING"))
@@ -4919,7 +5223,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self.notImplemented("Unsupported Data Mapping %s" % tag_name)
 
     def readSwcToEcuMapping(self, element: ET.Element, mapping: SwcToEcuMapping):
-        self.logger.debug("SwcToEcuMapping %s" % mapping.getShortName())
+        # self.logger.debug("SwcToEcuMapping %s" % mapping.getShortName())
         self.readIdentifiable(element, mapping)
         for child_element in self.findall(element, "COMPONENT-IREFS/COMPONENT-IREF"):
             mapping.addComponentIRef(self.getComponentInSystemInstanceRef(child_element))
@@ -4964,7 +5268,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self.notImplemented("Unsupported SwImplMapping <%s>" % tag_name)
 
     def readSystemMapping(self, element: ET.Element, mapping: SystemMapping):
-        self.logger.debug("SystemMapping %s" % mapping.getShortName())
+        # self.logger.debug("Read SystemMapping <%s>" % mapping.getShortName())
         self.readIdentifiable(element, mapping)
         self.readSystemMappingDataMappings(element, mapping)
         self.readSystemMappingEcuResourceMappings(element, mapping)
@@ -5100,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)
@@ -5109,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)
 
@@ -5352,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)
 
@@ -5368,7 +5695,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.addReferenceBase(base)
 
     def readARPackage(self, element: ET.Element, ar_package: ARPackage):
-        self.logger.debug("Read ARPackages %s" % ar_package.getFullName())
+        self.logger.debug("Read ARPackages <%s>" % ar_package.getFullName())
 
         self.readIdentifiable(element, ar_package)
         self.readARPackages(element, ar_package)