armodel 1.7.2__py3-none-any.whl → 1.7.4__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -2,13 +2,10 @@ 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
@@ -18,6 +15,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
@@ -25,15 +23,18 @@ 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 CryptoServiceNeeds, DiagEventDebounceAlgorithm, DiagEventDebounceMonitorInternal, DiagnosticEventNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
@@ -46,25 +47,26 @@ from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyI
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage, ReferenceBase
-from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType, ARLiteral
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Ip6AddressString, RefType, ARLiteral
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption, PortDefinedArgumentValue
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import DataReceivedEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationRecordDataType, ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, AutosarDataType, DataTypeMap, DataTypeMappingSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionSet, EndToEndDescription, EndToEndProtection, EndToEndProtectionVariablePrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface.InstanceRefs import ApplicationCompositeElementInPortInterfaceInstanceRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, AutosarVariableRef, VariableInAtomicSWCTypeInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, VariableInAtomicSWCTypeInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, TransmissionAcknowledgementRequest
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, CompositionSwComponentType, PortGroup, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
 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.SwcInternalBehavior.AutosarVariableRef import AutosarVariableRef
 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.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
 
@@ -73,12 +75,16 @@ from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderReceiv
 from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode
 from ..models.M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import LinFrameTriggering
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, FramePort, IPduPort, ISignalPort, LinPhysicalChannel, PhysicalChannel
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinPhysicalChannel, PhysicalChannel
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import Frame, FrameTriggering, IPdu, IPduTiming, ISignalIPdu, ISignalTriggering, PduTriggering
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import CyclicTiming, EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanCommunication import CanFrameTriggering, RxIdentifierRange
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import CanCommunicationConnector, CanCommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import EthernetCommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SocketConnection, SocketConnectionBundle, SocketConnectionIpduIdentifier
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import Ipv6Configuration, NetworkEndpoint
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import SoAdConfig, SocketAddress
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Multiplatform import ISignalMapping
 
 from .abstract_arxml_parser import AbstractARXMLParser
@@ -114,7 +120,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:
@@ -146,7 +152,7 @@ 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.readARObjectAttributes(child_element, l4)
             l4.value = child_element.text
@@ -156,7 +162,7 @@ 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.readARObjectAttributes(child_element, long_name)
@@ -164,7 +170,7 @@ class ARXMLParser(AbstractARXMLParser):
         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.readARObjectAttributes(child_element, l2)
             l2.value = child_element.text
@@ -174,7 +180,7 @@ 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.readARObjectAttributes(child_element, paragraph)
@@ -200,16 +206,18 @@ class ARXMLParser(AbstractARXMLParser):
             iref.setTargetComponentRef(self.getChildElementOptionalRefType(element, "TARGET-COMPONENT-REF"))
         return iref
 
-    def getAutosarVariableInImplDatatype(self, element: ET.Element) ->  AutosarVariableRef:
-        child_element = self.find(element, "ACCESSED-VARIABLE")
+    def getAutosarVariableRef(self, element: ET.Element, key: str) ->  AutosarVariableRef:
+        child_element = self.find(element, key)
         ref  = None
         if (child_element is not None):
             ref = AutosarVariableRef()
-            ref.setAutosarVariableIRef(self.getVariableInAtomicSWCTypeInstanceRef(self.find(child_element, "AUTOSAR-VARIABLE-IREF")))
+            #self.readARObjectAttributes(child_element, ref)
+            ref.setAutosarVariableIRef(self.getVariableInAtomicSWCTypeInstanceRef(self.find(child_element, "AUTOSAR-VARIABLE-IREF"))) \
+               .setLocalVariableRef(self.getChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF"))
         return ref
 
-    def getLocalVariableRef(self, element: ET.Element) ->  AutosarVariableRef:
-        child_element = self.find(element, "ACCESSED-VARIABLE")
+    def getLocalVariableRef(self, element: ET.Element, key: str) ->  AutosarVariableRef:
+        child_element = self.find(element, key)
         ref  = None
         if (child_element is not None):
             ref = AutosarVariableRef()
@@ -217,34 +225,34 @@ 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)
 
             if (key == "DATA-RECEIVE-POINT-BY-ARGUMENTS"):
                 variable_access = parent.createDataReceivePointByArgument(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "DATA-RECEIVE-POINT-BY-VALUES"):
                 variable_access = parent.createDataReceivePointByValue(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "DATA-READ-ACCESSS"):
                 variable_access = parent.createDataReadAccess(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "DATA-WRITE-ACCESSS"):
                 variable_access = parent.createDataWriteAccess(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "DATA-SEND-POINTS"):
                 variable_access = parent.createDataSendPoint(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "WRITTEN-LOCAL-VARIABLES"):
                 variable_access = parent.createWrittenLocalVariable(short_name)
