armodel 1.7.5__py3-none-any.whl → 1.7.7__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -2,16 +2,22 @@ from typing import List
 import xml.etree.ElementTree as ET
 import os
 
+from armodel.models.M2.AUTOSARTemplates.SystemTemplate.SWmapping import SwcToImplMapping
+
+
+
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
-from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition
+from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition, SwBaseType
 from ..models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstrRule, InternalConstrs, PhysConstrs, DataConstr
 from ..models.M2.MSR.AsamHdo.ComputationMethod import CompuConstContent, CompuConstFormulaContent, CompuConstNumericContent, CompuMethod, Compu, CompuConst, CompuConstTextContent, CompuNominatorDenominator, CompuRationalCoeffs, CompuScale, CompuScaleConstantContents, CompuScaleRationalFormula, CompuScales
 from ..models.M2.MSR.AsamHdo.SpecialData import Sdg, Sd
+from ..models.M2.MSR.AsamHdo.Units import PhysicalDimension, Unit
 from ..models.M2.MSR.CalibrationData.CalibrationValue import SwValueCont, SwValues
+from ..models.M2.MSR.DataDictionary.AuxillaryObjects import SwAddrMethod
 from ..models.M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps, SwPointerTargetProps
 from ..models.M2.MSR.DataDictionary.CalibrationParameter import SwCalprmAxis
 from ..models.M2.MSR.DataDictionary.Axis import SwAxisGrouped, SwAxisIndividual
-from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayoutGroupContent, SwRecordLayoutV
+from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayout, SwRecordLayoutGroupContent, SwRecordLayoutV
 from ..models.M2.MSR.DataDictionary.DataDefProperties import ValueList
 from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayoutGroup
 from ..models.M2.MSR.DataDictionary.CalibrationParameter import SwCalprmAxisSet
@@ -23,11 +29,11 @@ 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 BswCalledEntity, BswDataReceivedEvent, BswInternalBehavior, BswInternalTriggerOccurredEvent, BswInterruptEntity, BswModeSwitchEvent, BswModuleEntity, BswSchedulableEntity, BswScheduleEvent, BswModeSenderPolicy, BswTimingEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswBackgroundEvent, BswCalledEntity, BswDataReceivedEvent, BswExternalTriggerOccurredEvent, 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 import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, ConstantSpecification, 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
@@ -41,23 +47,25 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServ
 from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import Implementation
 from ..models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import ExecutionOrderConstraint
-from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingExtensions import TimingExtension
+from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingExtensions import SwcTiming, TimingExtension
+from ..models.M2.AUTOSARTemplates.DiagnosticExtract.DiagnosticContribution import DiagnosticServiceTable
 from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue, EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue, EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
 from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
-from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable, Referrable
 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 Ip6AddressString, RefType, ARLiteral
+from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfoSet
 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.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, BackgroundEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, ModeSwitchedAckEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationPrimitiveDataType, 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, VariableInAtomicSWCTypeInstanceRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, TransmissionAcknowledgementRequest
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, ModeSwitchedAckRequest, 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 import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, ApplicationSwComponentType, ComplexDeviceDriverSwComponentType, CompositionSwComponentType, EcuAbstractionSwComponentType, PortGroup, SensorActuatorSwComponentType, ServiceSwComponentType, 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
@@ -66,28 +74,32 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import Assembl
 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, DataPrototypeMapping, InvalidationPolicy, ModeSwitchInterface, ParameterInterface, PortInterface, PortInterfaceMappingSet, SenderReceiverInterface, VariableAndParameterInterfaceMapping
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ArgumentDataPrototype, ClientServerInterface, ClientServerOperation, DataPrototypeMapping, InvalidationPolicy, ModeSwitchInterface, ParameterInterface, PortInterface, PortInterfaceMappingSet, SenderReceiverInterface, TriggerInterface, VariableAndParameterInterfaceMapping
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AtomicSwComponentType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcImplementation import SwcImplementation
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationCompositeElementDataPrototype, AutosarDataPrototype, DataPrototype, ParameterDataPrototype, VariableDataPrototype
 
 from ..models.M2.AUTOSARTemplates.SystemTemplate import SwcToEcuMapping , System, SystemMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderReceiverToSignalGroupMapping, SenderReceiverToSignalMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.DiagnosticConnection import DiagnosticConnection
-from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmNode
+from ..models.M2.AUTOSARTemplates.SystemTemplate.ECUResourceMapping import ECUMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmEcu, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmEcu, UdpNmNode
 from ..models.M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import ApplicationEntry, LinFrameTriggering, LinScheduleTable, ScheduleTableEntry
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinMaster
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanClusterBusOffRecovery, 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.Fibex4Lin.LinCommunication import ApplicationEntry, LinFrameTriggering, LinScheduleTable, LinUnconditionalFrame, ScheduleTableEntry
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinCommunicationController, LinMaster
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanClusterBusOffRecovery, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, CommunicationController, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import DcmIPdu, DynamicPart, DynamicPartAlternative, Frame, FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignal, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalToIPduMapping, ISignalTriggering, MultiplexedIPdu, MultiplexedPart, NPdu, NmPdu, Pdu, PduTriggering, SecureCommunicationAuthenticationProps, SecureCommunicationFreshnessProps, SecureCommunicationProps, SecureCommunicationPropsSet, SecuredIPdu, SegmentPosition, StaticPart, SystemSignal, SystemSignalGroup, UserDefinedIPdu, UserDefinedPdu
 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 EthernetCommunicationConnector, EthernetCommunicationController, InitialSdDelayConfig, RequestResponseDelay, SdClientConfig
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SocketConnection, SocketConnectionBundle, SocketConnectionIpduIdentifier
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanCommunication import CanFrame, CanFrameTriggering, RxIdentifierRange
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import AbstractCanCommunicationController, AbstractCanCommunicationControllerAttributes, CanCommunicationConnector, CanCommunicationController, CanControllerConfigurationRequirements, CanControllerFdConfiguration, CanControllerFdConfigurationRequirements
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SoAdRoutingGroup, SocketConnection, SocketConnectionBundle, SocketConnectionIpduIdentifier
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetFrame import GenericEthernetFrame
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import DoIpEntity, InfrastructureServices, Ipv6Configuration, NetworkEndpoint
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import ApplicationEndpoint, ConsumedEventGroup, ConsumedServiceInstance, GenericTp, SoAdConfig, SocketAddress, TcpTp, TpPort, TransportProtocolConfiguration, UdpTp
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Multiplatform import ISignalMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import ApplicationEndpoint, ConsumedEventGroup, ConsumedServiceInstance, EventHandler, GenericTp, ProvidedServiceInstance, SdServerConfig, SoAdConfig, SocketAddress, TcpTp, TpPort, TransportProtocolConfiguration, UdpTp
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import CouplingPort, CouplingPortDetails, CouplingPortFifo, CouplingPortScheduler, CouplingPortStructuralElement, EthernetCluster, EthernetCommunicationConnector, EthernetCommunicationController, EthernetPriorityRegeneration, InitialSdDelayConfig, MacMulticastGroup, RequestResponseDelay, SdClientConfig, VlanMembership
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Multiplatform import Gateway, IPduMapping, ISignalMapping, TargetIPduRef
+from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpAddress, CanTpChannel, CanTpConfig, CanTpConnection, CanTpEcu, CanTpNode, DoIpLogicAddress, DoIpTpConfig, DoIpTpConnection, LinTpConfig, LinTpConnection, LinTpNode, TpAddress, TpConfig, TpConnection
 
 from .abstract_arxml_parser import AbstractARXMLParser
 
@@ -112,13 +124,24 @@ class ARXMLParser(AbstractARXMLParser):
             sd.setValue(child_element.text)
             sdg.addSd(sd)
 
+    def readSdgCaption(self, element: ET.Element, sdg:Sdg):
+        child_element = self.find(element, "SDG-CAPTION")
+        if child_element is not None:
+            sdg.createSdgCaption(self.getShortName(child_element))
+
+    def readSdgSdxRefs(self, element: ET.SubElement, sdg:Sdg):
+        for ref in self.getChildElementRefTypeList(element, "SDX-REF"):
+            sdg.addSdxRef(ref)
+
     def getSdg(self, element: ET.Element) -> Sdg:
         sdg = Sdg()
         if 'GID' in element.attrib:
             sdg.setGID(element.attrib["GID"])
+        self.readSdgCaption(element, sdg)
         self.readSd(element, sdg)
         for child_element in self.findall(element, "SDG"):
             sdg.addSdgContentsType(self.getSdg(child_element))
+        self.readSdgSdxRefs(element, sdg)
         return sdg
     
     def readSdgs(self, element: ET.Element, admin_data: AdminData):
@@ -136,9 +159,12 @@ class ARXMLParser(AbstractARXMLParser):
 
             self.readSdgs(child_element, admin_data)
         return admin_data
+    
+    def readReferrable(self, element: ET.Element, referrable: Referrable):
+        self.readARObjectAttributes(element, referrable)
 
     def readMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
-        self.readARObjectAttributes(element, referrable)
+        self.readReferrable(element, referrable)
         referrable.setLongName(self.getMultilanguageLongName(element, "LONG-NAME"))
     
     def readIdentifiable(self, element: ET.Element, identifiable: Identifiable):
@@ -308,12 +334,12 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBswEvent(element, event)
 
     def readBswModeSwitchEvent(self, element: ET.Element, event: BswModeSwitchEvent):
