armodel 1.7.1__py3-none-any.whl → 1.7.3__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -2,10 +2,14 @@ from typing import List
 import xml.etree.ElementTree as ET
 import os
 
+
+
+
+
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition
 from ..models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstrRule, InternalConstrs, PhysConstrs, DataConstr
-from ..models.M2.MSR.AsamHdo.ComputationMethod import CompuMethod, Compu, CompuConst, CompuConstTextContent, CompuNominatorDenominator, CompuRationalCoeffs, CompuScale, CompuScaleConstantContents, CompuScaleRationalFormula, CompuScales
+from ..models.M2.MSR.AsamHdo.ComputationMethod import CompuConstContent, CompuConstFormulaContent, CompuConstNumericContent, CompuMethod, Compu, CompuConst, CompuConstTextContent, CompuNominatorDenominator, CompuRationalCoeffs, CompuScale, CompuScaleConstantContents, CompuScaleRationalFormula, CompuScales
 from ..models.M2.MSR.AsamHdo.SpecialData import Sdg, Sd
 from ..models.M2.MSR.CalibrationData.CalibrationValue import SwValueCont, SwValues
 from ..models.M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps, SwPointerTargetProps
@@ -15,6 +19,7 @@ from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayoutGroupConte
 from ..models.M2.MSR.DataDictionary.DataDefProperties import ValueList
 from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayoutGroup
 from ..models.M2.MSR.DataDictionary.CalibrationParameter import SwCalprmAxisSet
+from ..models.M2.MSR.DataDictionary.ServiceProcessTask import SwServiceArg
 from ..models.M2.MSR.Documentation.Annotation import Annotation, GeneralAnnotation
 from ..models.M2.MSR.Documentation.TextModel.BlockElements import DocumentationBlock
 from ..models.M2.MSR.Documentation.TextModel.BlockElements.ListElements import ListElement
@@ -22,18 +27,21 @@ from ..models.M2.MSR.Documentation.TextModel.LanguageDataModel import LLongName,
 from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultiLanguagePlainText, MultilanguageLongName
 
 from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalBehavior, BswModuleEntity, BswScheduleEvent, BswModeSenderPolicy
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswDataReceivedEvent, BswInternalBehavior, BswInternalTriggerOccurredEvent, BswInterruptEntity, BswModeSwitchEvent, BswModuleEntity, BswSchedulableEntity, BswScheduleEvent, BswModeSenderPolicy, BswTimingEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswImplementation import BswImplementation
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
 from ..models.M2.AUTOSARTemplates.CommonStructure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, NumericalValueSpecification, RecordValueSpecification, TextValueSpecification, ValueSpecification
 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.ModeDeclaration import ModeDeclarationGroup, 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.InternalBehavior import ExecutableEntity, InternalBehavior
 from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
-from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import RoleBasedDataAssignment, ServiceDependency
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceAlgorithm, DiagEventDebounceMonitorInternal, DiagnosticEventNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
 from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import Implementation
 from ..models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import ExecutionOrderConstraint
@@ -55,13 +63,13 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import Compo
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import InnerPortGroupInCompositionInstanceRef, PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef, RModeInAtomicSwcInstanceRef, RVariableInAtomicSwcInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior import RunnableEntity, RunnableEntityArgument, SwcInternalBehavior
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import CompositionSwComponentType, PortGroup, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, CompositionSwComponentType, PortGroup, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import AssemblySwConnector, DelegationSwConnector
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet, ModeAccessPoint
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import ClientComSpec, ModeSwitchReceiverComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, ParameterRequireComSpec, QueuedReceiverComSpec, QueuedSenderComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ArgumentDataPrototype, ClientServerInterface, ClientServerOperation, InvalidationPolicy, ModeSwitchInterface, ParameterInterface, PortInterface, SenderReceiverInterface
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ArgumentDataPrototype, ClientServerInterface, ClientServerOperation, DataPrototypeMapping, InvalidationPolicy, ModeSwitchInterface, ParameterInterface, PortInterface, PortInterfaceMappingSet, SenderReceiverInterface, VariableAndParameterInterfaceMapping
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AtomicSwComponentType
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationCompositeElementDataPrototype, AutosarDataPrototype, DataPrototype, ParameterDataPrototype, VariableDataPrototype
 
@@ -111,7 +119,7 @@ class ARXMLParser(AbstractARXMLParser):
         return sdg
     
     def readSdgs(self, element: ET.Element, admin_data: AdminData):
-        for child_element in self.findall(element, "./SDGS/SDG"):
+        for child_element in self.findall(element, "SDGS/SDG"):
             admin_data.addSdg(self.getSdg(child_element))
     
     def getAdminData(self, element: ET.Element, key: str) -> AdminData:
@@ -127,7 +135,7 @@ class ARXMLParser(AbstractARXMLParser):
         return admin_data
 
     def readMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
-        self.readElementAttributes(element, referrable)
+        self.readARObjectAttributes(element, referrable)
         referrable.setLongName(self.getMultilanguageLongName(element, "LONG-NAME"))
     
     def readIdentifiable(self, element: ET.Element, identifiable: Identifiable):
@@ -143,9 +151,9 @@ class ARXMLParser(AbstractARXMLParser):
         identifiable.setAdminData(self.getAdminData(element, "ADMIN-DATA"))
     
     def readLLongName(self, element: ET.Element, long_name: MultilanguageLongName):
-        for child_element in self.findall(element, "./L-4"):
+        for child_element in self.findall(element, "L-4"):
             l4 = LLongName()
-            self.readElementAttributes(child_element, l4)
+            self.readARObjectAttributes(child_element, l4)
             l4.value = child_element.text
             if 'L' in child_element.attrib:
                 l4.l = child_element.attrib['L']
@@ -153,17 +161,17 @@ class ARXMLParser(AbstractARXMLParser):
     
     def getMultilanguageLongName(self, element: ET.Element, key: str) -> MultilanguageLongName:
         long_name = None
-        child_element = self.find(element, "./%s" % key)
+        child_element = self.find(element, "%s" % key)
         if child_element is not None:
             long_name = MultilanguageLongName()
-            self.readElementAttributes(child_element, long_name)
+            self.readARObjectAttributes(child_element, long_name)
             self.readLLongName(child_element, long_name)
         return long_name
     
     def readLOverviewParagraph(self, element: ET.Element, paragraph: MultiLanguageOverviewParagraph):
-        for child_element in self.findall(element, "./L-2"):
+        for child_element in self.findall(element, "L-2"):
             l2 = LOverviewParagraph()
-            self.readElementAttributes(child_element, l2)
+            self.readARObjectAttributes(child_element, l2)
             l2.value = child_element.text
             if 'L' in child_element.attrib:
                 l2.l = child_element.attrib['L']
@@ -171,10 +179,10 @@ class ARXMLParser(AbstractARXMLParser):
     
     def getMultiLanguageOverviewParagraph(self, element: ET.Element, key: str) -> MultiLanguageOverviewParagraph:
         paragraph = None
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         if child_element is not None:
             paragraph = MultiLanguageOverviewParagraph()
-            self.readElementAttributes(child_element, paragraph)
+            self.readARObjectAttributes(child_element, paragraph)
             self.readLOverviewParagraph(child_element, paragraph)
         return paragraph
     
@@ -182,7 +190,7 @@ class ARXMLParser(AbstractARXMLParser):
         iref  = None
         if element is not None:
             iref = VariableInAtomicSWCTypeInstanceRef()
-            self.readElementAttributes(element, iref)
+            self.readARObjectAttributes(element, iref)
             iref.setPortPrototypeRef(self.getChildElementOptionalRefType(element, "PORT-PROTOTYPE-REF"))
             iref.setTargetDataPrototypeRef(self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF"))
         return iref
@@ -191,7 +199,7 @@ class ARXMLParser(AbstractARXMLParser):
         iref  = None
         if element is not None:
             iref = ComponentInSystemInstanceRef()
-            self.readElementAttributes(element, iref)
+            self.readARObjectAttributes(element, iref)
             iref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF"))
             iref.setContextCompositionRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF"))
             iref.setTargetComponentRef(self.getChildElementOptionalRefType(element, "TARGET-COMPONENT-REF"))
@@ -202,6 +210,7 @@ class ARXMLParser(AbstractARXMLParser):
         ref  = None
         if (child_element is not None):
             ref = AutosarVariableRef()
+            #self.readARObjectAttributes(child_element, ref)
             ref.setAutosarVariableIRef(self.getVariableInAtomicSWCTypeInstanceRef(self.find(child_element, "AUTOSAR-VARIABLE-IREF")))
         return ref
 
@@ -214,7 +223,7 @@ class ARXMLParser(AbstractARXMLParser):
         return ref
 
     def _readVariableAccesses(self, element: ET.Element, parent: RunnableEntity, key: str):
-        for child_element in element.findall("./xmlns:%s/xmlns:VARIABLE-ACCESS" % key, self.nsmap):
+        for child_element in self.findall(element, "%s/VARIABLE-ACCESS" % key):
             short_name = self.getShortName(child_element)
 
             self.logger.debug("readVariableAccesses %s" % short_name)
@@ -241,12 +250,12 @@ class ARXMLParser(AbstractARXMLParser):
                 variable_access = parent.createReadLocalVariable(short_name)
                 variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element))
             else:
-                self._raiseError("Invalid key type <%s>" % key)
+                self.notImplemented("Unsupported Variable Accesss <%s>" % key)
 
             self.readIdentifiable(child_element, variable_access)
 
     def readBswModuleDescriptionImplementedEntry(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in element.findall("./xmlns:PROVIDED-ENTRYS/xmlns:BSW-MODULE-ENTRY-REF-CONDITIONAL", self.nsmap):
+        for child_element in self.findall(element, "PROVIDED-ENTRYS/BSW-MODULE-ENTRY-REF-CONDITIONAL"):
             ref = self.getChildElementOptionalRefType(child_element, "BSW-MODULE-ENTRY-REF") 
             if (ref is not None):
                 parent.addImplementedEntry(ref)
@@ -257,7 +266,7 @@ class ARXMLParser(AbstractARXMLParser):
         prototype.type_tref = self.getChildElementOptionalRefType(element, "TYPE-TREF")
 
     def readProvidedModeGroup(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in element.findall("./xmlns:PROVIDED-MODE-GROUPS/xmlns:MODE-DECLARATION-GROUP-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "PROVIDED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readProvidedModeGroup %s" % short_name)
 
@@ -265,7 +274,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.readModeDeclarationGroupPrototype(child_element, mode_group)
 
     def readRequiredModeGroup(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in element.findall("./xmlns:REQUIRED-MODE-GROUPS/xmlns:MODE-DECLARATION-GROUP-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "REQUIRED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readRequiredModeGroup %s" % short_name)
             mode_group = parent.createProvidedModeGroup(short_name)
@@ -283,71 +292,45 @@ class ARXMLParser(AbstractARXMLParser):
               .setSwAddrMethodRef(self.getChildElementOptionalRefType(element, "SW-ADDR-METHOD-REF"))
 
     def readBswModuleEntityManagedModeGroup(self, element: ET.Element, entity: BswModuleEntity):
-        for child_element in self.findall(element, "./MANAGED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE-REF-CONDITIONAL"):
+        for child_element in self.findall(element, "sMANAGED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE-REF-CONDITIONAL"):
             ref_type = self.getChildElementOptionalRefType(child_element, "MODE-DECLARATION-GROUP-PROTOTYPE-REF")
             if ref_type is not None:
                 entity.addManagedModeGroupRef(ref_type)
 
-    def readBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
-        self.readExecutableEntity(element, entity)
-        entity.setImplementedEntryRef(self.getChildElementRefType(entity.getShortName(), element, "IMPLEMENTED-ENTRY-REF"))
-        self.readBswModuleEntityManagedModeGroup(element, entity)
-
-    def readBswCalledEntity(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in element.findall("./xmlns:ENTITYS/xmlns:BSW-CALLED-ENTITY", self.nsmap):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readBswCalledEntity %s" % short_name)
-            entity = parent.createBswCalledEntity(short_name)
-
-            self.readBswModuleEntity(child_element, entity)
-
-    def readBswSchedulableEntity(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in element.findall("./xmlns:ENTITYS/xmlns:BSW-SCHEDULABLE-ENTITY", self.nsmap):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readBswSchedulableEntity %s" % short_name)
-            entity = parent.createBswSchedulableEntity(short_name)
-            self.readBswModuleEntity(child_element, entity)
+    
 
     def readBswEvent(self, element: ET.Element, event: BswScheduleEvent):
-        event.startsOnEventRef = self.getChildElementRefType(event.getShortName(), element, "STARTS-ON-EVENT-REF")
+        event.startsOnEventRef = self.getChildElementOptionalRefType(element, "STARTS-ON-EVENT-REF")
 
     def readBswScheduleEvent(self, element, event: BswScheduleEvent):
         self.readBswEvent(element, event)
 
-    def readBswModeSwitchEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:BSW-MODE-SWITCH-EVENT", self.nsmap):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readBswModeSwitchEvent %s" % short_name)
-            event = parent.createBswModeSwitchEvent(short_name)
-            # Read the Inherit BswScheduleEvent
-            self.readBswScheduleEvent(child_element, event)
+    def readBswModeSwitchEvent(self, element: ET.Element, event: BswModeSwitchEvent):
+        self.logger.debug("read BswModeSwitchEvent %s" % event.getShortName())
+        # Read the Inherit BswScheduleEvent
+        self.readBswScheduleEvent(element, event)
+
+    def readBswTimingEvent(self, element: ET.Element, event: BswTimingEvent):
+        self.logger.debug("read BswTimingEvent %s" % event.getShortName())
+        # Read the Inherit BswScheduleEvent
+        self.readBswScheduleEvent(element, event)
+        event.setPeriod(self.getChildElementOptionalTimeValue(element, "PERIOD"))
+        if event.getPeriod() is None:
+            self.logger.warning("Period of BswTimingEvent <%s> is invalid." % event.getShortName())
+        else:
+            self.logger.debug(" Period: <%f, %s>" % (event.getPeriod().getValue(), event.getPeriod().getText()))
 
-    def readBswTimingEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:BSW-TIMING-EVENT", self.nsmap):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readBswTimingEvent %s" % short_name)
-            event = parent.createBswTimingEvent(short_name)
-            event.period = self.getChildElementOptionalFloatValue(child_element, "PERIOD")
-            # Read the Inherit BswScheduleEvent
-            self.readBswScheduleEvent(child_element, event)
-
-    def readBswDataReceivedEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:BSW-DATA-RECEIVED-EVENT", self.nsmap):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readBswDataReceivedEvent %s" % short_name)
-            event = parent.createBswDataReceivedEvent(short_name)
-            event.data_ref = self.getChildElementRefType(parent.getShortName(), child_element, "DATA-REF")
-            # Read the Inherit BswScheduleEvent
-            self.readBswScheduleEvent(child_element, event)
-
-    def readBswInternalTriggerOccurredEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in self.findall(element, "./EVENTS/BSW-INTERNAL-TRIGGER-OCCURRED-EVENT"):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readBswInternalTriggerOccurredEvent %s" % short_name)
-            event = parent.createBswInternalTriggerOccurredEvent(short_name)
-            event.event_source_ref = self.getChildElementRefType(parent.getShortName(), child_element, "EVENT-SOURCE-REF")
-            # Read the Inherit BswScheduleEvent
-            self.readBswScheduleEvent(child_element, event)
+    def readBswDataReceivedEvent(self, element: ET.Element, event: BswDataReceivedEvent):
+        self.logger.debug("read BswTimingEvent %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 BswTimingEvent %s" % event.getShortName())
+        # Read the Inherit BswScheduleEvent
+        self.readBswScheduleEvent(element, event)
+        event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
     def getBswModeSenderPolicy(self, element: ET.Element) -> BswModeSenderPolicy:
         policy = BswModeSenderPolicy()
@@ -356,7 +339,7 @@ class ARXMLParser(AbstractARXMLParser):
         return policy
 
     def readBswInternalBehaviorModeSenderPolicy(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in self.findall(element, "./MODE-SENDER-POLICYS/*"):
+        for child_element in self.findall(element, "MODE-SENDER-POLICYS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "BSW-MODE-SENDER-POLICY":
                 parent.addModeSenderPolicy(self.getBswModeSenderPolicy(child_element))
@@ -364,13 +347,13 @@ class ARXMLParser(AbstractARXMLParser):
                 self._raiseError("Unsupported ModeSenderPolicy type <%s>." % tag_name)
 
     def readDataTypeMappingRefs(self, element: ET.Element, behavior: InternalBehavior):
-        child_element = element.find("./xmlns:DATA-TYPE-MAPPING-REFS", self.nsmap)
+        child_element = self.find(element, "DATA-TYPE-MAPPING-REFS")
         if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-MAPPING-REF"):
+            for ref in self.getChildElementRefTypeList(child_element, "DATA-TYPE-MAPPING-REF"):
                 behavior.addDataTypeMappingRef(ref)
 
     def readInternalBehaviorConstantMemories(self, element: ET.Element, behavior: InternalBehavior):
-        for child_element in element.findall("./xmlns:CONSTANT-MEMORYS/xmlns:PARAMETER-DATA-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "CONSTANT-MEMORYS/PARAMETER-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = behavior.createConstantMemory(short_name)
             self.readParameterDataPrototype(child_element, prototype)
@@ -378,16 +361,16 @@ class ARXMLParser(AbstractARXMLParser):
     def readInternalBehavior(self, element: ET.Element, behavior: InternalBehavior):
         self.readIdentifiable(element, behavior)
         self.readInternalBehaviorConstantMemories(element, behavior)
-        for child_element in element.findall("./xmlns:EXCLUSIVE-AREAS/xmlns:EXCLUSIVE-AREA", self.nsmap):
+        for child_element in self.findall(element, "EXCLUSIVE-AREAS/EXCLUSIVE-AREA"):
             short_name = self.getShortName(child_element)
             behavior.createExclusiveArea(short_name)
         self.readDataTypeMappingRefs(element, behavior)
 
     def getRoleBasedDataAssignment(self, element: ET.Element) -> RoleBasedDataAssignment:
         assignment = RoleBasedDataAssignment()
-        assignment.role = self.getChildElementOptionalLiteral(element, "ROLE")
-        assignment.used_parameter_element = self.getAutosarParameterRef(element, "USED-PARAMETER-ELEMENT")
-        assignment.used_pim_ref = self.getChildElementOptionalRefType(element, "USED-PIM-REF")
+        assignment.setRole(self.getChildElementOptionalLiteral(element, "ROLE")) \
+                  .setUsedParameterElement(self.getAutosarParameterRef(element, "USED-PARAMETER-ELEMENT")) \
+                  .setUsedPimRef(self.getChildElementOptionalRefType(element, "USED-PIM-REF"))
         return assignment
     
     def getRoleBasedPortAssignment(self, element: ET.Element) -> RoleBasedPortAssignment:
@@ -395,12 +378,24 @@ class ARXMLParser(AbstractARXMLParser):
         assignment.portPrototypeRef = self.getChildElementOptionalRefType(element, "PORT-PROTOTYPE-REF")
         assignment.role = self.getChildElementOptionalLiteral(element, "ROLE")
         return assignment
+    
+    def getRoleBasedDataTypeAssignment(self, element: ET.Element) -> RoleBasedDataTypeAssignment:
+        assignment = RoleBasedDataTypeAssignment()
+        assignment.setRole(self.getChildElementOptionalLiteral(element, "ROLE"))
+        assignment.setUsedImplementationDataTypeRef(self.getChildElementOptionalRefType(element, "USED-IMPLEMENTATION-DATA-TYPE-REF"))
+        return assignment
 
     def readServiceDependency(self, element: ET.Element, dependency: ServiceDependency):
         self.readIdentifiable(element, dependency)
+        for child_element in self.findall(element, "ASSIGNED-DATA-TYPES/*"):
+            tag_name = self.getTagName(child_element.tag)
+            if (tag_name == "ROLE-BASED-DATA-TYPE-ASSIGNMENT"):
+                dependency.addAssignedDataType(self.getRoleBasedDataTypeAssignment(child_element))
+            else:
+                self._raiseError("Unsupported assigned data type <%s>" % tag_name)
 
     def readSwcServiceDependencyAssignedData(self, element: ET.Element, dependency: SwcServiceDependency):
-        for child_element in element.findall("./xmlns:ASSIGNED-DATAS/*", self.nsmap):
+        for child_element in self.findall(element, "ASSIGNED-DATAS/*"):
             tag_name = self.getTagName(child_element.tag)
             if (tag_name == "ROLE-BASED-DATA-ASSIGNMENT"):
                 dependency.AddAssignedData(self.getRoleBasedDataAssignment(child_element))
@@ -408,7 +403,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self._raiseError("Unsupported assigned data <%s>" % tag_name)
 
     def readSwcServiceDependencyAssignedPorts(self, element: ET.Element, dependency: SwcServiceDependency):
-        for child_element in element.findall("./xmlns:ASSIGNED-PORTS/*", self.nsmap):
+        for child_element in self.findall(element, "ASSIGNED-PORTS/*"):
             tag_name = self.getTagName(child_element.tag)
             if (tag_name == "ROLE-BASED-PORT-ASSIGNMENT"):
                 dependency.AddAssignedPort(self.getRoleBasedPortAssignment(child_element))
@@ -418,57 +413,136 @@ class ARXMLParser(AbstractARXMLParser):
     def readNvBlockNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         short_name = self.getShortName(element)
         needs = parent.createNvBlockNeeds(short_name)
-        self.logger.debug("readNvBlockNeeds %s" % short_name)
-        needs.calc_ram_block_crc = self.getChildElementOptionalBooleanValue(element, "CALC-RAM-BLOCK-CRC")
-        needs.check_static_block_id = self.getChildElementOptionalBooleanValue(element, "CHECK-STATIC-BLOCK-ID")
-        needs.n_data_sets = self.getChildElementOptionalNumericalValue(element, "N-DATA-SETS")
-        needs.n_rom_blocks = self.getChildElementOptionalNumericalValue(element, "N-ROM-BLOCKS")
-        needs.readonly = self.getChildElementOptionalBooleanValue(element, "READONLY")
-        needs.reliability = self.getChildElementOptionalLiteral(element, "RELIABILITY")
-        needs.resistant_to_changed_sw = self.getChildElementOptionalBooleanValue(element, "RESISTANT-TO-CHANGED-SW")
-        needs.restore_at_start = self.getChildElementOptionalBooleanValue(element, "RESTORE-AT-START")
-        needs.store_at_shutdown = self.getChildElementOptionalBooleanValue(element, "STORE-AT-SHUTDOWN")
-        needs.write_only_once = self.getChildElementOptionalBooleanValue(element, "WRITE-ONLY-ONCE")
-        needs.write_verification = self.getChildElementOptionalBooleanValue(element, "WRITE-VERIFICATION")
-        needs.writing_priority = self.getChildElementOptionalLiteral(element, "WRITING-PRIORITY")                          
+        self.logger.debug("read NvBlockNeeds %s" % short_name)
+        self.readIdentifiable(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")) \
+             .setNRomBlocks(self.getChildElementOptionalNumericalValue(element, "N-ROM-BLOCKS")) \
+             .setRamBlockStatusControl(self.getChildElementOptionalLiteral(element, "RAM-BLOCK-STATUS-CONTROL")) \
+             .setReadonly(self.getChildElementOptionalBooleanValue(element, "READONLY")) \
+             .setReliability(self.getChildElementOptionalLiteral(element, "RELIABILITY")) \
+             .setResistantToChangedSw(self.getChildElementOptionalBooleanValue(element, "RESISTANT-TO-CHANGED-SW")) \
+             .setRestoreAtStart(self.getChildElementOptionalBooleanValue(element, "RESTORE-AT-START")) \
+             .setStoreAtShutdown(self.getChildElementOptionalBooleanValue(element, "STORE-AT-SHUTDOWN")) \
+             .setStoreCyclic(self.getChildElementOptionalBooleanValue(element, "STORE-CYCLIC")) \
+             .setStoreEmergency(self.getChildElementOptionalBooleanValue(element, "STORE-EMERGENCY")) \
+             .setStoreImmediate(self.getChildElementOptionalBooleanValue(element, "STORE-IMMEDIATE")) \
+             .setUseAutoValidationAtShutDown(self.getChildElementOptionalBooleanValue(element, "USE-AUTO-VALIDATION-AT-SHUT-DOWN")) \
+             .setUseCRCCompMechanism(self.getChildElementOptionalBooleanValue(element, "USE-CRC-COMP-MECHANISM")) \
+             .setWriteOnlyOnce(self.getChildElementOptionalBooleanValue(element, "WRITE-ONLY-ONCE")) \
+             .setWriteVerification(self.getChildElementOptionalBooleanValue(element, "WRITE-VERIFICATION")) \
+             .setWritingPriority(self.getChildElementOptionalLiteral(element, "WRITING-PRIORITY"))
+        
+    def reaDiagnosticCommunicationManagerNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticCommunicationManagerNeeds(short_name)
+        self.logger.debug("read DiagnosticCommunicationManagerNeeds %s" % short_name)
+        self.readIdentifiable(element, needs)
+        needs.setServiceRequestCallbackType(self.getChildElementOptionalLiteral(element, "SERVICE-REQUEST-CALLBACK-TYPE"))
+
+    def readDiagnosticRoutineNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticRoutineNeeds(short_name)
+        self.logger.debug("read DiagnosticRoutineNeeds %s" % short_name)
+        self.readIdentifiable(element, needs)
+        needs.setDiagRoutineType(self.getChildElementOptionalLiteral(element, "DIAG-ROUTINE-TYPE")) \
+             .setRidNumber(self.getChildElementOptionalIntegerValue(element, "RID-NUMBER"))
+
+    def readDiagnosticValueNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticValueNeeds(short_name)
+        self.logger.debug("read DiagnosticValueNeeds %s" % short_name)
+        self.readIdentifiable(element, needs)
+        needs.setDataLength(self.getChildElementOptionalPositiveInteger(element, "DATA-LENGTH")) \
+             .setDiagnosticValueAccess(self.getChildElementOptionalLiteral(element, "DIAGNOSTIC-VALUE-ACCESS")) \
+             .setDidNumber(self.getChildElementOptionalIntegerValue(element, "DID-NUMBER")) \
+             .setFixedLength(self.getChildElementOptionalBooleanValue(element, "FIXED-LENGTH")) \
+             .setProcessingStyle(self.getChildElementOptionalLiteral(element, "PROCESSING-STYLE"))
+        
+    def readDiagEventDebounceMonitorInternal(self, element: ET.Element, algorithm: DiagEventDebounceMonitorInternal):
+        self.readIdentifiable(element, algorithm)
+        
+    def readDiagEventDebounceAlgorithm(self, element: ET.Element, needs: DiagnosticEventNeeds):
+        for child_element in self.findall(element, "DIAG-EVENT-DEBOUNCE-ALGORITHM/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DIAG-EVENT-DEBOUNCE-MONITOR-INTERNAL":
+                algorithm = needs.createDiagEventDebounceMonitorInternal(self.getShortName(child_element))
+                self.readDiagEventDebounceMonitorInternal(child_element, algorithm)
+            else:
+                self.notImplemented("Unsupported DiagEventDebounceAlgorithm <%s>" % tag_name)
+    
+    def readDiagnosticEventNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticEventNeeds(short_name)
+        self.logger.debug("read DiagnosticEventNeeds %s" % short_name)
+        self.readIdentifiable(element, needs)
+        self.readDiagEventDebounceAlgorithm(element, needs)
+        needs.setDtcKind(self.getChildElementOptionalLiteral(element, "DTC-KIND")) \
+             .setUdsDtcNumber(self.getChildElementOptionalIntegerValue(element, "UDS-DTC-NUMBER")) 
+
+    def readCryptoServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createCryptoServiceNeeds(short_name)
+        self.logger.debug("read DiagnosticValueNeeds %s" % short_name)
+        self.readIdentifiable(element, needs)
+        needs.setMaximumKeyLength(self.getChildElementOptionalPositiveInteger(element, "MAXIMUM-KEY-LENGTH"))
+
+    def readEcuStateMgrUserNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createEcuStateMgrUserNeeds(short_name)
+        self.logger.debug("read DiagnosticValueNeeds %s" % short_name)
+        self.readIdentifiable(element, needs)
 
     def readSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        for child_element in element.findall("./xmlns:SERVICE-NEEDS/*", self.nsmap):
+        for child_element in self.findall(element, "SERVICE-NEEDS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "NV-BLOCK-NEEDS":
                 self.readNvBlockNeeds(child_element, parent)    
+            elif tag_name == "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS":
+                self.reaDiagnosticCommunicationManagerNeeds(child_element, parent)
+            elif tag_name == "DIAGNOSTIC-ROUTINE-NEEDS":
+                self.readDiagnosticRoutineNeeds(child_element, parent)
+            elif tag_name == "DIAGNOSTIC-VALUE-NEEDS":
+                self.readDiagnosticValueNeeds(child_element, parent)
+            elif tag_name == "DIAGNOSTIC-EVENT-NEEDS":
+                self.readDiagnosticEventNeeds(child_element, parent)
+            elif tag_name == "CRYPTO-SERVICE-NEEDS":
+                self.readCryptoServiceNeeds(child_element, parent)
+            elif tag_name == "ECU-STATE-MGR-USER-NEEDS":
+                self.readEcuStateMgrUserNeeds(child_element, parent)
             else:
-                self._raiseError("Unsupported service needs <%s>" % tag_name)
+                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("readSwcServiceDependency %s" % short_name)
+        self.logger.debug("read SwcServiceDependency %s" % short_name)
         self.readServiceDependency(element, dependency)
         self.readSwcServiceDependencyAssignedData(element, dependency)
         self.readSwcServiceDependencyAssignedPorts(element, dependency)
         self.readSwcServiceDependencyServiceNeeds(element, dependency)
 
     def readSwcInternalBehaviorServiceDependencies(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:SERVICE-DEPENDENCYS/*", self.nsmap):
+        for child_element in self.findall(element, "SERVICE-DEPENDENCYS/*"):
             tag_name = self.getTagName(child_element.tag)
             if (tag_name == "SWC-SERVICE-DEPENDENCY"):
                 self.readSwcServiceDependency(child_element, parent)
             else:
-                self._raiseError("Unsupported Service Dependencies <%s>" % tag_name)
+                self.notImplemented("Unsupported Service Dependencies <%s>" % tag_name)
 
     def getIncludedDataTypeSets(self, element: ET.Element) -> List[IncludedDataTypeSet]:
         include_data_type_sets = []
-        for child_element in self.findall(element, "./INCLUDED-DATA-TYPE-SETS/INCLUDED-DATA-TYPE-SET"):
+        for child_element in self.findall(element, "INCLUDED-DATA-TYPE-SETS/INCLUDED-DATA-TYPE-SET"):
             include_data_type_set = IncludedDataTypeSet()
-            self.readElementAttributes(child_element, include_data_type_set)
-            for ref_type in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-REFS/DATA-TYPE-REF"):
+            self.readARObjectAttributes(child_element, include_data_type_set)
+            for ref_type in self.getChildElementRefTypeList(child_element, "DATA-TYPE-REFS/DATA-TYPE-REF"):
                 include_data_type_set.addDataTypeRef(ref_type)
             include_data_type_sets.append(include_data_type_set)
         return include_data_type_sets
 
     def readSwcInternalBehavior(self, element: ET.Element, parent: AtomicSwComponentType):
-        for child_element in self.findall(element, "./INTERNAL-BEHAVIORS/SWC-INTERNAL-BEHAVIOR"):
+        for child_element in self.findall(element, "INTERNAL-BEHAVIORS/SWC-INTERNAL-BEHAVIOR"):
             short_name = self.getShortName(child_element)
             behavior = parent.createSwcInternalBehavior(short_name)
             self.logger.debug("readSwcInternalBehavior %s" % behavior.full_name)
@@ -483,35 +557,83 @@ class ARXMLParser(AbstractARXMLParser):
             self.readExplicitInterRunnableVariables(child_element, behavior)
             for data_type_set  in self.getIncludedDataTypeSets(child_element):
                 behavior.addIncludedDataTypeSet(data_type_set)
-            behavior.handle_termination_and_restart = self.getChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART")
+            behavior.handleTerminationAndRestart = self.getChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART")
             self.readPerInstanceMemories(child_element, behavior)
             self.readPerInstanceParameters(child_element, behavior)
             self.readPortAPIOptions(child_element, behavior)
-            behavior.supports_multiple_instantiation = self.getChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION")
+            behavior.setSupportsMultipleInstantiation(self.getChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION"))
 
     def getIncludedModeDeclarationGroupSets(self, element: ET.Element) -> List[IncludedModeDeclarationGroupSet]:
         group_sets = []
         for child_element in self.findall(element, "INCLUDED-MODE-DECLARATION-GROUP-SETS/INCLUDED-MODE-DECLARATION-GROUP-SET"):
             group_set = IncludedModeDeclarationGroupSet()
-            for ref_type in self.getChildElementRefTypeList(child_element, "./MODE-DECLARATION-GROUP-REFS/MODE-DECLARATION-GROUP-REF"):
+            for ref_type in self.getChildElementRefTypeList(child_element, "MODE-DECLARATION-GROUP-REFS/MODE-DECLARATION-GROUP-REF"):
                 group_set.addModeDeclarationGroupRef(ref_type)
             group_sets.append(group_set)
         return group_sets
+    
+    def readBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
+        self.readExecutableEntity(element, entity)
+        entity.setImplementedEntryRef(self.getChildElementRefType(entity.getShortName(), element, "IMPLEMENTED-ENTRY-REF"))
+        self.readBswModuleEntityManagedModeGroup(element, entity)
+    
+    def readBswCalledEntity(self, element: ET.Element, entity: BswCalledEntity):
+        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.readBswModuleEntity(element, entity)
+
+    def readBswInterruptEntity(self, element: ET.Element, entity: BswInterruptEntity):
+        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"))
+    
+    def readBswInternalBehaviorEntities(self, element: ET.Element, behavior: BswInternalBehavior):
+        for child_element in self.findall(element, "ENTITYS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-CALLED-ENTITY":
+                entity = behavior.createBswCalledEntity(self.getShortName(child_element))
+                self.readBswCalledEntity(child_element, entity)
+            elif tag_name == "BSW-SCHEDULABLE-ENTITY":  
+                entity = behavior.createBswSchedulableEntity(self.getShortName(child_element))
+                self.readBswSchedulableEntity(child_element, entity)
+            elif tag_name == "BSW-INTERRUPT-ENTITY":
+                entity = behavior.createBswInterruptEntity(self.getShortName(child_element))
+                self.readBswInterruptEntity(child_element, entity)
+            else:
+                self.notImplemented("Unsupported BswModuleEntity <%s>" % tag_name)
+
+    def readBswInternalBehaviorEvents(self, element: ET.Element, behavior: BswInternalBehavior):
+        for child_element in self.findall(element, "EVENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-MODE-SWITCH-EVENT":
+                event = behavior.createBswModeSwitchEvent(self.getShortName(child_element))
+                self.readBswModeSwitchEvent(child_element, event)
+            elif tag_name == "BSW-TIMING-EVENT":  
+                event = behavior.createBswTimingEvent(self.getShortName(child_element))
+                self.readBswTimingEvent(child_element, event)
+            elif tag_name == "BSW-DATA-RECEIVED-EVENT":
+                event = behavior.createBswDataReceivedEvent(self.getShortName(child_element))
+                self.readBswDataReceivedEvent(child_element, event)
+            elif tag_name == "BSW-INTERNAL-TRIGGER-OCCURRED-EVENT":
+                event = behavior.createBswInternalTriggerOccurredEvent(self.getShortName(child_element))
+                self.readBswInternalTriggerOccurredEvent(child_element, event)
+            else:
+                self.notImplemented("Unsupported BswModuleEntity <%s>" % tag_name)
 
     def readBswInternalBehavior(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in element.findall("./xmlns:INTERNAL-BEHAVIORS/xmlns:BSW-INTERNAL-BEHAVIOR", self.nsmap):
+        for child_element in self.findall(element, "INTERNAL-BEHAVIORS/BSW-INTERNAL-BEHAVIOR"):
             short_name = self.getShortName(child_element)
             behavior = parent.createBswInternalBehavior(short_name)
-            self.logger.debug("readBswInternalBehavior %s" % behavior.full_name)
+            self.logger.debug("read BswInternalBehavior %s" % behavior.full_name)
 
             # read the internal behavior
             self.readInternalBehavior(child_element, behavior)
-            self.readBswCalledEntity(child_element, behavior)
-            self.readBswSchedulableEntity(child_element, behavior)
-            self.readBswModeSwitchEvent(child_element, behavior)
-            self.readBswTimingEvent(child_element, behavior)
-            self.readBswDataReceivedEvent(child_element, behavior)
-            self.readBswInternalTriggerOccurredEvent(child_element, behavior)
+            self.readBswInternalBehaviorEntities(child_element, behavior)
+            self.readBswInternalBehaviorEvents(child_element, behavior)
             self.readBswInternalBehaviorModeSenderPolicy(child_element, behavior)
             for group_set in self.getIncludedModeDeclarationGroupSets(child_element):
                 behavior.addIncludedModeDeclarationGroupSet(group_set)
@@ -519,30 +641,45 @@ class ARXMLParser(AbstractARXMLParser):
     def readBswModuleDescription(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         bsw_module_description = parent.createBswModuleDescription(short_name)
-        bsw_module_description.module_id = self.getChildElementOptionalNumericalValue(element, "MODULE-ID")
+        bsw_module_description.moduleId = self.getChildElementOptionalNumericalValue(element, "MODULE-ID")
 
-        self.logger.debug("readBswModuleDescription %s" % bsw_module_description.full_name)
+        self.logger.debug("read BswModuleDescription %s" % bsw_module_description.full_name)
 
         self.readBswModuleDescriptionImplementedEntry(element, bsw_module_description)
         self.readProvidedModeGroup(element, bsw_module_description)
         self.readRequiredModeGroup(element, bsw_module_description)
         self.readBswInternalBehavior(element, bsw_module_description)
 
+    def readSwServiceArg(self, element: ET.Element, arg: SwServiceArg):
+        self.logger.debug("Read SwServiceArg <%s>" % arg.getShortName())
+        arg.setDirection(self.getChildElementOptionalLiteral(element, "DIRECTION")) \
+           .setSwDataDefProps(self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS"))
+
+    def readBswModuleEntryArguments(self, element: ET.Element, entry: BswModuleEntry):
+        for child_element in self.findall(element, "ARGUMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SW-SERVICE-ARG":
+                arg = entry.createArgument(self.getShortName(child_element))
+                self.readSwServiceArg(child_element, arg)
+            else:
+                self.notImplemented("Unsupported Argument <%s>" % tag_name)
+
     def readBswModuleEntry(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         entry = parent.createBswModuleEntry(short_name)
-        entry.is_reentrant = self.getChildElementOptionalBooleanValue(element, "IS-REENTRANT")
-        entry.is_synchronous = self.getChildElementOptionalBooleanValue(element, "IS-SYNCHRONOUS")
-        entry.service_id = self.getChildElementOptionalNumericalValue(element, "SERVICE-ID")
-        entry.call_type = self.getChildElementOptionalLiteral(element, "CALL-TYPE")
-        entry.execution_context = self.getChildElementOptionalLiteral(element, "EXECUTION-CONTEXT")
-        entry.sw_service_impl_policy = self.getChildElementOptionalLiteral(element, "SW-SERVICE-IMPL-POLICY")
+        self.readIdentifiable(element, entry)
+        self.readBswModuleEntryArguments(element, entry)
+        entry.setIsReentrant(self.getChildElementOptionalBooleanValue(element, "IS-REENTRANT")) \
+             .setIsSynchronous(self.getChildElementOptionalBooleanValue(element, "IS-SYNCHRONOUS")) \
+             .setServiceId(self.getChildElementOptionalNumericalValue(element, "SERVICE-ID")) \
+             .setCallType(self.getChildElementOptionalLiteral(element, "CALL-TYPE")) \
+             .setExecutionContext(self.getChildElementOptionalLiteral(element, "EXECUTION-CONTEXT")) \
+             .setSwServiceImplPolicy(self.getChildElementOptionalLiteral(element, "SW-SERVICE-IMPL-POLICY"))
 
-        #self.logger.debug("readBswModuleEntry \n%s" % entry)
-        self.logger.debug("readBswModuleEntry %s" % entry.getShortName())
+        self.logger.debug("read BswModuleEntry %s" % entry.getShortName())
 
     def readEngineeringObject(self, element: ET.Element, engineering_obj: EngineeringObject):
-        self.readElementAttributes(element, engineering_obj)
+        self.readARObjectAttributes(element, engineering_obj)
         engineering_obj.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
                        .setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY"))
         
@@ -553,7 +690,7 @@ class ARXMLParser(AbstractARXMLParser):
         return obj
 
     def readArtifactDescriptor(self, element: ET.Element, code_desc: Code):
-        for child_element in element.findall("./xmlns:ARTIFACT-DESCRIPTORS/*", self.nsmap):
+        for child_element in self.findall(element, "ARTIFACT-DESCRIPTORS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "AUTOSAR-ENGINEERING-OBJECT":
                 code_desc.addArtifactDescriptor(self.getAutosarEngineeringObject(child_element))
@@ -561,7 +698,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self._raiseError("Unsupported Artifact Descriptor <%s>" % tag_name)
             
     def readCodeDescriptor(self, element: ET.Element, impl: Implementation):
-        for child_element in element.findall("./xmlns:CODE-DESCRIPTORS/xmlns:CODE", self.nsmap):
+        for child_element in self.findall(element, "CODE-DESCRIPTORS/CODE"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readCodeDescriptor %s" % short_name)
             code_desc = impl.createCodeDescriptor(short_name)
@@ -569,47 +706,63 @@ class ARXMLParser(AbstractARXMLParser):
             self.readArtifactDescriptor(child_element, code_desc)
 
     def readMemorySectionOptions(self, element: ET.Element, section: MemorySection):
-        child_element = element.find("./xmlns:OPTIONS", self.nsmap)
+        child_element = self.find(element, "OPTIONS")
         if child_element is not None:
             for value in self.getChildElementLiteralValueList(child_element, "OPTION"):
                 section.addOption(value)
 
     def readMemorySections(self, element: ET.Element, consumption: ResourceConsumption):
-        for child_element in element.findall("./xmlns:MEMORY-SECTIONS/xmlns:MEMORY-SECTION", self.nsmap):
-            short_name = self.getShortName(child_element)
-            memory_section = consumption.createMemorySection(short_name)
+        for child_element in self.findall(element, "MEMORY-SECTIONS/MEMORY-SECTION"):
+            memory_section = consumption.createMemorySection(self.getShortName(child_element))
             self.readIdentifiable(child_element, memory_section)
-            memory_section.setAlignment(self.getChildElementOptionalLiteral(child_element, "ALIGNMENT"))
+            memory_section.setAlignment(self.getChildElementOptionalLiteral(child_element, "ALIGNMENT")) \
+                          .setMemClassSymbol(self.getChildElementOptionalLiteral(child_element, "MEM-CLASS-SYMBOL")) 
             self.readMemorySectionOptions(child_element, memory_section)
-            memory_section.size = self.getChildElementOptionalNumericalValue(child_element, "SIZE")
-            memory_section.swAddrMethodRef = self.getChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF")
-            memory_section.symbol = self.getChildElementOptionalLiteral(child_element, "SYMBOL")
-            self.logger.debug("readMemorySections %s" % memory_section.getShortName())
+            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())
+
+    def readStackUsage(self, element: ET.Element, usage: StackUsage):
+        self.logger.debug("read StackUsage %s" % usage.getShortName())
+        self.readIdentifiable(element, usage)
+
+    def readRoughEstimateStackUsage(self, element: ET.Element, usage: RoughEstimateStackUsage):
+        self.readStackUsage(element, usage)
+        usage.setMemoryConsumption(self.getChildElementOptionalPositiveInteger(element, "MEMORY-CONSUMPTION"))
+
+    def readStackUsages(self, element: ET.Element, consumption: ResourceConsumption):
+        for child_element in self.findall(element, "STACK-USAGES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ROUGH-ESTIMATE-STACK-USAGE":
+                usage = consumption.createRoughEstimateStackUsage(self.getShortName(child_element))
+                self.readRoughEstimateStackUsage(child_element, usage)
+            else:
+                self.notImplemented("Unsupported Stack Usages: <%s>" % tag_name)
 
     def readResourceConsumption(self, element: ET.Element, impl: Implementation):
-        child_element = element.find("./xmlns:RESOURCE-CONSUMPTION", self.nsmap)
+        child_element = self.find(element, "RESOURCE-CONSUMPTION")
         if (child_element is not None):
-            short_name = self.getShortName(child_element)
-            consumption = ResourceConsumption(impl, short_name)
+            consumption = impl.createResourceConsumption(self.getShortName(child_element))
             self.readIdentifiable(child_element, consumption)
             self.readMemorySections(child_element, consumption)
-            impl.setResourceConsumption(consumption)
+            self.readStackUsages(child_element, consumption)
 
     def readImplementation(self, element: ET.Element, impl: Implementation):
         self.readIdentifiable(element, impl)
         self.readCodeDescriptor(element, impl)
-        impl.programmingLanguage = self.getChildElementOptionalLiteral(element, "PROGRAMMING-LANGUAGE")
+        impl.setProgrammingLanguage(self.getChildElementOptionalLiteral(element, "PROGRAMMING-LANGUAGE"))
         self.readResourceConsumption(element, impl)
-        impl.swVersion = self.getChildElementOptionalLiteral(element, "SW-VERSION")
-        impl.swcBswMappingRef = self.getChildElementOptionalRefType(element, "SWC-BSW-MAPPING-REF")
-        impl.usedCodeGenerator = self.getChildElementOptionalLiteral(element, "USED-CODE-GENERATOR")
-        impl.vendorId = self.getChildElementOptionalNumericalValue(element, "VENDOR-ID")
+        impl.setSwVersion(self.getChildElementOptionalLiteral(element, "SW-VERSION")) \
+            .setSwcBswMappingRef(self.getChildElementOptionalRefType(element, "SWC-BSW-MAPPING-REF")) \
+            .setUsedCodeGenerator(self.getChildElementOptionalLiteral(element, "USED-CODE-GENERATOR")) \
+            .setVendorId(self.getChildElementOptionalNumericalValue(element, "VENDOR-ID"))
 
-    def readBswImplementationVendorSpecificModuleDefRefs(self, element: ET.Element, parent: BswImplementation):
-        child_element = element.find("./xmlns:VENDOR-SPECIFIC-MODULE-DEF-REFS", self.nsmap)
+    def readBswImplementationVendorSpecificModuleDefRefs(self, element: ET.Element, impl: BswImplementation):
+        child_element = self.find(element, "VENDOR-SPECIFIC-MODULE-DEF-REFS")
         if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "./VENDOR-SPECIFIC-MODULE-DEF-REF"):
-                parent.addVendorSpecificModuleDefRef(ref)
+            for ref in self.getChildElementRefTypeList(child_element, "VENDOR-SPECIFIC-MODULE-DEF-REF"):
+                impl.addVendorSpecificModuleDefRef(ref)
 
     def readBswImplementation(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -649,14 +802,14 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getAutosarParameterRef(self, element: ET.Element, key: str) -> AutosarParameterRef:
         accessed_parameter = None
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         if child_element is not None:
             accessed_parameter = AutosarParameterRef()
             accessed_parameter.local_parameter_ref = self.getChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF")
         return accessed_parameter
 
     def readParameterAccesses(self, element: ET.Element, parent: RunnableEntity):
-        for child_element in element.findall("./xmlns:PARAMETER-ACCESSS/xmlns:PARAMETER-ACCESS", self.nsmap):
+        for child_element in self.findall(element, "PARAMETER-ACCESSS/PARAMETER-ACCESS"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readParameterAccesses %s" % short_name)
             parameter_access = parent.createParameterAccess(short_name)
@@ -669,11 +822,12 @@ class ARXMLParser(AbstractARXMLParser):
         self._readVariableAccesses(element, parent, "READ-LOCAL-VARIABLES")
 
     def readROperationIRef(self, element: ET.Element, key: str, parent: ServerCallPoint):
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         if (child_element is not None):
             operation_iref = ROperationInAtomicSwcInstanceRef()
-            operation_iref.context_r_port_ref = self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")
-            operation_iref.target_required_operation_ref = self.getChildElementOptionalRefType(child_element, "TARGET-REQUIRED-OPERATION-REF")
+            self.readARObjectAttributes(child_element, operation_iref)
+            operation_iref.setContextRPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")) \
+                          .setTargetRequiredOperationRef(self.getChildElementOptionalRefType(child_element, "TARGET-REQUIRED-OPERATION-REF"))
             parent.setOperationIRef(operation_iref)
 
     def readRVariableInAtomicSwcInstanceRef(self, element: ET.Element, parent: DataReceivedEvent):
@@ -685,7 +839,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.setDataIRef(data_iref)
 
     def readRModeInAtomicSwcInstanceRef(self, element: ET.Element, parent: SwcModeSwitchEvent):
-        for child_element in element.findall("./xmlns:MODE-IREFS/xmlns:MODE-IREF", self.nsmap):
+        for child_element in self.findall(element, "MODE-IREFS/MODE-IREF"):
             mode_iref = RModeInAtomicSwcInstanceRef()
             mode_iref.setContextPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF")) \
                      .setContextModeDeclarationGroupPrototypeRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")) \
@@ -767,18 +921,23 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "RUNNABLE-ENTITY-ARGUMENT":
                 entity.addArgument(self.getRunnableEntityArgument(child_element))
             else:
-                raise NotImplementedError("Unsupported Arguments of runnable entity <%s>" % tag_name)
+                self.notImplemented("Unsupported Arguments of runnable entity <%s>" % tag_name)
+
+    def readAsynchronousServerCallResultPoint(self, element: ET.Element, entity: RunnableEntity):
+        for child_element in self.findall(element, "ASYNCHRONOUS-SERVER-CALL-RESULT-POINTS/ASYNCHRONOUS-SERVER-CALL-RESULT-POINT"):
+            point = entity.createAsynchronousServerCallResultPoint(self.getShortName(child_element))
+            self.readIdentifiable(child_element, point)
+            point.setAsynchronousServerCallPointRef(self.getChildElementOptionalRefType(child_element, "ASYNCHRONOUS-SERVER-CALL-POINT-REF"))
 
     def readRunnableEntity(self, element: ET.Element, entity: RunnableEntity):
         self.readExecutableEntity(element, entity)
         self.readRunnableEntityArguments(element, entity)
 
+        self.readAsynchronousServerCallResultPoint(element, entity)
         entity.setCanBeInvokedConcurrently(self.getChildElementOptionalBooleanValue(element, "CAN-BE-INVOKED-CONCURRENTLY"))
-        entity.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
-
+        self.readDataReadAccesses(element, entity)
         self.readDataReceivePointByArguments(element, entity)
         self.readDataReceivePointByValues(element, entity)
-        self.readDataReadAccesses(element, entity)
         self.readDataWriteAccesses(element, entity)
         self.readDataSendPoints(element, entity)
         self.readInternalBehaviorServerCallPoint(element, entity)
@@ -789,6 +948,8 @@ class ARXMLParser(AbstractARXMLParser):
         self.readReadLocalVariables(element, entity)
         self.readWrittenLocalVariables(element, entity)
 
+        entity.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
+
     def readSwcInternalBehaviorRunnables(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in self.findall(element, "RUNNABLES/RUNNABLE-ENTITY"):
             short_name = self.getShortName(child_element)
@@ -808,21 +969,23 @@ class ARXMLParser(AbstractARXMLParser):
     def readRTEEvent(self, element: ET.Element, event: RTEEvent):
         self.readIdentifiable(element, event)
         event.startOnEventRef = self.getChildElementOptionalRefType(element, "START-ON-EVENT-REF")
-        for child_element in element.findall("./xmlns:DISABLED-MODE-IREFS/xmlns:DISABLED-MODE-IREF", self.nsmap):
+        for child_element in self.findall(element, "DISABLED-MODE-IREFS/DISABLED-MODE-IREF"):
             iref = self.getRModeInAtomicSwcInstanceRef(child_element)
             event.addDisabledModeIRef(iref)
 
-    def readOperationIRef(self, element: ET.Element, parent: OperationInvokedEvent):
-        child_element = element.find("./xmlns:OPERATION-IREF", self.nsmap)
+    def readPOperationIRef(self, element: ET.Element, key: str, parent: OperationInvokedEvent):
+        child_element = self.find(element, key)
         if (child_element is not None):
-            parent.operationIRef = POperationInAtomicSwcInstanceRef()
-            parent.operationIRef.context_p_port_ref = self.getChildElementRefType(parent.getShortName(), child_element, "CONTEXT-P-PORT-REF")
-            parent.operationIRef.target_provided_operation_ref = self.getChildElementRefType(parent.getShortName(), child_element, "TARGET-PROVIDED-OPERATION-REF")
+            operation_iref = POperationInAtomicSwcInstanceRef()
+            self.readARObjectAttributes(child_element, operation_iref)
+            operation_iref.setContextPPortRef(self.getChildElementRefType(parent.getShortName(), child_element, "CONTEXT-P-PORT-REF")) \
+                          .setTargetProvidedOperationRef(self.getChildElementRefType(parent.getShortName(), child_element, "TARGET-PROVIDED-OPERATION-REF"))
+            parent.setOperationIRef(operation_iref)
 
     def readOperationInvokedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
         event = parent.createOperationInvokedEvent(short_name)
-        self.readOperationIRef(element, event)
+        self.readPOperationIRef(element, "OPERATION-IREF", event)
         self.readRTEEvent(element, event)
 
     def readVariableDataPrototype(self, element: ET.Element, prototype: VariableDataPrototype):
@@ -830,13 +993,13 @@ class ARXMLParser(AbstractARXMLParser):
         prototype.setInitValue(self.getInitValue(element))
         
     def readExplicitInterRunnableVariables(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EXPLICIT-INTER-RUNNABLE-VARIABLES/xmlns:VARIABLE-DATA-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "EXPLICIT-INTER-RUNNABLE-VARIABLES/VARIABLE-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = parent.createExplicitInterRunnableVariable(short_name)
             self.readVariableDataPrototype(child_element, prototype)
 
     def readPerInstanceMemories(self, element: ET.Element, behavior: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:PER-INSTANCE-MEMORYS/xmlns:PER-INSTANCE-MEMORY", self.nsmap):
+        for child_element in self.findall(element, "PER-INSTANCE-MEMORYS/PER-INSTANCE-MEMORY"):
             short_name = self.getShortName(child_element)
             memory = behavior.createPerInstanceMemory(short_name)
             self.readIdentifiable(child_element, memory)
@@ -855,26 +1018,27 @@ class ARXMLParser(AbstractARXMLParser):
         prototype.setInitValue(self.getInitValue(element))
         
     def readPerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:PER-INSTANCE-PARAMETERS/xmlns:PARAMETER-DATA-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "PER-INSTANCE-PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = behavior.createPerInstanceParameter(short_name)
             self.readParameterDataPrototype(child_element, prototype)
 
     def readPortDefinedArgumentValue(self, element: ET.Element) -> PortDefinedArgumentValue:
         argument_value = PortDefinedArgumentValue()
-        child_element = element.find("./xmlns:VALUE/*", self.nsmap)
+        child_element = self.find(element, "VALUE/*")
         if child_element is not None:
-            argument_value.value = self.getValueSpecification(child_element)
-        argument_value.valueTypeTRef = self.getChildElementOptionalRefType(element, "VALUE-TYPE-TREF")
+            argument_value.setValue(self.getValueSpecification(child_element, self.getTagName(child_element)))
+        argument_value.setValueTypeTRef(self.getChildElementOptionalRefType(element, "VALUE-TYPE-TREF"))
         return argument_value
 
     def readPortAPIOptions(self, element: ET.Element, behavior: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:PORT-API-OPTIONS/xmlns:PORT-API-OPTION", self.nsmap):
+        for child_element in self.findall(element, "PORT-API-OPTIONS/PORT-API-OPTION"):
             option = PortAPIOption()
-            option.enableTakeAddress = self.getChildElementOptionalBooleanValue(child_element, "ENABLE-TAKE-ADDRESS")
-            option.indirectAPI = self.getChildElementOptionalBooleanValue(child_element, "INDIRECT-API")
-            option.portRef = self.getChildElementOptionalRefType(child_element, "PORT-REF")
-            for argument_value_tag in child_element.findall("./xmlns:PORT-ARG-VALUES/xmlns:PORT-DEFINED-ARGUMENT-VALUE", self.nsmap):
+            option.setEnableTakeAddress(self.getChildElementOptionalBooleanValue(child_element, "ENABLE-TAKE-ADDRESS")) \
+                  .setErrorHandling(self.getChildElementOptionalLiteral(child_element, "ERROR-HANDLING")) \
+                  .setIndirectAPI(self.getChildElementOptionalBooleanValue(child_element, "INDIRECT-API")) \
+                  .setPortRef(self.getChildElementOptionalRefType(child_element, "PORT-REF"))
+            for argument_value_tag in self.findall(child_element, "PORT-ARG-VALUES/PORT-DEFINED-ARGUMENT-VALUE"):
                 option.addPortArgValue(self.readPortDefinedArgumentValue(argument_value_tag))
             behavior.addPortAPIOption(option)
             
@@ -882,8 +1046,8 @@ class ARXMLParser(AbstractARXMLParser):
         short_name = self.getShortName(element)
         event = parent.createTimingEvent(short_name)
         self.readRTEEvent(element, event)
-        event.offset = self.getChildElementOptionalFloatValue(element, "OFFSET")
-        event.period = self.getChildElementOptionalFloatValue(element, "PERIOD")
+        event.setOffset(self.getChildElementOptionalTimeValue(element, "OFFSET")) \
+             .setPeriod(self.getChildElementOptionalTimeValue(element, "PERIOD"))
 
     def readDataReceivedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
@@ -895,22 +1059,28 @@ class ARXMLParser(AbstractARXMLParser):
         short_name = self.getShortName(element)
         event = parent.createSwcModeSwitchEvent(short_name)
         self.readRTEEvent(element, event)
-        event.activation = self.getChildElementOptionalLiteral(element, "ACTIVATION")
+        event.setActivation(self.getChildElementOptionalLiteral(element, "ACTIVATION"))
         self.readRModeInAtomicSwcInstanceRef(element, event)
 
     def readInternalTriggerOccurredEvent(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
         event = parent.createInternalTriggerOccurredEvent(short_name)
         self.readRTEEvent(element, event)
-        event.event_source_ref = self.getChildElementRefType(parent.getShortName(), element, "EVENT-SOURCE-REF")
+        event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
     def readInitEvent(self, element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
         event = parent.createInitEvent(short_name)
         self.readRTEEvent(element, event)
 
+    def readAsynchronousServerCallReturnsEvent(self, element, parent: SwcInternalBehavior):
+        short_name = self.getShortName(element)
+        event = parent.createAsynchronousServerCallReturnsEvent(short_name)
+        self.readRTEEvent(element, event)
+        event.setActivationReasonRepresentationRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
+
     def readSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/*", self.nsmap):
+        for child_element in self.findall(element, "EVENTS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "TIMING-EVENT":
                 self.readTimingEvent(child_element, parent)
@@ -924,19 +1094,30 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readInternalTriggerOccurredEvent(child_element, parent)
             elif tag_name == "INIT-EVENT":
                 self.readInitEvent(child_element, parent)
+            elif tag_name == "ASYNCHRONOUS-SERVER-CALL-RETURNS-EVENT":
+                self.readAsynchronousServerCallReturnsEvent(child_element, parent)
             else:
-                self._raiseError("Unsupported SwcInternalBehavior Event <%s>" % tag_name)
+                self.notImplemented("Unsupported SwcInternalBehavior Event <%s>" % tag_name)
+
+    def getSwPointerTargetProps(self, element: ET.Element, key: str) -> SwPointerTargetProps:
+        child_element = self.find(element, key)
+        props = None
+        if child_element is not None:
+            props = SwPointerTargetProps()
+            props.setTargetCategory(self.getChildElementOptionalLiteral(child_element, "TARGET-CATEGORY")) \
+                 .setSwDataDefProps(self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS"))
+        return props
 
     def readSwPointerTargetProps(self, element: ET.Element, parent: SwDataDefProps):
         child_element = self.find(element, "SW-POINTER-TARGET-PROPS")
         if child_element is not None:
             sw_pointer_target_props = SwPointerTargetProps()
-            sw_pointer_target_props.target_category = self.getChildElementOptionalLiteral(child_element, "TARGET-CATEGORY")
-            sw_pointer_target_props.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+            sw_pointer_target_props.setTargetCategory(self.getChildElementOptionalLiteral(child_element, "TARGET-CATEGORY")) \
+                                   .setSwDataDefProps(self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS"))
             parent.swPointerTargetProps = sw_pointer_target_props
 
     def readLanguageSpecific(self, element: ET.Element, specific: LanguageSpecific):
-        self.readElementAttributes(element, specific)
+        self.readARObjectAttributes(element, specific)
         specific.value = element.text
         if 'L' in element.attrib:
             specific.l = element.attrib['L']
@@ -953,7 +1134,7 @@ class ARXMLParser(AbstractARXMLParser):
         paragraphs = []
         for child_element in self.findall(element, key):
             paragraph = MultiLanguageParagraph()
-            self.readElementAttributes(child_element, paragraph)
+            self.readARObjectAttributes(child_element, paragraph)
             for l1 in self.getLParagraphs(child_element, "L-1"):
                 paragraph.addL1(l1)
             paragraphs.append(paragraph)
@@ -986,13 +1167,13 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, key)
         if child_element is not None:
             paragraph = MultiLanguagePlainText()
-            self.readElementAttributes(child_element, paragraph)
+            self.readARObjectAttributes(child_element, paragraph)
             for l10 in self.getLPlainTexts(child_element, "L-10"):
                 paragraph.addL10(l10)
         return paragraph
     
     def readDocumentationBlock(self, element: ET.Element, block: DocumentationBlock):
-        self.readElementAttributes(element, block)
+        self.readARObjectAttributes(element, block)
         for paragraph in self.getMultiLanguageParagraphs(element, "P"):
             block.addP(paragraph)
         for list in self.getListElements(element, "LIST"):
@@ -1021,7 +1202,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getAnnotations(self, element: ET.Element) -> List[Annotation]:
         annotations = []
-        for child_element in element.findall("./xmlns:ANNOTATIONS/xmlns:ANNOTATION", self.nsmap):
+        for child_element in self.findall(element, "ANNOTATIONS/ANNOTATION"):
             annotation = Annotation()
             self.readGeneralAnnotation(child_element, annotation)
             annotations.append(annotation)
@@ -1029,7 +1210,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getSwAxisIndividual(self, element: ET.Element) -> SwAxisIndividual:
         props = SwAxisIndividual()
-        self.readElementAttributes(element, props)
+        self.readARObjectAttributes(element, props)
         props.setInputVariableTypeRef(self.getChildElementOptionalRefType(element, "INPUT-VARIABLE-TYPE-REF")) \
              .setCompuMethodRef(self.getChildElementOptionalRefType(element, "COMPU-METHOD-REF")) \
              .setSwMaxAxisPoints(self.getChildElementOptionalNumericalValue(element, "SW-MAX-AXIS-POINTS")) \
@@ -1046,10 +1227,10 @@ class ARXMLParser(AbstractARXMLParser):
         axis = SwCalprmAxis()
         axis.sw_axis_index = self.getChildElementOptionalNumericalValue(element, "SW-AXIS-INDEX")
         axis.category = self.getChildElementOptionalLiteral(element, "CATEGORY")
-        child_element = element.find("./xmlns:SW-AXIS-INDIVIDUAL", self.nsmap)
+        child_element = self.find(element, "SW-AXIS-INDIVIDUAL")
         if child_element is not None:
             axis.sw_calprm_axis_type_props = self.getSwAxisIndividual(child_element)
-        child_element = element.find("./xmlns:SW-AXIS-GROUPED", self.nsmap)
+        child_element = self.find(element, "SW-AXIS-GROUPED")
         if child_element is not None:
             axis.sw_calprm_axis_type_props = self.getSwAxisGrouped(child_element)
         
@@ -1057,7 +1238,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getSwCalprmAxisSet(self, element: ET.Element, key: str) -> SwCalprmAxisSet:
         set = SwCalprmAxisSet()
-        for child_element in element.findall("./xmlns:%s/*" % key, self.nsmap):
+        for child_element in self.findall(element, "%s/*" % key):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "SW-CALPRM-AXIS":
                 set.addSwCalprmAxis(self.getSwCalprmAxis(child_element))
@@ -1066,16 +1247,16 @@ class ARXMLParser(AbstractARXMLParser):
     def readSwDataDefProsInvalidValue(self, element: ET.Element, props: SwDataDefProps):
         child_element = self.find(element, "INVALID-VALUE/*")
         if child_element is not None:
-            props.setInvalidValue(self.getValueSpecification(child_element))
+            props.setInvalidValue(self.getValueSpecification(child_element, self.getTagName(child_element)))
 
     def getSwDataDefProps(self, element: ET.Element, key: str) -> SwDataDefProps:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         sw_data_def_props = None
         if child_element is not None:
-            conditional_tag = child_element.find("./xmlns:SW-DATA-DEF-PROPS-VARIANTS/xmlns:SW-DATA-DEF-PROPS-CONDITIONAL", self.nsmap)
+            conditional_tag = self.find(child_element, "SW-DATA-DEF-PROPS-VARIANTS/SW-DATA-DEF-PROPS-CONDITIONAL")
             if conditional_tag is not None:
                 sw_data_def_props = SwDataDefProps()
-                self.readElementAttributes(child_element, sw_data_def_props)
+                self.readARObjectAttributes(child_element, sw_data_def_props)
 
                 for annotation in self.getAnnotations(conditional_tag):
                     sw_data_def_props.addAnnotation(annotation)
@@ -1083,17 +1264,20 @@ class ARXMLParser(AbstractARXMLParser):
                 sw_data_def_props.setBaseTypeRef(self.getChildElementOptionalRefType(conditional_tag, "BASE-TYPE-REF")) \
                                  .setDataConstrRef(self.getChildElementOptionalRefType(conditional_tag, "DATA-CONSTR-REF")) \
                                  .setCompuMethodRef(self.getChildElementOptionalRefType(conditional_tag, "COMPU-METHOD-REF")) \
+                                 .setSwAddrMethodRef(self.getChildElementOptionalRefType(conditional_tag, "SW-ADDR-METHOD-REF")) \
                                  .setSwImplPolicy(self.getChildElementOptionalLiteral(conditional_tag, "SW-IMPL-POLICY")) \
                                  .setSwIntendedResolution(self.getChildElementOptionalNumericalValue(conditional_tag, "SW-INTENDED-RESOLUTION")) \
                                  .setImplementationDataTypeRef(self.getChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF")) \
+                                 .setStepSize(self.getChildElementOptionalFloatValue(conditional_tag, "STEP-SIZE")) \
                                  .setSwCalibrationAccess(self.getChildElementOptionalLiteral(conditional_tag, "SW-CALIBRATION-ACCESS")) \
                                  .setSwCalprmAxisSet(self.getSwCalprmAxisSet(conditional_tag, "SW-CALPRM-AXIS-SET")) \
+                                 .setSwPointerTargetProps(self.getSwPointerTargetProps(conditional_tag, "SW-POINTER-TARGET-PROPS")) \
                                  .setSwRecordLayoutRef(self.getChildElementOptionalRefType(conditional_tag, "SW-RECORD-LAYOUT-REF")) \
                                  .setValueAxisDataTypeRef(self.getChildElementOptionalRefType(conditional_tag, "VALUE-AXIS-DATA-TYPE-REF")) \
-                                 .setUnitRef(self.getChildElementOptionalRefType(conditional_tag, "UNIT-REF"))
+                                 .setUnitRef(self.getChildElementOptionalRefType(conditional_tag, "UNIT-REF")) 
                 self.readSwDataDefProsInvalidValue(conditional_tag, sw_data_def_props)
-                self.readSwPointerTargetProps(conditional_tag, sw_data_def_props)
-                self.readElementAttributes(conditional_tag, sw_data_def_props.conditional)
+                #self.readSwPointerTargetProps(conditional_tag, sw_data_def_props)
+                self.readARObjectAttributes(conditional_tag, sw_data_def_props.conditional)
         return sw_data_def_props
     
     def readAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
@@ -1110,7 +1294,7 @@ class ARXMLParser(AbstractARXMLParser):
         prototype.setTypeTRef(self.getChildElementOptionalRefType(element, "TYPE-TREF"))
 
     def readApplicationRecordElements(self, element: ET.Element, parent: ApplicationRecordDataType):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:APPLICATION-RECORD-ELEMENT", self.nsmap):
+        for child_element in self.findall(element, "ELEMENTS/APPLICATION-RECORD-ELEMENT"):
             short_name = self.getShortName(child_element)
             record_element = parent.createApplicationRecordElement(short_name)
             self.logger.debug("readApplicationRecordElements %s" % short_name)
@@ -1127,10 +1311,10 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readImplementationDataTypeElements(self, element: ET.Element, parent: ImplementationDataType):
         for child_element in self.findall(element, "SUB-ELEMENTS/IMPLEMENTATION-DATA-TYPE-ELEMENT"):
-            short_name = self.getShortName(child_element)
-            type_element = parent.createImplementationDataTypeElement(short_name)
+            type_element = parent.createImplementationDataTypeElement(self.getShortName(child_element))
             self.readIdentifiable(child_element, type_element)
             type_element.setArraySize(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE")) \
+                        .setArraySizeHandling(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-HANDLING")) \
                         .setArraySizeSemantics(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS"))
             self.readImplementationDataTypeElements(child_element, type_element)
             type_element.setSwDataDefProps(self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS"))
@@ -1139,6 +1323,7 @@ class ARXMLParser(AbstractARXMLParser):
         short_name = self.getShortName(element)
         data_type = parent.createImplementationDataType(short_name)
         self.readAutosarDataType(element, data_type)
+        data_type.setDynamicArraySizeProfile(self.getChildElementOptionalLiteral(element, "DYNAMIC-ARRAY-SIZE-PROFILE"))
         self.readImplementationDataTypeElements(element, data_type)
         data_type.setTypeEmitter(self.getChildElementOptionalLiteral(element, "TYPE-EMITTER"))
         
@@ -1183,7 +1368,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBaseTypeDirectDefinition(element, data_type.baseTypeDefinition)
 
     def getApplicationCompositeElementInPortInterfaceInstanceRef(self, element: ET.Element, key:str) -> ApplicationCompositeElementInPortInterfaceInstanceRef:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         iref = None
         if child_element is not None:
             iref = ApplicationCompositeElementInPortInterfaceInstanceRef()
@@ -1194,25 +1379,26 @@ class ARXMLParser(AbstractARXMLParser):
     def getCompositeNetworkRepresentation(self, element: ET.Element) -> CompositeNetworkRepresentation:
         self.logger.debug("getCompositeNetworkRepresentation")
         representation = CompositeNetworkRepresentation()
-        representation.leaf_element_iref = self.getApplicationCompositeElementInPortInterfaceInstanceRef(element, "LEAF-ELEMENT-IREF")
-        representation.network_representation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
+        representation.setLeafElementIRef(self.getApplicationCompositeElementInPortInterfaceInstanceRef(element, "LEAF-ELEMENT-IREF")) \
+                      .setNetworkRepresentation(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION"))
         return representation
 
     def readReceiverComSpec(self, element: ET.Element, com_spec: ReceiverComSpec):
-        self.readElementAttributes(element, com_spec)
+        self.readARObjectAttributes(element, com_spec)
         for child_element in self.findall(element, "COMPOSITE-NETWORK-REPRESENTATIONS/COMPOSITE-NETWORK-REPRESENTATION"):
             com_spec.addCompositeNetworkRepresentation(self.getCompositeNetworkRepresentation(child_element))
-        com_spec.dataElementRef = self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")
-        com_spec.networkRepresentation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
-        com_spec.handleOutOfRange = self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE")
-        com_spec.usesEndToEndProtection = self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION")
+        com_spec.setDataElementRef(self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")) \
+                .setNetworkRepresentation(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")) \
+                .setHandleOutOfRange(self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE")) \
+                .setHandleOutOfRangeStatus(self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE-STATUS")) \
+                .setUsesEndToEndProtection(self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION"))
 
     def getSwValues(self, element: ET.Element, key: str) -> SwValues:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap) # type: ET.Element
+        child_element = self.find(element, key)
         if child_element is None:
             return None
         sw_values = SwValues()
-        self.readElementAttributes(child_element, sw_values)
+        self.readARObjectAttributes(child_element, sw_values)
         for v in self.getChildElementFloatValueList(child_element, "V"):
             sw_values.addV(v)
         sw_values.vt = self.getChildElementOptionalLiteral(child_element, "VT")
@@ -1220,30 +1406,30 @@ class ARXMLParser(AbstractARXMLParser):
     
     def getValueList(self, element: ET.Element, key: str) -> ValueList:
         value_list = None
-        child_element = element.find("./xmlns:%s" % key, self.nsmap) # type: ET.Element
+        child_element = self.find(element, key)
         if child_element is not None:
             self.logger.debug("getValueList %s" % key)
             value_list = ValueList()
-            self.readElementAttributes(child_element, value_list)
-            value_list.v = self.getChildElementOptionalFloatValue(child_element, "V")
+            self.readARObjectAttributes(child_element, value_list)
+            value_list.setV(self.getChildElementOptionalFloatValue(child_element, "V"))
         return value_list
 
     def getSwValueCont(self, element: ET.Element) -> SwValueCont:
         cont = None
-        child_element = element.find("./xmlns:SW-VALUE-CONT", self.nsmap)
+        child_element = self.find(element, "SW-VALUE-CONT")
         if child_element is not None:
             self.logger.debug("getSwValueCont")
             cont = SwValueCont()
-            self.readElementAttributes(child_element, cont)
-            cont.unit_ref = self.getChildElementOptionalRefType(child_element, "UNIT-REF")
-            cont.sw_arraysize = self.getValueList(child_element, "SW-ARRAYSIZE")
-            cont.sw_values_phys = self.getSwValues(child_element, "SW-VALUES-PHYS")
+            self.readARObjectAttributes(child_element, cont)
+            cont.setUnitRef(self.getChildElementOptionalRefType(child_element, "UNIT-REF")) \
+                .setSwArraysize(self.getValueList(child_element, "SW-ARRAYSIZE")) \
+                .setSwValuesPhys(self.getSwValues(child_element, "SW-VALUES-PHYS"))
         return cont
     
     def readApplicationValueSpecification(self, element: ET.Element, value_spec: ApplicationValueSpecification):
         self.readValueSpecification(element, value_spec)
-        value_spec.category = self.getChildElementOptionalLiteral(element, "CATEGORY")
-        value_spec.sw_value_cont = self.getSwValueCont(element)
+        value_spec.setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY")) \
+                  .setSwValueCont(self.getSwValueCont(element))
 
         self.logger.debug("readApplicationValueSpecification Category %s" % value_spec.category)
 
@@ -1252,48 +1438,49 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, "INIT-VALUE/*")
         if child_element is not None:
             self.logger.debug("getInitValue")
-            value_spec = self.getValueSpecification(child_element)
+            value_spec = self.getValueSpecification(child_element, self.getTagName(child_element))
         return value_spec
     
     def getClientComSpec(self, element: ET.Element) -> ClientComSpec:
         com_spec = ClientComSpec()
-        self.readElementAttributes(element, com_spec)
+        self.readARObjectAttributes(element, com_spec)
         com_spec.operationRef = self.getChildElementOptionalRefType(element, "OPERATION-REF")
         return com_spec
     
     def getParameterRequireComSpec(self, element: ET.Element) -> ParameterRequireComSpec:
         com_spec = ParameterRequireComSpec()
-        self.readElementAttributes(element, com_spec)
+        self.readARObjectAttributes(element, com_spec)
         com_spec.setInitValue(self.getInitValue(element)) \
                 .setParameterRef(self.getChildElementOptionalRefType(element, "PARAMETER-REF"))
         return com_spec
     
     def getQueuedReceiverComSpec(self, element: ET.Element) -> QueuedReceiverComSpec:
         com_spec = QueuedReceiverComSpec()
-        self.readElementAttributes(element, com_spec)
+        self.readARObjectAttributes(element, com_spec)
         self.readReceiverComSpec(element, com_spec)
         com_spec.queueLength = self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH")
         return com_spec
     
     def getModeSwitchReceiverComSpec(self, element: ET.Element) -> ModeSwitchReceiverComSpec:
         com_spec = ModeSwitchReceiverComSpec()
-        self.readElementAttributes(element, com_spec)
+        self.readARObjectAttributes(element, com_spec)
         com_spec.modeGroupRef = self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")
         return com_spec
 
     def getNonqueuedReceiverComSpec(self, element: ET.Element) -> NonqueuedReceiverComSpec:
         com_spec = NonqueuedReceiverComSpec()
-        self.readElementAttributes(element, com_spec)            
+        self.readARObjectAttributes(element, com_spec)            
         self.readReceiverComSpec(element, com_spec)
-        com_spec.aliveTimeout = self.getChildElementOptionalFloatValue(element, "ALIVE-TIMEOUT")
-        com_spec.enableUpdated = self.getChildElementOptionalBooleanValue(element, "ENABLE-UPDATE")
-        com_spec.handleNeverReceived = self.getChildElementOptionalBooleanValue(element, "HANDLE-NEVER-RECEIVED")
-        com_spec.handleTimeoutType = self.getChildElementOptionalLiteral(element, "HANDLE-TIMEOUT-TYPE")
-        com_spec.initValue = self.getInitValue(element)
+        com_spec.setAliveTimeout(self.getChildElementOptionalFloatValue(element, "ALIVE-TIMEOUT")) \
+                .setEnableUpdated(self.getChildElementOptionalBooleanValue(element, "ENABLE-UPDATE")) \
+                .setHandleNeverReceived(self.getChildElementOptionalBooleanValue(element, "HANDLE-NEVER-RECEIVED")) \
+                .setFilter(self.getDataFilter(element, "FILTER")) \
+                .setHandleTimeoutType(self.getChildElementOptionalLiteral(element, "HANDLE-TIMEOUT-TYPE")) \
+                .setInitValue(self.getInitValue(element))
         return com_spec
 
     def readRequiredComSpec(self, element: ET.Element, parent: RPortPrototype):
-        for child_element in element.findall("./xmlns:REQUIRED-COM-SPECS/*", self.nsmap):
+        for child_element in self.findall(element, "REQUIRED-COM-SPECS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "NONQUEUED-RECEIVER-COM-SPEC":
                 parent.addRequiredComSpec(self.getNonqueuedReceiverComSpec(child_element))
@@ -1308,14 +1495,36 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
+    def readAbstractRequiredPortPrototype(self, element: ET.Element, prototype: AbstractRequiredPortPrototype):
+        self.readProvidedComSpec(element, prototype)
+
+    def readPPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
+        short_name = self.getShortName(element)
+        self.logger.debug("readPPortPrototype %s" % short_name)
+        prototype = parent.createPPortPrototype(short_name)
+        self.readIdentifiable(element, prototype)
+        self.readAbstractRequiredPortPrototype(element, prototype)
+        prototype.setProvidedInterfaceTRef(self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF"))
+        
+    def readAbstractProvidedPortPrototype(self, element: ET.Element, prototype: AbstractProvidedPortPrototype):
+        self.readRequiredComSpec(element, prototype)
+
     def readRPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
         short_name = self.getShortName(element)
-        self.logger.debug("readRPortPrototype %s" % short_name)
+        self.logger.debug("read RPortPrototype %s" % short_name)
         prototype = parent.createRPortPrototype(short_name)
         self.readIdentifiable(element, prototype)
+        self.readAbstractProvidedPortPrototype(element, prototype)
         prototype.setRequiredInterfaceTRef(self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF"))
 
-        self.readRequiredComSpec(element, prototype)
+    def readPRPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
+        short_name = self.getShortName(element)
+        self.logger.debug("read PRPortPrototype %s" % short_name)
+        prototype = parent.createPRPortPrototype(short_name)
+        self.readIdentifiable(element, prototype)
+        self.readAbstractRequiredPortPrototype(element, prototype)
+        self.readAbstractProvidedPortPrototype(element, prototype)
+        prototype.setProvidedRequiredInterface(self.getChildElementOptionalRefType(element, "PROVIDED-REQUIRED-INTERFACE-TREF"))
 
     def readAtomicSwComponentTypePorts(self, element: ET.Element, sw_component: AtomicSwComponentType):
         for child_element in self.findall(element, "PORTS/*"):
@@ -1324,21 +1533,23 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readPPortPrototype(child_element, sw_component)
             elif tag_name == "R-PORT-PROTOTYPE":
                 self.readRPortPrototype(child_element, sw_component)
+            elif tag_name == "PR-PORT-PROTOTYPE":
+                self.readPRPortPrototype(child_element, sw_component)
             else:
                 self._raiseError("Unsupported Port Prototype <%s>" % tag_name)
 
     def readTransmissionAcknowledgementRequest(self, element: ET.Element) -> TransmissionAcknowledgementRequest:
-        child_element = element.find("./xmlns:TRANSMISSION-ACKNOWLEDGE", self.nsmap)
+        child_element = self.find(element, "TRANSMISSION-ACKNOWLEDGE")
         if (child_element is not None):
             acknowledge = TransmissionAcknowledgementRequest()
-            self.readElementAttributes(child_element, acknowledge)
+            self.readARObjectAttributes(child_element, acknowledge)
             acknowledge.timeout = self.getChildElementOptionalFloatValue(child_element, "TIMEOUT")
             return acknowledge
         return None
 
     def readSenderComSpec(self, element:ET.Element, com_spec: SenderComSpec):
-        self.readElementAttributes(element, com_spec)
-        for child_element in element.findall("./xmlns:COMPOSITE-NETWORK-REPRESENTATIONS/xmlns:COMPOSITE-NETWORK-REPRESENTATION", self.nsmap):
+        self.readARObjectAttributes(element, com_spec)
+        for child_element in self.findall(element, "COMPOSITE-NETWORK-REPRESENTATIONS/COMPOSITE-NETWORK-REPRESENTATION"):
             com_spec.addCompositeNetworkRepresentation(self.getCompositeNetworkRepresentation(child_element))
         com_spec.setDataElementRef(self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")) \
                 .setNetworkRepresentation(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")) \
@@ -1354,6 +1565,7 @@ class ARXMLParser(AbstractARXMLParser):
     
     def getServerComSpec(self, element) -> ServerComSpec:
         com_spec = ServerComSpec()
+        self.readARObjectAttributes(element, com_spec)
         com_spec.setOperationRef(self.getChildElementOptionalRefType(element, "OPERATION-REF")) \
                 .setQueueLength(self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH"))
         return com_spec
@@ -1370,7 +1582,7 @@ class ARXMLParser(AbstractARXMLParser):
         return com_spec
 
     def readProvidedComSpec(self, element: ET.Element, parent: PPortPrototype):
-        for child_element in element.findall("./xmlns:PROVIDED-COM-SPECS/*", self.nsmap):
+        for child_element in self.findall(element, "PROVIDED-COM-SPECS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "NONQUEUED-SENDER-COM-SPEC":
                 parent.addProvidedComSpec(self.getNonqueuedSenderComSpec(child_element))
@@ -1383,15 +1595,6 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
-    def readPPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
-        short_name = self.getShortName(element)
-        self.logger.debug("readPPortPrototype %s" % short_name)
-        prototype = parent.createPPortPrototype(short_name)
-        self.readIdentifiable(element, prototype)
-        prototype.setProvidedInterfaceTRef(self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF"))
-
-        self.readProvidedComSpec(element, prototype)
-
     def readPortGroupInnerGroupIRefs(self, element: ET.Element, parent: PortGroup):
         for child_element in self.findall(element, "INNER-GROUP-IREFS/INNER-GROUP-IREF"):
             inner_group_iref = InnerPortGroupInCompositionInstanceRef()
@@ -1412,7 +1615,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readPortGroupOuterPortRefs(element, port_group)
 
     def readSwComponentTypePortGroups(self, element: ET.Element, parent: SwComponentType):
-        for child_element in element.findall("./xmlns:PORT-GROUPS/*", self.nsmap):
+        for child_element in self.findall(element, "PORT-GROUPS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "PORT-GROUP":
                 self.readPortGroup(child_element, parent)
@@ -1480,7 +1683,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, "PROVIDER-IREF")
         if (child_element is not None):
             provide_iref = PPortInCompositionInstanceRef()
-            self.readElementAttributes(child_element, provide_iref)
+            self.readARObjectAttributes(child_element, provide_iref)
             self.readPPortInCompositionInstanceRef(child_element, provide_iref)
             parent.setProviderIRef(provide_iref)
 
@@ -1488,17 +1691,18 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, "REQUESTER-IREF")
         if (child_element is not None):
             requester_iref = RPortInCompositionInstanceRef()
-            self.readElementAttributes(child_element, requester_iref)
+            self.readARObjectAttributes(child_element, requester_iref)
             self.readRPortInCompositionInstanceRef(child_element, requester_iref)
             parent.setRequesterIRef(requester_iref)
 
     def readAssemblySwConnectors(self, element: ET.Element, parent: CompositionSwComponentType):
-        for child_element in element.findall("./xmlns:CONNECTORS/xmlns:ASSEMBLY-SW-CONNECTOR", self.nsmap):
+        for child_element in self.findall(element, "CONNECTORS/ASSEMBLY-SW-CONNECTOR"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readAssemblySwConnectors %s" % short_name)
 
             connector = parent.createAssemblySwConnector(short_name)
             self.readIdentifiable(child_element, connector)
+            connector.setMappingRef(self.getChildElementOptionalRefType(child_element, "MAPPING-REF"))
             self.readAssemblySwConnectorProviderIRef(child_element, connector)
             self.readAssemblySwConnectorRequesterIRef(child_element, connector)
 
@@ -1569,9 +1773,9 @@ class ARXMLParser(AbstractARXMLParser):
     def readDataTypeMaps(self, element: ET.Element, parent: DataTypeMappingSet):
         for child_element in element.findall("./xmlns:DATA-TYPE-MAPS/xmlns:DATA-TYPE-MAP", self.nsmap):
             data_type_map = DataTypeMap()
-            self.readElementAttributes(child_element, data_type_map)
-            data_type_map.application_data_type_ref = self.getChildElementOptionalRefType(child_element, "APPLICATION-DATA-TYPE-REF")
-            data_type_map.implementation_data_type_ref = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
+            self.readARObjectAttributes(child_element, data_type_map)
+            data_type_map.applicationDataTypeRef = self.getChildElementOptionalRefType(child_element, "APPLICATION-DATA-TYPE-REF")
+            data_type_map.implementationDataTypeRef = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
             parent.addDataTypeMap(data_type_map)
             # add the data type map to global namespace
             AUTOSAR.getInstance().addDataTypeMap(data_type_map)
@@ -1579,9 +1783,9 @@ class ARXMLParser(AbstractARXMLParser):
     def readModeRequestTypeMaps(self, element: ET.Element, parent: DataTypeMappingSet):
         for child_element in element.findall("./xmlns:MODE-REQUEST-TYPE-MAPS/xmlns:MODE-REQUEST-TYPE-MAP", self.nsmap):
             map = ModeRequestTypeMap()
-            self.readElementAttributes(child_element, map)
-            map.implementation_data_type_ref = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
-            map.mode_group_ref = self.getChildElementOptionalRefType(child_element, "MODE-GROUP-REF")
+            self.readARObjectAttributes(child_element, map)
+            map.implementationDataTypeRef = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
+            map.modeGroupRef = self.getChildElementOptionalRefType(child_element, "MODE-GROUP-REF")
             parent.addModeRequestTypeMap(map)
 
     def readDataTypeMappingSet(self, element: ET.Element, parent: ARPackage):
@@ -1592,7 +1796,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readModeRequestTypeMaps(element, mapping_set)
 
     def readSenderReceiverInterfaceDataElements(self, element: ET.Element, sr_interface: SenderReceiverInterface):
-        for child_element in element.findall("./xmlns:DATA-ELEMENTS/xmlns:VARIABLE-DATA-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "DATA-ELEMENTS/VARIABLE-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = sr_interface.createDataElement(short_name)
             self.readIdentifiable(child_element, prototype)
@@ -1608,7 +1812,7 @@ class ARXMLParser(AbstractARXMLParser):
             sr_interface.addInvalidationPolicy(policy)
 
     def readInvalidationPolicys(self, element: ET.Element, parent: SenderReceiverInterface):
-        for child_element in element.findall("./xmlns:INVALIDATION-POLICYS/xmlns:INVALIDATION-POLICY", self.nsmap):
+        for child_element in self.findall(element, "INVALIDATION-POLICYS/INVALIDATION-POLICY"):
             # short_name = self.getShortName(child_element)
             policy = parent.createInvalidationPolicy()
             self.readIdentifiable(child_element, policy)
@@ -1624,24 +1828,24 @@ class ARXMLParser(AbstractARXMLParser):
         self.readSenderReceiverInterfaceInvalidationPolicies(element, sr_interface)
 
     def readArgumentDataPrototypes(self, element: ET.Element, parent: ClientServerOperation):
-        for child_element in element.findall("./xmlns:ARGUMENTS/xmlns:ARGUMENT-DATA-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "ARGUMENTS/ARGUMENT-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = ArgumentDataPrototype(property, short_name)
             self.readIdentifiable(child_element, prototype)
             prototype.swDataDefProps = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
             prototype.typeTRef = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
             prototype.direction = self.getChildElementOptionalLiteral(child_element, "DIRECTION")
-            prototype.server_argument_impl_policy = self.getChildElementOptionalLiteral(child_element, "SERVER-ARGUMENT-IMPL-POLICY")
+            prototype.serverArgumentImplPolicy = self.getChildElementOptionalLiteral(child_element, "SERVER-ARGUMENT-IMPL-POLICY")
             parent.addArgumentDataPrototype(prototype)
 
     def readPossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
-        child_element = element.find("./xmlns:POSSIBLE-ERROR-REFS", self.nsmap)
+        child_element = self.find(element, "POSSIBLE-ERROR-REFS")
         if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "./POSSIBLE-ERROR-REF"):
+            for ref in self.getChildElementRefTypeList(child_element, "POSSIBLE-ERROR-REF"):
                 parent.addPossibleErrorRef(ref)
 
     def readOperations(self, element: ET.Element, parent: ClientServerInterface):
-        for child_element in element.findall("./xmlns:OPERATIONS/xmlns:CLIENT-SERVER-OPERATION", self.nsmap):
+        for child_element in self.findall(element, "OPERATIONS/CLIENT-SERVER-OPERATION"):
             short_name = self.getShortName(child_element)
             operation = parent.createOperation(short_name)
             self.readIdentifiable(child_element, operation)
@@ -1649,123 +1853,174 @@ class ARXMLParser(AbstractARXMLParser):
             self.readPossibleErrorRefs(child_element, operation)
 
     def readPossibleErrors(self, element: ET.Element, parent: ClientServerInterface):
-        for child_element in element.findall("./xmlns:POSSIBLE-ERRORS/xmlns:APPLICATION-ERROR", self.nsmap):
+        for child_element in self.findall(element, "POSSIBLE-ERRORS/APPLICATION-ERROR"):
             short_name = self.getShortName(child_element)
             error = parent.createApplicationError(short_name)
             self.readIdentifiable(child_element, error) # some errors has its uuid
             error.error_code = self.getChildElementOptionalNumericalValue(child_element, "ERROR-CODE")
 
     def readPortInterface(self, element: ET.Element, port_interface: PortInterface):
+        self.readIdentifiable(element, port_interface)
         port_interface.isService = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
         port_interface.serviceKind = self.getChildElementOptionalLiteral(element, "SERVICE-KIND")
 
+    def readParameterInterfaceParameters(self, element: ET.Element, param_interface: ParameterInterface):
+        for child_element in self.findall(element, "PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
+            short_name = self.getShortName(child_element)
+            prototype = param_interface.createParameter(short_name)
+            self.readParameterDataPrototype(child_element, prototype)
+    
+    def readParameterInterface(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read ParameterInterface %s" % short_name)
+        param_interface = parent.createParameterInterface(short_name)
+        self.readPortInterface(element, param_interface)
+        self.readParameterInterfaceParameters(element, param_interface)
+
     def readClientServerInterface(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         cs_interface = parent.createClientServerInterface(short_name)
-        self.readIdentifiable(element, cs_interface)
         self.readPortInterface(element, cs_interface)
         self.readOperations(element, cs_interface)
         self.readPossibleErrors(element, cs_interface)
 
+    def getCompuConstContent(self, element: ET.Element) -> CompuConstContent:
+        child_element = self.find(element, "*")
+        content = None
+        if child_element is not None:
+            tag_name = self.getTagName(child_element)
+            if tag_name == "VF":
+                content = CompuConstFormulaContent()
+                content.setVf(self.getChildElementOptionalLiteral(element, "VF"))
+            elif tag_name == "V":
+                content = CompuConstNumericContent()
+                content.setV(self.getChildElementOptionalNumericalValue(element, "V"))
+            elif tag_name == "VT":
+                content = CompuConstTextContent()
+                content.setVt(self.getChildElementOptionalLiteral(element, "VT"))
+            else:
+                self.notImplemented("Unsupported CompuConstContent <%s>" % tag_name)
+        return content
+
+    def getCompuConst(self, element: ET.Element, key: str) -> CompuConst:
+        compu_const = None
+        child_element = self.find(element, key)
+        if (child_element is not None):
+            compu_const = CompuConst()
+            self.readARObjectAttributes(child_element, compu_const)
+            compu_const.setCompuConstContentType(self.getCompuConstContent(child_element))
+        return compu_const
+
     def readCompuConst(self, element: ET.Element, parent: CompuScale):
-        child_element = element.find("./xmlns:COMPU-CONST/xmlns:VT", self.nsmap)
+        child_element = self.find(element, "COMPU-CONST/VT")
         if (child_element is not None):
             self.logger.debug("readCompuConst VT: %s" % child_element.text)
             contents = CompuScaleConstantContents()
-            contents.compu_const = CompuConst()
-            contents.compu_const.compu_const_content_type = CompuConstTextContent()
-            contents.compu_const.compu_const_content_type.vt = ARLiteral()
-            contents.compu_const.compu_const_content_type.vt.setValue(child_element.text)
+            contents.compuConst = CompuConst()
+            contents.compuConst.compuConstContentType = CompuConstTextContent()
+            contents.compuConst.compuConstContentType.vt = ARLiteral()
+            contents.compuConst.compuConstContentType.vt.setValue(child_element.text)
             parent.compuScaleContents = contents
 
     def readCompuNominatorDenominator(self, element: ET.Element, key: str, parent: CompuNominatorDenominator):
-        for child_element in element.findall("./xmlns:%s/xmlns:V" % key, self.nsmap):
+        for child_element in self.findall(element, "%s/V" % key):
             self.logger.debug("readCompuNominatorDenominator - %s: %s" % (key, child_element.text))
             parent.add_v(child_element.text)
 
     def readCompuRationCoeffs(self, element: ET.Element, parent: CompuScale):
-        child_element = element.find("./xmlns:COMPU-RATIONAL-COEFFS", self.nsmap)
+        child_element = self.find(element, "COMPU-RATIONAL-COEFFS")
         if (child_element is not None):
             self.logger.debug("readCompuRationCoeffs")
             contents = CompuScaleRationalFormula()
-            contents.compu_rational_coeffs = CompuRationalCoeffs()
-            contents.compu_rational_coeffs.compu_denominator = CompuNominatorDenominator()
-            contents.compu_rational_coeffs.compu_numerator = CompuNominatorDenominator()
-            self.readCompuNominatorDenominator(child_element, "COMPU-DENOMINATOR", contents.compu_rational_coeffs.compu_denominator)
-            self.readCompuNominatorDenominator(child_element, "COMPU-NUMERATOR", contents.compu_rational_coeffs.compu_numerator)
+            contents.compuRationalCoeffs = CompuRationalCoeffs()
+            contents.compuRationalCoeffs.compuDenominator = CompuNominatorDenominator()
+            contents.compuRationalCoeffs.compuNumerator = CompuNominatorDenominator()
+            self.readCompuNominatorDenominator(child_element, "COMPU-DENOMINATOR", contents.compuRationalCoeffs.compuDenominator)
+            self.readCompuNominatorDenominator(child_element, "COMPU-NUMERATOR", contents.compuRationalCoeffs.compuNumerator)
             parent.compuScaleContents = contents
 
     def readCompuScaleContents(self, element: ET.Element, parent: CompuScale):
         self.readCompuConst(element, parent)
         self.readCompuRationCoeffs(element, parent)
 
-    def readCompuScales(self, element: ET.Element, parent: CompuScales):
-        for child_element in element.findall('./xmlns:COMPU-SCALES/xmlns:COMPU-SCALE', self.nsmap):
-            compu_scale = CompuScale()
-            self.readElementAttributes(child_element, compu_scale)
-            compu_scale.short_label = self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")
-            compu_scale.symbol = self.getChildElementOptionalLiteral(child_element, "SYMBOL")
-            compu_scale.lowerLimit = self.getChildLimitElement(child_element, "LOWER-LIMIT")
-            compu_scale.upperLimit = self.getChildLimitElement(child_element, "UPPER-LIMIT")
-            self.readCompuScaleContents(child_element, compu_scale)
-            parent.addCompuScale(compu_scale)
-
-    def readCompuInternalToPhys(self, element: ET.Element, parent: CompuMethod):
-        child_element = element.find("./xmlns:COMPU-INTERNAL-TO-PHYS", self.nsmap)
+    def getCompuScales(self, element: ET.Element) -> CompuScales:
+        compu_scales = None
+        compu_scales_tag = self.find(element, "COMPU-SCALES")
+        if compu_scales_tag is not None:
+            compu_scales = CompuScales()
+            for child_element in self.findall(compu_scales_tag, 'COMPU-SCALE'):
+                compu_scale = CompuScale()
+                self.readARObjectAttributes(child_element, compu_scale)
+                compu_scale.setLowerLimit(self.getChildLimitElement(child_element, "LOWER-LIMIT")) \
+                           .setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
+                           .setSymbol(self.getChildElementOptionalLiteral(child_element, "SYMBOL")) \
+                           .setUpperLimit(self.getChildLimitElement(child_element, "UPPER-LIMIT"))
+                self.readCompuScaleContents(child_element, compu_scale)
+                compu_scales.addCompuScale(compu_scale)
+        return compu_scales
+    
+    def getCompu(self, element: ET.Element, key: str) -> Compu:
+        child_element = self.find(element, key)
+        compu = None
         if (child_element is not None):
-            parent.compu_internal_to_phys = Compu()
-            self.readElementAttributes(child_element, parent.compu_internal_to_phys)
-            parent.compu_internal_to_phys.compu_content = CompuScales()
-            self.readCompuScales(child_element, parent.compu_internal_to_phys.compu_content)
+            compu = Compu()
+            self.readARObjectAttributes(child_element, compu)
+            compu.setCompuContent(self.getCompuScales(child_element)) 
+            compu.setCompuDefaultValue(self.getCompuConst(child_element, "COMPU-DEFAULT-VALUE"))
+        return compu
 
     def readCompuMethod(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         self.logger.debug("readCompuMethods %s" % short_name)
         compu_method = parent.createCompuMethod(short_name)
         self.readIdentifiable(element, compu_method)
-        compu_method.unit_ref = self.getChildElementOptionalRefType(element, "UNIT-REF")
-        self.readCompuInternalToPhys(element, compu_method)
+        compu_method.setUnitRef(self.getChildElementOptionalRefType(element, "UNIT-REF")) \
+                    .setCompuInternalToPhys(self.getCompu(element, "COMPU-INTERNAL-TO-PHYS")) \
+                    .setCompuPhysToInternal(self.getCompu(element, "COMPU-PHYS-TO-INTERNAL"))
 
     def readSwcBswRunnableMappings(self, element: ET.Element, parent: SwcBswMapping):
-        for child_element in element.findall("./xmlns:RUNNABLE-MAPPINGS/xmlns:SWC-BSW-RUNNABLE-MAPPING", self.nsmap):
+        for child_element in self.findall(element, "RUNNABLE-MAPPINGS/SWC-BSW-RUNNABLE-MAPPING"):
             mapping = SwcBswRunnableMapping()
-            mapping.bswEntityRef = self.getChildElementOptionalRefType(child_element, "BSW-ENTITY-REF")
-            mapping.swcRunnableRef = self.getChildElementOptionalRefType(child_element, "SWC-RUNNABLE-REF")
+            mapping.setBswEntityRef(self.getChildElementOptionalRefType(child_element, "BSW-ENTITY-REF")) \
+                   .setSwcRunnableRef(self.getChildElementOptionalRefType(child_element, "SWC-RUNNABLE-REF"))
             parent.addRunnableMapping(mapping)
 
     def readSwcBswMappings(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
-        self.logger.debug("readSwcBswMappings %s" % short_name)
+        self.logger.debug("read SwcBswMappings %s" % short_name)
         swc_bsw_mapping = parent.createSwcBswMapping(short_name)
-        swc_bsw_mapping.bswBehaviorRef = self.getChildElementOptionalRefType(element, "BSW-BEHAVIOR-REF")
+        swc_bsw_mapping.setBswBehaviorRef(self.getChildElementOptionalRefType(element, "BSW-BEHAVIOR-REF"))
         self.readSwcBswRunnableMappings(element, swc_bsw_mapping)
-        swc_bsw_mapping.swcBehaviorRef = self.getChildElementOptionalRefType(element, "SWC-BEHAVIOR-REF")
+        swc_bsw_mapping.setSwcBehaviorRef(self.getChildElementOptionalRefType(element, "SWC-BEHAVIOR-REF"))
 
     def readValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
-        self.readElementAttributes(element, value_spec)
-        value_spec.short_label = self.getChildElementOptionalLiteral(element, "SHORT-LABEL")
+        self.readARObjectAttributes(element, value_spec)
+        value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL"))
         self.logger.debug("readValueSpecification")
 
     def getApplicationValueSpecification(self, element: ET.Element) -> ApplicationValueSpecification:
         self.logger.debug("getApplicationValueSpecification")
         value_spec = ApplicationValueSpecification()
         self.readValueSpecification(element, value_spec)
-        value_spec.category = self.getChildElementOptionalLiteral(element, "CATEGORY")
-        value_spec.sw_value_cont = self.getSwValueCont(element)
+        value_spec.setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY")) \
+                  .setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
+                  .setSwValueCont(self.getSwValueCont(element))
         return value_spec
     
     def getNumericalValueSpecification(self, element: ET.Element) -> NumericalValueSpecification:
         self.logger.debug("getNumericalValueSpecification")
         value_spec = NumericalValueSpecification()
         self.readValueSpecification(element, value_spec)
-        value_spec.value = self.getChildElementOptionalFloatValue(element, "VALUE")
+        value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
+                  .setValue(self.getChildElementOptionalFloatValue(element, "VALUE"))
         return value_spec
     
     def getTextValueSpecification(self, element: ET.Element) -> TextValueSpecification:
         self.logger.debug("getTextValueSpecification")
         value_spec = TextValueSpecification()
         self.readValueSpecification(element, value_spec)
-        value_spec.value = self.getChildElementOptionalLiteral(element, "VALUE")
+        value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
+                  .setValue(self.getChildElementOptionalLiteral(element, "VALUE"))
         return value_spec
 
     def getArrayValueSpecification(self, element: ET.Element) -> ArrayValueSpecification:
@@ -1774,7 +2029,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readValueSpecification(element, value_spec)
         child_elements = element.findall("./xmlns:ELEMENTS/*", self.nsmap)
         for child_element in child_elements:
-            value_spec.addElement(self.getValueSpecification(child_element))
+            value_spec.addElement(self.getValueSpecification(child_element, self.getTagName(child_element)))
         return value_spec
 
     def getConstantReference(self, element: ET.Element) -> ConstantReference:
@@ -1784,8 +2039,7 @@ class ARXMLParser(AbstractARXMLParser):
         value_spec.setConstantRef(self.getChildElementOptionalRefType(element, "CONSTANT-REF"))
         return value_spec         
 
-    def getValueSpecification(self, element: ET.Element) -> ValueSpecification:
-        tag_name = self.getTagName(element.tag)
+    def getValueSpecification(self, element: ET.Element, tag_name: str) -> ValueSpecification:
         if tag_name == "APPLICATION-VALUE-SPECIFICATION":
             value_spec = self.getApplicationValueSpecification(element)
         elif tag_name == "RECORD-VALUE-SPECIFICATION":
@@ -1799,12 +2053,12 @@ class ARXMLParser(AbstractARXMLParser):
         elif tag_name == "CONSTANT-REFERENCE":
             value_spec = self.getConstantReference(element)
         else:
-            raise NotImplementedError("Unsupported RecordValueSpecificationField %s" % tag_name)
+            self.notImplemented("Unsupported RecordValueSpecificationField %s" % tag_name)
         return value_spec
 
     def readRecordValueSpecificationFields(self, element: ET.Element, spec: RecordValueSpecification):
         for child_element in element.findall("./xmlns:FIELDS/*", self.nsmap):
-            spec.addField(self.getValueSpecification(child_element))
+            spec.addField(self.getValueSpecification(child_element, self.getTagName(child_element)))
 
     def getRecordValueSpecification(self, element: ET.Element) -> RecordValueSpecification:
         value_spec = RecordValueSpecification()
@@ -1817,14 +2071,14 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("readConstantSpecification %s" % short_name)
         spec = parent.createConstantSpecification(short_name)
         self.readIdentifiable(element, spec)
-        for value_spec_tag in self.findall(element, "VALUE-SPEC/*"):
-            spec.setValueSpec(self.getValueSpecification(value_spec_tag))
+        for child_element in self.findall(element, "VALUE-SPEC/*"):
+            spec.setValueSpec(self.getValueSpecification(child_element, self.getTagName(child_element)))
                 
     def readInternalConstrs(self, element: ET.Element, parent: DataConstrRule):
         child_element = element.find("./xmlns:INTERNAL-CONSTRS", self.nsmap)
         if child_element is not None:
             constrs = InternalConstrs()
-            self.readElementAttributes(child_element, constrs)
+            self.readARObjectAttributes(child_element, constrs)
             constrs.lower_limit = self.getChildLimitElement(child_element, "LOWER-LIMIT")
             constrs.upper_limit = self.getChildLimitElement(child_element, "UPPER-LIMIT")
             parent.internalConstrs = constrs
@@ -1833,7 +2087,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = element.find("./xmlns:PHYS-CONSTRS", self.nsmap)
         if child_element is not None:
             constrs = PhysConstrs()
-            self.readElementAttributes(child_element, constrs)
+            self.readARObjectAttributes(child_element, constrs)
             constrs.lower_limit = self.getChildLimitElement(child_element, "LOWER-LIMIT")
             constrs.upper_limit = self.getChildLimitElement(child_element, "UPPER-LIMIT")
             constrs.unit_ref = self.getChildElementOptionalRefType(child_element, "UNIT-REF")
@@ -1843,7 +2097,7 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in element.findall("./xmlns:DATA-CONSTR-RULES/xmlns:DATA-CONSTR-RULE", self.nsmap):
             self.logger.debug("readDataConstrRule")
             rule = DataConstrRule()
-            self.readElementAttributes(child_element, rule)
+            self.readARObjectAttributes(child_element, rule)
             rule.constrLevel = self.getChildElementOptionalNumericalValue(child_element, "CONSTR-LEVEL")
             self.readInternalConstrs(child_element, rule)
             self.readPhysConstrs(child_element, rule)
@@ -1959,6 +2213,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readDataPrototype(self, element: ET.Element, prototype: DataPrototype):
         self.readIdentifiable(element, prototype)
+        prototype.setSwDataDefProps(self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS"))
 
     def readApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
         self.readDataPrototype(element, prototype)
@@ -2003,6 +2258,7 @@ class ARXMLParser(AbstractARXMLParser):
                  .setSwRecordLayoutGroupAxis(self.getChildElementOptionalNumericalValue(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS")) \
                  .setSwRecordLayoutGroupIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-INDEX")) \
                  .setSwRecordLayoutGroupFrom(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-FROM")) \
+                 .setSwRecordLayoutGroupStep(self.getChildElementOptionalIntegerValue(child_element, "SW-RECORD-LAYOUT-GROUP-STEP")) \
                  .setSwRecordLayoutGroupTo(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO")) \
             
             group_content = SwRecordLayoutGroupContent()
@@ -2025,8 +2281,14 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readSwAddrMethod(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
-        self.logger.debug("readSwAddrMethod %s" % short_name)
-        layout = parent.createSwAddrMethod(short_name)
+        self.logger.debug("read SwAddrMethod %s" % short_name)
+        method = parent.createSwAddrMethod(short_name)
+        self.readIdentifiable(element, method)
+        method.setMemoryAllocationKeywordPolicy(self.getChildElementOptionalLiteral(element, "MEMORY-ALLOCATION-KEYWORD-POLICY")) 
+        for option in self.getChildElementLiteralValueList(element, "OPTIONS/OPTION"):
+            method.addOption(option)
+        method.setSectionInitializationPolicy(self.getChildElementOptionalLiteral(element, "SECTION-INITIALIZATION-POLICY")) \
+              .setSectionType(self.getChildElementOptionalLiteral(element, "SECTION-TYPE"))
 
     def readTriggerInterface(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -2034,9 +2296,10 @@ class ARXMLParser(AbstractARXMLParser):
         trigger_if = parent.createTriggerInterface(short_name)
 
     def readModeDeclarationGroupModeDeclaration(self, element: ET.Element, parent: ModeDeclarationGroup):
-        for child_element in element.findall("./xmlns:MODE-DECLARATIONS/xmlns:MODE-DECLARATION", self.nsmap):
+        for child_element in self.findall(element, "MODE-DECLARATIONS/MODE-DECLARATION"):
             short_name = self.getShortName(child_element)
             declaration = parent.createModeDeclaration(short_name)
+            self.readARObjectAttributes(child_element, declaration)
             declaration.setValue(self.getChildElementOptionalNumericalValue(child_element, "VALUE"))
 
     def readModeDeclarationGroup(self, element: ET.Element, parent: ARPackage):
@@ -2157,7 +2420,7 @@ class ARXMLParser(AbstractARXMLParser):
                 triggering = channel.createLinFrameTriggering(self.getShortName(child_element))
                 self.readLinFrameTriggering(child_element, triggering)
             else:
-                raise NotImplementedError("Unsupported Frame Triggering <%s>" % tag_name)
+                self.notImplemented("Unsupported Frame Triggering <%s>" % tag_name)
             
         for child_element in self.findall(element, "I-SIGNAL-TRIGGERINGS/*"):
             tag_name = self.getTagName(child_element)
@@ -2165,7 +2428,7 @@ class ARXMLParser(AbstractARXMLParser):
                 triggering = channel.createISignalTriggering(self.getShortName(child_element))
                 self.readISignalTriggering(child_element, triggering)
             else:
-                raise NotImplementedError("Unsupported Frame Triggering <%s>" % tag_name)
+                self.notImplemented("Unsupported Frame Triggering <%s>" % tag_name)
             
         for child_element in self.findall(element, "PDU-TRIGGERINGS/*"):
             tag_name = self.getTagName(child_element)
@@ -2173,7 +2436,7 @@ class ARXMLParser(AbstractARXMLParser):
                 triggering = channel.createPduTriggering(self.getShortName(child_element))
                 self.readPduTriggering(child_element, triggering)
             else:
-                raise NotImplementedError("Unsupported Frame Triggering <%s>" % tag_name)
+                self.notImplemented("Unsupported Frame Triggering <%s>" % tag_name)
 
     def readCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
         self.readIdentifiable(element, channel)
@@ -2193,7 +2456,7 @@ class ARXMLParser(AbstractARXMLParser):
                 channel = cluster.createLinPhysicalChannel(self.getShortName(child_element))
                 self.readLinPhysicalChannel(child_element, channel)
             else:
-                raise NotImplementedError("Unsupported Physical Channel <%s>" % tag_name)
+                self.notImplemented("Unsupported Physical Channel <%s>" % tag_name)
 
 
     def readCommunicationCluster(self, element: ET.Element, cluster: CommunicationCluster):
@@ -2504,11 +2767,11 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("ISignal %s" % short_name)
         signal = parent.createISignal(short_name)
         self.readIdentifiable(element, signal)
-        signal.dataTypePolicy = self.getChildElementOptionalLiteral(element, "DATA-TYPE-POLICY")
-        signal.initValue = self.getInitValue(element)
-        signal.length = self.getChildElementOptionalNumericalValue(element, "LENGTH")
-        signal.networkRepresentationProps = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION-PROPS")
-        signal.systemSignalRef = self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF")
+        signal.setDataTypePolicy(self.getChildElementOptionalLiteral(element, "DATA-TYPE-POLICY")) \
+              .setInitValue(self.getInitValue(element)) \
+              .setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH")) \
+              .setNetworkRepresentationProps(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION-PROPS")) \
+              .setSystemSignalRef(self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF"))
 
     def readEcucValueCollectionEcucValues(self, element: ET.Element, parent: EcucValueCollection):
         for child_element in self.findall(element, "ECUC-VALUES/ECUC-MODULE-CONFIGURATION-VALUES-REF-CONDITIONAL"):
@@ -2550,7 +2813,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "ECUC-NUMERICAL-PARAM-VALUE":
                 container_value.addParameterValue(self.getEcucNumericalParamValue(child_element))
             else:
-                raise NotImplementedError("Unsupported EcucParameterValue <%s>" % tag_name)
+                self.notImplemented("Unsupported EcucParameterValue <%s>" % tag_name)
             
     def readEcucAbstractReferenceValue(self, element: ET.Element, value: EcucAbstractReferenceValue):
         value.setDefinitionRef(self.getChildElementOptionalRefType(element, "DEFINITION-REF"))
@@ -2568,9 +2831,10 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, key)
         if child_element is not None:
             instance_ref = AnyInstanceRef()
-            instance_ref.setBaseRef(self.getChildElementOptionalRefType(child_element, "BASE-REF")) \
-                        .setContextElementRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-ELEMENT-REF")) \
-                        .setTargetRef(self.getChildElementOptionalRefType(child_element, "TARGET-REF"))
+            instance_ref.setBaseRef(self.getChildElementOptionalRefType(child_element, "BASE-REF")) 
+            for ref in self.getChildElementRefTypeList(child_element, "CONTEXT-ELEMENT-REF"):
+                instance_ref.addContextElementRef(ref)
+            instance_ref.setTargetRef(self.getChildElementOptionalRefType(child_element, "TARGET-REF"))
         return instance_ref
     
     def getEcucInstanceReferenceValue(self, element: ET.Element) -> EcucInstanceReferenceValue:
@@ -2587,7 +2851,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "ECUC-INSTANCE-REFERENCE-VALUE":
                 container_value.addReferenceValue(self.getEcucInstanceReferenceValue(child_element))
             else:
-                raise NotImplementedError("Unsupported EcucParameterValue <%s>" % tag_name)
+                self.notImplemented("Unsupported EcucParameterValue <%s>" % tag_name)
 
     def readEcucContainerValue(self, element: ET.Element, container_value: EcucContainerValue):
         self.readIdentifiable(element, container_value)
@@ -2608,7 +2872,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "ECUC-CONTAINER-VALUE":
                 self.readEcucContainerValueEcucContainerValue(child_element, parent)
             else:
-                raise NotImplementedError("Unsupported Sub Container %s" % tag_name) 
+                self.notImplemented("Unsupported Sub Container %s" % tag_name) 
 
     def readEcucModuleConfigurationValuesEcucContainerValue(self, element: ET.Element, parent: EcucModuleConfigurationValues):
         short_name = self.getShortName(element)
@@ -2622,7 +2886,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "ECUC-CONTAINER-VALUE":
                 self.readEcucModuleConfigurationValuesEcucContainerValue(child_element, values)
             else:
-                raise NotImplementedError("Unsupported Container %s" % tag_name) 
+                self.notImplemented("Unsupported Container %s" % tag_name) 
 
     def readEcucModuleConfigurationValues(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -2636,11 +2900,12 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readPhysicalDimensions(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
-        self.logger.debug("readPhysicalDimensions %s" % short_name)
+        self.logger.debug("read PhysicalDimensions %s" % short_name)
         dimension = parent.createPhysicalDimension(short_name)
         self.readIdentifiable(element, dimension)
         dimension.setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP")) \
                  .setLengthExp(self.getChildElementOptionalNumericalValue(element, "LENGTH-EXP")) \
+                 .setTimeExp(self.getChildElementOptionalNumericalValue(element, "TIME-EXP"))
 
     '''
     def getIPduMappings(self, element: ET.Element) -> List[IPduMapping]:
@@ -2789,8 +3054,9 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getSenderReceiverToSignalMapping(self, element: ET.Element) -> SenderReceiverToSignalMapping:
         mapping = SenderReceiverToSignalMapping()
-        mapping.setDataElementIRef(self.getVariableDataPrototypeInSystemInstanceRef(self.find(element, "DATA-ELEMENT-IREF")))
-        mapping.setSystemSignalRef(self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF"))
+        mapping.setCommunicationDirection(self.getChildElementOptionalLiteral(element, "COMMUNICATION-DIRECTION")) \
+               .setDataElementIRef(self.getVariableDataPrototypeInSystemInstanceRef(self.find(element, "DATA-ELEMENT-IREF"))) \
+               .setSystemSignalRef(self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF"))
         return mapping
     
     def getSenderReceiverToSignalGroupMapping(self, element: ET.Element) -> SenderReceiverToSignalGroupMapping:
@@ -2807,7 +3073,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "SENDER-RECEIVER-TO-SIGNAL-GROUP-MAPPING":
                 mapping.addDataMapping(self.getSenderReceiverToSignalGroupMapping(child_element))
             else:
-                raise NotImplementedError("Unsupported Data Mapping %s" % tag_name)
+                self.notImplemented("Unsupported Data Mapping %s" % tag_name)
 
     def readSwcToEcuMapping(self, element: ET.Element, mapping: SwcToEcuMapping):
         self.logger.debug("SwcToEcuMapping %s" % mapping.getShortName())
@@ -2822,7 +3088,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "SWC-TO-ECU-MAPPING":
                 self.readSwcToEcuMapping(child_element, mapping.createSwcToEcuMapping(self.getShortName(child_element)))
             else:
-                raise NotImplementedError("Unsupported Sw Mapping %s" % tag_name)
+                self.notImplemented("Unsupported Sw Mapping %s" % tag_name)
 
     def readSystemMapping(self, element: ET.Element, parent: System):
         short_name = self.getShortName(element)
@@ -2838,7 +3104,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "SYSTEM-MAPPING":
                 self.readSystemMapping(child_element, system)
             else:
-                raise NotImplementedError("Unsupported Mapping %s" % tag_name)
+                self.notImplemented("Unsupported Mapping %s" % tag_name)
             
     def readRootSwCompositionPrototype(self, element: ET.Element, system: System):
         child_element = self.find(element, "ROOT-SOFTWARE-COMPOSITIONS/ROOT-SW-COMPOSITION-PROTOTYPE")
@@ -2847,7 +3113,9 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug("Read RootSwCompositionPrototype %s" % short_name)
             prototype = system.createRootSoftwareComposition(short_name)
             self.readIdentifiable(child_element, prototype)
-            prototype.setSoftwareCompositionTRef(self.getChildElementOptionalRefType(child_element, "SOFTWARE-COMPOSITION-TREF"))
+            prototype.setFlatMapRef(self.getChildElementOptionalRefType(child_element, "FLAT-MAP-REF")) \
+                     .setSoftwareCompositionTRef(self.getChildElementOptionalRefType(child_element, "SOFTWARE-COMPOSITION-TREF"))
+                     
 
     def readSystem(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -2862,19 +3130,6 @@ class ARXMLParser(AbstractARXMLParser):
         self.readRootSwCompositionPrototype(element, system)
         system.setSystemVersion(self.getChildElementOptionalRevisionLabelString(element, "SYSTEM-VERSION"))
 
-    def readParameterInterfaceParameters(self, element: ET.Element, parent: ParameterInterface):
-        for child_element in self.findall(element, "PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
-            short_name = self.getShortName(child_element)
-            prototype = parent.createParameter(short_name)
-            self.readParameterDataPrototype(child_element, prototype)
-    
-    def readParameterInterface(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read ParameterInterface %s" % short_name)
-        pi_interface = parent.createParameterInterface(short_name)
-        self.readIdentifiable(element, pi_interface)
-        self.readParameterInterfaceParameters(element, pi_interface)
-
     def readGenericEthernetFrame(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         self.logger.debug("Read EthernetFrame %s" % short_name)
@@ -2887,8 +3142,61 @@ class ARXMLParser(AbstractARXMLParser):
         frame = parent.createLifeCycleInfoSet(short_name)
         self.readIdentifiable(element, frame)
 
+    def readFlatInstanceDescriptor(self, element: ET.Element, desc: FlatInstanceDescriptor):
+        self.logger.debug("Read LifeCycleInfoSet %s" % desc.getShortName())
+        self.readIdentifiable(element, desc)
+        desc.setUpstreamReferenceIRef(self.getAnyInstanceRef(element, "UPSTREAM-REFERENCE-IREF")) \
+            .setEcuExtractReferenceIRef(self.getAnyInstanceRef(element, "ECU-EXTRACT-REFERENCE-IREF"))
+
+    def readFlatMapInstances(self, element: ET.Element, map: FlatMap):
+        for child_element in self.findall(element, "INSTANCES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "FLAT-INSTANCE-DESCRIPTOR":
+                desc = map.createFlatInstanceDescriptor(self.getShortName(child_element))
+                self.readFlatInstanceDescriptor(child_element, desc)
+            else:
+                self.notImplemented("Unsupported Flat Map Instances <%s>" % tag_name)
+
+    def readFlatMap(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read FlatMap %s" % short_name)
+        map = parent.createFlatMap(short_name)
+        self.readIdentifiable(element, map)
+        self.readFlatMapInstances(element, map)
+
+    def getDataPrototypeMappings(self, element: ET.Element, key: str) -> List[DataPrototypeMapping]:
+        mappings = []
+        for child_element in self.findall(element, "%s/DATA-PROTOTYPE-MAPPING" % key):
+            mapping = DataPrototypeMapping()
+            mapping.setFirstDataPrototypeRef(self.getChildElementOptionalRefType(child_element, "FIRST-DATA-PROTOTYPE-REF")) \
+                   .setSecondDataPrototypeRef(self.getChildElementOptionalRefType(child_element, "SECOND-DATA-PROTOTYPE-REF"))
+            mappings.append(mapping)
+        return mappings
+
+    def getVariableAndParameterInterfaceMapping(self, element: ET.Element, mapping: VariableAndParameterInterfaceMapping):
+        self.logger.debug("get VariableAndParameterInterfaceMapping %s" % mapping.getShortName())
+        self.readIdentifiable(element, mapping)
+        for item in self.getDataPrototypeMappings(element, "DATA-MAPPINGS"):
+            mapping.addDataMapping(item)
+
+    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)
+            if tag_name == "VARIABLE-AND-PARAMETER-INTERFACE-MAPPING":
+                mapping = mapping_set.createVariableAndParameterInterfaceMapping(self.getShortName(child_element))
+                self.getVariableAndParameterInterfaceMapping(child_element, mapping)
+            else:
+                self.notImplemented("Unsupported PortInterfaceMapping <%s>" % tag_name)
+
+    def readPortInterfaceMappingSet(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read PortInterfaceMappingSet %s" % short_name)
+        mapping_set = parent.createPortInterfaceMappingSet(short_name)
+        self.readIdentifiable(element, mapping_set)
+        self.readPortInterfaceMappings(element, mapping_set)
+
     def readARPackageElements(self, element: ET.Element, parent: ARPackage):
-        for child_element in self.findall(element, "./ELEMENTS/*"):
+        for child_element in self.findall(element, "ELEMENTS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "COMPOSITION-SW-COMPONENT-TYPE":
                 self.readCompositionSwComponentType(child_element, parent)
@@ -3002,8 +3310,12 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readGenericEthernetFrame(child_element, parent)
             elif tag_name == "LIFE-CYCLE-INFO-SET":
                 self.readLifeCycleInfoSet(child_element, parent)
+            elif tag_name == "FLAT-MAP":
+                self.readFlatMap(child_element, parent)
+            elif tag_name == "PORT-INTERFACE-MAPPING-SET":
+                self.readPortInterfaceMappingSet(child_element, parent)
             else:
-                self._raiseError("Unsupported element type of ARPackage <%s>" % tag_name)
+                self.notImplemented("Unsupported element type of ARPackage <%s>" % tag_name)
 
     def readReferenceBases(self, element: ET.Element, parent: ARPackage):
         self.logger.debug("Read ReferenceBases")