-                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element))
+                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "READ-LOCAL-VARIABLES"):
                 variable_access = parent.createReadLocalVariable(short_name)
-                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element))
+                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element, "ACCESSED-VARIABLE"))
             else:
-                self._raiseError("Invalid key type <%s>" % key)
+                self.notImplemented("Unsupported Variable Accesss <%s>" % key)
 
             self.readIdentifiable(child_element, variable_access)
 
@@ -286,71 +294,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 self.findall(element, "EVENTS/BSW-MODE-SWITCH-EVENT"):
-            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 readBswTimingEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in self.findall(element, "EVENTS/BSW-TIMING-EVENT"):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("read BswTimingEvent %s" % short_name)
-            event = parent.createBswTimingEvent(short_name)
-            event.setPeriod(self.getChildElementOptionalTimeValue(child_element, "PERIOD"))
-            # Read the Inherit BswScheduleEvent
-            self.readBswScheduleEvent(child_element, event)
-
-    def readBswDataReceivedEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in self.findall(element, "EVENTS/BSW-DATA-RECEIVED-EVENT"):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readBswDataReceivedEvent %s" % short_name)
-            event = parent.createBswDataReceivedEvent(short_name)
-            event.dataRef = 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.eventSourceRef = self.getChildElementRefType(parent.getShortName(), child_element, "EVENT-SOURCE-REF")
-            # 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 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()
@@ -367,13 +349,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)
@@ -381,7 +363,7 @@ 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)
@@ -389,6 +371,7 @@ class ARXMLParser(AbstractARXMLParser):
     def getRoleBasedDataAssignment(self, element: ET.Element) -> RoleBasedDataAssignment:
         assignment = RoleBasedDataAssignment()
         assignment.setRole(self.getChildElementOptionalLiteral(element, "ROLE")) \
+                  .setUsedDataElement(self.getAutosarVariableRef(element, "USED-DATA-ELEMENT")) \
                   .setUsedParameterElement(self.getAutosarParameterRef(element, "USED-PARAMETER-ELEMENT")) \
                   .setUsedPimRef(self.getChildElementOptionalRefType(element, "USED-PIM-REF"))
         return assignment
@@ -423,7 +406,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))
@@ -434,6 +417,7 @@ class ARXMLParser(AbstractARXMLParser):
         short_name = self.getShortName(element)
         needs = parent.createNvBlockNeeds(short_name)
         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")) \
@@ -451,18 +435,21 @@ class ARXMLParser(AbstractARXMLParser):
              .setUseCRCCompMechanism(self.getChildElementOptionalBooleanValue(element, "USE-CRC-COMP-MECHANISM")) \
              .setWriteOnlyOnce(self.getChildElementOptionalBooleanValue(element, "WRITE-ONLY-ONCE")) \
              .setWriteVerification(self.getChildElementOptionalBooleanValue(element, "WRITE-VERIFICATION")) \
+             .setWritingFrequency(self.getChildElementOptionalPositiveInteger(element, "WRITING-FREQUENCY")) \
              .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"))
 
@@ -470,6 +457,7 @@ class ARXMLParser(AbstractARXMLParser):
         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")) \
@@ -491,20 +479,34 @@ class ARXMLParser(AbstractARXMLParser):
     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.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")) 