-        self.logger.debug("read BswModeSwitchEvent %s" % event.getShortName())
+        self.logger.debug("Read BswModeSwitchEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
 
     def readBswTimingEvent(self, element: ET.Element, event: BswTimingEvent):
-        self.logger.debug("read BswTimingEvent %s" % event.getShortName())
+        self.logger.debug("Read BswTimingEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setPeriod(self.getChildElementOptionalTimeValue(element, "PERIOD"))
@@ -323,13 +349,13 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug(" Period: <%f, %s>" % (event.getPeriod().getValue(), event.getPeriod().getText()))
 
     def readBswDataReceivedEvent(self, element: ET.Element, event: BswDataReceivedEvent):
-        self.logger.debug("read BswTimingEvent %s" % event.getShortName())
+        self.logger.debug("Read BswDataReceivedEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setDataRef(self.getChildElementOptionalRefType(element, "DATA-REF"))
 
     def readBswInternalTriggerOccurredEvent(self, element: ET.Element, event: BswInternalTriggerOccurredEvent):
-        self.logger.debug("read BswTimingEvent %s" % event.getShortName())
+        self.logger.debug("Read BswInternalTriggerOccurredEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
@@ -346,7 +372,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "BSW-MODE-SENDER-POLICY":
                 parent.addModeSenderPolicy(self.getBswModeSenderPolicy(child_element))
             else:
-                self._raiseError("Unsupported ModeSenderPolicy type <%s>." % tag_name)
+                self.raiseError("Unsupported ModeSenderPolicy type <%s>." % tag_name)
 
     def readDataTypeMappingRefs(self, element: ET.Element, behavior: InternalBehavior):
         child_element = self.find(element, "DATA-TYPE-MAPPING-REFS")
@@ -391,27 +417,27 @@ class ARXMLParser(AbstractARXMLParser):
     def readServiceDependency(self, element: ET.Element, dependency: ServiceDependency):
         self.readIdentifiable(element, dependency)
         for child_element in self.findall(element, "ASSIGNED-DATA-TYPES/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if (tag_name == "ROLE-BASED-DATA-TYPE-ASSIGNMENT"):
                 dependency.addAssignedDataType(self.getRoleBasedDataTypeAssignment(child_element))
             else:
-                self._raiseError("Unsupported assigned data type <%s>" % tag_name)
+                self.notImplemented("Unsupported assigned data type <%s>" % tag_name)
 
     def readSwcServiceDependencyAssignedData(self, element: ET.Element, dependency: SwcServiceDependency):
         for child_element in self.findall(element, "ASSIGNED-DATAS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if (tag_name == "ROLE-BASED-DATA-ASSIGNMENT"):
                 dependency.AddAssignedData(self.getRoleBasedDataAssignment(child_element))
             else:
-                self._raiseError("Unsupported assigned data <%s>" % tag_name)
+                self.raiseError("Unsupported assigned data <%s>" % tag_name)
 
     def readSwcServiceDependencyAssignedPorts(self, element: ET.Element, dependency: SwcServiceDependency):
         for child_element in self.findall(element, "ASSIGNED-PORTS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if (tag_name == "ROLE-BASED-PORT-ASSIGNMENT"):
                 dependency.AddAssignedPort(self.getRoleBasedPortAssignment(child_element))
             else:
-                self._raiseError("Unsupported assigned ports <%s>" % tag_name)
+                self.raiseError("Unsupported assigned ports <%s>" % tag_name)
 
     def readNvBlockNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         short_name = self.getShortName(element)
@@ -507,7 +533,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         for child_element in self.findall(element, "SERVICE-NEEDS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "NV-BLOCK-NEEDS":
                 self.readNvBlockNeeds(child_element, parent)    
             elif tag_name == "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS":
@@ -538,7 +564,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readSwcInternalBehaviorServiceDependencies(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in self.findall(element, "SERVICE-DEPENDENCYS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if (tag_name == "SWC-SERVICE-DEPENDENCY"):
                 self.readSwcServiceDependency(child_element, parent)
             else:
@@ -632,6 +658,13 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported BswModuleEntity <%s>" % tag_name)
 
+    def readBswBackgroundEvent(self, element: ET.Element, event: BswBackgroundEvent):
+        self.readBswScheduleEvent(element, event)
+
+    def readBswExternalTriggerOccurredEvent(self, element: ET.Element, event: BswExternalTriggerOccurredEvent):
+        self.readBswScheduleEvent(element, event)
+        event.setTriggerRef(self.getChildElementOptionalRefType(element, "TRIGGER-REF"))
+
     def readBswInternalBehaviorEvents(self, element: ET.Element, behavior: BswInternalBehavior):
         for child_element in self.findall(element, "EVENTS/*"):
             tag_name = self.getTagName(child_element)
@@ -647,6 +680,12 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "BSW-INTERNAL-TRIGGER-OCCURRED-EVENT":
                 event = behavior.createBswInternalTriggerOccurredEvent(self.getShortName(child_element))
                 self.readBswInternalTriggerOccurredEvent(child_element, event)
+            elif tag_name == "BSW-BACKGROUND-EVENT":
+                event = behavior.createBswBackgroundEvent(self.getShortName(child_element))
+                self.readBswBackgroundEvent(child_element, event)
+            elif tag_name == "BSW-EXTERNAL-TRIGGER-OCCURRED-EVENT":
+                event = behavior.createBswExternalTriggerOccurredEvent(self.getShortName(child_element))
+                self.readBswExternalTriggerOccurredEvent(child_element, event)
             else:
                 self.notImplemented("Unsupported BswModuleEntity <%s>" % tag_name)
 
@@ -664,17 +703,15 @@ class ARXMLParser(AbstractARXMLParser):
             for group_set in self.getIncludedModeDeclarationGroupSets(child_element):
                 behavior.addIncludedModeDeclarationGroupSet(group_set)
 
-    def readBswModuleDescription(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        bsw_module_description = parent.createBswModuleDescription(short_name)
-        bsw_module_description.moduleId = self.getChildElementOptionalNumericalValue(element, "MODULE-ID")
+    def readBswModuleDescription(self, element: ET.Element, desc: BswModuleDescription):
+        self.logger.debug("Read BswModuleDescription <%s>" % desc.getShortName())
 
-        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)
+        self.readIdentifiable(element, desc)
+        desc.setModuleId(self.getChildElementOptionalNumericalValue(element, "MODULE-ID"))
+        self.readBswModuleDescriptionImplementedEntry(element, desc)
+        self.readProvidedModeGroup(element, desc)
+        self.readRequiredModeGroup(element, desc)
+        self.readBswInternalBehavior(element, desc)
 
     def readSwServiceArg(self, element: ET.Element, arg: SwServiceArg):
         self.logger.debug("Read SwServiceArg <%s>" % arg.getShortName())
@@ -690,9 +727,8 @@ class ARXMLParser(AbstractARXMLParser):
             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)
+    def readBswModuleEntry(self, element: ET.Element, entry: BswModuleEntry):
+        self.logger.debug("Read BswModuleEntry <%s>" % entry.getShortName())
         self.readIdentifiable(element, entry)
         self.readBswModuleEntryArguments(element, entry)
         entry.setIsReentrant(self.getChildElementOptionalBooleanValue(element, "IS-REENTRANT")) \
@@ -717,11 +753,11 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readArtifactDescriptor(self, element: ET.Element, code_desc: Code):
         for child_element in self.findall(element, "ARTIFACT-DESCRIPTORS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "AUTOSAR-ENGINEERING-OBJECT":
                 code_desc.addArtifactDescriptor(self.getAutosarEngineeringObject(child_element))
             else:
-                self._raiseError("Unsupported Artifact Descriptor <%s>" % tag_name)
+                self.raiseError("Unsupported Artifact Descriptor <%s>" % tag_name)
             
     def readCodeDescriptor(self, element: ET.Element, impl: Implementation):
         for child_element in self.findall(element, "CODE-DESCRIPTORS/CODE"):
@@ -790,21 +826,19 @@ class ARXMLParser(AbstractARXMLParser):
             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)
-        impl = parent.createBswImplementation(short_name)   
-        self.logger.debug("readBswImplementation %s" % impl.getShortName())
+    def readBswImplementation(self, element: ET.Element, impl: BswImplementation):
+        self.logger.debug("Read BswImplementation <%s>" % impl.getShortName())
         self.readImplementation(element, impl)
         impl.setArReleaseVersion(self.getChildElementOptionalLiteral(element, "AR-RELEASE-VERSION")) \
             .setBehaviorRef(self.getChildElementOptionalRefType(element, "BEHAVIOR-REF"))
         self.readBswImplementationVendorSpecificModuleDefRefs(element, impl)
+        AUTOSAR.getInstance().addImplementationBehaviorMap(impl.getFullName(), impl.getBehaviorRef().getValue())
 
-    def readSwcImplementation(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        impl = parent.createSwcImplementation(short_name)   
-        self.logger.debug("readSwcImplementation %s" % impl.getShortName())
+    def readSwcImplementation(self, element: ET.Element, impl: SwcImplementation):
+        self.logger.debug("Read SwcImplementation <%s>" % impl.getShortName())
         self.readImplementation(element, impl)
-        impl.behaviorRef = self.getChildElementOptionalRefType(element, "BEHAVIOR-REF")
+        impl.setBehaviorRef(self.getChildElementOptionalRefType(element, "BEHAVIOR-REF"))
+        AUTOSAR.getInstance().addImplementationBehaviorMap(impl.getFullName(), impl.getBehaviorRef().getValue())
 
     def readDataReceivePointByArguments(self, element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-RECEIVE-POINT-BY-ARGUMENTS")
@@ -890,13 +924,13 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readInternalBehaviorServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
         for child_element in self.findall(element, "SERVER-CALL-POINTS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "SYNCHRONOUS-SERVER-CALL-POINT":
                 self.readSynchronousServerCallPoint(child_element, parent)
             elif tag_name == "ASYNCHRONOUS-SERVER-CALL-POINT":
                 self.readAsynchronousServerCallPoint(child_element, parent)
             else:
-                self._raiseError("Unsupported server call point type <%s>" % tag_name)
+                self.raiseError("Unsupported server call point type <%s>" % tag_name)
 
     def readInternalTriggeringPoints(self, element: ET.Element, parent: RunnableEntity):
         for child_element in self.findall(element, "INTERNAL-TRIGGERING-POINTS/INTERNAL-TRIGGERING-POINT"):
@@ -1008,9 +1042,8 @@ class ARXMLParser(AbstractARXMLParser):
                           .setTargetProvidedOperationRef(self.getChildElementRefType(parent.getShortName(), child_element, "TARGET-PROVIDED-OPERATION-REF"))
             parent.setOperationIRef(operation_iref)
 
-    def readOperationInvokedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createOperationInvokedEvent(short_name)
+    def readOperationInvokedEvent(self, element: ET.Element, event: OperationInvokedEvent):
+        self.logger.debug("Read OperationInvokedEvent <%s>" % event.getShortName())
         self.readPOperationIRef(element, "OPERATION-IREF", event)
         self.readRTEEvent(element, event)
 
@@ -1068,60 +1101,76 @@ class ARXMLParser(AbstractARXMLParser):
                 option.addPortArgValue(self.readPortDefinedArgumentValue(argument_value_tag))
             behavior.addPortAPIOption(option)
             
-    def readTimingEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createTimingEvent(short_name)
+    def readTimingEvent(self, element: ET.Element, event: TimingEvent):
+        self.logger.debug("Read TimingEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setOffset(self.getChildElementOptionalTimeValue(element, "OFFSET")) \
              .setPeriod(self.getChildElementOptionalTimeValue(element, "PERIOD"))
 
-    def readDataReceivedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createDataReceivedEvent(short_name)
+    def readDataReceivedEvent(self, element: ET.Element, event: DataReceivedEvent):
+        self.logger.debug("Read DataReceivedEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         self.readRVariableInAtomicSwcInstanceRef(element, event)
 
-    def readSwcModeSwitchEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createSwcModeSwitchEvent(short_name)
+    def readSwcModeSwitchEvent(self, element: ET.Element, event: SwcModeSwitchEvent):
+        self.logger.debug("Read SwcModeSwitchEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setActivation(self.getChildElementOptionalLiteral(element, "ACTIVATION"))
         self.readRModeInAtomicSwcInstanceRef(element, event)
 
-    def readInternalTriggerOccurredEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createInternalTriggerOccurredEvent(short_name)
+    def readInternalTriggerOccurredEvent(self, element: ET.Element, event: InternalTriggerOccurredEvent):
+        self.logger.debug("Read InternalTriggerOccurredEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
-    def readInitEvent(self, element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createInitEvent(short_name)
+    def readInitEvent(self, element, event: InitEvent):
+        self.logger.debug("Read InitEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
 
-    def readAsynchronousServerCallReturnsEvent(self, element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createAsynchronousServerCallReturnsEvent(short_name)
+    def readAsynchronousServerCallReturnsEvent(self, element, event: AsynchronousServerCallReturnsEvent):
+        self.logger.debug("Read AsynchronousServerCallReturnsEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setActivationReasonRepresentationRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
+    def readModeSwitchedAckEvent(self, element, event: ModeSwitchedAckEvent):
+        self.logger.debug("Read ModeSwitchedAckEvent <%s>" % event.getShortName())
+        self.readRTEEvent(element, event)
+        event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
+
+    def readBackgroundEvent(self, element, event: BackgroundEvent):
+        self.logger.debug("Read BackgroundEvent <%s>" % event.getShortName())
+        self.readRTEEvent(element, event)
+
     def readSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in self.findall(element, "EVENTS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "TIMING-EVENT":
-                self.readTimingEvent(child_element, parent)
+                event = parent.createTimingEvent(self.getShortName(child_element))
+                self.readTimingEvent(child_element, event)
             elif tag_name == "SWC-MODE-SWITCH-EVENT":
-                self.readSwcModeSwitchEvent(child_element, parent)
+                event = parent.createSwcModeSwitchEvent(self.getShortName(child_element))
+                self.readSwcModeSwitchEvent(child_element, event)
             elif tag_name == "OPERATION-INVOKED-EVENT":
-                self.readOperationInvokedEvent(child_element, parent)
+                event = parent.createOperationInvokedEvent(self.getShortName(child_element))
+                self.readOperationInvokedEvent(child_element, event)
             elif tag_name == "DATA-RECEIVED-EVENT":
-                self.readDataReceivedEvent(child_element, parent)
+                event = parent.createDataReceivedEvent(self.getShortName(child_element))
+                self.readDataReceivedEvent(child_element, event)
             elif tag_name == "INTERNAL-TRIGGER-OCCURRED-EVENT":
-                self.readInternalTriggerOccurredEvent(child_element, parent)
+                event = parent.createInternalTriggerOccurredEvent(self.getShortName(child_element))
+                self.readInternalTriggerOccurredEvent(child_element, event)
             elif tag_name == "INIT-EVENT":
-                self.readInitEvent(child_element, parent)
+                event = parent.createInitEvent(self.getShortName(child_element))
+                self.readInitEvent(child_element, event)
             elif tag_name == "ASYNCHRONOUS-SERVER-CALL-RETURNS-EVENT":
-                self.readAsynchronousServerCallReturnsEvent(child_element, parent)
+                event = parent.createAsynchronousServerCallReturnsEvent(self.getShortName(child_element))
+                self.readAsynchronousServerCallReturnsEvent(child_element, event)
+            elif tag_name == "MODE-SWITCHED-ACK-EVENT":
+                event = parent.createModeSwitchedAckEvent(self.getShortName(child_element))
+                self.readModeSwitchedAckEvent(child_element, event)
+            elif tag_name == "BACKGROUND-EVENT":
+                event = parent.createBackgroundEvent(self.getShortName(child_element))
+                self.readBackgroundEvent(child_element, event)
             else:
                 self.notImplemented("Unsupported SwcInternalBehavior Event <%s>" % tag_name)
 
@@ -1265,7 +1314,7 @@ class ARXMLParser(AbstractARXMLParser):
     def getSwCalprmAxisSet(self, element: ET.Element, key: str) -> SwCalprmAxisSet:
         set = SwCalprmAxisSet()
         for child_element in self.findall(element, "%s/*" % key):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "SW-CALPRM-AXIS":
                 set.addSwCalprmAxis(self.getSwCalprmAxis(child_element))
         return set
@@ -1310,10 +1359,8 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, data_type)
         data_type.setSwDataDefProps(self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS"))
 
-    def readApplicationPrimitiveDataType(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        data_type = parent.createApplicationPrimitiveDataType(short_name)
-        self.logger.debug("readApplicationPrimitiveDataTypes %s" % short_name)
+    def readApplicationPrimitiveDataType(self, element: ET.Element, data_type: ApplicationPrimitiveDataType):
+        self.logger.debug("Read ApplicationPrimitiveDataType <%s>" % data_type.getShortName())
         self.readAutosarDataType(element, data_type)
 
     def readApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
@@ -1327,10 +1374,8 @@ class ARXMLParser(AbstractARXMLParser):
             self.readIdentifiable(child_element, record_element)
             self.readApplicationCompositeElementDataPrototype(child_element, record_element)
 
-    def readApplicationRecordDataTypes(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        data_type = parent.createApplicationRecordDataType(short_name)
-        self.logger.debug("readApplicationRecordDataTypes %s" % short_name)
+    def readApplicationRecordDataType(self, element: ET.Element, data_type: ApplicationRecordDataType):
+        self.logger.debug("Read ApplicationRecordDataType <%s>" % data_type.getShortName())
         self.readIdentifiable(element, data_type)
         data_type.setSwDataDefProps(self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS"))
         self.readApplicationRecordElements(element, data_type)
@@ -1345,41 +1390,13 @@ class ARXMLParser(AbstractARXMLParser):
             self.readImplementationDataTypeElements(child_element, type_element)
             type_element.setSwDataDefProps(self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS"))
 
-    def readImplementationDataType(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        data_type = parent.createImplementationDataType(short_name)
+    def readImplementationDataType(self, element: ET.Element, data_type: ImplementationDataType):
+        self.logger.debug("Read ImplementationDataType <%s>" % data_type.getShortName())
         self.readAutosarDataType(element, data_type)
         data_type.setDynamicArraySizeProfile(self.getChildElementOptionalLiteral(element, "DYNAMIC-ARRAY-SIZE-PROFILE"))
         self.readImplementationDataTypeElements(element, data_type)
+        self.readImplementationDataTypeSymbolProps(element, data_type)
         data_type.setTypeEmitter(self.getChildElementOptionalLiteral(element, "TYPE-EMITTER"))
-        
-        
-        '''
-        if (data_type.getCategory().getValue() == ImplementationDataType.CATEGORY_ARRAY):
-            if (len(data_type.getImplementationDataTypeElements()) < 1):
-                self._raiseError("Array Sub-Element of <%s> do not defined." % data_type.getShortName())
-
-            array_sub_element = data_type.getImplementationDataTypeElements()[0]
-            if (array_sub_element.getCategory().getValue() == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
-                data_type.setArrayElementType(array_sub_element.swDataDefProps.implementationDataTypeRef.value)
-            elif (array_sub_element.getCategory().getValue() == ImplementationDataType.CATEGORY_TYPE_VALUE):  # TODO: fix 
-                return
-            else:
-                self._raiseError("The category <%s> of array sub-element <%s> does not support." % (
-                    array_sub_element.getCategory().getValue(), data_type.getShortName()))
-        elif (data_type.getCategory().getValue() == ImplementationDataType.CATEGORY_TYPE_STRUCTURE):
-            if len(data_type.getImplementationDataTypeElements()) < 1:
-                self._raiseError("Structure Sub-Element of <%s> do not defined." % data_type.getShortName())
-            self.readImplementationDataTypeSymbolProps(element, data_type)
-            struct_sub_element = data_type.getImplementationDataTypeElements()[0]
-            if struct_sub_element.getCategory().getValue() == ImplementationDataType.CATEGORY_TYPE_REFERENCE:
-                data_type.setStructElementType(struct_sub_element.getSwDataDefProps().getImplementationDataTypeRef().getValue())
-            #elif struct_sub_element.getCategory().getValue() == ImplementationDataType.CATEGORY_TYPE_VALUE:
-            #    return
-            else:
-                self._raiseError("The category <%s> of structure sub-element <%s> does not support." % (
-                    struct_sub_element.getCategory().getValue(), data_type.getShortName()))
-        '''
 
     def readBaseTypeDirectDefinition(self, element: ET.Element, definition: BaseTypeDirectDefinition):
         definition.setBaseTypeSize(self.getChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE")) \
@@ -1388,9 +1405,8 @@ class ARXMLParser(AbstractARXMLParser):
                   .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)
+    def readSwBaseType(self, element: ET.Element, data_type: SwBaseType):
+        self.logger.debug("Read SwBaseType <%s>" % data_type.getShortName())
         self.readIdentifiable(element, data_type)
         self.readBaseTypeDirectDefinition(element, data_type.getBaseTypeDefinition())
 
@@ -1510,7 +1526,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readRequiredComSpec(self, element: ET.Element, parent: RPortPrototype):
         for child_element in self.findall(element, "REQUIRED-COM-SPECS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "NONQUEUED-RECEIVER-COM-SPEC":
                 parent.addRequiredComSpec(self.getNonqueuedReceiverComSpec(child_element))
             elif tag_name == "CLIENT-COM-SPEC":
@@ -1522,7 +1538,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "PARAMETER-REQUIRE-COM-SPEC":
                 parent.addRequiredComSpec(self.getParameterRequireComSpec(child_element))
             else:
-                self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
+                self.raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
     def readAbstractRequiredPortPrototype(self, element: ET.Element, prototype: AbstractRequiredPortPrototype):
         self.readProvidedComSpec(element, prototype)
@@ -1565,7 +1581,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "PR-PORT-PROTOTYPE":
                 self.readPRPortPrototype(child_element, sw_component)
             else:
-                self._raiseError("Unsupported Port Prototype <%s>" % tag_name)
+                self.raiseError("Unsupported Port Prototype <%s>" % tag_name)
 
     def readTransmissionAcknowledgementRequest(self, element: ET.Element) -> TransmissionAcknowledgementRequest:
         child_element = self.find(element, "TRANSMISSION-ACKNOWLEDGE")
@@ -1586,33 +1602,42 @@ class ARXMLParser(AbstractARXMLParser):
                 .setTransmissionAcknowledge(self.readTransmissionAcknowledgementRequest(element)) \
                 .setUsesEndToEndProtection(self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION"))
 
-    def getNonqueuedSenderComSpec(self, element) -> NonqueuedSenderComSpec:
+    def getNonqueuedSenderComSpec(self, element:ET.Element) -> NonqueuedSenderComSpec:
         com_spec = NonqueuedSenderComSpec()
         self.readSenderComSpec(element, com_spec)
         com_spec.setInitValue(self.getInitValue(element))
         return com_spec
     
-    def getServerComSpec(self, element) -> ServerComSpec:
+    def getServerComSpec(self, element:ET.Element) -> ServerComSpec:
         com_spec = ServerComSpec()
         self.readARObjectAttributes(element, com_spec)
         com_spec.setOperationRef(self.getChildElementOptionalRefType(element, "OPERATION-REF")) \
                 .setQueueLength(self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH"))
         return com_spec
     
-    def getQueuedSenderComSpec(self, element) -> QueuedSenderComSpec:
+    def getQueuedSenderComSpec(self, element:ET.Element) -> QueuedSenderComSpec:
         com_spec = QueuedSenderComSpec()
         self.readSenderComSpec(element, com_spec)
         return com_spec
     
+    def getModeSwitchedAckRequest(self, element: ET.Element, key: str) -> ModeSwitchedAckRequest:
+        request = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            request = ModeSwitchedAckRequest()
+            request.setTimeout(self.getChildElementOptionalTimeValue(child_element, "TIMEOUT"))
+        return request
+    
     def getModeSwitchSenderComSpec(self, element) -> ModeSwitchSenderComSpec:
         com_spec = ModeSwitchSenderComSpec()
         com_spec.setModeGroupRef(self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")) \
+                .setModeSwitchedAck(self.getModeSwitchedAckRequest(element, "MODE-SWITCHED-ACK")) \
                 .setQueueLength(self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH"))
         return com_spec
 
     def readProvidedComSpec(self, element: ET.Element, parent: PPortPrototype):
         for child_element in self.findall(element, "PROVIDED-COM-SPECS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "NONQUEUED-SENDER-COM-SPEC":
                 parent.addProvidedComSpec(self.getNonqueuedSenderComSpec(child_element))
             elif tag_name == "SERVER-COM-SPEC":
@@ -1622,7 +1647,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "MODE-SWITCH-SENDER-COM-SPEC":
                 parent.addProvidedComSpec(self.getModeSwitchSenderComSpec(child_element))
             else:
-                self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
+                self.raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
     def readPortGroupInnerGroupIRefs(self, element: ET.Element, parent: PortGroup):
         for child_element in self.findall(element, "INNER-GROUP-IREFS/INNER-GROUP-IREF"):
@@ -1645,11 +1670,11 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readSwComponentTypePortGroups(self, element: ET.Element, parent: SwComponentType):
         for child_element in self.findall(element, "PORT-GROUPS/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "PORT-GROUP":
                 self.readPortGroup(child_element, parent)
             else:
-                self._raiseError("Unsupported Port Group type: %s" % tag_name)
+                self.raiseError("Unsupported Port Group type: %s" % tag_name)
 
     def readSwComponentType(self, element: ET.Element, parent: SwComponentType):
         self.readIdentifiable(element, parent)
@@ -1660,32 +1685,24 @@ class ARXMLParser(AbstractARXMLParser):
         self.readSwComponentType(element, parent)
         self.readSwcInternalBehavior(element, parent)
 
-    def readEcuAbstractionSwComponent(self, element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        sw_component = parent.createEcuAbstractionSwComponentType(short_name)
+    def readEcuAbstractionSwComponentType(self, element, sw_component: EcuAbstractionSwComponentType):
+        self.logger.debug("Read EcuAbstractionSwComponentType <%s>" % sw_component.getShortName())
         self.readAtomicSwComponentType(element, sw_component)
 
-    def readApplicationSwComponentTypes(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        sw_component = parent.createApplicationSwComponentType(short_name)
+    def readApplicationSwComponentType(self, element: ET.Element, sw_component: ApplicationSwComponentType):
+        self.logger.debug("Read ApplicationSwComponentType <%s>" % sw_component.getShortName())
         self.readAtomicSwComponentType(element, sw_component)
 
-    def readComplexDeviceDriverSwComponentType(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        sw_component = parent.createComplexDeviceDriverSwComponentType(short_name)
-        self.logger.debug("readComplexDeviceDriverSwComponentType <%s>" % short_name)
-        self.readAtomicSwComponentType(element, sw_component)
+    def readComplexDeviceDriverSwComponentType(self, element: ET.Element, type: ComplexDeviceDriverSwComponentType):
+        self.logger.debug("Read ComplexDeviceDriverSwComponentType <%s>" % type.getShortName())
+        self.readAtomicSwComponentType(element, type)
 
-    def readSensorActuatorSwComponentType(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        sw_component = parent.createSensorActuatorSwComponentType(short_name)
-        self.logger.debug("readSensorActuatorSwComponentType <%s>" % short_name)
+    def readSensorActuatorSwComponentType(self, element: ET.Element, sw_component: SensorActuatorSwComponentType):
+        self.logger.debug("Read SensorActuatorSwComponentType <%s>" % sw_component.getShortName())
         self.readAtomicSwComponentType(element, sw_component)
 
-    def readServiceSwComponentType(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        sw_component = parent.createServiceSwComponentType(short_name)
-        self.logger.debug("readServiceSwComponentType <%s>" % short_name)
+    def readServiceSwComponentType(self, element: ET.Element, sw_component: ServiceSwComponentType):
+        self.logger.debug("Read ServiceSwComponentType <%s>" % sw_component.getShortName())
         self.readAtomicSwComponentType(element, sw_component)
 
     def readPPortInCompositionInstanceRef(self, element: ET.Element, p_port_in_composition_instance_ref: PPortInCompositionInstanceRef):
@@ -1752,7 +1769,7 @@ class ARXMLParser(AbstractARXMLParser):
                 parent.setInnerPortIRref(p_port_in_composition_instance_ref)
                 return
             
-            self._raiseError("Unsupported child element of INNER-PORT-IREF")
+            self.raiseError("Unsupported child element of INNER-PORT-IREF")
 
     def readDelegationSwConnectors(self, element, parent: CompositionSwComponentType):
         for child_element in self.findall(element, "CONNECTORS/DELEGATION-SW-CONNECTOR"):
@@ -1764,7 +1781,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.readDelegationSwConnectorInnerPortIRef(child_element, connector)
 
             if connector.getInnerPortIRref() == None and connector.getOuterPortRef() == None:
-                self._raiseError("Invalid PortPrototype of DELEGATION-SW-CONNECTOR")
+                self.raiseError("Invalid PortPrototype of DELEGATION-SW-CONNECTOR")
 
             connector.setOuterPortRef(self.getChildElementOptionalRefType(child_element, "OUTER-PORT-REF"))
             self.logger.debug("OUTER-PORT-REF DEST: %s, %s"
@@ -1785,19 +1802,14 @@ class ARXMLParser(AbstractARXMLParser):
             for ref in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-MAPPING-REF"):
                 parent.addDataTypeMapping(ref)
 
-    def readCompositionSwComponentType(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readCompositionSwComponentTypes: <%s>" % short_name)
-
-        sw_component = parent.createCompositionSwComponentType(short_name)
-        self.readIdentifiable(element, sw_component)
-        self.readSwComponentType(element, sw_component)
-        self.readSwComponentPrototypes(element, sw_component)
-        self.readAssemblySwConnectors(element, sw_component)
-        self.readDelegationSwConnectors(element, sw_component)
-        self.readCompositionSwComponentTypeDataTypeMappingSet(element, sw_component)
-
-        self.logger.debug("ReadCompositionSwComponentTypes: <%s> (Done)" % short_name)
+    def readCompositionSwComponentType(self, element: ET.Element, type: CompositionSwComponentType):
+        self.logger.debug("Read CompositionSwComponentType: <%s>" % type.getShortName())
+        self.readIdentifiable(element, type)
+        self.readSwComponentType(element, type)
+        self.readSwComponentPrototypes(element, type)
+        self.readAssemblySwConnectors(element, type)
+        self.readDelegationSwConnectors(element, type)
+        self.readCompositionSwComponentTypeDataTypeMappingSet(element, type)
 
     def readDataTypeMaps(self, element: ET.Element, parent: DataTypeMappingSet):
         for child_element in element.findall("./xmlns:DATA-TYPE-MAPS/xmlns:DATA-TYPE-MAP", self.nsmap):
@@ -1817,9 +1829,8 @@ class ARXMLParser(AbstractARXMLParser):
             map.modeGroupRef = self.getChildElementOptionalRefType(child_element, "MODE-GROUP-REF")
             parent.addModeRequestTypeMap(map)
 
-    def readDataTypeMappingSet(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        mapping_set = parent.createDataTypeMappingSet(short_name)
+    def readDataTypeMappingSet(self, element: ET.Element, mapping_set: DataTypeMappingSet):
+        self.logger.debug("Read DataTypeMappingSet: <%s>" % mapping_set.getShortName())
         self.readIdentifiable(element, mapping_set)
         self.readDataTypeMaps(element, mapping_set)
         self.readModeRequestTypeMaps(element, mapping_set)
@@ -1848,11 +1859,10 @@ class ARXMLParser(AbstractARXMLParser):
             policy.data_element_ref = self.getChildElementOptionalRefType(child_element, "DATA-ELEMENT-REF")
             policy.handle_invalid = self.getChildElementOptionalLiteral(child_element, "HANDLE-INVALID")
 
-    def readSenderReceiverInterfaces(self, element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        sr_interface = parent.createSenderReceiverInterface(short_name)
+    def readSenderReceiverInterface(self, element, sr_interface: SenderReceiverInterface):
+        self.logger.debug("Read SenderReceiverInterface <%s>" % sr_interface.getShortName())
         self.readIdentifiable(element, sr_interface)
-        sr_interface.isService = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
+        sr_interface.setIsService(self.getChildElementOptionalBooleanValue(element, "IS-SERVICE"))
         self.readSenderReceiverInterfaceDataElements(element, sr_interface)
         self.readSenderReceiverInterfaceInvalidationPolicies(element, sr_interface)
 
@@ -1899,16 +1909,13 @@ class ARXMLParser(AbstractARXMLParser):
             prototype = param_interface.createParameter(short_name)
             self.readParameterDataPrototype(child_element, prototype)
     
-    def readParameterInterface(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read ParameterInterface %s" % short_name)
-        param_interface = parent.createParameterInterface(short_name)
+    def readParameterInterface(self, element: ET.Element, param_interface: ParameterInterface):
+        self.logger.debug("Read ParameterInterface <%s>" % param_interface.getShortName())
         self.readPortInterface(element, param_interface)
         self.readParameterInterfaceParameters(element, param_interface)
 
-    def readClientServerInterface(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        cs_interface = parent.createClientServerInterface(short_name)
+    def readClientServerInterface(self, element: ET.Element, cs_interface: ClientServerInterface):
+        self.logger.debug("Read readClientServerInterface <%s>" % cs_interface.getShortName())
         self.readPortInterface(element, cs_interface)
         self.readOperations(element, cs_interface)
         self.readPossibleErrors(element, cs_interface)
@@ -1982,6 +1989,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readARObjectAttributes(child_element, compu_scale)
                 compu_scale.setLowerLimit(self.getChildLimitElement(child_element, "LOWER-LIMIT")) \
                            .setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
+                           .setDesc(self.getMultiLanguageOverviewParagraph(child_element, "DESC")) \
                            .setSymbol(self.getChildElementOptionalLiteral(child_element, "SYMBOL")) \
                            .setUpperLimit(self.getChildLimitElement(child_element, "UPPER-LIMIT"))
                 self.readCompuScaleContents(child_element, compu_scale)
@@ -1998,29 +2006,26 @@ class ARXMLParser(AbstractARXMLParser):
             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)
+    def readCompuMethod(self, element: ET.Element, compu_method: CompuMethod):
+        self.logger.debug("Read CompuMethods <%s>" % compu_method.getShortName())
         self.readIdentifiable(element, compu_method)
         compu_method.setUnitRef(self.getChildElementOptionalRefType(element, "UNIT-REF")) \
                     .setCompuInternalToPhys(self.getCompu(element, "COMPU-INTERNAL-TO-PHYS")) \
                     .setCompuPhysToInternal(self.getCompu(element, "COMPU-PHYS-TO-INTERNAL"))
 
-    def readSwcBswRunnableMappings(self, element: ET.Element, parent: SwcBswMapping):
+    def readSwcBswMappingSwcBswRunnableMappings(self, element: ET.Element, parent: SwcBswMapping):
         for child_element in self.findall(element, "RUNNABLE-MAPPINGS/SWC-BSW-RUNNABLE-MAPPING"):
             mapping = SwcBswRunnableMapping()
             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("read SwcBswMappings %s" % short_name)
-        swc_bsw_mapping = parent.createSwcBswMapping(short_name)
-        swc_bsw_mapping.setBswBehaviorRef(self.getChildElementOptionalRefType(element, "BSW-BEHAVIOR-REF"))
-        self.readSwcBswRunnableMappings(element, swc_bsw_mapping)
-        swc_bsw_mapping.setSwcBehaviorRef(self.getChildElementOptionalRefType(element, "SWC-BEHAVIOR-REF"))
+    def readSwcBswMapping(self, element: ET.Element, mapping: SwcBswMapping):
+        self.logger.debug("read SwcBswMappings %s" % mapping.getShortName())
+        self.readIdentifiable(element, mapping)
+        mapping.setBswBehaviorRef(self.getChildElementOptionalRefType(element, "BSW-BEHAVIOR-REF"))
+        self.readSwcBswMappingSwcBswRunnableMappings(element, mapping)
+        mapping.setSwcBehaviorRef(self.getChildElementOptionalRefType(element, "SWC-BEHAVIOR-REF"))
 
     def readValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
         self.readARObjectAttributes(element, value_spec)
@@ -2095,10 +2100,8 @@ class ARXMLParser(AbstractARXMLParser):
         self.readRecordValueSpecificationFields(element, value_spec)
         return value_spec
 
-    def readConstantSpecification(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readConstantSpecification %s" % short_name)
-        spec = parent.createConstantSpecification(short_name)
+    def readConstantSpecification(self, element: ET.Element, spec: ConstantSpecification):
+        self.logger.debug("readConstantSpecification %s" % spec.getShortName())
         self.readIdentifiable(element, spec)
         for child_element in self.findall(element, "VALUE-SPEC/*"):
             spec.setValueSpec(self.getValueSpecification(child_element, self.getTagName(child_element)))
@@ -2132,24 +2135,19 @@ class ARXMLParser(AbstractARXMLParser):
             self.readPhysConstrs(child_element, rule)
             parent.addDataConstrRule(rule)
                 
-    def readDataConstr(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readDataConstr %s" % short_name)
-        constr = parent.createDataConstr(short_name)
+    def readDataConstr(self, element: ET.Element, constr: DataConstr):
+        self.logger.debug("Read DataConstr <%s>" % constr.getShortName())
         self.readIdentifiable(element, constr)
         self.readDataConstrRule(element, constr)
 
-    def readUnit(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readUnit %s" % short_name)
-        unit = parent.createUnit(short_name)
+    def readUnit(self, element: ET.Element, unit: Unit):
+        self.logger.debug("Read Unit <%s>" % unit.getShortName())
         self.readIdentifiable(element, unit)
         unit.setDisplayName(self.getChildElementOptionalLiteral(element, "DISPLAY-NAME")) \
             .setFactorSiToUnit(self.getChildElementOptionalFloatValue(element, "FACTOR-SI-TO-UNIT")) \
             .setOffsetSiToUnit(self.getChildElementOptionalFloatValue(element, "OFFSET-SI-TO-UNIT")) \
             .setPhysicalDimensionRef(self.getChildElementOptionalRefType(element, "PHYSICAL-DIMENSION-REF"))
 
-
     def readEndToEndDescriptionDataId(self, element: ET.Element, parent: EndToEndDescription):
         child_element = element.find("./xmlns:DATA-IDS", self.nsmap)
         if child_element is not None:
@@ -2190,11 +2188,11 @@ class ARXMLParser(AbstractARXMLParser):
     
     def readEndToEndProtectionVariablePrototypes(self, element: ET.Element, parent: EndToEndProtection):
         for child_element in element.findall("./xmlns:END-TO-END-PROTECTION-VARIABLE-PROTOTYPES/*", self.nsmap):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "END-TO-END-PROTECTION-VARIABLE-PROTOTYPE":
                 parent.addEndToEndProtectionVariablePrototype(self.getEndToEndProtectionVariablePrototype(child_element))
             else:
-                self._raiseError("Unsupported End To End Protection Variable Prototype <%s>" % tag_name)
+                self.raiseError("Unsupported End To End Protection Variable Prototype <%s>" % tag_name)
 
     def readEndToEndProtection(self, element: ET.Element, parent: EndToEndProtectionSet):
         short_name = self.getShortName(element)
@@ -2205,15 +2203,16 @@ class ARXMLParser(AbstractARXMLParser):
         self.readEndToEndProtectionVariablePrototypes(element, protection)
 
     def readEndToEndProtections(self, element: ET.Element, parent: EndToEndProtectionSet):
-        for child_element in element.findall("./xmlns:END-TO-END-PROTECTIONS/*", self.nsmap):
-            tag_name = self.getTagName(child_element.tag)
+        for child_element in self.findall(element, "END-TO-END-PROTECTIONS/*"):
+            tag_name = self.getTagName(child_element)
             if tag_name == "END-TO-END-PROTECTION":
                 self.readEndToEndProtection(child_element, parent)
+            else:
+                self.notImplemented("Unsupported EndToEndProtectionSet <%s>" % tag_name)
 
-    def readEndToEndProtectionSet(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readEndToEndProtectionSet %s" % short_name)
-        protection_set = parent.createEndToEndProtectionSet(short_name)
+    def readEndToEndProtectionSet(self, element: ET.Element, protection_set: EndToEndProtectionSet):
+        self.logger.debug("Read EndToEndProtectionSet <%s>" % protection_set.getShortName())
+        self.readIdentifiable(element, protection_set)
         self.readEndToEndProtections(element, protection_set)
 
     def readAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
@@ -2227,11 +2226,9 @@ class ARXMLParser(AbstractARXMLParser):
         self.readImplementationProps(element, props)
 
     def readImplementationDataTypeSymbolProps(self, element: ET.Element, data_type: ImplementationDataType):
-        child_element = element.find("./xmlns:SYMBOL-PROPS", self.nsmap)
+        child_element = self.find(element, "SYMBOL-PROPS")
         if child_element is not None:
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readSymbolProps %s" % short_name)
-            props = data_type.createSymbolProps(short_name)
+            props = data_type.createSymbolProps(self.getShortName(child_element))
             self.readSymbolProps(child_element, props)
 
     def readApplicationDataType(self, element: ET.Element, data_type: ApplicationDataType):
@@ -2255,14 +2252,14 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug("readApplicationArrayElement %s" % short_name)
             array_element = parent.createApplicationArrayElement(short_name)
             self.readApplicationCompositeElementDataPrototype(child_element, array_element)
+            array_element.setArraySizeHandling(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-HANDLING"))
             array_element.setArraySizeSemantics(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS"))
             array_element.setMaxNumberOfElements(self.getChildElementOptionalNumericalValue(child_element, "MAX-NUMBER-OF-ELEMENTS"))
 
-    def readApplicationArrayDataType(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readApplicationArrayDataType %s" % short_name)
-        data_type = parent.createApplicationArrayDataType(short_name)
+    def readApplicationArrayDataType(self, element: ET.Element, data_type: ApplicationArrayDataType):
+        self.logger.debug("Read ApplicationArrayDataType <%s>" % data_type)
         self.readApplicationCompositeDataType(element, data_type)
+        data_type.setDynamicArraySizeProfile(self.getChildElementOptionalLiteral(element, "DYNAMIC-ARRAY-SIZE-PROFILE"))
         self.readApplicationArrayElement(element, data_type)
 
     def getSwRecordLayoutV(self, element: ET.Element, key: str) -> SwRecordLayoutV:
@@ -2275,7 +2272,14 @@ class ARXMLParser(AbstractARXMLParser):
                     .setSwRecordLayoutVAxis(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-AXIS")) \
                     .setSwRecordLayoutVProp(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-PROP")) \
                     .setSwRecordLayoutVIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-INDEX"))
+            #print(layout_v.getShortLabel())
         return layout_v
+    
+    def readSwRecordLayoutGroupSwRecordLayoutGroupContentType(self, element: ET.Element, group: SwRecordLayoutGroup):
+        content = SwRecordLayoutGroupContent()
+        content.setSwRecordLayoutGroup(self.getSwRecordLayoutGroup(element, "SW-RECORD-LAYOUT-GROUP")) \
+               .setSwRecordLayoutV(self.getSwRecordLayoutV(element, "SW-RECORD-LAYOUT-V"))
+        group.setSwRecordLayoutGroupContentType(content)
 
     def getSwRecordLayoutGroup(self, element: ET.Element, key: str) -> SwRecordLayoutGroup:
         child_element = element.find("./xmlns:%s" % key, self.nsmap)
@@ -2283,35 +2287,23 @@ class ARXMLParser(AbstractARXMLParser):
         if child_element is not None:
             group = SwRecordLayoutGroup()
             group.setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
-                 .setCategory(self.getChildElementOptionalLiteral(child_element, "CATEGORY")) \
-                 .setSwRecordLayoutGroupAxis(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS")) \
+                 .setCategory(self.getChildElementOptionalLiteral(child_element, "CATEGORY")) 
+            self.readSwRecordLayoutGroupSwRecordLayoutGroupContentType(child_element, group)
+            group.setSwRecordLayoutGroupAxis(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS")) \
                  .setSwRecordLayoutGroupIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-INDEX")) \
                  .setSwRecordLayoutGroupFrom(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-FROM")) \
                  .setSwRecordLayoutGroupStep(self.getChildElementOptionalIntegerValue(child_element, "SW-RECORD-LAYOUT-GROUP-STEP")) \
-                 .setSwRecordLayoutGroupTo(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO")) \
-            
-            group_content = SwRecordLayoutGroupContent()
-            group_content.swRecordLayoutGroup = self.getSwRecordLayoutGroup(child_element, "SW-RECORD-LAYOUT-GROUP")
-            group_content.swRecordLayoutV = self.getSwRecordLayoutV(child_element, "SW-RECORD-LAYOUT-V")
-
-            if group_content.swRecordLayoutGroup is not None:
-                group.setSwRecordLayoutGroupContentType(group_content)
-            elif group_content.swRecordLayoutV is not None:
-                group.setSwRecordLayoutGroupContentType(group_content)
-
+                 .setSwRecordLayoutGroupTo(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO"))
+            #print(group.getShortLabel())
         return group
 
-    def readSwRecordLayout(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readSwRecordLayout %s" % short_name)
-        layout = parent.createSwRecordLayout(short_name)
+    def readSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
+        self.logger.debug("Read SwRecordLayout <%s>" % layout.getShortName())
         self.readIdentifiable(element, layout)
         layout.setSwRecordLayoutGroup(self.getSwRecordLayoutGroup(element, "SW-RECORD-LAYOUT-GROUP"))
 
-    def readSwAddrMethod(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("read SwAddrMethod %s" % short_name)
-        method = parent.createSwAddrMethod(short_name)
+    def readSwAddrMethod(self, element: ET.Element, method: SwAddrMethod):
+        self.logger.debug("Read SwAddrMethod <%s>" % method.getShortName())
         self.readIdentifiable(element, method)
         method.setMemoryAllocationKeywordPolicy(self.getChildElementOptionalLiteral(element, "MEMORY-ALLOCATION-KEYWORD-POLICY")) 
         for option in self.getChildElementLiteralValueList(element, "OPTIONS/OPTION"):
@@ -2319,10 +2311,9 @@ class ARXMLParser(AbstractARXMLParser):
         method.setSectionInitializationPolicy(self.getChildElementOptionalLiteral(element, "SECTION-INITIALIZATION-POLICY")) \
               .setSectionType(self.getChildElementOptionalLiteral(element, "SECTION-TYPE"))
 
-    def readTriggerInterface(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readTriggerInterface %s" % short_name)
-        trigger_if = parent.createTriggerInterface(short_name)
+    def readTriggerInterface(self, element: ET.Element, trigger_if: TriggerInterface):
+        self.logger.debug("Read TriggerInterface <%s>" % trigger_if.getShortName())
+        self.readIdentifiable(element, trigger_if)
 
     def readModeDeclarationGroupModeDeclaration(self, element: ET.Element, parent: ModeDeclarationGroup):
         for child_element in self.findall(element, "MODE-DECLARATIONS/MODE-DECLARATION"):
@@ -2331,10 +2322,8 @@ class ARXMLParser(AbstractARXMLParser):
             self.readARObjectAttributes(child_element, declaration)
             declaration.setValue(self.getChildElementOptionalNumericalValue(child_element, "VALUE"))
 
-    def readModeDeclarationGroup(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readModeDeclarationGroup %s" % short_name)
-        group = parent.createModeDeclarationGroup(short_name)
+    def readModeDeclarationGroup(self, element: ET.Element, group: ModeDeclarationGroup):
+        self.logger.debug("Read ModeDeclarationGroup <%s>" % group.getShortName())
         self.readIdentifiable(element, group)
         self.readModeDeclarationGroupModeDeclaration(element, group)
         group.setInitialModeRef(self.getChildElementOptionalRefType(element, "INITIAL-MODE-REF"))
@@ -2348,10 +2337,8 @@ class ARXMLParser(AbstractARXMLParser):
             self.readIdentifiable(child_element, mode_group)
             mode_group.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
 
-    def readModeSwitchInterface(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readModeSwitchInterface %s" % short_name)
-        mode_interface = parent.createModeSwitchInterface(short_name)
+    def readModeSwitchInterface(self, element: ET.Element, mode_interface: ModeSwitchInterface):
+        self.logger.debug("Read ModeSwitchInterface <%s>" % mode_interface.getShortName())
         self.readPortInterface(element, mode_interface)
         self.readModeSwitchInterfaceModeGroup(element, mode_interface)
 
@@ -2369,7 +2356,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "EOC-EXECUTABLE-ENTITY-REF":
                 self.readEOCExecutableEntityRef(child_element, constrain)
             else:
-                self._raiseError("Unsupported order element <%s>." % tag_name)
+                self.raiseError("Unsupported order element <%s>." % tag_name)
 
     def readExecutionOrderConstraint(self, element: ET.Element, extension: TimingExtension):
         short_name = self.getShortName(element)
@@ -2384,12 +2371,10 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "EXECUTION-ORDER-CONSTRAINT":
                 self.readExecutionOrderConstraint(child_element, extension)
             else:
-                self._raiseError("Unsupported timing requirement <%s>" % tag_name)
+                self.raiseError("Unsupported timing requirement <%s>" % tag_name)
 
-    def readSwcTiming(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readSwcTiming %s" % short_name)
-        timing = parent.createSwcTiming(short_name)
+    def readSwcTiming(self, element: ET.Element, timing: SwcTiming):
+        self.logger.debug("Read SwcTiming <%s>" % timing.getShortName())
         self.readIdentifiable(element, timing)
         self.readTimingExtension(element, timing)
 
@@ -2727,19 +2712,80 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported ConsumedServiceInstances <%s>" % tag_name)
 
+    def getInitialSdDelayConfig(self, element: ET.Element, key: str) -> InitialSdDelayConfig:
+        config = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            config = InitialSdDelayConfig()
+            config.setInitialDelayMaxValue(self.getChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MAX-VALUE")) \
+                  .setInitialDelayMinValue(self.getChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MIN-VALUE")) \
+                  .setInitialRepetitionsBaseDelay(self.getChildElementOptionalTimeValue(child_element, "INITIAL-REPETITIONS-BASE-DELAY")) \
+                  .setInitialRepetitionsMax(self.getChildElementOptionalPositiveInteger(child_element, "INITIAL-REPETITIONS-MAX"))
+        return config
+
+    def getSdServerConfig(self, element: ET.Element, key: str) -> SdServerConfig:
+        config = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            config = SdServerConfig()
+            config.setInitialOfferBehavior(self.getInitialSdDelayConfig(child_element, "INITIAL-OFFER-BEHAVIOR")) \
+                  .setOfferCyclicDelay(self.getChildElementOptionalTimeValue(child_element, "OFFER-CYCLIC-DELAY")) \
+                  .setRequestResponseDelay(self.getRequestResponseDelay(child_element, "REQUEST-RESPONSE-DELAY")) \
+                  .setServerServiceMajorVersion(self.getChildElementOptionalPositiveInteger(child_element, "SERVER-SERVICE-MAJOR-VERSION")) \
+                  .setServerServiceMinorVersion(self.getChildElementOptionalPositiveInteger(child_element, "SERVER-SERVICE-MINOR-VERSION")) \
+                  .setTtl(self.getChildElementOptionalPositiveInteger(child_element, "TTL"))
+        return config
+
+    def readEventHandler(self, element: ET.Element, handler: EventHandler):
+        self.readIdentifiable(element, handler)
+        handler.setApplicationEndpointRef(self.getChildElementOptionalRefType(element, "APPLICATION-ENDPOINT-REF"))
+        for ref in self.getChildElementRefTypeList(element, "CONSUMED-EVENT-GROUP-REFS/CONSUMED-EVENT-GROUP-REF"):
+            handler.addConsumedEventGroupRef(ref)
+        handler.setMulticastThreshold(self.getChildElementOptionalPositiveInteger(element, "MULTICAST-THRESHOLD"))
+        for ref in self.getChildElementRefTypeList(element, "ROUTING-GROUP-REFS/ROUTING-GROUP-REF"):
+            handler.addRoutingGroupRef(ref)
+        handler.setSdServerConfig(self.getSdServerConfig(element, "SD-SERVER-CONFIG")) \
+
+    def readProvidedServiceInstanceEventHandlers(self, element: ET.Element, instance: ProvidedServiceInstance):
+        for child_element in self.findall(element, "EVENT-HANDLERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "EVENT-HANDLER":
+                handler = instance.createEventHandler(self.getShortName(child_element))
+                self.readEventHandler(child_element, handler)
+            else:
+                self.notImplemented("Unsupported Event Handler <%s>" % tag_name)
+
+    def readProvidedServiceInstance(self, element: ET.Element, instance: ProvidedServiceInstance):
+        self.readIdentifiable(element, instance)
+        self.readProvidedServiceInstanceEventHandlers(element, instance)
+        instance.setInstanceIdentifier(self.getChildElementOptionalPositiveInteger(element, "INSTANCE-IDENTIFIER")) \
+                .setSdServerConfig(self.getSdServerConfig(element, "SD-SERVER-CONFIG")) \
+                .setServiceIdentifier(self.getChildElementOptionalPositiveInteger(element, "SERVICE-IDENTIFIER"))
+
+    def readSocketAddressApplicationEndpointProvidedServiceInstance(self, element: ET.Element, end_point: ApplicationEndpoint):
+        for child_element in self.findall(element, "PROVIDED-SERVICE-INSTANCES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "PROVIDED-SERVICE-INSTANCE":
+                instance = end_point.createProvidedServiceInstance(self.getShortName(child_element))
+                self.readProvidedServiceInstance(child_element, instance)
+            else:
+                self.notImplemented("Unsupported ConsumedServiceInstances <%s>" % tag_name)
+
     def readSocketAddressApplicationEndpoint(self, element: ET.Element, address: SocketAddress):
         child_element = self.find(element, "APPLICATION-ENDPOINT")
         if child_element is not None:
             end_point = address.createApplicationEndpoint(self.getShortName(child_element))
             self.readSocketAddressApplicationEndpointConsumedServiceInstances(child_element, end_point)
             end_point.setNetworkEndpointRef(self.getChildElementOptionalRefType(child_element, "NETWORK-ENDPOINT-REF")) \
-                     .setPriority(self.getChildElementOptionalPositiveInteger(child_element, "PRIORITY")) \
-                     .setTpConfiguration(self.getTransportProtocolConfiguration(child_element, "TP-CONFIGURATION"))
+                     .setPriority(self.getChildElementOptionalPositiveInteger(child_element, "PRIORITY"))
+            self.readSocketAddressApplicationEndpointProvidedServiceInstance(child_element, end_point)
+            end_point.setTpConfiguration(self.getTransportProtocolConfiguration(child_element, "TP-CONFIGURATION"))
             
     def readSocketAddressMulticastConnectorRefs(self, element: ET.Element, address: SocketAddress):
         for ref in self.getChildElementRefTypeList(element, "MULTICAST-CONNECTOR-REFS/MULTICAST-CONNECTOR-REF"):
             address.addMulticastConnectorRef(ref)
 
+
     def readSocketAddress(self, element: ET.Element, address: SocketAddress):
         self.readIdentifiable(element, address)
         self.readSocketAddressApplicationEndpoint(element, address)
@@ -2747,7 +2793,6 @@ class ARXMLParser(AbstractARXMLParser):
         address.setConnectorRef(self.getChildElementOptionalRefType(element, "CONNECTOR-REF")) \
                .setPortAddress(self.getChildElementOptionalPositiveInteger(element, "PORT-ADDRESS"))
 
-
     def readSoAdConfigSocketAddresses(self, element: ET.Element, config: SoAdConfig):   
         for child_element in self.findall(element, "SOCKET-ADDRESSS/*"):
             tag_name = self.getTagName(child_element)
@@ -2816,98 +2861,226 @@ class ARXMLParser(AbstractARXMLParser):
                .setCanFdBaudrate(self.getChildElementOptionalNumericalValue(element, "CAN-FD-BAUDRATE")) \
                .setSpeed(self.getChildElementOptionalNumericalValue(element, "SPEED"))
 
-    def readLinCluster(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readLinCluster %s" % short_name)
-        cluster = parent.createLinCluster(short_name)
+    def readLinCluster(self, element: ET.Element, cluster: LinCluster):
+        self.logger.debug("Read LinCluster <%s>" % cluster.getShortName())
         self.readIdentifiable(element, cluster)
         child_element = self.find(element, "LIN-CLUSTER-VARIANTS/LIN-CLUSTER-CONDITIONAL")
         if child_element is not None:
             self.readCommunicationCluster(child_element, cluster)
 
-    def readCanCluster(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readCanCluster %s" % short_name)
-        cluster = parent.createCanCluster(short_name)
+    def readCanCluster(self, element: ET.Element, cluster: CanCluster):
+        self.logger.debug("Read CanCluster <%s>" % cluster.getShortName())
         self.readIdentifiable(element, cluster)
         child_element = self.find(element, "CAN-CLUSTER-VARIANTS/CAN-CLUSTER-CONDITIONAL")
         if child_element is not None:
             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)
+    def readMacMulticastGroup(self, element: ET.Element, group: MacMulticastGroup):
+        self.readIdentifiable(element, group)
+        group.setMacMulticastAddress(self.getChildElementOptionalLiteral(element, "MAC-MULTICAST-ADDRESS",))
+
+    def readEthernetClusterMacMulticastGroups(self, element: ET.Element, cluster: EthernetCluster):
+        for child_element in self.findall(element, "MAC-MULTICAST-GROUPS/*"):
+            tag_name = self.getTagName(child_element)
+            if (tag_name == "MAC-MULTICAST-GROUP"):
+                group = cluster.createMacMulticastGroup(self.getShortName(child_element))
+                self.readMacMulticastGroup(child_element, group)
+            else:
+                self.notImplemented("Unsupported assigned data type <%s>" % tag_name)
+
+    def readEthernetCluster(self, element: ET.Element, cluster: EthernetCluster):
+        self.logger.debug("Read EthernetCluster <%s>" % cluster.getShortName())
         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)
+            self.readEthernetClusterMacMulticastGroups(child_element, cluster)
 
     def readDiagnosticConnectionFunctionalRequestRefs(self, element: ET.Element, connection: DiagnosticConnection):
         for ref in self.getChildElementRefTypeList(element, "FUNCTIONAL-REQUEST-REFS/FUNCTIONAL-REQUEST-REF"):
             connection.addFunctionalRequestRef(ref)
 
     def readDiagnosticConnection(self, element: ET.Element, connection: DiagnosticConnection):
-        self.logger.debug("Read DiagnosticConnection %s" % connection.getShortName())
+        self.logger.debug("Read DiagnosticConnection <%s>" % connection.getShortName())
         self.readIdentifiable(element, connection)
         self.readDiagnosticConnectionFunctionalRequestRefs(element, connection)
         connection.setPhysicalRequestRef(self.getChildElementOptionalRefType(element, "PHYSICAL-REQUEST-REF")) \
                   .setResponseOnEventRef(self.getChildElementOptionalRefType(element, "RESPONSE-REF"))
-
-    def readDiagnosticServiceTable(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read DiagnosticServiceTable %s" % short_name)
-        table = parent.createDiagnosticServiceTable(short_name)
+        
+    def readDiagnosticServiceTableDiagnosticConnectionRefs(self, element: ET.Element, table: DiagnosticServiceTable):
+        for ref in self.getChildElementRefTypeList(element, "DIAGNOSTIC-CONNECTIONS/DIAGNOSTIC-CONNECTION-REF-CONDITIONAL/DIAGNOSTIC-CONNECTION-REF"):
+            table.addDiagnosticConnectionRef(ref)
+        
+    def readDiagnosticServiceTable(self, element: ET.Element, table: DiagnosticServiceTable):
+        self.logger.debug("Read DiagnosticServiceTable <%s>" % table.getShortName())
         self.readIdentifiable(element, table)
+        self.readDiagnosticServiceTableDiagnosticConnectionRefs(element, table)
+        table.setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF"))
 
-    def readMultiplexedIPdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read MultiplexedIPdu %s" % short_name)
-        i_pdu = parent.createMultiplexedIPdu(short_name)
-        self.readIdentifiable(element, i_pdu)
+    def readSegmentPosition(self, element: ET.Element, position: SegmentPosition):
+        position.setSegmentByteOrder(self.getChildElementOptionalLiteral(element, "SEGMENT-BYTE-ORDER")) \
+                .setSegmentLength(self.getChildElementOptionalIntegerValue(element, "SEGMENT-LENGTH")) \
+                .setSegmentPosition(self.getChildElementOptionalIntegerValue(element, "SEGMENT-POSITION"))
 
-    def readUserDefinedIPdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read UserDefinedIPdu %s" % short_name)
-        i_pdu = parent.createUserDefinedIPdu(short_name)
-        self.readIdentifiable(element, i_pdu)
+    def readMultiplexedPartSegmentPositions(self, element: ET.Element, part: MultiplexedPart):
+        for child_element in self.findall(element, "SEGMENT-POSITIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SEGMENT-POSITION":
+                position = SegmentPosition()
+                self.readSegmentPosition(child_element, position)
+                part.addSegmentPosition(position)
+            else:
+                self.notImplemented("Unsupported DynamicPart <%s>" % tag_name)
 
-    def readUserDefinedPdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read UserDefinedPdu %s" % short_name)
-        pdu = parent.createUserDefinedPdu(short_name)
-        self.readIdentifiable(element, pdu)
+    def readMultiplexedPart(self, element: ET.Element, part: MultiplexedPart):
+        self.readMultiplexedPartSegmentPositions(element, part)
 
-    def readGeneralPurposePdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read GeneralPurposePdu %s" % short_name)
-        pdu = parent.createGeneralPurposePdu(short_name)
-        self.readIdentifiable(element, pdu)
+    def readDynamicPartAlternative(self, element: ET.Element, alternative: DynamicPartAlternative):
+        alternative.setIPduRef(self.getChildElementOptionalRefType(element, "I-PDU-REF")) \
+                   .setInitialDynamicPart(self.getChildElementOptionalBooleanValue(element, "INITIAL-DYNAMIC-PART")) \
+                   .setSelectorFieldCode(self.getChildElementOptionalIntegerValue(element, "SELECTOR-FIELD-CODE"))
 
-    def readGeneralPurposeIPdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read GeneralPurposeIPdu %s" % short_name)
-        i_pdu = parent.createGeneralPurposeIPdu(short_name)
-        self.readIdentifiable(element, i_pdu)
+    def readDynamicPartDynamicPartAlternatives(self, element: ET.Element, part: DynamicPart):
+        for child_element in self.findall(element, "DYNAMIC-PART-ALTERNATIVES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DYNAMIC-PART-ALTERNATIVE":
+                alternative = DynamicPartAlternative()
+                self.readDynamicPartAlternative(child_element, alternative)
+                part.addDynamicPartAlternative(alternative)
+            else:
+                self.notImplemented("Unsupported DynamicPartAlternative <%s>" % tag_name)
 
-    def readSecureCommunicationPropsSet(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read SecureCommunicationPropsSet %s" % short_name)
-        prop_set = parent.createSecureCommunicationPropsSet(short_name)
-        self.readIdentifiable(element, prop_set)
+    def readDynamicPart(self, element: ET.Element, part: DynamicPart):
+        self.readMultiplexedPart(element, part)
+        self.readDynamicPartDynamicPartAlternatives(element, part)
 
-    def readSoAdRoutingGroup(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read SoAdRoutingGroup %s" % short_name)
-        group = parent.createSoAdRoutingGroup(short_name)
-        self.readIdentifiable(element, group)
+    def readMultiplexedIPduDynamicParts(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        for child_element in self.findall(element, "DYNAMIC-PARTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DYNAMIC-PART":
+                part = DynamicPart()
+                self.readDynamicPart(child_element, part)
+                ipdu.setDynamicPart(part)
+            else:
+                self.notImplemented("Unsupported DynamicPart <%s>" % tag_name)
 
-    def readDoIpTpConfig(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read DoIpTpConfig %s" % short_name)
-        group = parent.createDoIpTpConfig(short_name)
+    def readStaticPart(self, element: ET.Element, part: StaticPart):
+        self.readMultiplexedPart(element, part)
+        part.setIPduRef(self.getChildElementOptionalRefType(element, "I-PDU-REF"))
+
+    def readMultiplexedIPduStaticParts(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        for child_element in self.findall(element, "STATIC-PARTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "STATIC-PART":
+                part = StaticPart()
+                self.readStaticPart(child_element, part)
+                ipdu.setStaticPart(part)
+            else:
+                self.notImplemented("Unsupported StaticPart <%s>" % tag_name)
+
+    def readMultiplexedIPdu(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        self.logger.debug("Read MultiplexedIPdu <%s>" % ipdu.getShortName())
+        self.readIPdu(element, ipdu)
+        self.readMultiplexedIPduDynamicParts(element, ipdu)
+        ipdu.setSelectorFieldByteOrder(self.getChildElementOptionalLiteral(element, "SELECTOR-FIELD-BYTE-ORDER")) \
+            .setSelectorFieldLength(self.getChildElementOptionalIntegerValue(element, "SELECTOR-FIELD-LENGTH")) \
+            .setSelectorFieldStartPosition(self.getChildElementOptionalIntegerValue(element, "SELECTOR-FIELD-START-POSITION"))
+        self.readMultiplexedIPduStaticParts(element, ipdu)
+        ipdu.setTriggerMode(self.getChildElementOptionalLiteral(element, "TRIGGER-MODE")) \
+            .setUnusedBitPattern(self.getChildElementOptionalIntegerValue(element, "UNUSED-BIT-PATTERN"))
+
+    def readUserDefinedIPdu(self, element: ET.Element, ipdu: UserDefinedIPdu):
+        self.logger.debug("Read UserDefinedIPdu <%s>" % ipdu.getShortName())
+        self.readIPdu(element, ipdu)
+        ipdu.setCddType(self.getChildElementOptionalLiteral(element, "CDD-TYPE"))
+
+    def readUserDefinedPdu(self, element: ET.Element, pdu: UserDefinedPdu):
+        self.logger.debug("Read UserDefinedPdu <%s>" % pdu.getShortName())
+        self.readPdu(element, pdu)
+        pdu.setCddType(self.getChildElementOptionalLiteral(element, "CDD-TYPE"))
+
+    def readGeneralPurposePdu(self, element: ET.Element, pdu: GeneralPurposePdu):
+        self.logger.debug("Read GeneralPurposePdu <%s>" % pdu.getShortName())
+        self.readPdu(element, pdu)
+
+    def readGeneralPurposeIPdu(self, element: ET.Element, i_pdu: GeneralPurposeIPdu):
+        self.logger.debug("Read GeneralPurposeIPdu <%s>" % i_pdu.getShortName())
+        self.readIPdu(element, i_pdu)
+
+    def readSecureCommunicationAuthenticationProps(self, element: ET.Element, props: SecureCommunicationAuthenticationProps):
+        self.readIdentifiable(element, props)
+        props.setAuthAlgorithm(self.getChildElementOptionalLiteral(element, "AUTH-ALGORITHM")) \
+             .setAuthInfoTxLength(self.getChildElementOptionalPositiveInteger(element, "AUTH-INFO-TX-LENGTH"))
+
+    def readSecureCommunicationPropsSetAuthenticationProps(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
+        for child_element in self.findall(element, "AUTHENTICATION-PROPSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SECURE-COMMUNICATION-AUTHENTICATION-PROPS":
+                props = props_set.createSecureCommunicationAuthenticationProps(self.getShortName(child_element))
+                self.readSecureCommunicationAuthenticationProps(child_element, props)
+            else:
+                self.notImplemented("Unsupported AuthenticationProps <%s>" % tag_name)
+
+    def readSecureCommunicationFreshnessProps(self, element: ET.Element, props: SecureCommunicationFreshnessProps):
+        self.readIdentifiable(element, props)
+        props.setFreshnessValueLength(self.getChildElementOptionalLiteral(element, "FRESHNESS-VALUE-LENGTH")) \
+             .setFreshnessValueTxLength(self.getChildElementOptionalPositiveInteger(element, "FRESHNESS-VALUE-TX-LENGTH"))
+
+    def readSecureCommunicationPropsSetFreshnessProps(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
+        for child_element in self.findall(element, "FRESHNESS-PROPSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SECURE-COMMUNICATION-FRESHNESS-PROPS":
+                props = props_set.createSecureCommunicationFreshnessProps(self.getShortName(child_element))
+                self.readSecureCommunicationFreshnessProps(child_element, props)
+            else:
+                self.notImplemented("Unsupported FreshnessProps <%s>" % tag_name)
+
+    def readSecureCommunicationPropsSet(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
+        self.logger.debug("Read SecureCommunicationPropsSet <%s>" % props_set.getShortName())
+        self.readIdentifiable(element, props_set)
+        self.readSecureCommunicationPropsSetAuthenticationProps(element, props_set)
+        self.readSecureCommunicationPropsSetFreshnessProps(element, props_set)
+    
+    def readSoAdRoutingGroup(self, element: ET.Element, group: SoAdRoutingGroup):
+        self.logger.debug("Read SoAdRoutingGroup <%s>" % group.getShortName())
         self.readIdentifiable(element, group)
+        group.setEventGroupControlType(self.getChildElementOptionalLiteral(element, "EVENT-GROUP-CONTROL-TYPE"))
+
+    def readDoIpLogicAddress(self, element: ET.Element, address: DoIpLogicAddress):
+        self.readIdentifiable(element, address)
+        address.setAddress(self.getChildElementOptionalIntegerValue(element, "ADDRESS"))
+
+    def readDoIpTpConfigDoIpLogicAddresses(self, element: ET.Element, config: DoIpTpConfig):
+        for child_element in self.findall(element, "DO-IP-LOGIC-ADDRESSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DO-IP-LOGIC-ADDRESS":
+                address = config.createDoIpLogicAddress(self.getShortName(child_element))
+                self.readDoIpLogicAddress(child_element, address)
+            else:
+                self.notImplemented("Unsupported DoIpLogicAddress <%s>" % tag_name)
+
+    def readDoIpTpConnection(self, element: ET.Element, connection: DoIpTpConnection):
+        self.readTpConnection(element, connection)
+        connection.setDoIpSourceAddressRef(self.getChildElementOptionalRefType(element, "DO-IP-SOURCE-ADDRESS-REF")) \
+                  .setDoIpTargetAddressRef(self.getChildElementOptionalRefType(element, "DO-IP-TARGET-ADDRESS-REF")) \
+                  .setTpSduRef(self.getChildElementOptionalRefType(element, "TP-SDU-REF"))
+
+    def readDoIpTpConfigTpConnections(self, element: ET.Element, config: DoIpTpConfig):
+        for child_element in self.findall(element, "TP-CONNECTIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DO-IP-TP-CONNECTION":
+                connection = DoIpTpConnection()
+                self.readDoIpTpConnection(child_element, connection)
+                config.addTpConnection(connection)
+            else:
+                self.notImplemented("Unsupported TpConnection <%s>" % tag_name)
+
+    def readDoIpTpConfig(self, element: ET.Element, config: DoIpTpConfig):
+        self.logger.debug("Read DoIpTpConfig <%s>" % config.getShortName())
+        self.readTpConfig(element, config)
+        self.readDoIpTpConfigDoIpLogicAddresses(element, config)
+        self.readDoIpTpConfigTpConnections(element, config)
 
     def readPduToFrameMappings(self, element: ET.Element, parent: Frame):
         for child_element in self.findall(element, "PDU-TO-FRAME-MAPPINGS/PDU-TO-FRAME-MAPPING"):
@@ -2924,99 +3097,129 @@ class ARXMLParser(AbstractARXMLParser):
         frame.frameLength = self.getChildElementOptionalNumericalValue(element, "FRAME-LENGTH")
         self.readPduToFrameMappings(element, frame)
 
-    def readLinUnconditionalFrame(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("LinUnconditionalFrame %s" % short_name)
-        frame = parent.createLinUnconditionalFrame(short_name)
+    def readLinUnconditionalFrame(self, element: ET.Element, frame: LinUnconditionalFrame):
+        self.logger.debug("Read LinUnconditionalFrame <%s>" % frame.getShortName())
         self.readFrame(element, frame)
 
-    def readNmPdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readNmPdu %s" % short_name)
-        pdu = parent.createNmPdu(short_name)
+    def readPdu(self, element: ET.Element, pdu: Pdu):
         self.readIdentifiable(element, pdu)
-        self.readIPdu(element, pdu)
+        pdu.setHasDynamicLength(self.getChildElementOptionalBooleanValue(element, "HAS-DYNAMIC-LENGTH")) \
+           .setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH"))
+        
+    def readISignalToIPduMapping(self, element: ET.Element, mapping: ISignalToIPduMapping):
+        self.readIdentifiable(element, mapping)
+        mapping.setISignalRef(self.getChildElementOptionalRefType(element, "I-SIGNAL-REF")) \
+               .setPackingByteOrder(self.getChildElementOptionalLiteral(element, "PACKING-BYTE-ORDER")) \
+               .setStartPosition(self.getChildElementOptionalIntegerValue(element, "START-POSITION")) \
+               .setTransferProperty(self.getChildElementOptionalLiteral(element, "TRANSFER-PROPERTY"))
+        
+    def readNmPduISignalToIPduMappings(self, element: ET.Element, pdu: NmPdu):
+        for child_element in self.findall(element, "I-SIGNAL-TO-I-PDU-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "I-SIGNAL-TO-I-PDU-MAPPING":
+                mapping = pdu.createISignalToIPduMapping(self.getShortName(child_element))
+                self.readISignalToIPduMapping(child_element, mapping)
+            else:
+                self.notImplemented("Unsupported ISignalToIPduMapping <%s>" % tag_name)
 
-    def readNPdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readNPdu %s" % short_name)
-        pdu = parent.createNPdu(short_name)
-        self.readIdentifiable(element, pdu)
-        self.readIPdu(element, pdu)
+    def readNmPdu(self, element: ET.Element, pdu: NmPdu):
+        self.logger.debug("Read NmPdu <%s>" % pdu.getShortName())
+        self.readPdu(element, pdu)
+        self.readNmPduISignalToIPduMappings(element, pdu)
+        pdu.setUnusedBitPattern(self.getChildElementOptionalIntegerValue(element, "UNUSED-BIT-PATTERN"))
 
     def readIPdu(self, element: ET.Element, pdu: IPdu):
-        pdu.setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH"))
-        
-    def readDcmIPdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readDcmIPdu %s" % short_name)
-        pdu = parent.createDcmIPdu(short_name)
-        self.readIdentifiable(element, pdu)
-        self.readIPdu(element, pdu)
-        pdu.setDiagPduType(self.getChildElementOptionalLiteral(element, "DIAG-PDU-TYPE"))
+        self.readPdu(element, pdu)
 
-    def readSecuredIPdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("readSecuredIPdu %s" % short_name)
-        pdu = parent.createSecuredIPdu(short_name)
-        self.readIdentifiable(element, pdu)
+    def readNPdu(self, element: ET.Element, pdu: NPdu):
+        self.logger.debug("Read NPdu <%s>" % pdu.getShortName())
         self.readIPdu(element, pdu)
 
+    def readDcmIPdu(self, element: ET.Element, i_pdu: DcmIPdu):
+        self.logger.debug("Read DcmIPdu <%s>" % i_pdu.getShortName())
+        self.readIPdu(element, i_pdu)
+        i_pdu.setDiagPduType(self.getChildElementOptionalLiteral(element, "DIAG-PDU-TYPE"))
+
+    def getSecureCommunicationProps(self, element: ET.Element, key: str) -> SecureCommunicationProps:
+        props = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            props = SecureCommunicationProps()
+            props.setAuthDataFreshnessLength(self.getChildElementOptionalPositiveInteger(child_element, "AUTH-DATA-FRESHNESS-LENGTH")) \
+                 .setAuthDataFreshnessStartPosition(self.getChildElementOptionalPositiveInteger(child_element, "AUTH-DATA-FRESHNESS-START-POSITION")) \
+                 .setAuthInfoTxLength(self.getChildElementOptionalPositiveInteger(child_element, "AUTH-INFO-TX-LENGTH")) \
+                 .setAuthenticationBuildAttempts(self.getChildElementOptionalPositiveInteger(child_element, "AUTHENTICATION-BUILD-ATTEMPTS")) \
+                 .setAuthenticationRetries(self.getChildElementOptionalPositiveInteger(child_element, "AUTHENTICATION-RETRIES")) \
+                 .setDataId(self.getChildElementOptionalPositiveInteger(child_element, "DATA-ID")) \
+                 .setFreshnessValueId(self.getChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-ID")) \
+                 .setFreshnessValueLength(self.getChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-LENGTH")) \
+                 .setFreshnessValueTxLength(self.getChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-TX-LENGTH"))
+        return props
+
+    def readSecuredIPdu(self, element: ET.Element, i_pdu: SecuredIPdu):
+        self.logger.debug("Read SecuredIPdu <%s>" % i_pdu.getShortName())
+        self.readIPdu(element, i_pdu)
+        i_pdu.setAuthenticationPropsRef(self.getChildElementOptionalRefType(element, "AUTHENTICATION-PROPS-REF")) \
+             .setFreshnessPropsRef(self.getChildElementOptionalRefType(element, "FRESHNESS-PROPS-REF")) \
+             .setPayloadRef(self.getChildElementOptionalRefType(element, "PAYLOAD-REF")) \
+             .setSecureCommunicationProps(self.getSecureCommunicationProps(element, "SECURE-COMMUNICATION-PROPS")) \
+             .setUseAsCryptographicIPdu(self.getChildElementOptionalBooleanValue(element, "USE-AS-CRYPTOGRAPHIC-I-PDU"))
+
     def readNmNode(self, element: ET.Element, nm_node: NmNode):
         self.readIdentifiable(element, nm_node)
 
         nm_node.setControllerRef(self.getChildElementOptionalRefType(element, "CONTROLLER-REF")) \
-            .setNmIfEcuRef(self.getChildElementOptionalRefType(element, "NM-IF-ECU-REF")) \
-            .setNmNodeId(self.getChildElementOptionalNumericalValue(element, "NM-NODE-ID"))
+               .setNmIfEcuRef(self.getChildElementOptionalRefType(element, "NM-IF-ECU-REF")) \
+               .setNmPassiveModeEnabled(self.getChildElementOptionalBooleanValue(element, "NM-PASSIVE-MODE-ENABLED")) \
+               .setNmNodeId(self.getChildElementOptionalNumericalValue(element, "NM-NODE-ID"))
         for ref in self.getChildElementRefTypeList(element, "RX-NM-PDU-REFS/RX-NM-PDU-REF"):
             nm_node.addRxNmPduRef(ref)
         for ref in self.getChildElementRefTypeList(element, "TX-NM-PDU-REFS/TX-NM-PDU-REF"):
             nm_node.addTxNmPduRefs(ref)
+        
 
     def readCanNmNode(self, element: ET.Element, nm_node: CanNmNode):
-        self.logger.debug("Read CanNmNode %s" % nm_node.getShortName())
-        
+        self.logger.debug("Read CanNmNode <%s>" % nm_node.getShortName())
         self.readNmNode(element, nm_node)
-
-        nm_node.setNmMsgCycleOffset(self.getChildElementOptionalFloatValue(element, "NM-MSG-CYCLE-OFFSET")) \
+        nm_node.setNmCarWakeUpRxEnabled(self.getChildElementOptionalBooleanValue(element, "NM-CAR-WAKE-UP-RX-ENABLED")) \
+               .setNmMsgCycleOffset(self.getChildElementOptionalFloatValue(element, "NM-MSG-CYCLE-OFFSET")) \
                .setNmMsgReducedTime(self.getChildElementOptionalFloatValue(element, "NM-MSG-REDUCED-TIME")) \
                .setNmRangeConfig(self.getChildElementRxIdentifierRange(element, "NM-RANGE-CONFIG"))
         
     def readUdpNmNode(self, element: ET.Element, nm_node: UdpNmNode):
-        self.logger.debug("Read UdpNmNode %s" % nm_node.getShortName())
-        
+        self.logger.debug("Read UdpNmNode <%s>" % nm_node.getShortName())
         self.readNmNode(element, nm_node)
+        nm_node.setNmMsgCycleOffset(self.getChildElementOptionalTimeValue(element, "NM-MSG-CYCLE-OFFSET"))
 
-    def readNmClusterNmNodes(self, element: ET.Element, parent: NmCluster):
-        self.logger.debug("readNmConfigNmNodes %s" % parent.getShortName())
+    def readNmClusterNmNodes(self, element: ET.Element, cluster: NmCluster):
+        self.logger.debug("readNmConfigNmNodes %s" % cluster.getShortName())
         for child_element in self.findall(element, "NM-NODES/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "CAN-NM-NODE":
-                nm_node = parent.createCanNmNode(self.getShortName(child_element))
+                nm_node = cluster.createCanNmNode(self.getShortName(child_element))
                 self.readCanNmNode(child_element, nm_node)
             elif tag_name == "UDP-NM-NODE":
-                nm_node = parent.readUdpNmNode(self.getShortName(child_element))
+                nm_node = cluster.readUdpNmNode(self.getShortName(child_element))
                 self.readUdpNmNode(child_element, nm_node)
             else:
-                self._raiseError("Unsupported Nm Node <%s>" % tag_name)
+                self.notImplemented("Unsupported Nm Node <%s>" % tag_name)
 
     def getCanNmClusterCoupling(self, element: ET.Element) -> CanNmClusterCoupling:
         coupling  = CanNmClusterCoupling()
-        
         for ref in self.getChildElementRefTypeList(element, "COUPLED-CLUSTER-REFS/COUPLED-CLUSTER-REF"):
             coupling.addCoupledClusterRef(ref)
-
         coupling.setNmBusloadReductionEnabled(self.getChildElementOptionalBooleanValue(element, "NM-BUSLOAD-REDUCTION-ENABLED")) \
                 .setNmImmediateRestartEnabled(self.getChildElementOptionalBooleanValue(element, "NM-IMMEDIATE-RESTART-ENABLED"))
-    
         return coupling
     
     def getUdpNmClusterCoupling(self, element: ET.Element) -> UdpNmClusterCoupling:
         coupling = UdpNmClusterCoupling()
+        for ref in self.getChildElementRefTypeList(element, "COUPLED-CLUSTER-REFS/COUPLED-CLUSTER-REF"):
+            coupling.addCoupledClusterRef(ref)
+        coupling.setNmImmediateRestartEnabled(self.getChildElementOptionalBooleanValue(element, "NM-IMMEDIATE-RESTART-ENABLED"))
         return coupling
 
     def readNmConfigNmClusterCouplings(self, element: ET.Element, nm_config: NmConfig):
-        self.logger.debug("readNmClusterNmClusterCouplings %s" % nm_config.getShortName())
         for child_element in self.findall(element, "NM-CLUSTER-COUPLINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "CAN-NM-CLUSTER-COUPLING":
@@ -3027,6 +3230,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self.notImplemented("Unsupported Nm Node <%s>" % tag_name)
 
     def readNmCluster(self, element: ET.Element, cluster: NmCluster):
+        self.logger.debug("read NmCluster %s" % cluster.getShortName())
         self.readIdentifiable(element, cluster)
         cluster.setCommunicationClusterRef(self.getChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF")) \
                .setNmChannelId(self.getChildElementOptionalNumericalValue(element, "NM-CHANNEL-ID")) \
@@ -3034,12 +3238,9 @@ class ARXMLParser(AbstractARXMLParser):
         self.readNmClusterNmNodes(element, cluster)
         cluster.setNmSynchronizingNetwork(self.getChildElementOptionalBooleanValue(element, "NM-SYNCHRONIZING-NETWORK"))
 
-    def readCanNmCluster(self, element: ET.Element, parent: NmConfig):
-        short_name = self.getShortName(element)
-        self.logger.debug("readCanNmCluster %s" % short_name)
-        cluster = parent.createCanNmCluster(short_name)         # type: CanNmCluster
+    def readCanNmCluster(self, element: ET.Element, cluster: CanNmCluster):
+        self.logger.debug("Read CanNmCluster <%s>" % cluster.getShortName())
         self.readNmCluster(element, cluster)
-
         cluster.setNmBusloadReductionActive(self.getChildElementOptionalBooleanValue(element, "NM-BUSLOAD-REDUCTION-ACTIVE")) \
                .setNmCarWakeUpRxEnabled(self.getChildElementOptionalBooleanValue(element, "NM-CAR-WAKE-UP-RX-ENABLED")) \
                .setNmCbvPosition(self.getChildElementOptionalNumericalValue(element, "NM-CBV-POSITION")) \
@@ -3055,53 +3256,408 @@ class ARXMLParser(AbstractARXMLParser):
                .setNmUserDataLength(self. getChildElementOptionalNumericalValue(element, "NM-USER-DATA-LENGTH")) \
                .setNmWaitBusSleepTime(self.getChildElementOptionalFloatValue(element, "NM-WAIT-BUS-SLEEP-TIME"))
         
-    def readUdpNmCluster(self, element: ET.Element, parent: NmConfig):
-        short_name = self.getShortName(element)
-        self.logger.debug("readCanNmCluster %s" % short_name)
-        cluster = parent.createUdpNmCluster(short_name)         # type: CanNmCluster
+    def readUdpNmCluster(self, element: ET.Element, cluster: UdpNmCluster):
+        self.logger.debug("Read UdpNmCluster %s" % cluster.getShortName())
         self.readNmCluster(element, cluster)
+        cluster.setNmCbvPosition(self.getChildElementOptionalIntegerValue(element, "NM-CBV-POSITION")) \
+               .setNmChannelActive(self.getChildElementOptionalBooleanValue(element, "NM-CHANNEL-ACTIVE")) \
+               .setNmImmediateNmCycleTime(self.getChildElementOptionalTimeValue(element, "NM-IMMEDIATE-NM-CYCLE-TIME")) \
+               .setNmImmediateNmTransmissions(self.getChildElementOptionalPositiveInteger(element, "NM-IMMEDIATE-NM-TRANSMISSIONS")) \
+               .setNmMessageTimeoutTime(self.getChildElementOptionalTimeValue(element, "NM-MESSAGE-TIMEOUT-TIME")) \
+               .setNmMsgCycleTime(self.getChildElementOptionalTimeValue(element, "NM-MSG-CYCLE-TIME")) \
+               .setNmNetworkTimeout(self.getChildElementOptionalTimeValue(element, "NM-NETWORK-TIMEOUT")) \
+               .setNmNidPosition(self.getChildElementOptionalIntegerValue(element, "NM-NID-POSITION")) \
+               .setNmRemoteSleepIndicationTime(self.getChildElementOptionalTimeValue(element, "NM-REMOTE-SLEEP-INDICATION-TIME")) \
+               .setNmRepeatMessageTime(self.getChildElementOptionalTimeValue(element, "NM-REPEAT-MESSAGE-TIME")) \
+               .setNmWaitBusSleepTime(self.getChildElementOptionalTimeValue(element, "NM-WAIT-BUS-SLEEP-TIME")) \
+               .setVlanRef(self.getChildElementOptionalRefType(element, "VLAN-REF"))
         
-    def readNmConfigNmClusters(self, element: ET.Element, parent: NmConfig):
+    def readNmConfigNmClusters(self, element: ET.Element, nm_config: NmConfig):
         for child_element in self.findall(element, "NM-CLUSTERS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "CAN-NM-CLUSTER":
-                self.readCanNmCluster(child_element, parent)
+                cluster = nm_config.createCanNmCluster(self.getShortName(child_element))
+                self.readCanNmCluster(child_element, cluster)
             elif tag_name == "UDP-NM-CLUSTER":
-                self.readUdpNmCluster(child_element, parent)
+                cluster = nm_config.createUdpNmCluster(self.getShortName(child_element))
+                self.readUdpNmCluster(child_element, cluster)
+            else:
+                self.raiseError("Unsupported Nm Cluster <%s>" % tag_name)
+
+    def readUdpNmEcu(self, element: ET.Element, ecu: UdpNmEcu):
+        ecu.setNmSynchronizationPointEnabled(self.getChildElementOptionalBooleanValue(element, "NM-SYNCHRONIZATION-POINT-ENABLED"))
+
+    def readBusDependentNmEcus(self, element: ET.Element, nm_ecu: NmEcu):
+        for child_element in self.findall(element, "BUS-DEPENDENT-NM-ECUS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "UDP-NM-ECU":
+                udp_nm_ecu = UdpNmEcu()
+                self.readUdpNmEcu(child_element, udp_nm_ecu)
+                nm_ecu.addBusDependentNmEcu(udp_nm_ecu)
             else:
-                self._raiseError("Unsupported Nm Cluster <%s>" % tag_name)
+                self.notImplemented("Unsupported BusDependentNmEcu <%s>" % tag_name)
+
+    def readNmEcu(self, element: ET.Element, nm_ecu: NmEcu):
+        self.readIdentifiable(element, nm_ecu)
+        self.readBusDependentNmEcus(element, nm_ecu)
+        nm_ecu.setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF")) \
+              .setNmBusSynchronizationEnabled(self.getChildElementOptionalBooleanValue(element, "NM-BUS-SYNCHRONIZATION-ENABLED")) \
+              .setNmComControlEnabled(self.getChildElementOptionalBooleanValue(element, "NM-COM-CONTROL-ENABLED")) \
+              .setNmNodeDetectionEnabled(self.getChildElementOptionalBooleanValue(element, "NM-NODE-DETECTION-ENABLED")) \
+              .setNmNodeIdEnabled(self.getChildElementOptionalBooleanValue(element, "NM-NODE-ID-ENABLED")) \
+              .setNmPduRxIndicationEnabled(self.getChildElementOptionalBooleanValue(element, "NM-PDU-RX-INDICATION-ENABLED")) \
+              .setNmRemoteSleepIndEnabled(self.getChildElementOptionalBooleanValue(element, "NM-REMOTE-SLEEP-IND-ENABLED")) \
+              .setNmRepeatMsgIndEnabled(self.getChildElementOptionalBooleanValue(element, "NM-REPEAT-MSG-IND-ENABLED")) \
+              .setNmStateChangeIndEnabled(self.getChildElementOptionalBooleanValue(element, "NM-STATE-CHANGE-IND-ENABLED")) \
+              .setNmUserDataEnabled(self.getChildElementOptionalBooleanValue(element, "NM-USER-DATA-ENABLED"))
+
+    def readNmConfigNmIfEcus(self, element: ET.Element, nm_config: NmConfig):
+        for child_element in self.findall(element, "NM-IF-ECUS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "NM-ECU":
+                ecu = nm_config.createNmEcu(self.getShortName(child_element))
+                self.readNmEcu(child_element, ecu)
+            else:
+                self.notImplemented("Unsupported NmIfEcus <%s>" % tag_name)
     
-    def readNmConfig(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("NmConfig %s" % short_name)
-        config = parent.createNmConfig(short_name)                  # type: NmConfig
+    def readNmConfig(self, element: ET.Element, config: NmConfig):
+        self.logger.debug("Read NmConfig <%s>" % config.getShortName())
         self.readIdentifiable(element, config)
         self.readNmConfigNmClusters(element, config)
         self.readNmConfigNmClusterCouplings(element, config)
+        self.readNmConfigNmIfEcus(element, config)
 
-    def readCanTpConfig(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("read CanTpConfig %s" % short_name)
-        pdu = parent.createCanTpConfig(short_name)
-        self.readIdentifiable(element, pdu)
+    def readTpConfig(self, element: ET.Element, config: TpConfig):
+        self.readIdentifiable(element, config)
+        config.setCommunicationClusterRef(self.getChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF"))
 
-    def readCanFrame(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("read CanFrame %s" % short_name)
-        frame = parent.createCanFrame(short_name)
+    def readCanTpAddress(self, element: ET.Element, address: CanTpAddress):
+        self.readIdentifiable(element, address)
+        address.setTpAddress(self.getChildElementOptionalIntegerValue(element, "TP-ADDRESS")) \
+               .setTpAddressExtensionValue(self.getChildElementOptionalIntegerValue(element, "TP-ADDRESS-EXTENSION-VALUE"))
+
+    def readCanTpConfigTpAddresses(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-ADDRESSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-ADDRESS":
+                address = config.createCanTpAddress(self.getShortName(child_element))
+                self.readCanTpAddress(child_element, address)
+            else:
+                self.notImplemented("Unsupported TpAddress <%s>" % tag_name)
+
+    def readCanTpChannel(self, element: ET.Element, channel: CanTpChannel):
+        self.readIdentifiable(element, channel)
+        channel.setChannelId(self.getChildElementOptionalPositiveInteger(element, "CHANNEL-ID")) \
+               .setChannelMode(self.getChildElementOptionalLiteral(element, "CHANNEL-MODE"))
+
+    def readCanTpConfigTpChannels(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-CHANNELS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-CHANNEL":
+                channel = config.createCanTpChannel(self.getShortName(child_element))
+                self.readCanTpChannel(child_element, channel)
+            else:
+                self.notImplemented("Unsupported TpChannel <%s>" % tag_name)
+
+    def readTpConnection(self, element: ET.Element, connection: TpConnection):
+        self.readARObjectAttributes(element, connection)
+        child_element = self.find(element, "IDENT")
+        if child_element is not None:
+            ident = connection.createTpConnectionIdent(self.getShortName(child_element))
+            self.readReferrable(child_element, ident)
+
+    def readTpConnectionReceiverRefs(self, element: ET.Element, connection: CanTpConnection):
+        for ref in self.getChildElementRefTypeList(element, "RECEIVER-REFS/RECEIVER-REF"):
+            connection.addReceiverRef(ref)
+
+    def readCanTpConnection(self, element: ET.Element, connection: CanTpConnection):
+        self.readTpConnection(element, connection)
+        connection.setAddressingFormat(self.getChildElementOptionalLiteral(element, "ADDRESSING-FORMAT")) \
+                  .setCanTpChannelRef(self.getChildElementOptionalRefType(element, "CAN-TP-CHANNEL-REF")) \
+                  .setCancellation(self.getChildElementOptionalBooleanValue(element, "CANCELLATION")) \
+                  .setDataPduRef(self.getChildElementOptionalRefType(element, "DATA-PDU-REF")) \
+                  .setFlowControlPduRef(self.getChildElementOptionalRefType(element, "FLOW-CONTROL-PDU-REF")) \
+                  .setMaxBlockSize(self.getChildElementOptionalIntegerValue(element, "MAX-BLOCK-SIZE")) \
+                  .setMulticastRef(self.getChildElementOptionalRefType(element, "MULTICAST-REF")) \
+                  .setPaddingActivation(self.getChildElementOptionalBooleanValue(element, "PADDING-ACTIVATION"))
+        self.readTpConnectionReceiverRefs(element, connection)
+        connection.setTaType(self.getChildElementOptionalLiteral(element, "TA-TYPE")) \
+                  .setTimeoutBr(self.getChildElementOptionalTimeValue(element, "TIMEOUT-BR")) \
+                  .setTimeoutBs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-BS")) \
+                  .setTimeoutCr(self.getChildElementOptionalTimeValue(element, "TIMEOUT-CR")) \
+                  .setTimeoutCs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-CS")) \
+                  .setTpSduRef(self.getChildElementOptionalRefType(element, "TP-SDU-REF")) \
+                  .setTransmitterRef(self.getChildElementOptionalRefType(element, "TRANSMITTER-REF"))
+
+    def readCanTpConfigTpConnections(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-CONNECTIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-CONNECTION":
+                connection = CanTpConnection()
+                self.readCanTpConnection(child_element, connection)
+                config.addTpConnection(connection)
+            else:
+                self.notImplemented("Unsupported TpConnection <%s>" % tag_name)
+
+    def readCanTpEcu(self, element: ET.Element, tp_ecu: CanTpEcu):
+        tp_ecu.setCycleTimeMainFunction(self.getChildElementOptionalTimeValue(element, "CYCLE-TIME-MAIN-FUNCTION")) \
+              .setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF")) 
+
+    def readCanTpConfigTpEcus(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-ECUS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-ECU":
+                tp_ecu = CanTpEcu()
+                self.readCanTpEcu(child_element, tp_ecu)
+                config.addTpEcu(tp_ecu)
+            else:
+                self.notImplemented("Unsupported TpEcu <%s>" % tag_name)
+
+    def readCanTpNode(self, element: ET.Element, tp_node: CanTpNode):
+        self.readIdentifiable(element, tp_node)
+        tp_node.setConnectorRef(self.getChildElementOptionalRefType(element, "CONNECTOR-REF")) \
+               .setMaxFcWait(self.getChildElementOptionalIntegerValue(element, "MAX-FC-WAIT")) \
+               .setStMin(self.getChildElementOptionalTimeValue(element, "ST-MIN")) \
+               .setTimeoutAr(self.getChildElementOptionalTimeValue(element, "TIMEOUT-AR")) \
+               .setTimeoutAs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-AS")) \
+               .setTpAddressRef(self.getChildElementOptionalRefType(element, "TP-ADDRESS-REF"))
+
+    def readCanTpConfigTpNodes(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-NODES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-NODE":
+                tp_node = config.createCanTpNode(self.getShortName(child_element))
+                self.readCanTpNode(child_element, tp_node)
+            else:
+                self.notImplemented("Unsupported TpNode <%s>" % tag_name)
+
+    def readCanTpConfig(self, element: ET.Element, config: CanTpConfig):
+        self.logger.debug("Read CanTpConfig <%s>" % config.getShortName())
+        self.readTpConfig(element, config)
+        self.readCanTpConfigTpAddresses(element, config)
+        self.readCanTpConfigTpChannels(element, config)
+        self.readCanTpConfigTpConnections(element, config)
+        self.readCanTpConfigTpEcus(element, config)
+        self.readCanTpConfigTpNodes(element, config)
+
+    def readTpAddress(self, element: ET.Element, address: TpAddress):
+        self.readIdentifiable(element, address)
+        address.setTpAddress(self.getChildElementOptionalIntegerValue(element, "TP-ADDRESS"))
+
+    def readLinTpConfigTpAddresses(self, element: ET.Element, config: LinTpConfig):
+        for child_element in self.findall(element, "TP-ADDRESSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "TP-ADDRESS":
+                address = config.createTpAddress(self.getShortName(child_element))
+                self.readTpAddress(child_element, address)
+            else:
+                self.notImplemented("Unsupported TpAddress <%s>" % tag_name)
+
+    def readLinTpConnection(self, element: ET.Element, connection: LinTpConnection):
+        self.readTpConnection(element, connection)
+        connection.setDataPduRef(self.getChildElementOptionalRefType(element, "DATA-PDU-REF")) \
+                  .setFlowControlRef(self.getChildElementOptionalRefType(element, "FLOW-CONTROL-REF")) \
+                  .setLinTpNSduRef(self.getChildElementOptionalRefType(element, "LIN-TP-N-SDU-REF")) 
+        self.readTpConnectionReceiverRefs(element, connection)
+        connection.setTimeoutAs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-AS")) \
+                  .setTimeoutCr(self.getChildElementOptionalTimeValue(element, "TIMEOUT-CR")) \
+                  .setTimeoutCs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-CS")) \
+                  .setTransmitterRef(self.getChildElementOptionalRefType(element, "TRANSMITTER-REF"))
+
+    def readLinTpConfigTpConnections(self, element: ET.Element, config: LinTpConfig):
+        for child_element in self.findall(element, "TP-CONNECTIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "LIN-TP-CONNECTION":
+                connection = LinTpConnection()
+                self.readLinTpConnection(child_element, connection)
+                config.addTpConnection(connection)
+            else:
+                self.notImplemented("Unsupported TpConnection <%s>" % tag_name)
+
+    def readLinTpNode(self, element: ET.Element, tp_node: LinTpNode):
+        self.readIdentifiable(element, tp_node)
+        tp_node.setConnectorRef(self.getChildElementOptionalRefType(element, "CONNECTOR-REF")) \
+               .setDropNotRequestedNad(self.getChildElementOptionalBooleanValue(element, "DROP-NOT-REQUESTED-NAD")) \
+               .setP2Max(self.getChildElementOptionalTimeValue(element, "P-2-MAX")) \
+               .setP2Timing(self.getChildElementOptionalTimeValue(element, "P-2-TIMING")) \
+               .setTpAddressRef(self.getChildElementOptionalRefType(element, "TP-ADDRESS-REF"))
+
+    def readLinTpConfigTpNodes(self, element: ET.Element, config: LinTpConfig):
+        for child_element in self.findall(element, "TP-NODES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "LIN-TP-NODE":
+                tp_node = config.createLinTpNode(self.getShortName(child_element))
+                self.readLinTpNode(child_element, tp_node)
+            else:
+                self.notImplemented("Unsupported TpNode <%s>" % tag_name)
+
+    def readLinTpConfig(self, element: ET.Element, config: LinTpConfig):
+        self.logger.debug("Read LinTpConfig <%s>" % config.getShortName())
+        self.readTpConfig(element, config)
+        self.readLinTpConfigTpAddresses(element, config)
+        self.readLinTpConfigTpConnections(element, config)
+        self.readLinTpConfigTpNodes(element, config)
+
+    def readCanFrame(self, element: ET.Element, frame: CanFrame):
+        self.logger.debug("Read CanFrame <%s>" % frame.getShortName())
         self.readFrame(element, frame)
 
+    def readCommunicationController(self, element: ET.Element, controller: CommunicationController):
+        controller.setWakeUpByControllerSupported(self.getChildElementOptionalBooleanValue(element, "WAKE-UP-BY-CONTROLLER-SUPPORTED"))
+
+    def getCanControllerFdConfiguration(self, element: ET.Element, key: str) -> CanControllerFdConfiguration:
+        configuration = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            configuration = CanControllerFdConfiguration()
+            #TODO: need to implemented
+        return configuration
+    
+    def getCanControllerFdConfigurationRequirements(self, element: ET.Element, key: str) -> CanControllerFdConfigurationRequirements:
+        requirements = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            requirements = CanControllerFdConfigurationRequirements()
+            requirements.setMaxNumberOfTimeQuantaPerBit(self.getChildElementOptionalIntegerValue(child_element, "MAX-NUMBER-OF-TIME-QUANTA-PER-BIT")) \
+                        .setMaxSamplePoint(self.getChildElementOptionalFloatValue(child_element, "MAX-SAMPLE-POINT")) \
+                        .setMaxSyncJumpWidth(self.getChildElementOptionalFloatValue(child_element, "MAX-SYNC-JUMP-WIDTH")) \
+                        .setMaxTrcvDelayCompensationOffset(self.getChildElementOptionalTimeValue(child_element, "MAX-TRCV-DELAY-COMPENSATION-OFFSET")) \
+                        .setMinNumberOfTimeQuantaPerBit(self.getChildElementOptionalIntegerValue(child_element, "MIN-NUMBER-OF-TIME-QUANTA-PER-BIT")) \
+                        .setMinSamplePoint(self.getChildElementOptionalFloatValue(child_element, "MIN-SAMPLE-POINT")) \
+                        .setMinSyncJumpWidth(self.getChildElementOptionalFloatValue(child_element, "MIN-SYNC-JUMP-WIDTH")) \
+                        .setMinTrcvDelayCompensationOffset(self.getChildElementOptionalTimeValue(child_element, "MIN-TRCV-DELAY-COMPENSATION-OFFSET")) \
+                        .setTxBitRateSwitch(self.getChildElementOptionalBooleanValue(child_element, "TX-BIT-RATE-SWITCH"))
+        return requirements
+
+    def readAbstractCanCommunicationControllerAttributes(self, element: ET.Element, attributes: AbstractCanCommunicationControllerAttributes):
+        attributes.setCanControllerFdAttributes(self.getCanControllerFdConfiguration(element, "CAN-CONTROLLER-FD-CONFIGURATION")) \
+                  .setCanControllerFdRequirements(self.getCanControllerFdConfigurationRequirements(element, "CAN-CONTROLLER-FD-REQUIREMENTS"))
+
+    def readCanControllerConfigurationRequirements(self, element: ET.Element, requirements: CanControllerConfigurationRequirements):
+        self.readAbstractCanCommunicationControllerAttributes(element, requirements)
+        requirements.setMaxNumberOfTimeQuantaPerBit(self.getChildElementOptionalIntegerValue(element, "MAX-NUMBER-OF-TIME-QUANTA-PER-BIT")) \
+                    .setMaxSamplePoint(self.getChildElementOptionalFloatValue(element, "MAX-SAMPLE-POINT")) \
+                    .setMaxSyncJumpWidth(self.getChildElementOptionalFloatValue(element, "MAX-SYNC-JUMP-WIDTH")) \
+                    .setMinNumberOfTimeQuantaPerBit(self.getChildElementOptionalIntegerValue(element, "MIN-NUMBER-OF-TIME-QUANTA-PER-BIT")) \
+                    .setMinSamplePoint(self.getChildElementOptionalFloatValue(element, "MIN-SAMPLE-POINT")) \
+                    .setMinSyncJumpWidth(self.getChildElementOptionalFloatValue(element, "MIN-SYNC-JUMP-WIDTH"))
+
+    def readAbstractCanCommunicationControllerCanControllerAttributes(self, element: ET.SubElement, controller: AbstractCanCommunicationController):
+        for child_element in self.findall(element, "CAN-CONTROLLER-ATTRIBUTES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-CONTROLLER-CONFIGURATION-REQUIREMENTS":
+                requirements = CanControllerConfigurationRequirements()
+                self.readCanControllerConfigurationRequirements(child_element, requirements)
+                controller.setCanControllerAttributes(requirements)
+            else:
+                self.notImplemented("Unsupported CanControllerAttributes <%s>" % tag_name)
+
+    def readAbstractCanCommunicationController(self, element: ET.Element, controller: AbstractCanCommunicationController):
+        self.readCommunicationController(element, controller)
+        self.readAbstractCanCommunicationControllerCanControllerAttributes(element, controller)
+
     def readCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
         self.logger.debug("Read CanCommunicationController %s" % controller.getShortName())
         self.readIdentifiable(element, controller)
+        child_element = self.find(element, "CAN-COMMUNICATION-CONTROLLER-VARIANTS/CAN-COMMUNICATION-CONTROLLER-CONDITIONAL")
+        if child_element is not None:
+            self.readAbstractCanCommunicationController(child_element, controller)
+
+    def readCouplingPortSchedulerCouplingPortStructuralElement(self, element: ET.Element, item: CouplingPortStructuralElement):
+        self.readIdentifiable(element, item)
+
+    def readCouplingPortFifo(self, element: ET.Element, fifo: CouplingPortFifo):
+        self.readCouplingPortSchedulerCouplingPortStructuralElement(element, fifo)
+
+    def readCouplingPortScheduler(self, element: ET.Element, scheduler: CouplingPortScheduler):
+        self.readCouplingPortSchedulerCouplingPortStructuralElement(element, scheduler)
+        scheduler.setPortScheduler(self.getChildElementOptionalLiteral(element, "PORT-SCHEDULER"))
+
+    def readCouplingPortDetailsCouplingPortStructuralElements(self, item: ET.Element, details: CouplingPortDetails):
+        for child_element in self.findall(item, "COUPLING-PORT-STRUCTURAL-ELEMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "COUPLING-PORT-FIFO":
+                item = details.createCouplingPortFifo(self.getShortName(child_element))
+                self.readCouplingPortFifo(child_element, item)
+            elif tag_name == "COUPLING-PORT-SCHEDULER":
+                item = details.createCouplingPortScheduler(self.getShortName(child_element))
+                self.readCouplingPortScheduler(child_element, item)
+            else:
+                self.notImplemented("Unsupported CouplingPortStructuralElement <%s>" % tag_name)
+
+    def readEthernetPriorityRegeneration(self, element: ET.Element, regeneration: EthernetPriorityRegeneration):
+        regeneration.setIngressPriority(self.getChildElementOptionalPositiveInteger(element, "INGRESS-PRIORITY")) \
+                    .setRegeneratedPriority(self.getChildElementOptionalPositiveInteger(element, "REGENERATED-PRIORITY"))
+
+    def readCouplingPortDetailsEthernetPriorityRegenerations(self, element: ET.Element, details: CouplingPortDetails):
+        for child_element in self.findall(element, "ETHERNET-PRIORITY-REGENERATIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ETHERNET-PRIORITY-REGENERATION":
+                item = details.createEthernetPriorityRegeneration(self.getShortName(child_element))
+                self.readEthernetPriorityRegeneration(child_element, item)
+            else:
+                self.notImplemented("Unsupported EthernetPriorityRegeneration <%s>" % tag_name)
+
+    def getCouplingPortDetails(self, element: ET.Element, key: str) -> CouplingPortDetails:
+        details = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            details = CouplingPortDetails()
+            self.readCouplingPortDetailsCouplingPortStructuralElements(child_element, details)
+            self.readCouplingPortDetailsEthernetPriorityRegenerations(child_element, details)
+            details.setLastEgressSchedulerRef(self.getChildElementOptionalRefType(child_element, "LAST-EGRESS-SCHEDULER-REF"))
+        return details
+    
+    def readVlanMembership(self, element: ET.Element, membership: VlanMembership):
+        membership.setSendActivity(self.getChildElementOptionalLiteral(element, "SEND-ACTIVITY")) \
+                  .setVlanRef(self.getChildElementOptionalRefType(element, "VLAN-REF"))
+    
+    def readCouplingPortVlanMemberships(self, element: ET.Element, port: CouplingPort):
+        for child_element in self.findall(element, "VLAN-MEMBERSHIPS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "VLAN-MEMBERSHIP":
+                 membership = VlanMembership()
+                 self.readVlanMembership(child_element, membership)
+                 port.addVlanMembership(membership)
+            else:
+                self.notImplemented("Unsupported VlanMembership <%s>" % tag_name)
+
+    def readCouplingPort(self, element: ET.Element, port: CouplingPort):
+        self.readIdentifiable(element, port)
+        port.setCouplingPortDetails(self.getCouplingPortDetails(element, "COUPLING-PORT-DETAILS")) \
+            .setMacAddressVlanAssignments(self.getChildElementOptionalLiteral(element, "MAC-LAYER-TYPE"))
+        self.readCouplingPortVlanMemberships(element, port)
+
+    def readEthernetCommunicationControllerCouplingPorts(self, element: ET.Element, controller: EthernetCommunicationController):
+        for child_element in self.findall(element, "COUPLING-PORTS/*"):
+            tag_name = self.getTagName(child_element)
+            if (tag_name == "COUPLING-PORT"):
+                port = controller.createCouplingPort(self.getShortName(child_element))
+                self.readCouplingPort(child_element, port)
+            else:
+                self.notImplemented("Unsupported Coupling Port <%s>" % tag_name)
 
     def readEthernetCommunicationController(self, element: ET.Element, controller: EthernetCommunicationController):
         self.logger.debug("Read EthernetCommunicationController %s" % controller.getShortName())
         self.readIdentifiable(element, controller)
+        child_element = self.find(element, "ETHERNET-COMMUNICATION-CONTROLLER-VARIANTS/ETHERNET-COMMUNICATION-CONTROLLER-CONDITIONAL")
+        if child_element is not None:
+            self.readCommunicationController(child_element, controller)
+            self.readEthernetCommunicationControllerCouplingPorts(child_element, controller)
+
+    def readLinCommunicationController(self, element: ET.Element, controller: LinCommunicationController):
+        self.readCommunicationController(element, controller)
+        controller.setProtocolVersion(self.getChildElementOptionalLiteral(element, "PROTOCOL-VERSION"))
 
     def readLinMaster(self, element: ET.Element, controller: LinMaster):
         self.logger.debug("Read LinMaster %s" % controller.getShortName())
         self.readIdentifiable(element, controller)
+        child_element = self.find(element, "LIN-MASTER-VARIANTS/LIN-MASTER-CONDITIONAL")
+        if child_element is not None:
+            self.readLinCommunicationController(child_element, controller)
+            controller.setTimeBase(self.getChildElementOptionalTimeValue(child_element, "TIME-BASE")) \
+                      .setTimeBaseJitter(self.getChildElementOptionalTimeValue(child_element, "TIME-BASE-JITTER"))
+            
 
     def readEcuInstanceCommControllers(self, element: ET.Element, instance: EcuInstance):
         self.logger.debug("readEcuInstanceCommControllers %s" % instance.getShortName())
@@ -3117,7 +3673,7 @@ class ARXMLParser(AbstractARXMLParser):
                 controller = instance.createLinMaster(self.getShortName(child_element))
                 self.readLinMaster(child_element, controller)
             else:
-                self._raiseError("Unsupported Communication Controller <%s>" % tag_name)
+                self.raiseError("Unsupported Communication Controller <%s>" % tag_name)
 
     def readCommConnectorPort(self, element: ET.Element, port: CommConnectorPort):
         self.readIdentifiable(element, port)
@@ -3128,9 +3684,13 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readIPduPort(self, element: ET.Element, port: IPduPort):
         self.readCommConnectorPort(element, port)
+        port.setKeyId(self.getChildElementOptionalPositiveInteger(element, "KEY-ID")) \
+            .setRxSecurityVerification(self.getChildElementOptionalBooleanValue(element, "RX-SECURITY-VERIFICATION")) \
+            .setUseAuthDataFreshness(self.getChildElementOptionalBooleanValue(element, "USE-AUTH-DATA-FRESHNESS")) \
 
     def readISignalPort(self, element: ET.Element, port: ISignalPort):
         self.readCommConnectorPort(element, port)
+        port.setTimeout(self.getChildElementOptionalTimeValue(element, "TIMEOUT"))
 
     def readCommunicationConnectorEcuCommPortInstances(self, element: ET.Element, connector: CommunicationConnector):
         self.logger.debug("read EcuCommPortInstances of CommunicationConnector %s" % connector.getShortName())
@@ -3146,18 +3706,25 @@ class ARXMLParser(AbstractARXMLParser):
                 port = connector.createISignalPort(self.getShortName(child_element))
                 self.readISignalPort(child_element, port)
             else:
-                self._raiseError("Unsupported EcuCommPortInstances <%s>" % tag_name)       
+                self.raiseError("Unsupported EcuCommPortInstances <%s>" % tag_name)       
 
     def readCommunicationConnector(self, element: ET.Element, connector: CommunicationConnector):
         self.readIdentifiable(element, connector)
         connector.setCommControllerRef(self.getChildElementOptionalRefType(element, "COMM-CONTROLLER-REF"))
         self.readCommunicationConnectorEcuCommPortInstances(element, connector)
+        connector.setPncGatewayType(self.getChildElementOptionalLiteral(element, "PNC-GATEWAY-TYPE"))
 
     def readCanCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
         self.readCommunicationConnector(element, connector)
 
+    def readEthernetCommunicationConnectorNetworkEndpointRefs(self, element: ET.Element, connector: EthernetCommunicationConnector):
+        for ref in self.getChildElementRefTypeList(element, "NETWORK-ENDPOINT-REFS/NETWORK-ENDPOINT-REF"):
+            connector.addNetworkEndpointRef(ref)
+
     def readEthernetCommunicationConnector(self, element: ET.Element, connector: EthernetCommunicationConnector):
         self.readCommunicationConnector(element, connector)
+        connector.setMaximumTransmissionUnit(self.getChildElementOptionalPositiveInteger(element, "MAXIMUM-TRANSMISSION-UNIT"))
+        self.readEthernetCommunicationConnectorNetworkEndpointRefs(element, connector)
 
     def readLinCommunicationConnector(self, element: ET.Element, connector: LinCommunicationConnector):
         self.readCommunicationConnector(element, connector)
@@ -3176,20 +3743,24 @@ class ARXMLParser(AbstractARXMLParser):
                 connector = instance.createLinCommunicationConnector(self.getShortName(child_element))
                 self.readLinCommunicationConnector(child_element, connector)
             else:
-                self._raiseError("Unsupported Communication Connector <%s>" % tag_name)                
+                self.notImplemented("Unsupported Communication Connector <%s>" % tag_name)
 
-    def readEcuInstance(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("EcuInstance %s" % short_name)
-        instance = parent.createEcuInstance(short_name)
+    def readEcuInstanceAssociatedComIPduGroupRefs(self, element: ET.Element, instance: EcuInstance):
+        for ref in self.getChildElementRefTypeList(element, "ASSOCIATED-COM-I-PDU-GROUP-REFS/ASSOCIATED-COM-I-PDU-GROUP-REF"):
+            instance.addAssociatedComIPduGroupRef(ref)
+
+    def readEcuInstance(self, element: ET.Element, instance: EcuInstance):
+        self.logger.debug("Read EcuInstance <%s>" % instance.getShortName())
         self.readIdentifiable(element, instance)
+        self.readEcuInstanceAssociatedComIPduGroupRefs(element, instance)
         instance.setComConfigurationGwTimeBase(self.getChildElementOptionalTimeValue(element, "COM-CONFIGURATION-GW-TIME-BASE")) \
                 .setComConfigurationRxTimeBase(self.getChildElementOptionalTimeValue(element, "COM-CONFIGURATION-RX-TIME-BASE")) \
                 .setComConfigurationTxTimeBase(self.getChildElementOptionalTimeValue(element, "COM-CONFIGURATION-TX-TIME-BASE")) \
                 .setComEnableMDTForCyclicTransmission(self.getChildElementOptionalBooleanValue(element, "COM-ENABLE-MDT-FOR-CYCLIC-TRANSMISSION"))
         self.readEcuInstanceCommControllers(element, instance)
         self.readEcuInstanceConnectors(element, instance)
-        instance.setSleepModeSupported(self.getChildElementOptionalBooleanValue(element, "SLEEP-MODE-SUPPORTED")) \
+        instance.setDiagnosticAddress(self.getChildElementOptionalIntegerValue(element, "DIAGNOSTIC-ADDRESS")) \
+                .setSleepModeSupported(self.getChildElementOptionalBooleanValue(element, "SLEEP-MODE-SUPPORTED")) \
                 .setWakeUpOverBusSupported(self.getChildElementOptionalBooleanValue(element, "WAKE-UP-OVER-BUS-SUPPORTED"))
 
     '''
@@ -3212,30 +3783,34 @@ class ARXMLParser(AbstractARXMLParser):
             mappings.append(mapping)
         return mappings
     
-    '''
+    def getTargetIPduRef(self, element, key: str) -> TargetIPduRef:
+        i_pdu_ref = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            i_pdu_ref = TargetIPduRef()
+            i_pdu_ref.setTargetIPdu(self.getChildElementOptionalRefType(child_element, "TARGET-I-PDU-REF"))
+        return i_pdu_ref
+    
     def getIPduMappings(self, element: ET.Element) -> List[IPduMapping]:
         mappings = []
-        for child_element in self.findall(element, tag_name):
+        for child_element in self.findall(element, "I-PDU-MAPPINGS/I-PDU-MAPPING"):
             mapping = IPduMapping()
-            mapping.sourceIPduRef = self.getChildElementOptionalRefType(child_element, "SOURCE-IPDU-REF")
-            mapping.targetIPduRef = self.getChildElementOptionalRefType(child_element, "TARGET-IPDU-REF")
+            mapping.setSourceIpduRef(self.getChildElementOptionalRefType(child_element, "SOURCE-I-PDU-REF")) \
+                   .setTargetIPdu(self.getTargetIPduRef(child_element, "TARGET-I-PDU"))
             mappings.append(mapping)
         return mappings
-    '''
 
-    def readGateway(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Gateway %s" % short_name)
-        gateway = parent.createGateway(short_name)
+    def readGateway(self, element: ET.Element, gateway: Gateway):
+        self.logger.debug("Read Gateway <%s>" % gateway.getShortName())
         self.readIdentifiable(element, gateway)
-        gateway.ecuRef = self.getChildElementOptionalRefType(element, "ECU-REF")
+        gateway.setEcuRef(self.getChildElementOptionalRefType(element, "ECU-REF"))
+        for mapping in self.getIPduMappings(element):
+            gateway.addIPduMapping(mapping)
         for mapping in self.getISignalMappings(element):
             gateway.addSignalMapping(mapping)
 
-    def readISignal(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("ISignal %s" % short_name)
-        signal = parent.createISignal(short_name)
+    def readISignal(self, element: ET.Element, signal: ISignal):
+        self.logger.debug("Read ISignal <%s>" % signal.getShortName())
         self.readIdentifiable(element, signal)
         signal.setDataTypePolicy(self.getChildElementOptionalLiteral(element, "DATA-TYPE-POLICY")) \
               .setISignalType(self.getChildElementOptionalLiteral(element, "I-SIGNAL-TYPE")) \
@@ -3251,10 +3826,8 @@ class ARXMLParser(AbstractARXMLParser):
                 parent.addEcucValueRef(ref)
             self.logger.debug("EcucValue <%s> of EcucValueCollection <%s> has been added", ref.value, parent.getShortName())
 
-    def readEcucValueCollection(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("EcucValueCollection %s" % short_name)
-        collection = parent.createEcucValueCollection(short_name)
+    def readEcucValueCollection(self, element: ET.Element, collection: EcucValueCollection):
+        self.logger.debug("Read EcucValueCollection <%s>" % collection.getShortName())
         self.readIdentifiable(element, collection)
         collection.setEcuExtractRef(self.getChildElementOptionalRefType(element, "ECU-EXTRACT-REF"))
         self.readEcucValueCollectionEcucValues(element, collection)
@@ -3359,24 +3932,23 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported Container %s" % tag_name) 
 
-    def readEcucModuleConfigurationValues(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("EcucModuleConfigurationValues %s" % short_name)
-        values = parent.createEcucModuleConfigurationValues(short_name)
+    def readEcucModuleConfigurationValues(self, element: ET.Element, values: EcucModuleConfigurationValues):
+        self.logger.debug("Read EcucModuleConfigurationValues %s" % values.getShortName())
         self.readIdentifiable(element, values)
         values.setDefinitionRef(self.getChildElementOptionalRefType(element, "DEFINITION-REF"))
         values.setImplementationConfigVariant(self.getChildElementOptionalLiteral(element, "IMPLEMENTATION-CONFIG-VARIANT"))
         values.setModuleDescriptionRef(self.getChildElementOptionalRefType(element, "MODULE-DESCRIPTION-REF"))
         self.readEcucModuleConfigurationValuesContainers(element, values)
 
-    def readPhysicalDimensions(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("read PhysicalDimensions %s" % short_name)
-        dimension = parent.createPhysicalDimension(short_name)
+    def readPhysicalDimension(self, element: ET.Element, dimension: PhysicalDimension):
+        self.logger.debug("Read PhysicalDimension <%s>" % dimension.getShortName())
         self.readIdentifiable(element, dimension)
-        dimension.setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP")) \
-                 .setLengthExp(self.getChildElementOptionalNumericalValue(element, "LENGTH-EXP")) \
-                 .setTimeExp(self.getChildElementOptionalNumericalValue(element, "TIME-EXP"))
+        dimension.setLengthExp(self.getChildElementOptionalNumericalValue(element, "LENGTH-EXP")) \
+                 .setLuminousIntensityExp(self.getChildElementOptionalNumericalValue(element, "LUMINOUS-INTENSITY-EXP")) \
+                 .setMassExp(self.getChildElementOptionalNumericalValue(element, "MASS-EXP")) \
+                 .setTemperatureExp(self.getChildElementOptionalNumericalValue(element, "TEMPERATURE-EXP")) \
+                 .setTimeExp(self.getChildElementOptionalNumericalValue(element, "TIME-EXP")) \
+                 .setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP")) \
 
     '''
     def getIPduMappings(self, element: ET.Element) -> List[IPduMapping]:
@@ -3389,27 +3961,21 @@ class ARXMLParser(AbstractARXMLParser):
         return mappings
     '''
 
-    def readISignalGroup(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("ISignalGroup %s" % short_name)
-        group = parent.createISignalGroup(short_name)
+    def readISignalGroup(self, element: ET.Element, group: ISignalGroup):
+        self.logger.debug("Read ISignalGroup <%s>" % group.getShortName())
         self.readIdentifiable(element, group)
         for ref_type in self.getChildElementRefTypeList(element, "I-SIGNAL-REFS/I-SIGNAL-REF"):
             group.addISignalRef(ref_type)
         group.systemSignalGroupRef = self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-GROUP-REF")
 
-    def readSystemSignal(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("SystemSignal %s" % short_name)
-        signal = parent.createSystemSignal(short_name)
+    def readSystemSignal(self, element: ET.Element, signal: SystemSignal):
+        self.logger.debug("Read SystemSignal <%s>" % signal.getShortName())
         self.readIdentifiable(element, signal)
         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)
-        self.logger.debug("SystemSignalGroup %s" % short_name)
-        group = parent.createSystemSignalGroup(short_name)
+    def readSystemSignalGroup(self, element: ET.Element, group: SystemSignalGroup):
+        self.logger.debug("Read SystemSignalGroup <%s>" % group.getShortName())
         self.readIdentifiable(element, group)
         for ref_type in self.getChildElementRefTypeList(element, "SYSTEM-SIGNAL-REFS/SYSTEM-SIGNAL-REF"):
             group.addSystemSignalRefs(ref_type)
@@ -3431,7 +3997,10 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, key)
         if child_element is not None:
             filter = DataFilter()
-            filter.setDataFilterType(self.getChildElementOptionalLiteral(child_element, "DATA-FILTER-TYPE"))
+            filter.setDataFilterType(self.getChildElementOptionalLiteral(child_element, "DATA-FILTER-TYPE")) \
+                  .setMask(self.getChildElementOptionalIntegerValue(child_element, "MASK")) \
+                  .setX(self.getChildElementOptionalIntegerValue(child_element, "X")) 
+
         return filter
             
     def getTransmissionModeConditions(self, element: ET.Element, key: str) -> List[TransmissionModeCondition]:
@@ -3487,7 +4056,8 @@ class ARXMLParser(AbstractARXMLParser):
             decl = TransmissionModeDeclaration()
             for condition in self.getTransmissionModeConditions(child_element, "TRANSMISSION-MODE-CONDITIONS/TRANSMISSION-MODE-CONDITION"):
                 decl.addTransmissionModeCondition(condition)
-            decl.setTransmissionModeTrueTiming(self.getTransmissionModeTiming(child_element, "TRANSMISSION-MODE-TRUE-TIMING"))
+            decl.setTransmissionModeFalseTiming(self.getTransmissionModeTiming(child_element, "TRANSMISSION-MODE-FALSE-TIMING")) \
+                .setTransmissionModeTrueTiming(self.getTransmissionModeTiming(child_element, "TRANSMISSION-MODE-TRUE-TIMING"))
         return decl
 
     def getISignalIPduIPduTimingSpecification(self, element: ET.Element) -> IPduTiming:
@@ -3499,15 +4069,13 @@ class ARXMLParser(AbstractARXMLParser):
                   .setTransmissionModeDeclaration(self.getTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION"))
         return timing
 
-    def readISignalIPdu(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("ISignalIPdu %s" % short_name)
-        i_pdu = parent.createISignalIPdu(short_name)
-        self.readIdentifiable(element, i_pdu)
-        i_pdu.setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH")) \
+    def readISignalIPdu(self, element: ET.Element, ipdu: ISignalIPdu):
+        self.logger.debug("Read ISignalIPdu <%s>" % ipdu.getShortName())
+        self.readIdentifiable(element, ipdu)
+        ipdu.setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH")) \
             .setIPduTimingSpecification(self.getISignalIPduIPduTimingSpecification(element))
-        self.readISignalToPduMappings(element, i_pdu)
-        i_pdu.setUnusedBitPattern(self.getChildElementOptionalLiteral(element, "UNUSED-BIT-PATTERN"))
+        self.readISignalToPduMappings(element, ipdu)
+        ipdu.setUnusedBitPattern(self.getChildElementOptionalIntegerValue(element, "UNUSED-BIT-PATTERN"))
 
     def getISignalIPduRefs(self, element: ET.Element) -> List[RefType]:
         ref_types = [] 
@@ -3515,13 +4083,11 @@ class ARXMLParser(AbstractARXMLParser):
             ref_types.append(self.getChildElementOptionalRefType(child_element, "I-SIGNAL-I-PDU-REF"))
         return ref_types
 
-    def readISignalIPduGroup(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("ISignalIPduGroup %s" % short_name)
-        group = parent.createISignalIPduGroup(short_name)
+    def readISignalIPduGroup(self, element: ET.Element, group: ISignalIPduGroup):
+        self.logger.debug("Read ISignalIPduGroup <%s>" % group.getShortName())
         self.readIdentifiable(element, group)
-        group.communicationDirection = self.getChildElementOptionalLiteral(element, "COMMUNICATION-DIRECTION")
-        group.communicationMode = self.getChildElementOptionalLiteral(element, "COMMUNICATION-MODE")
+        group.setCommunicationDirection(self.getChildElementOptionalLiteral(element, "COMMUNICATION-DIRECTION")) \
+             .setCommunicationMode(self.getChildElementOptionalLiteral(element, "COMMUNICATION-MODE"))
         for ref_type in self.getChildElementRefTypeList(element, "CONTAINED-I-SIGNAL-I-PDU-GROUP-REFS/CONTAINED-I-SIGNAL-I-PDU-GROUP-REF"):
             group.addContainedISignalIPduGroupRef(ref_type)
         for ref_type in self.getISignalIPduRefs(element):
@@ -3561,23 +4127,54 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in self.findall(element, "SW-MAPPINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "SWC-TO-ECU-MAPPING":
-                self.readSwcToEcuMapping(child_element, mapping.createSwcToEcuMapping(self.getShortName(child_element)))
+                swc_to_ecu_mapping = mapping.createSwcToEcuMapping(self.getShortName(child_element))
+                self.readSwcToEcuMapping(child_element, swc_to_ecu_mapping)
             else:
                 self.notImplemented("Unsupported Sw Mapping %s" % tag_name)
 
-    def readSystemMapping(self, element: ET.Element, parent: System):
-        short_name = self.getShortName(element)
-        self.logger.debug("SystemMapping %s" % short_name)
-        mapping = parent.createSystemMapping(short_name)
+    def readEcuMapping(self, element: ET.Element, mapping: ECUMapping):
+        self.readIdentifiable(element, mapping)
+        mapping.setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF")) \
+               .setEcuRef(self.getChildElementOptionalRefType(element, "ECU-REF")) 
+
+    def readSystemMappingEcuResourceMappings(self, element: ET.Element, mapping: SystemMapping):
+        for child_element in self.findall(element, "ECU-RESOURCE-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECU-MAPPING":
+                ecu_mapping = mapping.createECUMapping(self.getShortName(child_element))
+                self.readEcuMapping(child_element, ecu_mapping)
+            else:
+                self.notImplemented("Unsupported EcuResourceMapping <%s>" % tag_name)
+
+    def readSwcToImplMapping(self, element: ET.Element, mapping: SwcToImplMapping):
+        self.readIdentifiable(element, mapping)
+        mapping.setComponentImplementationRef(self.getChildElementOptionalRefType(element, "COMPONENT-IMPLEMENTATION-REF"))
+        for child_element in self.findall(element, "COMPONENT-IREFS/COMPONENT-IREF"):
+            mapping.addComponentIRef(self.getComponentInSystemInstanceRef(child_element))
+
+    def readSystemMappingSwImplMappings(self, element: ET.Element, mapping: SystemMapping):
+        for child_element in self.findall(element, "SW-IMPL-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SWC-TO-IMPL-MAPPING":
+                sw_impl_mapping = mapping.createSwcToImplMapping(self.getShortName(child_element))
+                self.readSwcToImplMapping(child_element, sw_impl_mapping)
+            else:
+                self.notImplemented("Unsupported SwImplMapping <%s>" % tag_name)
+
+    def readSystemMapping(self, element: ET.Element, mapping: SystemMapping):
+        self.logger.debug("SystemMapping %s" % mapping.getShortName())
         self.readIdentifiable(element, mapping)
         self.readSystemMappingDataMappings(element, mapping)
+        self.readSystemMappingEcuResourceMappings(element, mapping)
+        self.readSystemMappingSwImplMappings(element, mapping)
         self.readSystemMappingSwMappings(element, mapping)
 
     def readSystemMappings(self, element: ET.Element, system: System):
         for child_element in self.findall(element, "MAPPINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "SYSTEM-MAPPING":
-                self.readSystemMapping(child_element, system)
+                mapping = system.createSystemMapping(self.getShortName(child_element))
+                self.readSystemMapping(child_element, mapping)
             else:
                 self.notImplemented("Unsupported Mapping %s" % tag_name)
             
@@ -3590,32 +4187,29 @@ class ARXMLParser(AbstractARXMLParser):
             self.readIdentifiable(child_element, prototype)
             prototype.setFlatMapRef(self.getChildElementOptionalRefType(child_element, "FLAT-MAP-REF")) \
                      .setSoftwareCompositionTRef(self.getChildElementOptionalRefType(child_element, "SOFTWARE-COMPOSITION-TREF"))
-                     
+            AUTOSAR.getInstance().setRootSwCompositionPrototype(prototype)
+            
+    def readSystemFibexElementRefs(self, element: ET.Element, system: System):
+        for ref in self.getChildElementRefTypeList(element, "FIBEX-ELEMENTS/FIBEX-ELEMENT-REF-CONDITIONAL/FIBEX-ELEMENT-REF"):
+            system.addFibexElementRef(ref)
 
-    def readSystem(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read System %s" % short_name)
-        system = parent.createSystem(short_name)
+    def readSystem(self, element: ET.Element, system: System):
+        self.logger.debug("Read System <%s>" % system.getShortName())
         self.readIdentifiable(element, system)
-
         system.setEcuExtractVersion(self.getChildElementOptionalLiteral(element, "ECU-EXTRACT-VERSION"))
-        for child_element in self.findall(element, "FIBEX-ELEMENTS/FIBEX-ELEMENT-REF-CONDITIONAL"):
-            system.addFibexElementRef(self.getChildElementOptionalRefType(child_element, "FIBEX-ELEMENT-REF"))
+        self.readSystemFibexElementRefs(element, system)
         self.readSystemMappings(element, system)
         self.readRootSwCompositionPrototype(element, system)
         system.setSystemVersion(self.getChildElementOptionalRevisionLabelString(element, "SYSTEM-VERSION"))
+        AUTOSAR.getInstance().addSystem(system)
 
-    def readGenericEthernetFrame(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read EthernetFrame %s" % short_name)
-        frame = parent.createGenericEthernetFrame(short_name)
+    def readGenericEthernetFrame(self, element: ET.Element, frame: GenericEthernetFrame):
+        self.logger.debug("Read GenericEthernetFrame <%s>" % frame.getShortName())
         self.readFrame(element, frame)
 
-    def readLifeCycleInfoSet(self, element: ET.Element, parent: ARPackage):
-        short_name = self.getShortName(element)
-        self.logger.debug("Read LifeCycleInfoSet %s" % short_name)
-        frame = parent.createLifeCycleInfoSet(short_name)
-        self.readIdentifiable(element, frame)
+    def readLifeCycleInfoSet(self, element: ET.Element, info_set: LifeCycleInfoSet):
+        self.logger.debug("Read LifeCycleInfoSet <%s>" % info_set.getShortName())
+        self.readIdentifiable(element, info_set)
 
     def readFlatInstanceDescriptor(self, element: ET.Element, desc: FlatInstanceDescriptor):
         self.logger.debug("Read LifeCycleInfoSet %s" % desc.getShortName())
@@ -3632,10 +4226,8 @@ class ARXMLParser(AbstractARXMLParser):
             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)
+    def readFlatMap(self, element: ET.Element, map: FlatMap):
+        self.logger.debug("Read FlatMap <%s>" % map.getShortName())
         self.readIdentifiable(element, map)
         self.readFlatMapInstances(element, map)
 
@@ -3663,156 +4255,221 @@ class ARXMLParser(AbstractARXMLParser):
             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)
+    def readPortInterfaceMappingSet(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
+        self.logger.debug("Read PortInterfaceMappingSet %s" % mapping_set.getShortName())
         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/*"):
-            tag_name = self.getTagName(child_element.tag)
+            tag_name = self.getTagName(child_element)
             if tag_name == "COMPOSITION-SW-COMPONENT-TYPE":
-                self.readCompositionSwComponentType(child_element, parent)
+                type = parent.createCompositionSwComponentType(self.getShortName(child_element))
+                self.readCompositionSwComponentType(child_element, type)
             elif tag_name == "COMPLEX-DEVICE-DRIVER-SW-COMPONENT-TYPE":
-                self.readComplexDeviceDriverSwComponentType(child_element, parent)
+                type = parent.createComplexDeviceDriverSwComponentType(self.getShortName(child_element))
+                self.readComplexDeviceDriverSwComponentType(child_element, type)
             elif tag_name == "SWC-IMPLEMENTATION":
-                self.readSwcImplementation(child_element, parent)
+                impl = parent.createSwcImplementation(self.getShortName(child_element))  
+                self.readSwcImplementation(child_element, impl)
             elif tag_name == "APPLICATION-PRIMITIVE-DATA-TYPE":
-                self.readApplicationPrimitiveDataType(child_element, parent)
+                data_type = parent.createApplicationPrimitiveDataType(self.getShortName(child_element))
+                self.readApplicationPrimitiveDataType(child_element, data_type)
             elif tag_name == "APPLICATION-RECORD-DATA-TYPE":
-                self.readApplicationRecordDataTypes(child_element, parent)
+                data_type = parent.createApplicationRecordDataType(self.getShortName(child_element))
+                self.readApplicationRecordDataType(child_element, data_type)
             elif tag_name == "SW-BASE-TYPE":
-                self.readSwBaseType(child_element, parent)
+                data_type = parent.createSwBaseType(self.getShortName(child_element))
+                self.readSwBaseType(child_element, data_type)
             elif tag_name == "COMPU-METHOD":
-                self.readCompuMethod(child_element, parent)
+                compu_method = parent.createCompuMethod(self.getShortName(child_element))
+                self.readCompuMethod(child_element, compu_method)
             elif tag_name == "CONSTANT-SPECIFICATION":
-                self.readConstantSpecification(child_element, parent)
+                spec = parent.createConstantSpecification(self.getShortName(child_element))
+                self.readConstantSpecification(child_element, spec)
             elif tag_name == "DATA-CONSTR":
-                self.readDataConstr(child_element, parent)
+                constr = parent.createDataConstr(self.getShortName(child_element))
+                self.readDataConstr(child_element, constr)
             elif tag_name == "END-TO-END-PROTECTION-SET":
-                self.readEndToEndProtectionSet(child_element, parent)
+                protection_set = parent.createEndToEndProtectionSet(self.getShortName(child_element))
+                self.readEndToEndProtectionSet(child_element, protection_set)
             elif tag_name == "SENDER-RECEIVER-INTERFACE":
-                self.readSenderReceiverInterfaces(child_element, parent)
+                sr_interface = parent.createSenderReceiverInterface(self.getShortName(child_element))
+                self.readSenderReceiverInterface(child_element, sr_interface)
             elif tag_name == "UNIT":
-                self.readUnit(child_element, parent)
+                unit = parent.createUnit(self.getShortName(child_element))
+                self.readUnit(child_element, unit)
             elif tag_name == "BSW-MODULE-DESCRIPTION":
-                self.readBswModuleDescription(child_element, parent)
+                desc = parent.createBswModuleDescription(self.getShortName(child_element))
+                self.readBswModuleDescription(child_element, desc)
             elif tag_name == "BSW-MODULE-ENTRY":
-                self.readBswModuleEntry(child_element, parent)
+                entry = parent.createBswModuleEntry(self.getShortName(child_element))
+                self.readBswModuleEntry(child_element, entry)
             elif tag_name == "SWC-BSW-MAPPING":
-                self.readSwcBswMappings(child_element, parent)
+                mapping = parent.createSwcBswMapping(self.getShortName(child_element))
+                self.readSwcBswMapping(child_element, mapping)
             elif tag_name == "BSW-IMPLEMENTATION":
-                self.readBswImplementation(child_element, parent)
+                impl = parent.createBswImplementation(self.getShortName(child_element))   
+                self.readBswImplementation(child_element, impl)
             elif tag_name == "IMPLEMENTATION-DATA-TYPE":
-                self.readImplementationDataType(child_element, parent)
+                data_type = parent.createImplementationDataType(self.getShortName(child_element))
+                self.readImplementationDataType(child_element, data_type)
             elif tag_name == "CLIENT-SERVER-INTERFACE":
-                self.readClientServerInterface(child_element, parent)
+                cs_interface = parent.createClientServerInterface(self.getShortName(child_element))
+                self.readClientServerInterface(child_element, cs_interface)
             elif tag_name == "APPLICATION-SW-COMPONENT-TYPE":
-                self.readApplicationSwComponentTypes(child_element, parent)
+                sw_component = parent.createApplicationSwComponentType(self.getShortName(child_element))
+                self.readApplicationSwComponentType(child_element, sw_component)
             elif tag_name == "ECU-ABSTRACTION-SW-COMPONENT-TYPE":
-                self.readEcuAbstractionSwComponent(child_element, parent)
+                sw_component = parent.createEcuAbstractionSwComponentType(self.getShortName(child_element))
+                self.readEcuAbstractionSwComponentType(child_element, sw_component)
             elif tag_name == "APPLICATION-ARRAY-DATA-TYPE":
-                self.readApplicationArrayDataType(child_element, parent)
+                data_type = parent.createApplicationArrayDataType(self.getShortName(child_element))
+                self.readApplicationArrayDataType(child_element, data_type)
             elif tag_name == "SW-RECORD-LAYOUT":
-                
-                self.readSwRecordLayout(child_element, parent)
+                layout = parent.createSwRecordLayout(self.getShortName(child_element))
+                self.readSwRecordLayout(child_element, layout)
             elif tag_name == "SW-ADDR-METHOD":
-                self.readSwAddrMethod(child_element, parent)
+                method = parent.createSwAddrMethod(self.getShortName(child_element))
+                self.readSwAddrMethod(child_element, method)
             elif tag_name == "TRIGGER-INTERFACE":
-                self.readTriggerInterface(child_element, parent)
+                trigger_if = parent.createTriggerInterface(self.getShortName(child_element))
+                self.readTriggerInterface(child_element, trigger_if)
             elif tag_name == "SERVICE-SW-COMPONENT-TYPE":
-                self.readServiceSwComponentType(child_element, parent)
+                sw_component = parent.createServiceSwComponentType(self.getShortName(child_element))
+                self.readServiceSwComponentType(child_element, sw_component)
             elif tag_name == "SENSOR-ACTUATOR-SW-COMPONENT-TYPE":
-                self.readSensorActuatorSwComponentType(child_element, parent)
+                sw_component = parent.createSensorActuatorSwComponentType(self.getShortName(child_element))
+                self.readSensorActuatorSwComponentType(child_element, sw_component)
             elif tag_name == "DATA-TYPE-MAPPING-SET":
-                self.readDataTypeMappingSet(child_element, parent)
+                mapping_set = parent.createDataTypeMappingSet(self.getShortName(child_element))
+                self.readDataTypeMappingSet(child_element, mapping_set)
             elif tag_name == "MODE-DECLARATION-GROUP":
-                self.readModeDeclarationGroup(child_element, parent)
+                group = parent.createModeDeclarationGroup(self.getShortName(child_element))
+                self.readModeDeclarationGroup(child_element, group)
             elif tag_name == "MODE-SWITCH-INTERFACE":
-                self.readModeSwitchInterface(child_element, parent)
+                mode_interface = parent.createModeSwitchInterface(self.getShortName(child_element))
+                self.readModeSwitchInterface(child_element, mode_interface)
             elif tag_name == "SWC-TIMING":
-                self.readSwcTiming(child_element, parent)
+                timing = parent.createSwcTiming(self.getShortName(child_element))
+                self.readSwcTiming(child_element, timing)
             elif tag_name == "LIN-CLUSTER":
-                self.readLinCluster(child_element, parent)
+                cluster = parent.createLinCluster(self.getShortName(child_element))
+                self.readLinCluster(child_element, cluster)
             elif tag_name == "LIN-UNCONDITIONAL-FRAME":
-                self.readLinUnconditionalFrame(child_element, parent)
+                frame = parent.createLinUnconditionalFrame(self.getShortName(child_element))
+                self.readLinUnconditionalFrame(child_element, frame)
             elif tag_name == "NM-PDU":
-                self.readNmPdu(child_element, parent)
+                pdu = parent.createNmPdu(self.getShortName(child_element))
+                self.readNmPdu(child_element, pdu)
             elif tag_name == "N-PDU":
-                self.readNPdu(child_element, parent)
+                pdu = parent.createNPdu(self.getShortName(child_element))
+                self.readNPdu(child_element, pdu)
             elif tag_name == "DCM-I-PDU":
-                self.readDcmIPdu(child_element, parent)
+                i_pdu = parent.createDcmIPdu(self.getShortName(child_element))
+                self.readDcmIPdu(child_element, i_pdu)
             elif tag_name == "SECURED-I-PDU":
-                self.readSecuredIPdu(child_element, parent)
+                i_pdu = parent.createSecuredIPdu(self.getShortName(child_element))
+                self.readSecuredIPdu(child_element, i_pdu)
             elif tag_name == "NM-CONFIG":
-                self.readNmConfig(child_element, parent)
+                config = parent.createNmConfig(self.getShortName(child_element)) 
+                self.readNmConfig(child_element, config)
             elif tag_name == "CAN-TP-CONFIG":
-                self.readCanTpConfig(child_element, parent)
+                config = parent.createCanTpConfig(self.getShortName(child_element))
+                self.readCanTpConfig(child_element, config)
             elif tag_name == "LIN-TP-CONFIG":
-                pass
+                config = parent.createLinTpConfig(self.getShortName(child_element))
+                self.readLinTpConfig(child_element, config)
             elif tag_name == "SYSTEM":
-                self.readSystem(child_element, parent)
+                system = parent.createSystem(self.getShortName(child_element))
+                self.readSystem(child_element, system)
             elif tag_name == "ECU-INSTANCE":
-                self.readEcuInstance(child_element, parent)
+                instance = parent.createEcuInstance(self.getShortName(child_element))
+                self.readEcuInstance(child_element, instance)
             elif tag_name == "GATEWAY":
-                self.readGateway(child_element, parent)
+                gateway = parent.createGateway(self.getShortName(child_element))
+                self.readGateway(child_element, gateway)
             elif tag_name == "I-SIGNAL-I-PDU-GROUP":
-                self.readISignalIPduGroup(child_element, parent)
+                group = parent.createISignalIPduGroup(self.getShortName(child_element))
+                self.readISignalIPduGroup(child_element, group)
             elif tag_name == "CAN-CLUSTER":
-                self.readCanCluster(child_element, parent)
+                cluster = parent.createCanCluster(self.getShortName(child_element))
+                self.readCanCluster(child_element, cluster)
             elif tag_name == "CAN-FRAME":
-                self.readCanFrame(child_element, parent)
+                frame = parent.createCanFrame(self.getShortName(child_element))
+                self.readCanFrame(child_element, frame)
             elif tag_name == "I-SIGNAL":
-                self.readISignal(child_element, parent)
+                signal = parent.createISignal(self.getShortName(child_element))
+                self.readISignal(child_element, signal)
             elif tag_name == "I-SIGNAL-GROUP":
-                self.readISignalGroup(child_element, parent)
+                group = parent.createISignalGroup(self.getShortName(child_element))
+                self.readISignalGroup(child_element, group)
             elif tag_name == "I-SIGNAL-I-PDU":
-                self.readISignalIPdu(child_element, parent)
+                i_pdu = parent.createISignalIPdu(self.getShortName(child_element))
+                self.readISignalIPdu(child_element, i_pdu)
             elif tag_name == "SYSTEM-SIGNAL":
-                self.readSystemSignal(child_element, parent)
+                signal = parent.createSystemSignal(self.getShortName(child_element))
+                self.readSystemSignal(child_element, signal)
             elif tag_name == "SYSTEM-SIGNAL-GROUP":
-                self.readSystemSignalGroup(child_element, parent)
+                group = parent.createSystemSignalGroup(self.getShortName(child_element))
+                self.readSystemSignalGroup(child_element, group)
             elif tag_name == "ECUC-VALUE-COLLECTION":
-                self.readEcucValueCollection(child_element, parent)
+                collection = parent.createEcucValueCollection(self.getShortName(child_element))
+                self.readEcucValueCollection(child_element, collection)
             elif tag_name == "ECUC-MODULE-CONFIGURATION-VALUES":
-                self.readEcucModuleConfigurationValues(child_element, parent)
+                values = parent.createEcucModuleConfigurationValues(self.getShortName(child_element))
+                self.readEcucModuleConfigurationValues(child_element, values)
             elif tag_name == "PHYSICAL-DIMENSION":
-                self.readPhysicalDimensions(child_element, parent)
+                dimension = parent.createPhysicalDimension(self.getShortName(child_element))
+                self.readPhysicalDimension(child_element, dimension)
             elif tag_name == "PARAMETER-INTERFACE":
-                self.readParameterInterface(child_element, parent)
+                param_interface = parent.createParameterInterface(self.getShortName(child_element))
+                self.readParameterInterface(child_element, param_interface)
             elif tag_name == "ETHERNET-FRAME":
-                self.readGenericEthernetFrame(child_element, parent)
+                frame = parent.createGenericEthernetFrame(self.getShortName(child_element))
+                self.readGenericEthernetFrame(child_element, frame)
             elif tag_name == "LIFE-CYCLE-INFO-SET":
-                self.readLifeCycleInfoSet(child_element, parent)
+                info_set = parent.createLifeCycleInfoSet(self.getShortName(child_element))
+                self.readLifeCycleInfoSet(child_element, info_set)
             elif tag_name == "FLAT-MAP":
-                self.readFlatMap(child_element, parent)
+                map = parent.createFlatMap(self.getShortName(child_element))
+                self.readFlatMap(child_element, map)
             elif tag_name == "PORT-INTERFACE-MAPPING-SET":
-                self.readPortInterfaceMappingSet(child_element, parent)
+                mapping_set = parent.createPortInterfaceMappingSet(self.getShortName(child_element))
+                self.readPortInterfaceMappingSet(child_element, mapping_set)
             elif tag_name == "ETHERNET-CLUSTER":
-                self.readEthernetCluster(child_element, parent)
+                cluster = parent.createEthernetCluster(self.getShortName(child_element))
+                self.readEthernetCluster(child_element, cluster)
             elif tag_name == "DIAGNOSTIC-CONNECTION":
                 connection = parent.createDiagnosticConnection(self.getShortName(child_element))
                 self.readDiagnosticConnection(child_element, connection)
             elif tag_name == "DIAGNOSTIC-SERVICE-TABLE":
-                self.readDiagnosticServiceTable(child_element, parent)
+                table = parent.createDiagnosticServiceTable(self.getShortName(child_element))
+                self.readDiagnosticServiceTable(child_element, table)
             elif tag_name == "MULTIPLEXED-I-PDU":
-                self.readMultiplexedIPdu(child_element, parent)
+                i_pdu = parent.createMultiplexedIPdu(self.getShortName(child_element))
+                self.readMultiplexedIPdu(child_element, i_pdu)
             elif tag_name == "USER-DEFINED-I-PDU":
-                self.readUserDefinedIPdu(child_element, parent)
+                i_pdu = parent.createUserDefinedIPdu(self.getShortName(child_element))
+                self.readUserDefinedIPdu(child_element, i_pdu)
             elif tag_name == "USER-DEFINED-PDU":
-                self.readUserDefinedPdu(child_element, parent)
+                pdu = parent.createUserDefinedPdu(self.getShortName(child_element))
+                self.readUserDefinedPdu(child_element, pdu)
             elif tag_name == "GENERAL-PURPOSE-PDU":
-                self.readGeneralPurposePdu(child_element, parent)
+                pdu = parent.createGeneralPurposePdu(self.getShortName(child_element))
+                self.readGeneralPurposePdu(child_element, pdu)
             elif tag_name == "GENERAL-PURPOSE-I-PDU":
-                self.readGeneralPurposeIPdu(child_element, parent)
+                i_pdu = parent.createGeneralPurposeIPdu(self.getShortName(child_element))
+                self.readGeneralPurposeIPdu(child_element, i_pdu)
             elif tag_name == "SECURE-COMMUNICATION-PROPS-SET":
-                self.readSecureCommunicationPropsSet(child_element, parent)
+                prop_set = parent.createSecureCommunicationPropsSet(self.getShortName(child_element))
+                self.readSecureCommunicationPropsSet(child_element, prop_set)
             elif tag_name == "SO-AD-ROUTING-GROUP":
-                self.readSoAdRoutingGroup(child_element, parent)
+                group = parent.createSoAdRoutingGroup(self.getShortName(child_element))
+                self.readSoAdRoutingGroup(child_element, group)
             elif tag_name == "DO-IP-TP-CONFIG":
-                self.readDoIpTpConfig(child_element, parent)
+                config = parent.createDoIpTpConfig(self.getShortName(child_element))
+                self.readDoIpTpConfig(child_element, config)
             else:
                 self.notImplemented("Unsupported element type of ARPackage <%s>" % tag_name)
 
@@ -3840,12 +4497,12 @@ class ARXMLParser(AbstractARXMLParser):
             self.readReferenceBases(child_element, ar_package)
 
     def load(self, filename, document: AUTOSAR):
-        self.logger.info("Load %s ..." % os.path.realpath(filename))
+        self.logger.info("Loading %s ..." % os.path.realpath(filename))
 
         tree = ET.parse(filename)
         root = tree.getroot()
         if (self.getPureTagName(root.tag) != "AUTOSAR"):
-            self._raiseError("Invalid ARXML file <%s>" % filename)
+            self.raiseError("Invalid ARXML file <%s>" % filename)
 
         self.getAUTOSARInfo(root, document)
         document.setAdminData(self.getAdminData(root, "ADMIN-DATA"))