+             .setUdsDtcNumber(self.getChildElementOptionalIntegerValue(element, "UDS-DTC-NUMBER"))
+        
+    def readDiagnosticEventInfoNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticEventInfoNeeds(short_name)
+        self.logger.debug("Read DiagnosticEventInfoNeeds %s" % short_name)
+        self.readIdentifiable(element, needs)
+        needs.setUdsDtcNumber(self.getChildElementOptionalPositiveInteger(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.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)    
@@ -516,40 +518,56 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readDiagnosticValueNeeds(child_element, parent)
             elif tag_name == "DIAGNOSTIC-EVENT-NEEDS":
                 self.readDiagnosticEventNeeds(child_element, parent)
+            elif tag_name == "DIAGNOSTIC-EVENT-INFO-NEEDS":
+                self.readDiagnosticEventInfoNeeds(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.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.readARObjectAttributes(child_element, include_data_type_set)
-            for ref_type in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-REFS/DATA-TYPE-REF"):
+            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 readSwcInternalBehaviorArTypedPerInstanceMemories(self, element: ET.Element, parent: SwcInternalBehavior):
+        for child_element in self.findall(element, "AR-TYPED-PER-INSTANCE-MEMORYS/VARIABLE-DATA-PROTOTYPE"):
+            short_name = self.getShortName(child_element)
+            prototype = parent.createArTypedPerInstanceMemory(short_name)
+            self.readVariableDataPrototype(child_element, prototype)
+
+    def readSwcInternalBehaviorSharedParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
+        for child_element in self.findall(element, "SHARED-PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
+            short_name = self.getShortName(child_element)
+            prototype = behavior.createSharedParameter(short_name)
+            self.readParameterDataPrototype(child_element, prototype)
 
     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)
@@ -558,41 +576,90 @@ class ARXMLParser(AbstractARXMLParser):
             self.readInternalBehavior(child_element, behavior)
             
             # read the extra SwcInternalBehavior
+            self.readSwcInternalBehaviorArTypedPerInstanceMemories(child_element, behavior)
             self.readSwcInternalBehaviorRunnables(child_element, behavior)
             self.readSwcInternalBehaviorEvents(child_element, behavior)
             self.readSwcInternalBehaviorServiceDependencies(child_element, behavior)
             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.setHandleTerminationAndRestart(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")
+            self.readSwcInternalBehaviorSharedParameters(child_element, behavior)
+            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)
@@ -600,27 +667,42 @@ 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.readARObjectAttributes(element, engineering_obj)
@@ -634,7 +716,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))
@@ -642,7 +724,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)
@@ -650,13 +732,13 @@ 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):
+        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")) \
@@ -665,32 +747,48 @@ class ARXMLParser(AbstractARXMLParser):
             memory_section.setSize(self.getChildElementOptionalNumericalValue(child_element, "SIZE")) \
                           .setSwAddrMethodRef(self.getChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF")) \
                           .setSymbol(self.getChildElementOptionalLiteral(child_element, "SYMBOL"))
-            self.logger.debug("readMemorySections %s" % memory_section.getShortName())
+            self.logger.debug("read MemorySections %s" % memory_section.getShortName())
+
+    def readStackUsage(self, element: ET.Element, usage: StackUsage):
+        self.logger.debug("read StackUsage %s" % usage.getShortName())
+        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)
@@ -727,21 +825,21 @@ class ARXMLParser(AbstractARXMLParser):
         argument = RunnableEntityArgument()
         argument.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
         return argument
-
+    
     def getAutosarParameterRef(self, element: ET.Element, key: str) -> AutosarParameterRef:
-        accessed_parameter = None
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        parameter = None
+        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
+            parameter = AutosarParameterRef()
+            parameter.setLocalParameterRef(self.getChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF"))
+        return 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)
-            parameter_access.accessed_parameter = self.getAutosarParameterRef(child_element, "ACCESSED-PARAMETER")
+            parameter_access.setAccessedParameter(self.getAutosarParameterRef(child_element, "ACCESSED-PARAMETER"))
 
     def readWrittenLocalVariables(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "WRITTEN-LOCAL-VARIABLES")
@@ -897,7 +995,7 @@ 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)
 
@@ -919,7 +1017,7 @@ class ARXMLParser(AbstractARXMLParser):
     def readVariableDataPrototype(self, element: ET.Element, prototype: VariableDataPrototype):
         self.readAutosarDataPrototype(element, prototype)
         prototype.setInitValue(self.getInitValue(element))
-        
+
     def readExplicitInterRunnableVariables(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in self.findall(element, "EXPLICIT-INTER-RUNNABLE-VARIABLES/VARIABLE-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
@@ -944,7 +1042,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, prototype)
         self.readAutosarDataPrototype(element, prototype)
         prototype.setInitValue(self.getInitValue(element))
-        
+
     def readPerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
         for child_element in self.findall(element, "PER-INSTANCE-PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
@@ -955,16 +1053,17 @@ class ARXMLParser(AbstractARXMLParser):
         argument_value = PortDefinedArgumentValue()
         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 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")
+            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)
@@ -1026,6 +1125,15 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 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:
@@ -1165,7 +1273,7 @@ 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 = self.find(element, key)
@@ -1186,13 +1294,15 @@ class ARXMLParser(AbstractARXMLParser):
                                  .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.readSwPointerTargetProps(conditional_tag, sw_data_def_props)
                 self.readARObjectAttributes(conditional_tag, sw_data_def_props.conditional)
         return sw_data_def_props
     
@@ -1272,16 +1382,17 @@ class ARXMLParser(AbstractARXMLParser):
         '''
 
     def readBaseTypeDirectDefinition(self, element: ET.Element, definition: BaseTypeDirectDefinition):
-        definition.baseTypeSize = self.getChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE")
-        definition.baseTypeEncoding = self.getChildElementOptionalLiteral(element, "BASE-TYPE-ENCODING")
-        definition.memAlignment = self.getChildElementOptionalNumericalValue(element, "MEM-ALIGNMENT")
-        definition.nativeDeclaration = self.getChildElementOptionalLiteral(element, "NATIVE-DECLARATION")
+        definition.setBaseTypeSize(self.getChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE")) \
+                  .setBaseTypeEncoding(self.getChildElementOptionalLiteral(element, "BASE-TYPE-ENCODING")) \
+                  .setByteOrder(self.getChildElementOptionalLiteral(element, "BYTE-ORDER")) \
+                  .setMemAlignment(self.getChildElementOptionalNumericalValue(element, "MEM-ALIGNMENT")) \
+                  .setNativeDeclaration(self.getChildElementOptionalLiteral(element, "NATIVE-DECLARATION"))
 
     def readSwBaseType(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         data_type = parent.createSwBaseType(short_name)
         self.readIdentifiable(element, data_type)
-        self.readBaseTypeDirectDefinition(element, data_type.baseTypeDefinition)
+        self.readBaseTypeDirectDefinition(element, data_type.getBaseTypeDefinition())
 
     def getApplicationCompositeElementInPortInterfaceInstanceRef(self, element: ET.Element, key:str) -> ApplicationCompositeElementInPortInterfaceInstanceRef:
         child_element = self.find(element, key)
@@ -1310,7 +1421,7 @@ class ARXMLParser(AbstractARXMLParser):
                 .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()
@@ -1322,30 +1433,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.readARObjectAttributes(child_element, value_list)
-            value_list.v = self.getChildElementOptionalFloatValue(child_element, "V")
+            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.readARObjectAttributes(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")
+            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)
 
@@ -1354,7 +1465,7 @@ 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:
@@ -1380,7 +1491,9 @@ class ARXMLParser(AbstractARXMLParser):
     def getModeSwitchReceiverComSpec(self, element: ET.Element) -> ModeSwitchReceiverComSpec:
         com_spec = ModeSwitchReceiverComSpec()
         self.readARObjectAttributes(element, com_spec)
-        com_spec.modeGroupRef = self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")
+        com_spec.setEnhancedModeApi(self.getChildElementOptionalBooleanValue(element, "ENHANCED-MODE-API")) \
+                .setModeGroupRef(self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")) \
+                .setSupportsAsynchronousModeSwitch(self.getChildElementOptionalBooleanValue(element, "SUPPORTS-ASYNCHRONOUS-MODE-SWITCH"))
         return com_spec
 
     def getNonqueuedReceiverComSpec(self, element: ET.Element) -> NonqueuedReceiverComSpec:
@@ -1390,6 +1503,7 @@ class ARXMLParser(AbstractARXMLParser):
         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
@@ -1454,7 +1568,7 @@ class ARXMLParser(AbstractARXMLParser):
                 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.readARObjectAttributes(child_element, acknowledge)
@@ -1464,7 +1578,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readSenderComSpec(self, element:ET.Element, com_spec: SenderComSpec):
         self.readARObjectAttributes(element, com_spec)
-        for child_element in element.findall("./xmlns:COMPOSITE-NETWORK-REPRESENTATIONS/xmlns:COMPOSITE-NETWORK-REPRESENTATION", self.nsmap):
+        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")) \
@@ -1497,7 +1611,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))
@@ -1530,7 +1644,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)
@@ -1611,12 +1725,13 @@ class ARXMLParser(AbstractARXMLParser):
             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)
 
@@ -1749,7 +1864,7 @@ class ARXMLParser(AbstractARXMLParser):
             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):
@@ -1798,6 +1913,33 @@ class ARXMLParser(AbstractARXMLParser):
         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 = self.find(element, "COMPU-CONST/VT")
         if (child_element is not None):
@@ -1845,46 +1987,40 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readCompuScaleContents(child_element, compu_scale)
                 compu_scales.addCompuScale(compu_scale)
         return compu_scales
-
-    def readCompuInternalToPhys(self, element: ET.Element, compu_method: CompuMethod):
-        child_element = self.find(element, "COMPU-INTERNAL-TO-PHYS")
-        if (child_element is not None):
-            compu = Compu()
-            self.readARObjectAttributes(child_element, compu)
-            compu.setCompuContent(self.getCompuScales(child_element))
-            compu_method.setCompuInternalToPhys(compu)
-
-    def readCompuPhysToInternal(self, element: ET.Element, compu_method: CompuMethod):
-        child_element = self.find(element, "COMPU-PHYS-TO-INTERNAL")
+    
+    def getCompu(self, element: ET.Element, key: str) -> Compu:
+        child_element = self.find(element, key)
+        compu = None
         if (child_element is not None):
             compu = Compu()
             self.readARObjectAttributes(child_element, compu)
-            compu.setCompuContent(self.getCompuScales(child_element))
-            compu_method.setCompuPhysToInternal(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.setUnitRef(self.getChildElementOptionalRefType(element, "UNIT-REF"))
-        self.readCompuInternalToPhys(element, compu_method)
-        self.readCompuPhysToInternal(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.readARObjectAttributes(element, value_spec)
@@ -1922,7 +2058,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:
@@ -1932,8 +2068,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":
@@ -1952,7 +2087,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     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()
@@ -1965,8 +2100,8 @@ 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)
@@ -2340,6 +2475,119 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, channel)
         self.readPhysicalChannel(element, channel)
 
+    def getIpv6Configuration(self, element: ET.Element) -> Ipv6Configuration:
+        configuration = None
+        if element is not None:
+            configuration = Ipv6Configuration()
+            configuration.setAssignmentPriority(self.getChildElementOptionalPositiveInteger(element, "ASSIGNMENT-PRIORITY")) \
+                         .setDefaultRouter(self.getChildElementOptionalLiteral(element, "DEFAULT-ROUTER")) \
+                         .setEnableAnycast(self.getChildElementOptionalBooleanValue(element, "ENABLE-ANYCAST")) \
+                         .setHopCount(self.getChildElementOptionalPositiveInteger(element, "HOP-COUNT")) \
+                         .setIpAddressPrefixLength(self.getChildElementOptionalPositiveInteger(element, "IP-ADDRESS-PREFIX-LENGTH")) \
+                         .setIpv6Address(self.getChildElementOptionalLiteral(element, "IPV-6-ADDRESS")) \
+                         .setIpv6AddressSource(self.getChildElementOptionalLiteral(element, "IPV-6-ADDRESS-SOURCE"))
+        return configuration
+
+    def readNetworkEndPointNetworkEndPointAddress(self, element: ET.Element, end_point: NetworkEndpoint):
+        for child_element in self.findall(element, "NETWORK-ENDPOINT-ADDRESSES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "IPV-6-CONFIGURATION":
+                end_point.addNetworkEndpointAddress(self.getIpv6Configuration(child_element))
+            else:
+                self.notImplemented("Unsupported Network EndPoint Address <%s>" % tag_name)
+
+    def readNetworkEndPoint(self, element: ET.Element, end_point: NetworkEndpoint):
+        self.readIdentifiable(element, end_point)
+        self.readNetworkEndPointNetworkEndPointAddress(element, end_point)
+        end_point.setPriority(self.getChildElementOptionalPositiveInteger(element, "PRIORITY"))
+
+    def readEthernetPhysicalChannelNetworkEndPoints(self, element: ET.Element, channel: EthernetPhysicalChannel):
+        for child_element in self.findall(element, "NETWORK-ENDPOINTS/NETWORK-ENDPOINT"):
+            end_point = channel.createNetworkEndPoint(self.getShortName(child_element))
+            self.readNetworkEndPoint(child_element, end_point)
+
+    def getSocketConnectionIpduIdentifier(self, element: ET.Element) -> SocketConnectionIpduIdentifier:
+        identifier = None
+        if element is not None:
+            identifier = SocketConnectionIpduIdentifier()
+            identifier.setHeaderId(self.getChildElementOptionalPositiveInteger(element, "HEADER-ID")) \
+                      .setPduCollectionSemantics(self.getChildElementOptionalLiteral(element, "PDU-COLLECTION-SEMANTICS")) \
+                      .setPduCollectionTrigger(self.getChildElementOptionalLiteral(element, "PDU-COLLECTION-TRIGGER")) \
+                      .setPduRef(self.getChildElementOptionalRefType(element, "PDU-REF")) \
+                      .setPduTriggeringRef(self.getChildElementOptionalRefType(element, "PDU-TRIGGERING-REF"))
+        return identifier
+
+    def getSocketConnectionPdus(self, element: ET.Element) -> List[SocketConnectionIpduIdentifier]:
+        pdus = []
+        for child_element in self.findall(element, "PDUS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SOCKET-CONNECTION-IPDU-IDENTIFIER":
+                pdus.append(self.getSocketConnectionIpduIdentifier(child_element))
+            else:
+                self.notImplemented("Unsupported Pdu <%s>" % tag_name)
+        return pdus
+
+    def getSocketConnection(self, element: ET.Element) -> SocketConnection:
+        connection = None
+        if element is not None:
+            connection = SocketConnection()
+            connection.setClientPortRef(self.getChildElementOptionalRefType(element, "CLIENT-PORT-REF"))
+            for pdu in self.getSocketConnectionPdus(element):
+                connection.addPdu(pdu)
+            connection.setPduCollectionMaxBufferSize(self.getChildElementOptionalPositiveInteger(element, "PDU-COLLECTION-MAX-BUFFER-SIZE")) \
+                      .setPduCollectionTimeout(self.getChildElementOptionalTimeValue(element, "PDU-COLLECTION-TIMEOUT")) \
+                      .setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL"))
+        return connection
+         
+    def readSocketConnectionBundleConnections(self, element: ET.Element, bundle: SocketConnectionBundle):
+        for child_element in self.findall(element, "BUNDLED-CONNECTIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SOCKET-CONNECTION":
+                bundle.addBundledConnection(self.getSocketConnection(child_element))
+            else: 
+                self.notImplemented("Unsupported Bundled Connection <%s>" % tag_name)
+
+    def readSocketConnectionBundle(self, element: ET.Element, bundle: SocketConnectionBundle):
+        self.readSocketConnectionBundleConnections(element, bundle)
+        bundle.setServerPortRef(self.getChildElementOptionalRefType(element, "SERVER-PORT-REF"))
+
+    def readSoAdConfigConnectionBundles(self, element: ET.Element, config: SoAdConfig):
+        for child_element in self.findall(element, "CONNECTION-BUNDLES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SOCKET-CONNECTION-BUNDLE":
+                bundle = config.createSocketConnectionBundle(self.getShortName(child_element))
+                self.readSocketConnectionBundle(child_element, bundle)
+            else:
+                self.notImplemented("Unsupported Connection Bundle <%s>" % tag_name)
+
+    def readSocketAddress(self, element: ET.Element, address: SocketAddress):
+        self.readSocketConnectionBundleConnections(element, address)
+        address.setConnectorRef(self.getChildElementOptionalRefType(element, "CONNECTOR-REF"))
+
+    def readSoAdConfigSocketAddresses(self, element: ET.Element, config: SoAdConfig):   
+        for child_element in self.findall(element, "SOCKET-ADDRESSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SOCKET-ADDRESS":
+                bundle = config.createSocketAddress(self.getShortName(child_element))
+                self.readSocketAddress(child_element, bundle)
+            else:
+                self.notImplemented("Unsupported Connection Bundle <%s>" % tag_name)
+
+    def getSoAdConfig(self, element: ET.Element, key: str) -> SoAdConfig:
+        child_element = self.find(element, key)
+        config = None
+        if child_element is not None:
+            config = SoAdConfig()
+            self.readSoAdConfigConnectionBundles(child_element, config)
+            self.readSoAdConfigSocketAddresses(child_element, config)
+        return config
+
+    def readEthernetPhysicalChannel(self, element: ET.Element, channel: EthernetPhysicalChannel):
+        self.readIdentifiable(element, channel)
+        self.readPhysicalChannel(element, channel)
+        self.readEthernetPhysicalChannelNetworkEndPoints(element, channel)
+        channel.setSoAdConfig(self.getSoAdConfig(element, "SO-AD-CONFIG"))
+
     def readCommunicationClusterPhysicalChannels(self, element: ET.Element, cluster: CommunicationCluster):
         for child_element in self.findall(element, "PHYSICAL-CHANNELS/*"):
             tag_name = self.getTagName(child_element)
@@ -2349,6 +2597,9 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "LIN-PHYSICAL-CHANNEL":
                 channel = cluster.createLinPhysicalChannel(self.getShortName(child_element))
                 self.readLinPhysicalChannel(child_element, channel)
+            elif tag_name == "ETHERNET-PHYSICAL-CHANNEL":
+                channel = cluster.createEthernetPhysicalChannel(self.getShortName(child_element))
+                self.readEthernetPhysicalChannel(child_element, channel)
             else:
                 self.notImplemented("Unsupported Physical Channel <%s>" % tag_name)
 
@@ -2382,6 +2633,15 @@ class ARXMLParser(AbstractARXMLParser):
             self.readCommunicationCluster(child_element, cluster)
             self.readAbstractCanCluster(child_element, cluster)
 
+    def readEthernetCluster(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read EthernetCluster %s" % short_name)
+        cluster = parent.createEthernetCluster(short_name)
+        self.readIdentifiable(element, cluster)
+        child_element = self.find(element, "ETHERNET-CLUSTER-VARIANTS/ETHERNET-CLUSTER-CONDITIONAL")
+        if child_element is not None:
+            self.readCommunicationCluster(child_element, cluster)
+
     def readPduToFrameMappings(self, element: ET.Element, parent: Frame):
         for child_element in self.findall(element, "PDU-TO-FRAME-MAPPINGS/PDU-TO-FRAME-MAPPING"):
             short_name = self.getShortName(child_element)
@@ -2542,7 +2802,11 @@ class ARXMLParser(AbstractARXMLParser):
         self.readFrame(element, frame)
 
     def readCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
-        self.logger.debug("read CanCommunicationController %s" % controller.getShortName())
+        self.logger.debug("Read CanCommunicationController %s" % controller.getShortName())
+        self.readIdentifiable(element, controller)
+
+    def readEthernetCommunicationController(self, element: ET.Element, controller: EthernetCommunicationController):
+        self.logger.debug("Read CanCommunicationController %s" % controller.getShortName())
         self.readIdentifiable(element, controller)
 
     def readEcuInstanceCommControllers(self, element: ET.Element, instance: EcuInstance):
@@ -2552,6 +2816,9 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "CAN-COMMUNICATION-CONTROLLER":
                 controller = instance.createCanCommunicationController(self.getShortName(child_element))
                 self.readCanCommunicationController(child_element, controller)
+            elif tag_name == "ETHERNET-COMMUNICATION-CONTROLLER":
+                controller = instance.createEthernetCommunicationController(self.getShortName(child_element))
+                self.readEthernetCommunicationController(child_element, controller)
             else:
                 self._raiseError("Unsupported Communication Controller <%s>" % tag_name)
 
@@ -2592,6 +2859,9 @@ class ARXMLParser(AbstractARXMLParser):
     def readCanCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
         self.readCommunicationConnector(element, connector)
 
+    def readEthernetCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
+        self.readCommunicationConnector(element, connector)
+
     def readEcuInstanceConnectors(self, element: ET.Element, instance: EcuInstance):
         self.logger.debug("readEcuInstanceCommControllers %s" % instance.getShortName())
         for child_element in self.findall(element, "CONNECTORS/*"):
@@ -2599,8 +2869,11 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "CAN-COMMUNICATION-CONNECTOR":
                 connector = instance.createCanCommunicationConnector(self.getShortName(child_element))
                 self.readCanCommunicationConnector(child_element, connector)
+            elif tag_name == "ETHERNET-COMMUNICATION-CONNECTOR":
+                connector = instance.createEthernetCommunicationConnector(self.getShortName(child_element))
+                self.readEthernetCommunicationConnector(child_element, connector)
             else:
-                self._raiseError("Unsupported Communication Controller <%s>" % tag_name)                
+                self._raiseError("Unsupported Communication Connector <%s>" % tag_name)                
 
     def readEcuInstance(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -2662,6 +2935,7 @@ class ARXMLParser(AbstractARXMLParser):
         signal = parent.createISignal(short_name)
         self.readIdentifiable(element, signal)
         signal.setDataTypePolicy(self.getChildElementOptionalLiteral(element, "DATA-TYPE-POLICY")) \
+              .setISignalType(self.getChildElementOptionalLiteral(element, "I-SIGNAL-TYPE")) \
               .setInitValue(self.getInitValue(element)) \
               .setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH")) \
               .setNetworkRepresentationProps(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION-PROPS")) \
@@ -2725,9 +2999,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:
@@ -2825,7 +3100,8 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("SystemSignal %s" % short_name)
         signal = parent.createSystemSignal(short_name)
         self.readIdentifiable(element, signal)
-        signal.setDynamicLength(self.getChildElementOptionalBooleanValue(element, "DYNAMIC-LENGTH"))
+        signal.setDynamicLength(self.getChildElementOptionalBooleanValue(element, "DYNAMIC-LENGTH")) \
+              .setPhysicalProps(self.getSwDataDefProps(element, "PHYSICAL-PROPS"))
 
     def readSystemSignalGroup(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -2878,6 +3154,8 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, key)
         if child_element is not None:
             timing = CyclicTiming()
+            timing.setTimeOffset(self.getTimeRangeType(child_element, "TIME-OFFSET")) \
+                  .setTimePeriod(self.getTimeRangeType(child_element, "TIME-PERIOD"))
         return timing
 
     def getEventControlledTiming(self, element: ET.Element, key: str) -> EventControlledTiming:
@@ -2895,8 +3173,8 @@ class ARXMLParser(AbstractARXMLParser):
         if child_element is not None:
             self.logger.debug("Get TransmissionModeTiming of <%s>" % key)
             timing = TransmissionModeTiming()
-            #timing.getCyclicTiming(child_element, "")
-            timing.setEventControlledTiming(self.getEventControlledTiming(child_element, "EVENT-CONTROLLED-TIMING"))
+            timing.setCyclicTiming(self.getCyclicTiming(child_element, "CYCLIC-TIMING")) \
+                  .setEventControlledTiming(self.getEventControlledTiming(child_element, "EVENT-CONTROLLED-TIMING"))
         return timing
 
     def getTransmissionModeDeclaration(self, element: ET.Element, key: str) -> TransmissionModeDeclaration:
@@ -2914,7 +3192,8 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, "I-PDU-TIMING-SPECIFICATIONS/I-PDU-TIMING")
         if child_element is not None:
             timing = IPduTiming()
-            timing.setTransmissionModeDeclaration(self.getTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION"))
+            timing.setMinimumDelay(self.getChildElementOptionalTimeValue(child_element, "MINIMUM-DELAY")) \
+                  .setTransmissionModeDeclaration(self.getTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION"))
         return timing
 
     def readISignalIPdu(self, element: ET.Element, parent: ARPackage):
@@ -2947,8 +3226,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:
@@ -3005,7 +3285,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)
@@ -3032,8 +3314,63 @@ 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)
@@ -3147,8 +3484,14 @@ 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)
+            elif tag_name == "ETHERNET-CLUSTER":
+                self.readEthernetCluster(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")