armodel 1.7.6__py3-none-any.whl → 1.7.8__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -5,7 +5,9 @@ import os
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 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.ComputationMethod import CompuConstContent, CompuConstFormulaContent, CompuConstNumericContent, CompuMethod, Compu
+from ..models.M2.MSR.AsamHdo.ComputationMethod import CompuConst, CompuConstTextContent, CompuNominatorDenominator, CompuRationalCoeffs, CompuScale
+from ..models.M2.MSR.AsamHdo.ComputationMethod import 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
@@ -22,82 +24,180 @@ from ..models.M2.MSR.Documentation.Annotation import Annotation, GeneralAnnotati
 from ..models.M2.MSR.Documentation.TextModel.BlockElements import DocumentationBlock
 from ..models.M2.MSR.Documentation.TextModel.BlockElements.ListElements import ListElement
 from ..models.M2.MSR.Documentation.TextModel.LanguageDataModel import LLongName, LOverviewParagraph, LParagraph, LanguageSpecific
-from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultiLanguagePlainText, MultilanguageLongName
+from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultiLanguagePlainText
+from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import 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 BswApiOptions, BswBackgroundEvent, BswCalledEntity, BswDataReceivedEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswOperationInvokedEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswDataReceptionPolicy, BswExternalTriggerOccurredEvent, BswInternalBehavior
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalTriggerOccurredEvent, BswInterruptEntity, BswModeSwitchEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswModuleEntity, BswQueuedDataReceptionPolicy, BswSchedulableEntity
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswScheduleEvent, BswModeSenderPolicy, BswTimingEvent, BswVariableAccess
 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, ConstantSpecification, NumericalValueSpecification, RecordValueSpecification, TextValueSpecification, ValueSpecification
+from ..models.M2.AUTOSARTemplates.CommonStructure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference
+from ..models.M2.AUTOSARTemplates.CommonStructure import ConstantSpecification, NumericalValueSpecification, RecordValueSpecification
+from ..models.M2.AUTOSARTemplates.CommonStructure import TextValueSpecification, ValueSpecification
 from ..models.M2.AUTOSARTemplates.CommonStructure.Filter import DataFilter
 from ..models.M2.AUTOSARTemplates.CommonStructure.FlatMap import FlatInstanceDescriptor, FlatMap
 from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import ImplementationProps, Code
+from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity, InternalBehavior
 from ..models.M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroup, ModeRequestTypeMap, ModeDeclarationGroupPrototype
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import ResourceConsumption
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.MemorySectionUsage import MemorySection
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import RoughEstimateStackUsage, StackUsage
-from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity, InternalBehavior
 from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
-from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceAlgorithm, DiagEventDebounceMonitorInternal, DiagnosticEventNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import EcuStateMgrUserNeeds, NvBlockNeeds, RoleBasedDataAssignment
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import RoleBasedDataTypeAssignment, ServiceDependency
 from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import Implementation
 from ..models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import ExecutionOrderConstraint
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingExtensions import SwcTiming, TimingExtension
+from ..models.M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger
 from ..models.M2.AUTOSARTemplates.DiagnosticExtract.DiagnosticContribution import DiagnosticServiceTable
-from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue, EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue, EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
+from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue
+from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue
+from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
+from ..models.M2.AUTOSARTemplates.EcuResourceTemplate import HwDescriptionEntity, HwElement, HwPinGroup
+from ..models.M2.AUTOSARTemplates.EcuResourceTemplate.HwElementCategory import HwAttributeDef, HwCategory, HwType
 from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
-from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Describable, Identifiable
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Referrable, MultilanguageReferrable
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage, ReferenceBase
-from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Ip6AddressString, RefType, ARLiteral
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import 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 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.Datatype.Datatypes import ApplicationPrimitiveDataType, ApplicationRecordDataType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationDataType, AutosarDataType, DataTypeMap, DataTypeMappingSet
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionISignalIPdu, EndToEndProtectionSet
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndDescription, EndToEndProtection
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionVariablePrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import 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.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
-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.Communication import CompositeNetworkRepresentation, ModeSwitchedAckRequest
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import TransmissionAcknowledgementRequest
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import ClientComSpec, ModeSwitchReceiverComSpec, ModeSwitchSenderComSpec
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import NonqueuedReceiverComSpec, NonqueuedSenderComSpec, ParameterRequireComSpec
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import QueuedReceiverComSpec, QueuedSenderComSpec, ReceiverComSpec, SenderComSpec
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import ServerComSpec
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, PRPortPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import ApplicationSwComponentType, ComplexDeviceDriverSwComponentType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import CompositionSwComponentType, EcuAbstractionSwComponentType, PortGroup
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import SensorActuatorSwComponentType, ServiceSwComponentType, SwComponentType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import SymbolProps, PPortPrototype, RPortPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AtomicSwComponentType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import InnerPortGroupInCompositionInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import ModeGroupInAtomicSwcInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import PModeGroupInAtomicSwcInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import RModeGroupInAtomicSWCInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import RModeInAtomicSwcInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import RVariableInAtomicSwcInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import AssemblySwConnector, DelegationSwConnector, SwComponentPrototype, SwConnector
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationCompositeElementDataPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationRecordElement, AutosarDataPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import DataPrototype, ParameterDataPrototype, VariableDataPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ArgumentDataPrototype, ClientServerInterface, ClientServerOperation
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import DataPrototypeMapping, InvalidationPolicy, ModeSwitchInterface
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ParameterInterface, PortInterface, PortInterfaceMappingSet
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import SenderReceiverInterface, TriggerInterface, DataInterface
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import VariableAndParameterInterfaceMapping
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcImplementation import SwcImplementation
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior import RunnableEntity, RunnableEntityArgument, SwcInternalBehavior
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AutosarVariableRef import AutosarVariableRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import AssemblySwConnector, DelegationSwConnector
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet, ModeAccessPoint
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import VariableInAtomicSWCTypeInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import ModeAccessPoint, ModeSwitchPoint
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption, PortDefinedArgumentValue
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, BackgroundEvent
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import ModeSwitchedAckEvent, OperationInvokedEvent, RTEEvent
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import SwcModeSwitchEvent, TimingEvent
 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, 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.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
 
-from ..models.M2.AUTOSARTemplates.SystemTemplate import SwcToEcuMapping , System, SystemMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate import SwcToEcuMapping, System, SystemMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderRecCompositeTypeMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderRecRecordElementMapping, SenderRecRecordTypeMapping
 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.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
-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, Frame, FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignal, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalTriggering, MultiplexedIPdu, NPdu, NmPdu, PduTriggering, SecureCommunicationPropsSet, SecuredIPdu, 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.EcuResourceMapping import ECUMapping
 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.Fibex4Can.CanTopology import AbstractCanCommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import AbstractCanCommunicationControllerAttributes
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import CanCommunicationConnector, CanCommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import CanControllerConfigurationRequirements
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import CanControllerFdConfiguration
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import CanControllerFdConfigurationRequirements
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SoAdRoutingGroup, SocketConnection
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SocketConnectionBundle
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import 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, 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.Fibex4Ethernet.EthernetTopology import CouplingPort, CouplingPortDetails, CouplingPortFifo
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import CouplingPortScheduler, CouplingPortStructuralElement
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import EthernetCluster, EthernetCommunicationConnector
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import EthernetCommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import EthernetPriorityRegeneration, InitialSdDelayConfig
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import MacMulticastGroup, RequestResponseDelay, SdClientConfig
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import VlanMembership
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import DoIpEntity, InfrastructureServices, Ipv6Configuration
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import NetworkEndpoint
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import ApplicationEndpoint, ConsumedEventGroup
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import ConsumedServiceInstance, EventHandler, GenericTp
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import ProvidedServiceInstance, SdServerConfig, SoAdConfig
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import SocketAddress, TcpTp, TpPort
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import TransportProtocolConfiguration, UdpTp
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Flexray.FlexrayCommunication import FlexrayAbsolutelyScheduledTiming, FlexrayFrame
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Flexray.FlexrayCommunication import FlexrayFrameTriggering
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Flexray.FlexrayTopology import FlexrayCluster, FlexrayCommunicationConnector
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Flexray.FlexrayTopology import FlexrayCommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import ApplicationEntry, LinFrameTriggering, LinScheduleTable
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import LinUnconditionalFrame, ScheduleTableEntry
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinCommunicationController, LinMaster
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Multiplatform import Gateway, IPduMapping, ISignalMapping, TargetIPduRef
-from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpConfig, DoIpTpConfig, LinTpConfig
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import DcmIPdu, DynamicPart, DynamicPartAlternative, Frame
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import IPdu, IPduTiming, ISignal, ISignalGroup, ISignalIPdu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import ISignalIPduGroup, ISignalToIPduMapping, ISignalTriggering
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import MultiplexedIPdu, MultiplexedPart, NPdu, NmPdu, Pdu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import PduTriggering, SecureCommunicationAuthenticationProps
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import SecureCommunicationFreshnessProps, SecureCommunicationProps
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import SecureCommunicationPropsSet, SecuredIPdu, SegmentPosition
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import StaticPart, SystemSignal, SystemSignalGroup
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import UserDefinedIPdu, UserDefinedPdu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanClusterBusOffRecovery
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import FlexrayPhysicalChannel, CycleRepetition, CommunicationCycle
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import CanPhysicalChannel, CommConnectorPort, CommunicationCluster
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import CommunicationConnector, CommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import LinCluster, LinPhysicalChannel, PhysicalChannel
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import CyclicTiming, EventControlledTiming, TimeRangeType
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import TransmissionModeCondition, TransmissionModeDeclaration
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import TransmissionModeTiming
+from ..models.M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
+from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmEcu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmEcu, UdpNmNode
+from ..models.M2.AUTOSARTemplates.SystemTemplate.SWmapping import SwcToImplMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Transformer import BufferProperties, DataTransformation, DataTransformationSet
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Transformer import EndToEndTransformationISignalProps, TransformationISignalProps
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Transformer import EndToEndTransformationDescription, TransformationDescription
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Transformer import TransformationTechnology
+from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpAddress, CanTpChannel, CanTpConfig, CanTpConnection, CanTpEcu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpNode, DoIpLogicAddress, DoIpTpConfig, DoIpTpConnection, LinTpConfig
+from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import LinTpConnection, LinTpNode, TpAddress, TpConfig, TpConnection
 
 from .abstract_arxml_parser import AbstractARXMLParser
 
+
 class ARXMLParser(AbstractARXMLParser):
     def __init__(self, options=None) -> None:
         super().__init__(options)
@@ -110,7 +210,7 @@ class ARXMLParser(AbstractARXMLParser):
             range.setLowerCanId(self.getChildElementOptionalNumericalValue(child_element, "LOWER-CAN-ID")) \
                  .setUpperCanId(self.getChildElementOptionalNumericalValue(child_element, "UPPER-CAN-ID"))
         return range
-        
+
     def readSd(self, element: ET.Element, sdg: Sdg):
         for child_element in self.findall(element, "./SD"):
             sd = Sd()
@@ -119,33 +219,51 @@ 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):
-        for child_element in self.findall(element, "SDGS/SDG"):
-            admin_data.addSdg(self.getSdg(child_element))
+        for child_element in self.findall(element, "SDGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SDG":
+                admin_data.addSdg(self.getSdg(child_element))
+            else:
+                self.notImplemented("Unsupported SDG <%s>" % tag_name)
     
     def getAdminData(self, element: ET.Element, key: str) -> AdminData:
         admin_data = None
         child_element = self.find(element, key)
         if child_element is not None:
-            self.logger.debug("readAdminData")
+            # self.logger.debug("Read AdminData")
             admin_data = AdminData()
             admin_data.setLanguage(self.getChildElementOptionalLiteral(child_element, "LANGUAGE")) \
                       .setUsedLanguages(self.getMultiLanguagePlainText(child_element, "USED-LANGUAGES"))
 
             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):
@@ -157,8 +275,11 @@ class ARXMLParser(AbstractARXMLParser):
         identifiable.setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY")) \
                     .setDesc(self.getMultiLanguageOverviewParagraph(element, "DESC")) \
                     .setIntroduction(self.getDocumentationBlock(element, "INTRODUCTION"))
-        
+
         identifiable.setAdminData(self.getAdminData(element, "ADMIN-DATA"))
+
+    def readARElement(self, element: ET.Element, ar_element: ARElement):
+        self.readIdentifiable(element, ar_element)
     
     def readLLongName(self, element: ET.Element, long_name: MultilanguageLongName):
         for child_element in self.findall(element, "L-4"):
@@ -166,7 +287,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.readARObjectAttributes(child_element, l4)
             l4.value = child_element.text
             if 'L' in child_element.attrib:
-                l4.l = child_element.attrib['L']
+                l4.l = child_element.attrib['L']            # noqa: E741
             long_name.addL4(l4)
     
     def getMultilanguageLongName(self, element: ET.Element, key: str) -> MultilanguageLongName:
@@ -184,7 +305,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.readARObjectAttributes(child_element, l2)
             l2.value = child_element.text
             if 'L' in child_element.attrib:
-                l2.l = child_element.attrib['L']
+                l2.l = child_element.attrib['L']        # noqa: E741
             paragraph.addL2(l2)
     
     def getMultiLanguageOverviewParagraph(self, element: ET.Element, key: str) -> MultiLanguageOverviewParagraph:
@@ -197,37 +318,37 @@ class ARXMLParser(AbstractARXMLParser):
         return paragraph
     
     def getVariableInAtomicSWCTypeInstanceRef(self, element: ET.Element) -> VariableInAtomicSWCTypeInstanceRef:
-        iref  = None
+        instance_ref = None
         if element is not None:
-            iref = VariableInAtomicSWCTypeInstanceRef()
-            self.readARObjectAttributes(element, iref)
-            iref.setPortPrototypeRef(self.getChildElementOptionalRefType(element, "PORT-PROTOTYPE-REF"))
-            iref.setTargetDataPrototypeRef(self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF"))
-        return iref
+            instance_ref = VariableInAtomicSWCTypeInstanceRef()
+            self.readARObjectAttributes(element, instance_ref)
+            instance_ref.setPortPrototypeRef(self.getChildElementOptionalRefType(element, "PORT-PROTOTYPE-REF"))
+            instance_ref.setTargetDataPrototypeRef(self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF"))
+        return instance_ref
     
     def getComponentInSystemInstanceRef(self, element: ET.Element) -> ComponentInSystemInstanceRef:
-        iref  = None
+        instance_ref = None
         if element is not None:
-            iref = ComponentInSystemInstanceRef()
-            self.readARObjectAttributes(element, iref)
-            iref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF"))
-            iref.setContextCompositionRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF"))
-            iref.setTargetComponentRef(self.getChildElementOptionalRefType(element, "TARGET-COMPONENT-REF"))
-        return iref
+            instance_ref = ComponentInSystemInstanceRef()
+            self.readARObjectAttributes(element, instance_ref)
+            instance_ref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF"))
+            instance_ref.setContextCompositionRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF"))
+            instance_ref.setTargetComponentRef(self.getChildElementOptionalRefType(element, "TARGET-COMPONENT-REF"))
+        return instance_ref
 
-    def getAutosarVariableRef(self, element: ET.Element, key: str) ->  AutosarVariableRef:
+    def getAutosarVariableRef(self, element: ET.Element, key: str) -> AutosarVariableRef:
         child_element = self.find(element, key)
-        ref  = None
+        instance_ref = None
         if (child_element is not None):
-            ref = AutosarVariableRef()
-            #self.readARObjectAttributes(child_element, ref)
-            ref.setAutosarVariableIRef(self.getVariableInAtomicSWCTypeInstanceRef(self.find(child_element, "AUTOSAR-VARIABLE-IREF"))) \
-               .setLocalVariableRef(self.getChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF"))
-        return ref
+            instance_ref = AutosarVariableRef()
+            # self.readARObjectAttributes(child_element, ref)
+            instance_ref.setAutosarVariableIRef(self.getVariableInAtomicSWCTypeInstanceRef(self.find(child_element, "AUTOSAR-VARIABLE-IREF"))) \
+                        .setLocalVariableRef(self.getChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF"))
+        return instance_ref
 
-    def getLocalVariableRef(self, element: ET.Element, key: str) ->  AutosarVariableRef:
+    def getLocalVariableRef(self, element: ET.Element, key: str) -> AutosarVariableRef:
         child_element = self.find(element, key)
-        ref  = None
+        ref = None
         if (child_element is not None):
             ref = AutosarVariableRef()
             ref.setLocalVariableRef(self.getChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF"))
@@ -265,31 +386,34 @@ class ARXMLParser(AbstractARXMLParser):
 
             self.readIdentifiable(child_element, variable_access)
 
-    def readBswModuleDescriptionImplementedEntry(self, element: ET.Element, parent: BswModuleDescription):
+    def readBswModuleDescriptionImplementedEntryRefs(self, element: ET.Element, parent: BswModuleDescription):
         for child_element in self.findall(element, "PROVIDED-ENTRYS/BSW-MODULE-ENTRY-REF-CONDITIONAL"):
-            ref = self.getChildElementOptionalRefType(child_element, "BSW-MODULE-ENTRY-REF") 
+            ref = self.getChildElementOptionalRefType(child_element, "BSW-MODULE-ENTRY-REF")
             if (ref is not None):
-                parent.addImplementedEntry(ref)
+                parent.addImplementedEntryRef(ref)
             self.logger.debug("ImplementedEntry <%s> of BswModuleDescription <%s> has been added", ref.value, parent.getShortName())
 
     def readModeDeclarationGroupPrototype(self, element: ET.Element, prototype: ModeDeclarationGroupPrototype):
         self.readIdentifiable(element, prototype)
-        prototype.type_tref = self.getChildElementOptionalRefType(element, "TYPE-TREF")
-
-    def readProvidedModeGroup(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in self.findall(element, "PROVIDED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE"):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readProvidedModeGroup %s" % short_name)
+        prototype.setTypeTRef(self.getChildElementOptionalRefType(element, "TYPE-TREF"))
 
-            mode_group = parent.createProvidedModeGroup(short_name)
-            self.readModeDeclarationGroupPrototype(child_element, mode_group)
+    def readBswModuleDescriptionProvidedModeGroups(self, element: ET.Element, parent: BswModuleDescription):
+        for child_element in self.findall(element, "PROVIDED-MODE-GROUPS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "MODE-DECLARATION-GROUP-PROTOTYPE":
+                mode_group = parent.createProvidedModeGroup(self.getShortName(child_element))
+                self.readModeDeclarationGroupPrototype(child_element, mode_group)
+            else:
+                self.notImplemented("Unsupported ProvidedModeGroup <%s>" % tag_name)
 
-    def readRequiredModeGroup(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in self.findall(element, "REQUIRED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE"):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readRequiredModeGroup %s" % short_name)
-            mode_group = parent.createProvidedModeGroup(short_name)
-            mode_group.type_tref = self.getChildElementRefType(parent.getShortName(), child_element, "TYPE-TREF")
+    def readBswModuleDescriptionRequiredModeGroups(self, element: ET.Element, parent: BswModuleDescription):
+        for child_element in self.findall(element, "REQUIRED-MODE-GROUPS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "MODE-DECLARATION-GROUP-PROTOTYPE":
+                prototype = parent.createProvidedModeGroup(self.getShortName(child_element))
+                self.readModeDeclarationGroupPrototype(child_element, prototype)
+            else:
+                self.notImplemented("Unsupported RequiredModeGroup <%s>" % tag_name)
 
     def readCanEnterExclusiveAreaRefs(self, element: ET.Element, entity: ExecutableEntity):
         for ref in self.getChildElementRefTypeList(element, "CAN-ENTER-EXCLUSIVE-AREA-REFS/CAN-ENTER-EXCLUSIVE-AREA-REF"):
@@ -302,8 +426,8 @@ class ARXMLParser(AbstractARXMLParser):
         entity.setMinimumStartInterval(self.getChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL")) \
               .setSwAddrMethodRef(self.getChildElementOptionalRefType(element, "SW-ADDR-METHOD-REF"))
 
-    def readBswModuleEntityManagedModeGroup(self, element: ET.Element, entity: BswModuleEntity):
-        for child_element in self.findall(element, "sMANAGED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE-REF-CONDITIONAL"):
+    def readBswModuleEntityManagedModeGroups(self, element: ET.Element, entity: BswModuleEntity):
+        for child_element in self.findall(element, "MANAGED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE-REF-CONDITIONAL"):
             ref_type = self.getChildElementOptionalRefType(child_element, "MODE-DECLARATION-GROUP-PROTOTYPE-REF")
             if ref_type is not None:
                 entity.addManagedModeGroupRef(ref_type)
@@ -315,12 +439,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"))
@@ -330,13 +454,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"))
@@ -362,10 +486,22 @@ class ARXMLParser(AbstractARXMLParser):
                 behavior.addDataTypeMappingRef(ref)
 
     def readInternalBehaviorConstantMemories(self, element: ET.Element, behavior: InternalBehavior):
-        for child_element in self.findall(element, "CONSTANT-MEMORYS/PARAMETER-DATA-PROTOTYPE"):
-            short_name = self.getShortName(child_element)
-            prototype = behavior.createConstantMemory(short_name)
-            self.readParameterDataPrototype(child_element, prototype)
+        for child_element in self.findall(element, "CONSTANT-MEMORYS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "PARAMETER-DATA-PROTOTYPE":
+                prototype = behavior.createConstantMemory(self.getShortName(child_element))
+                self.readParameterDataPrototype(child_element, prototype)
+            else:
+                self.notImplemented("Unsupported constant memories <%s>" % tag_name)
+
+    def readInternalBehaviorStaticMemories(self, element: ET.Element, behavior: InternalBehavior):
+        for child_element in self.findall(element, "STATIC-MEMORYS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "VARIABLE-DATA-PROTOTYPE":
+                prototype = behavior.createStaticMemory(self.getShortName(child_element))
+                self.readVariableDataPrototype(child_element, prototype)
+            else:
+                self.notImplemented("Unsupported static memories <%s>" % tag_name)
 
     def readInternalBehavior(self, element: ET.Element, behavior: InternalBehavior):
         self.readIdentifiable(element, behavior)
@@ -374,6 +510,7 @@ class ARXMLParser(AbstractARXMLParser):
             short_name = self.getShortName(child_element)
             behavior.createExclusiveArea(short_name)
         self.readDataTypeMappingRefs(element, behavior)
+        self.readInternalBehaviorStaticMemories(element, behavior)
 
     def getRoleBasedDataAssignment(self, element: ET.Element) -> RoleBasedDataAssignment:
         assignment = RoleBasedDataAssignment()
@@ -420,10 +557,8 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.raiseError("Unsupported assigned ports <%s>" % tag_name)
 
-    def readNvBlockNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        short_name = self.getShortName(element)
-        needs = parent.createNvBlockNeeds(short_name)
-        self.logger.debug("read NvBlockNeeds %s" % short_name)
+    def readNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
+        self.logger.debug("Read NvBlockNeeds <%s>" % needs.getShortName())
         self.readIdentifiable(element, needs)
         needs.setCalcRamBlockCrc(self.getChildElementOptionalBooleanValue(element, "CALC-RAM-BLOCK-CRC")) \
              .setCheckStaticBlockId(self.getChildElementOptionalBooleanValue(element, "CHECK-STATIC-BLOCK-ID")) \
@@ -445,25 +580,19 @@ class ARXMLParser(AbstractARXMLParser):
              .setWritingFrequency(self.getChildElementOptionalPositiveInteger(element, "WRITING-FREQUENCY")) \
              .setWritingPriority(self.getChildElementOptionalLiteral(element, "WRITING-PRIORITY"))
         
-    def reaDiagnosticCommunicationManagerNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        short_name = self.getShortName(element)
-        needs = parent.createDiagnosticCommunicationManagerNeeds(short_name)
-        self.logger.debug("read DiagnosticCommunicationManagerNeeds %s" % short_name)
+    def reaDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
+        self.logger.debug("Read DiagnosticCommunicationManagerNeeds <%s>" % needs.getShortName())
         self.readIdentifiable(element, needs)
         needs.setServiceRequestCallbackType(self.getChildElementOptionalLiteral(element, "SERVICE-REQUEST-CALLBACK-TYPE"))
 
-    def readDiagnosticRoutineNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        short_name = self.getShortName(element)
-        needs = parent.createDiagnosticRoutineNeeds(short_name)
-        self.logger.debug("read DiagnosticRoutineNeeds %s" % short_name)
+    def readDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
+        self.logger.debug("Read DiagnosticRoutineNeeds %s" % needs.getShortName())
         self.readIdentifiable(element, needs)
         needs.setDiagRoutineType(self.getChildElementOptionalLiteral(element, "DIAG-ROUTINE-TYPE")) \
              .setRidNumber(self.getChildElementOptionalIntegerValue(element, "RID-NUMBER"))
 
-    def readDiagnosticValueNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        short_name = self.getShortName(element)
-        needs = parent.createDiagnosticValueNeeds(short_name)
-        self.logger.debug("read DiagnosticValueNeeds %s" % short_name)
+    def readDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
+        self.logger.debug("Read DiagnosticValueNeeds %s" % needs.getShortName())
         self.readIdentifiable(element, needs)
         needs.setDataLength(self.getChildElementOptionalPositiveInteger(element, "DATA-LENGTH")) \
              .setDiagnosticValueAccess(self.getChildElementOptionalLiteral(element, "DIAGNOSTIC-VALUE-ACCESS")) \
@@ -483,54 +612,54 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported DiagEventDebounceAlgorithm <%s>" % tag_name)
     
-    def readDiagnosticEventNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        short_name = self.getShortName(element)
-        needs = parent.createDiagnosticEventNeeds(short_name)
-        self.logger.debug("Read DiagnosticEventNeeds %s" % short_name)
+    def readDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
+        self.logger.debug("Read DiagnosticEventNeeds <%s>" % needs.getShortName())
         self.readIdentifiable(element, needs)
         self.readDiagEventDebounceAlgorithm(element, needs)
         needs.setDtcKind(self.getChildElementOptionalLiteral(element, "DTC-KIND")) \
              .setUdsDtcNumber(self.getChildElementOptionalIntegerValue(element, "UDS-DTC-NUMBER"))
         
-    def readDiagnosticEventInfoNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        short_name = self.getShortName(element)
-        needs = parent.createDiagnosticEventInfoNeeds(short_name)
-        self.logger.debug("Read DiagnosticEventInfoNeeds %s" % short_name)
+    def readDiagnosticEventInfoNeeds(self, element: ET.Element, needs: DiagnosticEventInfoNeeds):
+        self.logger.debug("Read DiagnosticEventInfoNeeds <%s>" % needs.getShortName())
         self.readIdentifiable(element, needs)
         needs.setUdsDtcNumber(self.getChildElementOptionalPositiveInteger(element, "UDS-DTC-NUMBER"))
 
-    def readCryptoServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        short_name = self.getShortName(element)
-        needs = parent.createCryptoServiceNeeds(short_name)
-        self.logger.debug("Read DiagnosticValueNeeds %s" % short_name)
+    def readCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
+        self.logger.debug("Read CryptoServiceNeeds <%s>" % needs.getShortName())
         self.readIdentifiable(element, needs)
         needs.setMaximumKeyLength(self.getChildElementOptionalPositiveInteger(element, "MAXIMUM-KEY-LENGTH"))
 
-    def readEcuStateMgrUserNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        short_name = self.getShortName(element)
-        needs = parent.createEcuStateMgrUserNeeds(short_name)
-        self.logger.debug("read DiagnosticValueNeeds %s" % short_name)
+    def readEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
+        self.logger.debug("read EcuStateMgrUserNeeds %s" % needs.getShortName())
         self.readIdentifiable(element, needs)
 
     def readSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         for child_element in self.findall(element, "SERVICE-NEEDS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "NV-BLOCK-NEEDS":
-                self.readNvBlockNeeds(child_element, parent)    
+                needs = parent.createNvBlockNeeds(self.getShortName(child_element))
+                self.readNvBlockNeeds(child_element, needs)
             elif tag_name == "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS":
-                self.reaDiagnosticCommunicationManagerNeeds(child_element, parent)
+                needs = parent.createDiagnosticCommunicationManagerNeeds(self.getShortName(child_element))
+                self.reaDiagnosticCommunicationManagerNeeds(child_element, needs)
             elif tag_name == "DIAGNOSTIC-ROUTINE-NEEDS":
-                self.readDiagnosticRoutineNeeds(child_element, parent)
+                needs = parent.createDiagnosticRoutineNeeds(self.getShortName(child_element))
+                self.readDiagnosticRoutineNeeds(child_element, needs)
             elif tag_name == "DIAGNOSTIC-VALUE-NEEDS":
-                self.readDiagnosticValueNeeds(child_element, parent)
+                needs = parent.createDiagnosticValueNeeds(self.getShortName(child_element))
+                self.readDiagnosticValueNeeds(child_element, needs)
             elif tag_name == "DIAGNOSTIC-EVENT-NEEDS":
-                self.readDiagnosticEventNeeds(child_element, parent)
+                needs = parent.createDiagnosticEventNeeds(self.getShortName(child_element))
+                self.readDiagnosticEventNeeds(child_element, needs)
             elif tag_name == "DIAGNOSTIC-EVENT-INFO-NEEDS":
-                self.readDiagnosticEventInfoNeeds(child_element, parent)
+                needs = parent.createDiagnosticEventInfoNeeds(self.getShortName(child_element))
+                self.readDiagnosticEventInfoNeeds(child_element, needs)
             elif tag_name == "CRYPTO-SERVICE-NEEDS":
-                self.readCryptoServiceNeeds(child_element, parent)
+                needs = parent.createCryptoServiceNeeds(self.getShortName(child_element))
+                self.readCryptoServiceNeeds(child_element, needs)
             elif tag_name == "ECU-STATE-MGR-USER-NEEDS":
-                self.readEcuStateMgrUserNeeds(child_element, parent)
+                needs = parent.createEcuStateMgrUserNeeds(self.getShortName(child_element))
+                self.readEcuStateMgrUserNeeds(child_element, needs)
             else:
                 self.notImplemented("Unsupported service needs <%s>" % tag_name)
 
@@ -573,28 +702,47 @@ class ARXMLParser(AbstractARXMLParser):
             prototype = behavior.createSharedParameter(short_name)
             self.readParameterDataPrototype(child_element, prototype)
 
-    def readSwcInternalBehavior(self, element: ET.Element, parent: AtomicSwComponentType):
-        for child_element in self.findall(element, "INTERNAL-BEHAVIORS/SWC-INTERNAL-BEHAVIOR"):
-            short_name = self.getShortName(child_element)
-            behavior = parent.createSwcInternalBehavior(short_name)
-            self.logger.debug("readSwcInternalBehavior %s" % behavior.full_name)
+    def readIncludedModeDeclarationGroupSet(self, element: ET.Element, group_set: IncludedModeDeclarationGroupSet):
+        for ref in self.getChildElementRefTypeList(element, "MODE-DECLARATION-GROUP-REFS/MODE-DECLARATION-GROUP-REF"):
+            group_set.addModeDeclarationGroupRef(ref)
+        group_set.setPrefix(self.getChildElementOptionalLiteral(element, "PREFIX"))
 
-            # read the internal behavior
-            self.readInternalBehavior(child_element, behavior)
-            
-            # read the extra SwcInternalBehavior
-            self.readSwcInternalBehaviorArTypedPerInstanceMemories(child_element, behavior)
-            self.readSwcInternalBehaviorRunnables(child_element, behavior)
-            self.readSwcInternalBehaviorEvents(child_element, behavior)
-            self.readSwcInternalBehaviorServiceDependencies(child_element, behavior)
-            self.readExplicitInterRunnableVariables(child_element, behavior)
-            
-            behavior.setHandleTerminationAndRestart(self.getChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART"))
-            self.readPerInstanceMemories(child_element, behavior)
-            self.readPerInstanceParameters(child_element, behavior)
-            self.readPortAPIOptions(child_element, behavior)
-            self.readSwcInternalBehaviorSharedParameters(child_element, behavior)
-            behavior.setSupportsMultipleInstantiation(self.getChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION"))
+    def readSwcInternalBehaviorIncludedModeDeclarationGroupSets(self, element: ET.Element, behavior: SwcInternalBehavior):
+        for child_element in self.findall(element, "INCLUDED-MODE-DECLARATION-GROUP-SETS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "INCLUDED-MODE-DECLARATION-GROUP-SET":
+                group_set = IncludedModeDeclarationGroupSet()
+                self.readIncludedModeDeclarationGroupSet(child_element, group_set)
+                behavior.addIncludedModeDeclarationGroupSet(group_set)
+            else:
+                self.notImplemented("Unsupported IncludedModeDeclarationGroupSet <%s>" % tag_name)
+
+    def readSwcInternalBehavior(self, element: ET.Element, behavior: SwcInternalBehavior):
+        # read the internal behavior
+        self.readInternalBehavior(element, behavior)
+        
+        # read the extra SwcInternalBehavior
+        self.readSwcInternalBehaviorArTypedPerInstanceMemories(element, behavior)
+        self.readSwcInternalBehaviorEvents(element, behavior)
+        self.readSwcInternalBehaviorExplicitInterRunnableVariables(element, behavior)
+        behavior.setHandleTerminationAndRestart(self.getChildElementOptionalLiteral(element, "HANDLE-TERMINATION-AND-RESTART"))
+        self.readSwcInternalBehaviorIncludedModeDeclarationGroupSets(element, behavior)
+        self.readSwcInternalBehaviorPerInstanceMemories(element, behavior)
+        self.readSwcInternalBehaviorPerInstanceParameters(element, behavior)
+        self.readSwcInternalBehaviorPortAPIOptions(element, behavior)
+        self.readSwcInternalBehaviorRunnables(element, behavior)
+        self.readSwcInternalBehaviorServiceDependencies(element, behavior)
+        self.readSwcInternalBehaviorSharedParameters(element, behavior)
+        behavior.setSupportsMultipleInstantiation(self.getChildElementOptionalBooleanValue(element, "SUPPORTS-MULTIPLE-INSTANTIATION"))
+
+    def readAtomicSwComponentTypeSwcInternalBehavior(self, element: ET.Element, parent: AtomicSwComponentType):
+        for child_element in self.findall(element, "INTERNAL-BEHAVIORS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SWC-INTERNAL-BEHAVIOR":
+                behavior = parent.createSwcInternalBehavior(self.getShortName(child_element))
+                self.readSwcInternalBehavior(child_element, behavior)
+            else:
+                self.notImplemented("Unsupported Internal Behaviors <%s>" % tag_name)
 
     def getIncludedModeDeclarationGroupSets(self, element: ET.Element) -> List[IncludedModeDeclarationGroupSet]:
         group_sets = []
@@ -605,10 +753,39 @@ class ARXMLParser(AbstractARXMLParser):
             group_sets.append(group_set)
         return group_sets
     
+    def readBswVariableAccess(self, element: ET.Element, access: BswVariableAccess):
+        self.readReferrable(element, access)
+        access.setAccessedVariableRef(self.getChildElementOptionalRefType(element, "ACCESSED-VARIABLE-REF"))
+    
+    def readBswModuleEntityDataSendPoints(self, element: ET.Element, entity: BswModuleEntity):
+        for child_element in self.findall(element, "DATA-SEND-POINTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-VARIABLE-ACCESS":
+                point = entity.createDataSendPoint(self.getShortName(child_element))
+                self.readBswVariableAccess(child_element, point)
+            else:
+                self.notImplemented("Unsupported Data Send Point <%s>" % tag_name)
+
+    def readBswModuleEntityDataReceiverPoints(self, element: ET.Element, entity: BswModuleEntity):
+        for child_element in self.findall(element, "DATA-RECEIVE-POINTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-VARIABLE-ACCESS":
+                point = entity.createDataReceivePoint(self.getShortName(child_element))
+                self.readBswVariableAccess(child_element, point)
+            else:
+                self.notImplemented("Unsupported Data Receive Point <%s>" % tag_name)
+
+    def readBswModuleEntityIssuedTriggerRefs(self, element: ET.Element, entity: BswModuleEntity):
+        for ref in self.getChildElementRefTypeList(element, "ISSUED-TRIGGERS/TRIGGER-REF-CONDITIONAL/TRIGGER-REF"):
+            entity.addIssuedTriggerRef(ref)
+    
     def readBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
         self.readExecutableEntity(element, entity)
+        self.readBswModuleEntityDataReceiverPoints(element, entity)
+        self.readBswModuleEntityDataSendPoints(element, entity)
         entity.setImplementedEntryRef(self.getChildElementRefType(entity.getShortName(), element, "IMPLEMENTED-ENTRY-REF"))
-        self.readBswModuleEntityManagedModeGroup(element, entity)
+        self.readBswModuleEntityManagedModeGroups(element, entity)
+        self.readBswModuleEntityIssuedTriggerRefs(element, entity)
     
     def readBswCalledEntity(self, element: ET.Element, entity: BswCalledEntity):
         self.logger.debug("read BswCalledEntity %s" % entity.getShortName())
@@ -630,7 +807,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "BSW-CALLED-ENTITY":
                 entity = behavior.createBswCalledEntity(self.getShortName(child_element))
                 self.readBswCalledEntity(child_element, entity)
-            elif tag_name == "BSW-SCHEDULABLE-ENTITY":  
+            elif tag_name == "BSW-SCHEDULABLE-ENTITY":
                 entity = behavior.createBswSchedulableEntity(self.getShortName(child_element))
                 self.readBswSchedulableEntity(child_element, entity)
             elif tag_name == "BSW-INTERRUPT-ENTITY":
@@ -639,13 +816,24 @@ 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 readBswOperationInvokedEvent(self, element: ET.Element, event: BswOperationInvokedEvent):
+        self.readBswEvent(element, event)
+        event.setEntryRef(self.getChildElementOptionalRefType(element, "ENTRY-REF"))
+
     def readBswInternalBehaviorEvents(self, element: ET.Element, behavior: BswInternalBehavior):
         for child_element in self.findall(element, "EVENTS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "BSW-MODE-SWITCH-EVENT":
                 event = behavior.createBswModeSwitchEvent(self.getShortName(child_element))
                 self.readBswModeSwitchEvent(child_element, event)
-            elif tag_name == "BSW-TIMING-EVENT":  
+            elif tag_name == "BSW-TIMING-EVENT":
                 event = behavior.createBswTimingEvent(self.getShortName(child_element))
                 self.readBswTimingEvent(child_element, event)
             elif tag_name == "BSW-DATA-RECEIVED-EVENT":
@@ -654,35 +842,116 @@ 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)
+            elif tag_name == "BSW-OPERATION-INVOKED-EVENT":
+                event = behavior.createBswOperationInvokedEvent(self.getShortName(child_element))
+                self.readBswOperationInvokedEvent(child_element, event)
             else:
                 self.notImplemented("Unsupported BswModuleEntity <%s>" % tag_name)
 
-    def readBswInternalBehavior(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in self.findall(element, "INTERNAL-BEHAVIORS/BSW-INTERNAL-BEHAVIOR"):
-            short_name = self.getShortName(child_element)
-            behavior = parent.createBswInternalBehavior(short_name)
-            self.logger.debug("read BswInternalBehavior %s" % behavior.full_name)
-
-            # read the internal behavior
-            self.readInternalBehavior(child_element, behavior)
-            self.readBswInternalBehaviorEntities(child_element, behavior)
-            self.readBswInternalBehaviorEvents(child_element, behavior)
-            self.readBswInternalBehaviorModeSenderPolicy(child_element, behavior)
-            for group_set in self.getIncludedModeDeclarationGroupSets(child_element):
-                behavior.addIncludedModeDeclarationGroupSet(group_set)
+    def readBswApiOptions(self, element: ET.Element, options: BswApiOptions):
+        self.readARObjectAttributes(element, options)
+        options.setEnableTakeAddress(self.getChildElementOptionalBooleanValue(element, "ENABLE-TAKE-ADDRESS"))
+
+    def readBswDataReceptionPolicy(self, element: ET.Element, policy: BswDataReceptionPolicy):
+        self.readBswApiOptions(element, policy)
+        policy.setReceivedDataRef(self.getChildElementOptionalRefType(element, "RECEIVED-DATA-REF"))
+
+    def readBswQueuedDataReceptionPolicy(self, element: ET.Element, policy: BswQueuedDataReceptionPolicy):
+        self.readBswDataReceptionPolicy(element, policy)
+        policy.setQueueLength(self.getChildElementOptionalPositiveInteger(element, "QUEUE-LENGTH"))
+
+    def readBswInternalBehaviorReceptionPolicies(self, element: ET.Element, behavior: BswInternalBehavior):
+        for child_element in self.findall(element, "RECEPTION-POLICYS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-QUEUED-DATA-RECEPTION-POLICY":
+                policy = BswQueuedDataReceptionPolicy()
+                self.readBswQueuedDataReceptionPolicy(child_element, policy)
+                behavior.addReceptionPolicy(policy)
+            else:
+                self.notImplemented("Unsupported Reception Policies <%s>" % tag_name)
+
+    def readBswInternalBehavior(self, element: ET.Element, behavior: BswInternalBehavior):
+        self.logger.debug("Read BswInternalBehavior <%s>" % behavior.full_name)
+
+        # read the internal behavior
+        self.readInternalBehavior(element, behavior)
+        self.readBswInternalBehaviorEntities(element, behavior)
+        self.readBswInternalBehaviorEvents(element, behavior)
+        self.readBswInternalBehaviorModeSenderPolicy(element, behavior)
+        for group_set in self.getIncludedModeDeclarationGroupSets(element):
+            behavior.addIncludedModeDeclarationGroupSet(group_set)
+        self.readBswInternalBehaviorReceptionPolicies(element, behavior)
+
+    def readBswModuleDescriptionBswInternalBehaviors(self, element: ET.Element, desc: BswModuleDescription):
+        for child_element in self.findall(element, "INTERNAL-BEHAVIORS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-INTERNAL-BEHAVIOR":
+                behavior = desc.createBswInternalBehavior(self.getShortName(child_element))
+                self.readBswInternalBehavior(child_element, behavior)
+            else:
+                self.notImplemented("Unsupported Internal Behavior <%s>" % tag_name)
+
+    def readTrigger(self, element: ET.Element, trigger: Trigger):
+        self.readIdentifiable(element, trigger)
+
+    def readBswModuleDescriptionReleasedTriggers(self, element: ET.Element, desc: BswModuleDescription):
+        for child_element in self.findall(element, "RELEASED-TRIGGERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "TRIGGER":
+                trigger = desc.createReleasedTrigger(self.getShortName(child_element))
+                self.readTrigger(child_element, trigger)
+            else:
+                self.notImplemented("Unsupported Released Trigger <%s>" % tag_name)
+
+    def readBswModuleDescriptionRequiredTriggers(self, element: ET.Element, desc: BswModuleDescription):
+        for child_element in self.findall(element, "REQUIRED-TRIGGERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "TRIGGER":
+                trigger = desc.createRequiredTrigger(self.getShortName(child_element))
+                self.readTrigger(child_element, trigger)
+            else:
+                self.notImplemented("Unsupported Required Trigger <%s>" % tag_name)
+
+    def readBswModuleDescriptionProvidedDatas(self, element: ET.Element, desc: BswModuleDescription):
+        for child_element in self.findall(element, "PROVIDED-DATAS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "VARIABLE-DATA-PROTOTYPE":
+                data = desc.createProvidedData(self.getShortName(child_element))
+                self.readVariableDataPrototype(child_element, data)
+            else:
+                self.notImplemented("Unsupported Provided Data <%s>" % tag_name)
+
+    def readBswModuleDescriptionRequiredDatas(self, element: ET.Element, desc: BswModuleDescription):
+        for child_element in self.findall(element, "REQUIRED-DATAS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "VARIABLE-DATA-PROTOTYPE":
+                data = desc.createRequiredData(self.getShortName(child_element))
+                self.readVariableDataPrototype(child_element, data)
+            else:
+                self.notImplemented("Unsupported Required Data <%s>" % tag_name)
 
     def readBswModuleDescription(self, element: ET.Element, desc: BswModuleDescription):
         self.logger.debug("Read BswModuleDescription <%s>" % desc.getShortName())
 
         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)
+        self.readBswModuleDescriptionImplementedEntryRefs(element, desc)
+        self.readBswModuleDescriptionProvidedModeGroups(element, desc)
+        self.readBswModuleDescriptionRequiredModeGroups(element, desc)
+        self.readBswModuleDescriptionReleasedTriggers(element, desc)
+        self.readBswModuleDescriptionRequiredTriggers(element, desc)
+        self.readBswModuleDescriptionProvidedDatas(element, desc)
+        self.readBswModuleDescriptionRequiredDatas(element, desc)
+        self.readBswModuleDescriptionBswInternalBehaviors(element, desc)
 
     def readSwServiceArg(self, element: ET.Element, arg: SwServiceArg):
-        self.logger.debug("Read SwServiceArg <%s>" % arg.getShortName())
+        self.readIdentifiable(element, arg)
         arg.setDirection(self.getChildElementOptionalLiteral(element, "DIRECTION")) \
            .setSwDataDefProps(self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS"))
 
@@ -746,7 +1015,7 @@ class ARXMLParser(AbstractARXMLParser):
             memory_section = consumption.createMemorySection(self.getShortName(child_element))
             self.readIdentifiable(child_element, memory_section)
             memory_section.setAlignment(self.getChildElementOptionalLiteral(child_element, "ALIGNMENT")) \
-                          .setMemClassSymbol(self.getChildElementOptionalLiteral(child_element, "MEM-CLASS-SYMBOL")) 
+                          .setMemClassSymbol(self.getChildElementOptionalLiteral(child_element, "MEM-CLASS-SYMBOL"))
             self.readMemorySectionOptions(child_element, memory_section)
             memory_section.setSize(self.getChildElementOptionalNumericalValue(child_element, "SIZE")) \
                           .setSwAddrMethodRef(self.getChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF")) \
@@ -798,27 +1067,30 @@ class ARXMLParser(AbstractARXMLParser):
         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"))
+            .setBehaviorRef(self.getChildElementOptionalRefType(element, "BEHAVIOR-REF")) \
+            .setVendorApiInfix(self.getChildElementOptionalLiteral(element, "VENDOR-API-INFIX"))
         self.readBswImplementationVendorSpecificModuleDefRefs(element, impl)
+        AUTOSAR.getInstance().addImplementationBehaviorMap(impl.getFullName(), impl.getBehaviorRef().getValue())
 
     def readSwcImplementation(self, element: ET.Element, impl: SwcImplementation):
         self.logger.debug("Read SwcImplementation <%s>" % impl.getShortName())
         self.readImplementation(element, impl)
         impl.setBehaviorRef(self.getChildElementOptionalRefType(element, "BEHAVIOR-REF"))
+        AUTOSAR.getInstance().addImplementationBehaviorMap(impl.getFullName(), impl.getBehaviorRef().getValue())
 
-    def readDataReceivePointByArguments(self, element, parent: RunnableEntity):
+    def readRunnableEntityDataReceivePointByArguments(self, element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-RECEIVE-POINT-BY-ARGUMENTS")
 
-    def readDataReceivePointByValues(self, element: ET.Element, parent: RunnableEntity):
+    def readRunnableEntityDataReceivePointByValues(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-RECEIVE-POINT-BY-VALUES")
 
-    def readDataReadAccesses(self, element: ET.Element, parent: RunnableEntity):
+    def readRunnableEntityDataReadAccesses(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-READ-ACCESSS")
 
-    def readDataWriteAccesses(self, element: ET.Element, parent: RunnableEntity):
+    def readRunnableEntityDataWriteAccesses(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-WRITE-ACCESSS")
 
-    def readDataSendPoints(self, element: ET.Element, parent: RunnableEntity):
+    def readRunnableEntityDataSendPoints(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-SEND-POINTS")
 
     def getRunnableEntityArgument(self, element: ET.Element) -> RunnableEntityArgument:
@@ -834,17 +1106,17 @@ class ARXMLParser(AbstractARXMLParser):
             parameter.setLocalParameterRef(self.getChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF"))
         return parameter
 
-    def readParameterAccesses(self, element: ET.Element, parent: RunnableEntity):
+    def readRunnableEntityParameterAccesses(self, element: ET.Element, parent: RunnableEntity):
         for child_element in self.findall(element, "PARAMETER-ACCESSS/PARAMETER-ACCESS"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readParameterAccesses %s" % short_name)
             parameter_access = parent.createParameterAccess(short_name)
             parameter_access.setAccessedParameter(self.getAutosarParameterRef(child_element, "ACCESSED-PARAMETER"))
 
-    def readWrittenLocalVariables(self, element: ET.Element, parent: RunnableEntity):
+    def readRunnableEntityWrittenLocalVariables(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "WRITTEN-LOCAL-VARIABLES")
 
-    def readReadLocalVariables(self, element: ET.Element, parent: RunnableEntity):
+    def readRunnableEntityReadLocalVariables(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "READ-LOCAL-VARIABLES")
 
     def readROperationIRef(self, element: ET.Element, key: str, parent: ServerCallPoint):
@@ -869,7 +1141,7 @@ class ARXMLParser(AbstractARXMLParser):
             mode_iref = RModeInAtomicSwcInstanceRef()
             mode_iref.setContextPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF")) \
                      .setContextModeDeclarationGroupPrototypeRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")) \
-                     .setTargetModeDeclarationRef(self.getChildElementOptionalRefType(child_element, "TARGET-MODE-DECLARATION-REF"))
+                     .setTargetModeDeclarationRef(self.getChildElementOptionalRefType(child_element, "TARGET-MODE-DECLARATION-REF"))            # NOQA E501
             parent.addModeIRef(mode_iref)
 
     def readSynchronousServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
@@ -888,7 +1160,7 @@ class ARXMLParser(AbstractARXMLParser):
         server_call_point.setTimeout(self.getChildElementOptionalFloatValue(element, "TIMEOUT"))
         self.readROperationIRef(element, "OPERATION-IREF", server_call_point)
 
-    def readInternalBehaviorServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
+    def readRunnableEntityInternalBehaviorServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
         for child_element in self.findall(element, "SERVER-CALL-POINTS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "SYNCHRONOUS-SERVER-CALL-POINT":
@@ -898,48 +1170,73 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.raiseError("Unsupported server call point type <%s>" % tag_name)
 
-    def readInternalTriggeringPoints(self, element: ET.Element, parent: RunnableEntity):
+    def readRunnableEntityInternalTriggeringPoints(self, element: ET.Element, parent: RunnableEntity):
         for child_element in self.findall(element, "INTERNAL-TRIGGERING-POINTS/INTERNAL-TRIGGERING-POINT"):
             short_name = self.getShortName(child_element)
             point = parent.createInternalTriggeringPoint(short_name)
             point.sw_impl_policy = self.getChildElementOptionalLiteral(child_element, "SW-IMPL-POLICY")
 
-    def getRModeInAtomicSwcInstanceRef(self, element: ET.Element) -> RModeInAtomicSwcInstanceRef:
-        iref = RModeInAtomicSwcInstanceRef()
-        iref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF")) \
-            .setContextPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")) \
-            .setContextModeDeclarationGroupPrototypeRef(self.getChildElementOptionalRefType(element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")) \
-            .setTargetModeDeclarationRef(self.getChildElementOptionalRefType(element, "TARGET-MODE-DECLARATION-REF"))
-        return iref
-    
-    def getRModeGroupInAtomicSWCInstanceRef(self, element: ET.Element) -> RModeGroupInAtomicSWCInstanceRef:
-        child_element = self.find(element, "MODE-GROUP-IREF/R-MODE-GROUP-IN-ATOMIC-SWC-INSTANCE-REF")
-        iref = None
-        if child_element is not None:
-            iref = RModeGroupInAtomicSWCInstanceRef()
-            iref.setContextRPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")) \
-                .setTargetModeGroupRef(self.getChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF"))
-        return iref
-    
-    def getPModeGroupInAtomicSWCInstanceRef(self, element: ET.Element) -> PModeGroupInAtomicSwcInstanceRef:
+    def readModeGroupInAtomicSwcInstanceRef(self, element: ET.Element, instance_ref: ModeGroupInAtomicSwcInstanceRef):
+        instance_ref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF")) \
+                    .setContextPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF"))
+
+    def readRModeGroupInAtomicSWCInstanceRef(self, element: ET.Element, instance_ref: RModeGroupInAtomicSWCInstanceRef):
+        self.readModeGroupInAtomicSwcInstanceRef(element, instance_ref)
+        instance_ref.setContextRPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-R-PORT-REF")) \
+                    .setTargetModeGroupRef(self.getChildElementOptionalRefType(element, "TARGET-MODE-GROUP-REF"))
+
+    def readPModeGroupInAtomicSWCInstanceRef(self, element: ET.Element, instance_ref: PModeGroupInAtomicSwcInstanceRef):
+        self.readModeGroupInAtomicSwcInstanceRef(element, instance_ref)
+        instance_ref.setContextPPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-P-PORT-REF")) \
+                    .setTargetModeGroupRef(self.getChildElementOptionalRefType(element, "TARGET-MODE-GROUP-REF"))
+
+    def getModeGroupIRef(self, element: ET.Element, key: str) -> ModeGroupInAtomicSwcInstanceRef:
+        instance_ref = None
+        for child_element in self.findall(element, "%s/*" % key):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "P-MODE-GROUP-IN-ATOMIC-SWC-INSTANCE-REF":
+                instance_ref = PModeGroupInAtomicSwcInstanceRef()
+                self.readPModeGroupInAtomicSWCInstanceRef(child_element, instance_ref)
+            elif tag_name == "R-MODE-GROUP-IN-ATOMIC-SWC-INSTANCE-REF":
+                instance_ref = RModeGroupInAtomicSWCInstanceRef()
+                self.readRModeGroupInAtomicSWCInstanceRef(child_element, instance_ref)
+            else:
+                self.notImplemented("Unsupported Mode Group IRef <%s>" % tag_name)
+        return instance_ref
+
+    def readModeAccessPoint(self, element: ET.Element, point: ModeAccessPoint):
+        self.readARObjectAttributes(element, point)
+        point.setModeGroupIRef(self.getModeGroupIRef(element, "MODE-GROUP-IREF"))
+
+    def readRunnableEntityModeAccessPoints(self, element: ET.Element, entity: RunnableEntity):
+        for child_element in self.findall(element, "MODE-ACCESS-POINTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "MODE-ACCESS-POINT":
+                point = ModeAccessPoint()
+                self.readModeAccessPoint(child_element, point)
+                entity.addModeAccessPoint(point)
+            else:
+                self.notImplemented("Unsupported Mode Access Point <%s>" % tag_name)
+
+    def readModeSwitchPointModeGroupIRef(self, element: ET.Element, point: ModeSwitchPoint):
         child_element = self.find(element, "MODE-GROUP-IREF")
-        iref = None
         if child_element is not None:
-            iref = PModeGroupInAtomicSwcInstanceRef()
-            iref.setContextPPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-P-PORT-REF")) \
-                .setTargetModeGroupRef(self.getChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF"))
-        return iref
+            instance_ref = PModeGroupInAtomicSwcInstanceRef()
+            self.readPModeGroupInAtomicSWCInstanceRef(child_element, instance_ref)
+            point.setModeGroupIRef(instance_ref)
 
-    def readModeAccessPoints(self, element: ET.Element, parent: RunnableEntity):
-        for child_element in self.findall(element, "MODE-ACCESS-POINTS/MODE-ACCESS-POINT"):
-            point = ModeAccessPoint()
-            point.setModeGroupIRef(self.getRModeGroupInAtomicSWCInstanceRef(child_element))
-            parent.addModeAccessPoint(point)
-
-    def readModeSwitchPoints(self, element: ET.Element, parent: RunnableEntity):
-        for child_element in self.findall(element, "MODE-SWITCH-POINTS/MODE-SWITCH-POINT"):
-            point = parent.createModeSwitchPoint(self.getShortName(child_element))
-            point.setModeGroupIRef(self.getPModeGroupInAtomicSWCInstanceRef(child_element))
+    def readModeSwitchPoint(self, element: ET.Element, point: ModeSwitchPoint):
+        self.readARObjectAttributes(element, point)
+        self.readModeSwitchPointModeGroupIRef(element, point)
+    
+    def readRunnableEntityModeSwitchPoints(self, element: ET.Element, parent: RunnableEntity):
+        for child_element in self.findall(element, "MODE-SWITCH-POINTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "MODE-SWITCH-POINT":
+                point = parent.createModeSwitchPoint(self.getShortName(child_element))
+                self.readModeSwitchPoint(child_element, point)
+            else:
+                self.notImplemented("Unsupported Mode Switch Point <%s>" % tag_name)
 
     def readRunnableEntityArguments(self, element: ET.Element, entity: RunnableEntity):
         for child_element in self.findall(element, "ARGUMENTS/*"):
@@ -949,7 +1246,7 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported Arguments of runnable entity <%s>" % tag_name)
 
-    def readAsynchronousServerCallResultPoint(self, element: ET.Element, entity: RunnableEntity):
+    def readRunnableEntityAsynchronousServerCallResultPoint(self, element: ET.Element, entity: RunnableEntity):
         for child_element in self.findall(element, "ASYNCHRONOUS-SERVER-CALL-RESULT-POINTS/ASYNCHRONOUS-SERVER-CALL-RESULT-POINT"):
             point = entity.createAsynchronousServerCallResultPoint(self.getShortName(child_element))
             self.readIdentifiable(child_element, point)
@@ -959,38 +1256,39 @@ class ARXMLParser(AbstractARXMLParser):
         self.readExecutableEntity(element, entity)
         self.readRunnableEntityArguments(element, entity)
 
-        self.readAsynchronousServerCallResultPoint(element, entity)
+        self.readRunnableEntityAsynchronousServerCallResultPoint(element, entity)
         entity.setCanBeInvokedConcurrently(self.getChildElementOptionalBooleanValue(element, "CAN-BE-INVOKED-CONCURRENTLY"))
-        self.readDataReadAccesses(element, entity)
-        self.readDataReceivePointByArguments(element, entity)
-        self.readDataReceivePointByValues(element, entity)
-        self.readDataWriteAccesses(element, entity)
-        self.readDataSendPoints(element, entity)
-        self.readInternalBehaviorServerCallPoint(element, entity)
-        self.readInternalTriggeringPoints(element, entity)
-        self.readModeAccessPoints(element, entity)
-        self.readModeSwitchPoints(element, entity)
-        self.readParameterAccesses(element, entity)
-        self.readReadLocalVariables(element, entity)
-        self.readWrittenLocalVariables(element, entity)
+        self.readRunnableEntityDataReadAccesses(element, entity)
+        self.readRunnableEntityDataReceivePointByArguments(element, entity)
+        self.readRunnableEntityDataReceivePointByValues(element, entity)
+        self.readRunnableEntityDataWriteAccesses(element, entity)
+        self.readRunnableEntityDataSendPoints(element, entity)
+        self.readRunnableEntityInternalBehaviorServerCallPoint(element, entity)
+        self.readRunnableEntityInternalTriggeringPoints(element, entity)
+        self.readRunnableEntityModeAccessPoints(element, entity)
+        self.readRunnableEntityModeSwitchPoints(element, entity)
+        self.readRunnableEntityParameterAccesses(element, entity)
+        self.readRunnableEntityReadLocalVariables(element, entity)
+        self.readRunnableEntityWrittenLocalVariables(element, entity)
 
         entity.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
 
     def readSwcInternalBehaviorRunnables(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in self.findall(element, "RUNNABLES/RUNNABLE-ENTITY"):
-            short_name = self.getShortName(child_element)
-            entity = parent.createRunnableEntity(short_name)
-            self.logger.debug("readRunnableEntities %s" % short_name)
-            
-            self.readRunnableEntity(child_element, entity)
+        for child_element in self.findall(element, "RUNNABLES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "RUNNABLE-ENTITY":
+                entity = parent.createRunnableEntity(self.getShortName(child_element))
+                self.readRunnableEntity(child_element, entity)
+            else:
+                self.notImplemented("Unsupported Runnables <%s>" % tag_name)
 
     def getRModeInAtomicSwcInstanceRef(self, element: ET.Element) -> RModeInAtomicSwcInstanceRef:
-        iref = RModeInAtomicSwcInstanceRef()
-        iref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF")) \
+        instance_ref = RModeInAtomicSwcInstanceRef()
+        instance_ref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF")) \
             .setContextPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")) \
             .setContextModeDeclarationGroupPrototypeRef(self.getChildElementOptionalRefType(element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")) \
-            .setTargetModeDeclarationRef(self.getChildElementOptionalRefType(element, "TARGET-MODE-DECLARATION-REF"))
-        return iref
+            .setTargetModeDeclarationRef(self.getChildElementOptionalRefType(element, "TARGET-MODE-DECLARATION-REF"))       # NOQA E501
+        return instance_ref
 
     def readRTEEvent(self, element: ET.Element, event: RTEEvent):
         self.readIdentifiable(element, event)
@@ -1005,12 +1303,11 @@ class ARXMLParser(AbstractARXMLParser):
             operation_iref = POperationInAtomicSwcInstanceRef()
             self.readARObjectAttributes(child_element, operation_iref)
             operation_iref.setContextPPortRef(self.getChildElementRefType(parent.getShortName(), child_element, "CONTEXT-P-PORT-REF")) \
-                          .setTargetProvidedOperationRef(self.getChildElementRefType(parent.getShortName(), child_element, "TARGET-PROVIDED-OPERATION-REF"))
+                          .setTargetProvidedOperationRef(self.getChildElementRefType(parent.getShortName(), child_element, "TARGET-PROVIDED-OPERATION-REF"))    # NOQA E501
             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)
 
@@ -1018,13 +1315,13 @@ class ARXMLParser(AbstractARXMLParser):
         self.readAutosarDataPrototype(element, prototype)
         prototype.setInitValue(self.getInitValue(element))
 
-    def readExplicitInterRunnableVariables(self, element: ET.Element, parent: SwcInternalBehavior):
+    def readSwcInternalBehaviorExplicitInterRunnableVariables(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in self.findall(element, "EXPLICIT-INTER-RUNNABLE-VARIABLES/VARIABLE-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = parent.createExplicitInterRunnableVariable(short_name)
             self.readVariableDataPrototype(child_element, prototype)
 
-    def readPerInstanceMemories(self, element: ET.Element, behavior: SwcInternalBehavior):
+    def readSwcInternalBehaviorPerInstanceMemories(self, element: ET.Element, behavior: SwcInternalBehavior):
         for child_element in self.findall(element, "PER-INSTANCE-MEMORYS/PER-INSTANCE-MEMORY"):
             short_name = self.getShortName(child_element)
             memory = behavior.createPerInstanceMemory(short_name)
@@ -1039,11 +1336,10 @@ class ARXMLParser(AbstractARXMLParser):
         prototype.setTypeTRef(self.getChildElementOptionalRefType(element, "TYPE-TREF"))
 
     def readParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
-        self.readIdentifiable(element, prototype)
         self.readAutosarDataPrototype(element, prototype)
         prototype.setInitValue(self.getInitValue(element))
 
-    def readPerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
+    def readSwcInternalBehaviorPerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
         for child_element in self.findall(element, "PER-INSTANCE-PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = behavior.createPerInstanceParameter(short_name)
@@ -1057,7 +1353,7 @@ class ARXMLParser(AbstractARXMLParser):
         argument_value.setValueTypeTRef(self.getChildElementOptionalRefType(element, "VALUE-TYPE-TREF"))
         return argument_value
 
-    def readPortAPIOptions(self, element: ET.Element, behavior: SwcInternalBehavior):
+    def readSwcInternalBehaviorPortAPIOptions(self, element: ET.Element, behavior: SwcInternalBehavior):
         for child_element in self.findall(element, "PORT-API-OPTIONS/PORT-API-OPTION"):
             option = PortAPIOption()
             option.setEnableTakeAddress(self.getChildElementOptionalBooleanValue(child_element, "ENABLE-TAKE-ADDRESS")) \
@@ -1068,60 +1364,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)
             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)
 
@@ -1146,7 +1458,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readARObjectAttributes(element, specific)
         specific.value = element.text
         if 'L' in element.attrib:
-            specific.l = element.attrib['L']
+            specific.l = element.attrib['L']        # noqa E741
 
     def getLParagraphs(self, element: ET.Element, key: str) -> List[LParagraph]:
         results = []
@@ -1155,7 +1467,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.readLanguageSpecific(child_element, l1)
             results.append(l1)
         return results
-    
+
     def getMultiLanguageParagraphs(self, element: ET.Element, key: str) -> List[MultiLanguageParagraph]:
         paragraphs = []
         for child_element in self.findall(element, key):
@@ -1186,7 +1498,7 @@ class ARXMLParser(AbstractARXMLParser):
             for block in self.getDocumentationBlockList(child_element, "ITEM"):
                 list.addItem(block)
             result.append(list)
-        return result       
+        return result
     
     def getMultiLanguagePlainText(self, element: ET.Element, key: str) -> MultiLanguagePlainText:
         paragraph = None
@@ -1228,10 +1540,14 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getAnnotations(self, element: ET.Element) -> List[Annotation]:
         annotations = []
-        for child_element in self.findall(element, "ANNOTATIONS/ANNOTATION"):
-            annotation = Annotation()
-            self.readGeneralAnnotation(child_element, annotation)
-            annotations.append(annotation)
+        for child_element in self.findall(element, "ANNOTATIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ANNOTATION":
+                annotation = Annotation()
+                self.readGeneralAnnotation(child_element, annotation)
+                annotations.append(annotation)
+            else:
+                self.notImplemented("Unsupported Annotation <%s>" % tag_name)
         return annotations
 
     def getSwAxisIndividual(self, element: ET.Element) -> SwAxisIndividual:
@@ -1300,12 +1616,12 @@ class ARXMLParser(AbstractARXMLParser):
                                  .setSwPointerTargetProps(self.getSwPointerTargetProps(conditional_tag, "SW-POINTER-TARGET-PROPS")) \
                                  .setSwRecordLayoutRef(self.getChildElementOptionalRefType(conditional_tag, "SW-RECORD-LAYOUT-REF")) \
                                  .setValueAxisDataTypeRef(self.getChildElementOptionalRefType(conditional_tag, "VALUE-AXIS-DATA-TYPE-REF")) \
-                                 .setUnitRef(self.getChildElementOptionalRefType(conditional_tag, "UNIT-REF")) 
+                                 .setUnitRef(self.getChildElementOptionalRefType(conditional_tag, "UNIT-REF"))
                 self.readSwDataDefProsInvalidValue(conditional_tag, sw_data_def_props)
-                #self.readSwPointerTargetProps(conditional_tag, sw_data_def_props)
+                # self.readSwPointerTargetProps(conditional_tag, sw_data_def_props)
                 self.readARObjectAttributes(conditional_tag, sw_data_def_props.conditional)
         return sw_data_def_props
-    
+
     def readAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
         self.readIdentifiable(element, data_type)
         data_type.setSwDataDefProps(self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS"))
@@ -1314,22 +1630,24 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("Read ApplicationPrimitiveDataType <%s>" % data_type.getShortName())
         self.readAutosarDataType(element, data_type)
 
-    def readApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
-        prototype.setTypeTRef(self.getChildElementOptionalRefType(element, "TYPE-TREF"))
+    def readApplicationRecordElement(self, element: ET.Element, record_element: ApplicationRecordElement):
+        self.logger.debug("read ApplicationRecordElement %s" % record_element.getShortName())
+        self.readApplicationCompositeElementDataPrototype(element, record_element)
 
-    def readApplicationRecordElements(self, element: ET.Element, parent: ApplicationRecordDataType):
-        for child_element in self.findall(element, "ELEMENTS/APPLICATION-RECORD-ELEMENT"):
-            short_name = self.getShortName(child_element)
-            record_element = parent.createApplicationRecordElement(short_name)
-            self.logger.debug("readApplicationRecordElements %s" % short_name)
-            self.readIdentifiable(child_element, record_element)
-            self.readApplicationCompositeElementDataPrototype(child_element, record_element)
+    def readApplicationRecordDataTypeElements(self, element: ET.Element, parent: ApplicationRecordDataType):
+        for child_element in self.findall(element, "ELEMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "APPLICATION-RECORD-ELEMENT":
+                record_element = parent.createApplicationRecordElement(self.getShortName(child_element))
+                self.readApplicationRecordElement(child_element, record_element)
+            else:
+                self.notImplemented("Unsupported ApplicationRecordDataType Element <%s>" % tag_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)
+        self.readApplicationRecordDataTypeElements(element, data_type)
 
     def readImplementationDataTypeElements(self, element: ET.Element, parent: ImplementationDataType):
         for child_element in self.findall(element, "SUB-ELEMENTS/IMPLEMENTATION-DATA-TYPE-ELEMENT"):
@@ -1361,7 +1679,8 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, data_type)
         self.readBaseTypeDirectDefinition(element, data_type.getBaseTypeDefinition())
 
-    def getApplicationCompositeElementInPortInterfaceInstanceRef(self, element: ET.Element, key:str) -> ApplicationCompositeElementInPortInterfaceInstanceRef:
+    def getApplicationCompositeElementInPortInterfaceInstanceRef(self, element: ET.Element, key: str) \
+            -> ApplicationCompositeElementInPortInterfaceInstanceRef:
         child_element = self.find(element, key)
         iref = None
         if child_element is not None:
@@ -1431,7 +1750,6 @@ class ARXMLParser(AbstractARXMLParser):
         value_spec = None
         child_element = self.find(element, "INIT-VALUE/*")
         if child_element is not None:
-            self.logger.debug("getInitValue")
             value_spec = self.getValueSpecification(child_element, self.getTagName(child_element))
         return value_spec
     
@@ -1465,7 +1783,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getNonqueuedReceiverComSpec(self, element: ET.Element) -> NonqueuedReceiverComSpec:
         com_spec = NonqueuedReceiverComSpec()
-        self.readARObjectAttributes(element, com_spec)            
+        self.readARObjectAttributes(element, com_spec)
         self.readReceiverComSpec(element, com_spec)
         com_spec.setAliveTimeout(self.getChildElementOptionalFloatValue(element, "ALIVE-TIMEOUT")) \
                 .setEnableUpdated(self.getChildElementOptionalBooleanValue(element, "ENABLE-UPDATE")) \
@@ -1494,10 +1812,8 @@ class ARXMLParser(AbstractARXMLParser):
     def readAbstractRequiredPortPrototype(self, element: ET.Element, prototype: AbstractRequiredPortPrototype):
         self.readProvidedComSpec(element, prototype)
 
-    def readPPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
-        short_name = self.getShortName(element)
-        self.logger.debug("readPPortPrototype %s" % short_name)
-        prototype = parent.createPPortPrototype(short_name)
+    def readPPortPrototype(self, element: ET.Element, prototype: PPortPrototype):
+        self.logger.debug("Read PPortPrototype %s" % prototype.getShortName())
         self.readIdentifiable(element, prototype)
         self.readAbstractRequiredPortPrototype(element, prototype)
         prototype.setProvidedInterfaceTRef(self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF"))
@@ -1505,34 +1821,33 @@ class ARXMLParser(AbstractARXMLParser):
     def readAbstractProvidedPortPrototype(self, element: ET.Element, prototype: AbstractProvidedPortPrototype):
         self.readRequiredComSpec(element, prototype)
 
-    def readRPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
-        short_name = self.getShortName(element)
-        self.logger.debug("read RPortPrototype %s" % short_name)
-        prototype = parent.createRPortPrototype(short_name)
+    def readRPortPrototype(self, element: ET.Element, prototype: RPortPrototype):
+        self.logger.debug("Read RPortPrototype %s" % prototype.getShortName())
         self.readIdentifiable(element, prototype)
         self.readAbstractProvidedPortPrototype(element, prototype)
         prototype.setRequiredInterfaceTRef(self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF"))
 
-    def readPRPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
-        short_name = self.getShortName(element)
-        self.logger.debug("read PRPortPrototype %s" % short_name)
-        prototype = parent.createPRPortPrototype(short_name)
+    def readPRPortPrototype(self, element: ET.Element, prototype: PRPortPrototype):
+        self.logger.debug("Read PRPortPrototype %s" % prototype.getShortName())
         self.readIdentifiable(element, prototype)
         self.readAbstractRequiredPortPrototype(element, prototype)
         self.readAbstractProvidedPortPrototype(element, prototype)
         prototype.setProvidedRequiredInterface(self.getChildElementOptionalRefType(element, "PROVIDED-REQUIRED-INTERFACE-TREF"))
 
-    def readAtomicSwComponentTypePorts(self, element: ET.Element, sw_component: AtomicSwComponentType):
+    def readSwComponentTypePorts(self, element: ET.Element, sw_component: SwComponentType):
         for child_element in self.findall(element, "PORTS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "P-PORT-PROTOTYPE":
-                self.readPPortPrototype(child_element, sw_component)
+                prototype = sw_component.createPPortPrototype(self.getShortName(child_element))
+                self.readPPortPrototype(child_element, prototype)
             elif tag_name == "R-PORT-PROTOTYPE":
-                self.readRPortPrototype(child_element, sw_component)
+                prototype = sw_component.createRPortPrototype(self.getShortName(child_element))
+                self.readRPortPrototype(child_element, prototype)
             elif tag_name == "PR-PORT-PROTOTYPE":
-                self.readPRPortPrototype(child_element, sw_component)
+                prototype = sw_component.createPRPortPrototype(self.getShortName(child_element))
+                self.readPRPortPrototype(child_element, prototype)
             else:
-                self.raiseError("Unsupported Port Prototype <%s>" % tag_name)
+                self.notImplemented("Unsupported Port Prototype <%s>" % tag_name)
 
     def readTransmissionAcknowledgementRequest(self, element: ET.Element) -> TransmissionAcknowledgementRequest:
         child_element = self.find(element, "TRANSMISSION-ACKNOWLEDGE")
@@ -1543,7 +1858,7 @@ class ARXMLParser(AbstractARXMLParser):
             return acknowledge
         return None
 
-    def readSenderComSpec(self, element:ET.Element, com_spec: SenderComSpec):
+    def readSenderComSpec(self, element: ET.Element, com_spec: SenderComSpec):
         self.readARObjectAttributes(element, com_spec)
         for child_element in self.findall(element, "COMPOSITE-NETWORK-REPRESENTATIONS/COMPOSITE-NETWORK-REPRESENTATION"):
             com_spec.addCompositeNetworkRepresentation(self.getCompositeNetworkRepresentation(child_element))
@@ -1553,27 +1868,36 @@ 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
 
@@ -1594,7 +1918,7 @@ class ARXMLParser(AbstractARXMLParser):
     def readPortGroupInnerGroupIRefs(self, element: ET.Element, parent: PortGroup):
         for child_element in self.findall(element, "INNER-GROUP-IREFS/INNER-GROUP-IREF"):
             inner_group_iref = InnerPortGroupInCompositionInstanceRef()
-            #inner_group_iref.contextRef = self.getChildElementOptionalRefType(child_element, "CONTEXT-REF")
+            # inner_group_iref.contextRef = self.getChildElementOptionalRefType(child_element, "CONTEXT-REF")
             inner_group_iref.setTargetRef(self.getChildElementOptionalRefType(child_element, "TARGET-REF"))
             parent.addInnerGroupIRef(inner_group_iref)
 
@@ -1620,12 +1944,12 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readSwComponentType(self, element: ET.Element, parent: SwComponentType):
         self.readIdentifiable(element, parent)
-        self.readAtomicSwComponentTypePorts(element, parent)
+        self.readSwComponentTypePorts(element, parent)
         self.readSwComponentTypePortGroups(element, parent)
 
     def readAtomicSwComponentType(self, element, parent: AtomicSwComponentType):
         self.readSwComponentType(element, parent)
-        self.readSwcInternalBehavior(element, parent)
+        self.readAtomicSwComponentTypeSwcInternalBehavior(element, parent)
 
     def readEcuAbstractionSwComponentType(self, element, sw_component: EcuAbstractionSwComponentType):
         self.logger.debug("Read EcuAbstractionSwComponentType <%s>" % sw_component.getShortName())
@@ -1653,9 +1977,11 @@ class ARXMLParser(AbstractARXMLParser):
         
         self.logger.debug("PPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
-                          % (p_port_in_composition_instance_ref.getContextComponentRef().getDest(), p_port_in_composition_instance_ref.getContextComponentRef().getValue()))
-        self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s" 
-                          % (p_port_in_composition_instance_ref.getTargetPPortRef().getDest(), p_port_in_composition_instance_ref.getTargetPPortRef().getValue()))
+                          % (p_port_in_composition_instance_ref.getContextComponentRef().getDest(),
+                             p_port_in_composition_instance_ref.getContextComponentRef().getValue()))
+        self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s"
+                          % (p_port_in_composition_instance_ref.getTargetPPortRef().getDest(),
+                             p_port_in_composition_instance_ref.getTargetPPortRef().getValue()))
 
     def readRPortInCompositionInstanceRef(self, element, r_port_in_composition_instance_ref: RPortInCompositionInstanceRef):
         r_port_in_composition_instance_ref.setContextComponentRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")) \
@@ -1663,9 +1989,11 @@ class ARXMLParser(AbstractARXMLParser):
 
         self.logger.debug("RPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
-                          % (r_port_in_composition_instance_ref.getContextComponentRef().getDest(), r_port_in_composition_instance_ref.getContextComponentRef().getValue()))
-        self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s" 
-                          % (r_port_in_composition_instance_ref.getTargetRPortRef().getDest(), r_port_in_composition_instance_ref.getTargetRPortRef().getValue()))
+                          % (r_port_in_composition_instance_ref.getContextComponentRef().getDest(),
+                             r_port_in_composition_instance_ref.getContextComponentRef().getValue()))
+        self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s"
+                          % (r_port_in_composition_instance_ref.getTargetRPortRef().getDest(),
+                             r_port_in_composition_instance_ref.getTargetRPortRef().getValue()))
 
     def readAssemblySwConnectorProviderIRef(self, element: ET.Element, parent: AssemblySwConnector):
         child_element = self.find(element, "PROVIDER-IREF")
@@ -1683,16 +2011,27 @@ class ARXMLParser(AbstractARXMLParser):
             self.readRPortInCompositionInstanceRef(child_element, requester_iref)
             parent.setRequesterIRef(requester_iref)
 
-    def readAssemblySwConnectors(self, element: ET.Element, parent: CompositionSwComponentType):
-        for child_element in self.findall(element, "CONNECTORS/ASSEMBLY-SW-CONNECTOR"):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readAssemblySwConnectors %s" % short_name)
+    def readSwConnector(self, element: ET.Element, connector: SwConnector):
+        self.readIdentifiable(element, connector)
+        connector.setMappingRef(self.getChildElementOptionalRefType(element, "MAPPING-REF"))
+
+    def readAssemblySwConnector(self, element: ET.Element, connector: AssemblySwConnector):
+        self.logger.debug("Read AssemblySwConnectors %s" % connector.getShortName())
+        self.readSwConnector(element, connector)
+        self.readAssemblySwConnectorProviderIRef(element, connector)
+        self.readAssemblySwConnectorRequesterIRef(element, connector)
 
-            connector = parent.createAssemblySwConnector(short_name)
-            self.readIdentifiable(child_element, connector)
-            connector.setMappingRef(self.getChildElementOptionalRefType(child_element, "MAPPING-REF"))
-            self.readAssemblySwConnectorProviderIRef(child_element, connector)
-            self.readAssemblySwConnectorRequesterIRef(child_element, connector)
+    def readCompositionSwComponentTypeSwConnectors(self, element: ET.Element, parent: CompositionSwComponentType):
+        for child_element in self.findall(element, "CONNECTORS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ASSEMBLY-SW-CONNECTOR":
+                connector = parent.createAssemblySwConnector(self.getShortName(child_element))
+                self.readAssemblySwConnector(child_element, connector)
+            elif tag_name == "DELEGATION-SW-CONNECTOR":
+                connector = parent.createDelegationSwConnector(self.getShortName(child_element))
+                self.readDelegationSwConnector(child_element, connector)
+            else:
+                self.notImplemented("Unsupported SwConnector <%s>" % tag_name)
 
     def readDelegationSwConnectorInnerPortIRef(self, element, parent: DelegationSwConnector):
         inner_port_iref_element = self.find(element, "INNER-PORT-IREF")
@@ -1713,45 +2052,45 @@ class ARXMLParser(AbstractARXMLParser):
             
             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"):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readDelegationSwConnectors %s" % short_name)
+    def readDelegationSwConnector(self, element, connector: DelegationSwConnector):
+        self.logger.debug("Read DelegationSwConnectors %s" % connector.getShortName())
+        self.readSwConnector(element, connector)
+        self.readDelegationSwConnectorInnerPortIRef(element, connector)
 
-            connector = parent.createDelegationSwConnector(short_name)
-            self.readIdentifiable(child_element, connector)
-            self.readDelegationSwConnectorInnerPortIRef(child_element, connector)
+        if connector.getInnerPortIRref() is None and connector.getOuterPortRef() is None:
+            self.raiseError("Invalid PortPrototype of DELEGATION-SW-CONNECTOR")
 
-            if connector.getInnerPortIRref() == None and connector.getOuterPortRef() == None:
-                self.raiseError("Invalid PortPrototype of DELEGATION-SW-CONNECTOR")
+        connector.setOuterPortRef(self.getChildElementOptionalRefType(element, "OUTER-PORT-REF"))
+        self.logger.debug("OUTER-PORT-REF DEST: %s, %s" % (connector.getOuterPortRef().getDest(), connector.getOuterPortRef().getValue()))
 
-            connector.setOuterPortRef(self.getChildElementOptionalRefType(child_element, "OUTER-PORT-REF"))
-            self.logger.debug("OUTER-PORT-REF DEST: %s, %s"
-                          % (connector.getOuterPortRef().getDest(), connector.getOuterPortRef().getValue()))
+    def readSwComponentPrototype(self, element: ET.Element, prototype: SwComponentPrototype):
+        self.logger.debug("Read SwComponentPrototypes <%s>" % prototype.getShortName())
+        self.readIdentifiable(element, prototype)
+        prototype.setTypeTRef(self.getChildElementOptionalRefType(element, "TYPE-TREF"))
 
-    def readSwComponentPrototypes(self, element: ET.Element, parent: CompositionSwComponentType):
-        for child_element in element.findall("./xmlns:COMPONENTS/xmlns:SW-COMPONENT-PROTOTYPE", self.nsmap):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readSwComponentPrototypes %s" % short_name)
-            prototype = parent.createSwComponentPrototype(short_name)
-            self.readIdentifiable(child_element, prototype)
-            prototype.typeTRef = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
+    def readCompositionSwComponentTypeComponents(self, element: ET.Element, parent: CompositionSwComponentType):
+        for child_element in self.findall(element, "COMPONENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SW-COMPONENT-PROTOTYPE":
+                prototype = parent.createSwComponentPrototype(self.getShortName(child_element))
+                self.readSwComponentPrototype(child_element, prototype)
+            else:
+                self.notImplemented("Unsupported Component <%s>" % tag_name)
 
     def readCompositionSwComponentTypeDataTypeMappingSet(self, element: ET.Element, parent: CompositionSwComponentType):
-        child_element = element.find("./xmlns:DATA-TYPE-MAPPING-REFS", self.nsmap)
+        child_element = self.find(element, "DATA-TYPE-MAPPING-REFS")
         self.logger.debug("readDataTypeMappingSet")
         if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-MAPPING-REF"):
+            for ref in self.getChildElementRefTypeList(child_element, "DATA-TYPE-MAPPING-REF"):
                 parent.addDataTypeMapping(ref)
 
     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.readCompositionSwComponentTypeComponents(element, type)
+        self.readCompositionSwComponentTypeSwConnectors(element, type)
         self.readCompositionSwComponentTypeDataTypeMappingSet(element, type)
+        AUTOSAR.getInstance().addCompositionSwComponentType(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):
@@ -1778,13 +2117,15 @@ class ARXMLParser(AbstractARXMLParser):
         self.readModeRequestTypeMaps(element, mapping_set)
 
     def readSenderReceiverInterfaceDataElements(self, element: ET.Element, sr_interface: SenderReceiverInterface):
-        for child_element in self.findall(element, "DATA-ELEMENTS/VARIABLE-DATA-PROTOTYPE"):
-            short_name = self.getShortName(child_element)
-            prototype = sr_interface.createDataElement(short_name)
-            self.readIdentifiable(child_element, prototype)
-            prototype.swDataDefProps = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
-            self.readAutosarDataPrototype(child_element, prototype)
-            prototype.initValue = self.getInitValue(child_element)
+        for child_element in self.findall(element, "DATA-ELEMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "VARIABLE-DATA-PROTOTYPE":
+                prototype = sr_interface.createDataElement(self.getShortName(child_element))
+                self.readVariableDataPrototype(child_element, prototype)
+                # prototype.swDataDefProps = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+                # self.readAutosarDataPrototype(child_element, prototype)
+            else:
+                self.notImplemented("Unsupported Data Element <%s>" % tag_name)
 
     def readSenderReceiverInterfaceInvalidationPolicies(self, element: ET.Element, sr_interface: SenderReceiverInterface):
         for child_element in self.findall(element, "INVALIDATION-POLICYS/INVALIDATION-POLICY"):
@@ -1808,16 +2149,19 @@ class ARXMLParser(AbstractARXMLParser):
         self.readSenderReceiverInterfaceDataElements(element, sr_interface)
         self.readSenderReceiverInterfaceInvalidationPolicies(element, sr_interface)
 
-    def readArgumentDataPrototypes(self, element: ET.Element, parent: ClientServerOperation):
-        for child_element in self.findall(element, "ARGUMENTS/ARGUMENT-DATA-PROTOTYPE"):
-            short_name = self.getShortName(child_element)
-            prototype = ArgumentDataPrototype(property, short_name)
-            self.readIdentifiable(child_element, prototype)
-            prototype.swDataDefProps = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
-            prototype.typeTRef = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
-            prototype.direction = self.getChildElementOptionalLiteral(child_element, "DIRECTION")
-            prototype.serverArgumentImplPolicy = self.getChildElementOptionalLiteral(child_element, "SERVER-ARGUMENT-IMPL-POLICY")
-            parent.addArgumentDataPrototype(prototype)
+    def readArgumentDataPrototype(self, element: ET.Element, prototype: ArgumentDataPrototype):
+        self.readAutosarDataPrototype(element, prototype)
+        prototype.setDirection(self.getChildElementOptionalLiteral(element, "DIRECTION")) \
+                 .setServerArgumentImplPolicy(self.getChildElementOptionalLiteral(element, "SERVER-ARGUMENT-IMPL-POLICY"))
+
+    def readClientServerOperationArguments(self, element: ET.Element, operation: ClientServerOperation):
+        for child_element in self.findall(element, "ARGUMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ARGUMENT-DATA-PROTOTYPE":
+                prototype = operation.createArgumentDataPrototype(self.getShortName(child_element))
+                self.readArgumentDataPrototype(child_element, prototype)
+            else:
+                self.notImplemented("Unsupported Argument <%s>" % tag_name)
 
     def readPossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
         child_element = self.find(element, "POSSIBLE-ERROR-REFS")
@@ -1825,41 +2169,53 @@ class ARXMLParser(AbstractARXMLParser):
             for ref in self.getChildElementRefTypeList(child_element, "POSSIBLE-ERROR-REF"):
                 parent.addPossibleErrorRef(ref)
 
-    def readOperations(self, element: ET.Element, parent: ClientServerInterface):
-        for child_element in self.findall(element, "OPERATIONS/CLIENT-SERVER-OPERATION"):
-            short_name = self.getShortName(child_element)
-            operation = parent.createOperation(short_name)
-            self.readIdentifiable(child_element, operation)
-            self.readArgumentDataPrototypes(child_element, operation)
-            self.readPossibleErrorRefs(child_element, operation)
+    def readClientServerOperation(self, element: ET.Element, operation: ClientServerOperation):
+        self.readIdentifiable(element, operation)
+        self.readClientServerOperationArguments(element, operation)
+        self.readPossibleErrorRefs(element, operation)
+
+    def readClientServerInterfaceOperations(self, element: ET.Element, parent: ClientServerInterface):
+        for child_element in self.findall(element, "OPERATIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CLIENT-SERVER-OPERATION":
+                operation = parent.createOperation(self.getShortName(child_element))
+                self.readClientServerOperation(child_element, operation)
+            else:
+                self.notImplemented("Unsupported Operation <%s>" % tag_name)
 
     def readPossibleErrors(self, element: ET.Element, parent: ClientServerInterface):
         for child_element in self.findall(element, "POSSIBLE-ERRORS/APPLICATION-ERROR"):
             short_name = self.getShortName(child_element)
             error = parent.createApplicationError(short_name)
-            self.readIdentifiable(child_element, error) # some errors has its uuid
+            self.readIdentifiable(child_element, error)  # some errors has its uuid
             error.error_code = self.getChildElementOptionalNumericalValue(child_element, "ERROR-CODE")
 
     def readPortInterface(self, element: ET.Element, port_interface: PortInterface):
         self.readIdentifiable(element, port_interface)
-        port_interface.isService = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
-        port_interface.serviceKind = self.getChildElementOptionalLiteral(element, "SERVICE-KIND")
+        port_interface.setIsService(self.getChildElementOptionalBooleanValue(element, "IS-SERVICE"))\
+                      .setServiceKind(self.getChildElementOptionalLiteral(element, "SERVICE-KIND"))
 
     def readParameterInterfaceParameters(self, element: ET.Element, param_interface: ParameterInterface):
-        for child_element in self.findall(element, "PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
-            short_name = self.getShortName(child_element)
-            prototype = param_interface.createParameter(short_name)
-            self.readParameterDataPrototype(child_element, prototype)
+        for child_element in self.findall(element, "PARAMETERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "PARAMETER-DATA-PROTOTYPE":
+                prototype = param_interface.createParameterDataPrototype(self.getShortName(child_element))
+                self.readParameterDataPrototype(child_element, prototype)
+            else:
+                self.notImplemented("Unsupported Parameter <%s>" % tag_name)
+
+    def readDataInterface(self, element: ET.Element, interface: DataInterface):
+        self.readPortInterface(element, interface)
     
-    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 readParameterInterface(self, element: ET.Element, interface: ParameterInterface):
+        self.logger.debug("Read ParameterInterface <%s>" % interface.getShortName())
+        self.readDataInterface(element, interface)
+        self.readParameterInterfaceParameters(element, interface)
 
     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.readClientServerInterfaceOperations(element, cs_interface)
         self.readPossibleErrors(element, cs_interface)
 
     def getCompuConstContent(self, element: ET.Element) -> CompuConstContent:
@@ -1921,6 +2277,15 @@ class ARXMLParser(AbstractARXMLParser):
         self.readCompuConst(element, parent)
         self.readCompuRationCoeffs(element, parent)
 
+    def readCompuScale(self, element: ET.Element, compu_scale: CompuScale):
+        self.readARObjectAttributes(element, compu_scale)
+        compu_scale.setLowerLimit(self.getChildLimitElement(element, "LOWER-LIMIT")) \
+                   .setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
+                   .setDesc(self.getMultiLanguageOverviewParagraph(element, "DESC")) \
+                   .setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL")) \
+                   .setUpperLimit(self.getChildLimitElement(element, "UPPER-LIMIT"))
+        self.readCompuScaleContents(element, compu_scale)
+
     def getCompuScales(self, element: ET.Element) -> CompuScales:
         compu_scales = None
         compu_scales_tag = self.find(element, "COMPU-SCALES")
@@ -1928,12 +2293,7 @@ class ARXMLParser(AbstractARXMLParser):
             compu_scales = CompuScales()
             for child_element in self.findall(compu_scales_tag, 'COMPU-SCALE'):
                 compu_scale = CompuScale()
-                self.readARObjectAttributes(child_element, compu_scale)
-                compu_scale.setLowerLimit(self.getChildLimitElement(child_element, "LOWER-LIMIT")) \
-                           .setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
-                           .setSymbol(self.getChildElementOptionalLiteral(child_element, "SYMBOL")) \
-                           .setUpperLimit(self.getChildLimitElement(child_element, "UPPER-LIMIT"))
-                self.readCompuScaleContents(child_element, compu_scale)
+                self.readCompuScale(child_element, compu_scale)
                 compu_scales.addCompuScale(compu_scale)
         return compu_scales
     
@@ -1943,7 +2303,7 @@ class ARXMLParser(AbstractARXMLParser):
         if (child_element is not None):
             compu = Compu()
             self.readARObjectAttributes(child_element, compu)
-            compu.setCompuContent(self.getCompuScales(child_element)) 
+            compu.setCompuContent(self.getCompuScales(child_element))
             compu.setCompuDefaultValue(self.getCompuConst(child_element, "COMPU-DEFAULT-VALUE"))
         return compu
 
@@ -1971,10 +2331,9 @@ class ARXMLParser(AbstractARXMLParser):
     def readValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
         self.readARObjectAttributes(element, value_spec)
         value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL"))
-        self.logger.debug("readValueSpecification")
+        # self.logger.debug("read ValueSpecification")
 
     def getApplicationValueSpecification(self, element: ET.Element) -> ApplicationValueSpecification:
-        self.logger.debug("getApplicationValueSpecification")
         value_spec = ApplicationValueSpecification()
         self.readValueSpecification(element, value_spec)
         value_spec.setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY")) \
@@ -1983,7 +2342,6 @@ class ARXMLParser(AbstractARXMLParser):
         return value_spec
     
     def getNumericalValueSpecification(self, element: ET.Element) -> NumericalValueSpecification:
-        self.logger.debug("getNumericalValueSpecification")
         value_spec = NumericalValueSpecification()
         self.readValueSpecification(element, value_spec)
         value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
@@ -2012,7 +2370,7 @@ class ARXMLParser(AbstractARXMLParser):
         value_spec = ConstantReference()
         self.readValueSpecification(element, value_spec)
         value_spec.setConstantRef(self.getChildElementOptionalRefType(element, "CONSTANT-REF"))
-        return value_spec         
+        return value_spec
 
     def getValueSpecification(self, element: ET.Element, tag_name: str) -> ValueSpecification:
         if tag_name == "APPLICATION-VALUE-SPECIFICATION":
@@ -2089,62 +2447,83 @@ class ARXMLParser(AbstractARXMLParser):
             .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)
+    def readEndToEndDescriptionDataIds(self, element: ET.Element, parent: EndToEndDescription):
+        child_element = self.find(element, "DATA-IDS")
         if child_element is not None:
             for value in self.getChildElementNumericalValueList(child_element, "DATA-ID"):
                 parent.addDataId(value)
 
     def getEndToEndDescription(self, element: ET.Element, key: str) -> EndToEndDescription:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         desc = None
         if (child_element is not None):
             desc = EndToEndDescription()
-            desc.category = self.getChildElementOptionalLiteral(child_element, "CATEGORY")
-            self.readEndToEndDescriptionDataId(child_element, desc)
-            desc.dataIdMode = self.getChildElementOptionalNumericalValue(child_element, "DATA-ID-MODE")
-            desc.maxDeltaCounterInit = self.getChildElementOptionalNumericalValue(child_element, "MAX-DELTA-COUNTER-INIT")
-            desc.crcOffset = self.getChildElementOptionalNumericalValue(child_element, "CRC-OFFSET")
-            desc.counterOffset = self.getChildElementOptionalNumericalValue(child_element, "COUNTER-OFFSET")
+            self.readARObjectAttributes(child_element, desc)
+            desc.setCategory(self.getChildElementOptionalLiteral(child_element, "CATEGORY"))
+            self.readEndToEndDescriptionDataIds(child_element, desc)
+            desc.setDataIdMode(self.getChildElementOptionalPositiveInteger(child_element, "DATA-ID-MODE")) \
+                .setDataLength(self.getChildElementOptionalPositiveInteger(child_element, "DATA-LENGTH")) \
+                .setMaxDeltaCounterInit(self.getChildElementOptionalPositiveInteger(child_element, "MAX-DELTA-COUNTER-INIT")) \
+                .setCrcOffset(self.getChildElementOptionalPositiveInteger(child_element, "CRC-OFFSET")) \
+                .setCounterOffset(self.getChildElementOptionalPositiveInteger(child_element, "COUNTER-OFFSET"))
         return desc
     
     def getVariableDataPrototypeInSystemInstanceRef(self, element: ET.Element) -> VariableDataPrototypeInSystemInstanceRef:
-        iref = None
+        instance_ref = None
         if element is not None:
-            iref = VariableDataPrototypeInSystemInstanceRef()
-            #iref.addContextComponentRef() = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
-            iref.setContextCompositionRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF")) \
-                .setContextPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")) \
-                .setTargetDataPrototypeRef(self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF"))
-        return iref
+            instance_ref = VariableDataPrototypeInSystemInstanceRef()
+            for ref in self.getChildElementRefTypeList(element, "CONTEXT-COMPONENT-REF"):
+                instance_ref.addContextComponentRef(ref)
+            instance_ref.setContextCompositionRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF")) \
+                        .setContextPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")) \
+                        .setTargetDataPrototypeRef(self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF"))
+        return instance_ref
     
-    def getEndToEndProtectionVariablePrototype(self, element: ET.Element) -> EndToEndProtectionVariablePrototype:
-        prototype = EndToEndProtectionVariablePrototype()
-        for child_element in element.findall("./xmlns:RECEIVER-IREFS/xmlns:RECEIVER-IREF", self.nsmap):
+    def readEndToEndProtectionVariablePrototype(self, element: ET.Element, prototype: EndToEndProtectionVariablePrototype):
+        self.readARObjectAttributes(element, prototype)
+        for child_element in self.findall(element, "RECEIVER-IREFS/RECEIVER-IREF"):
             prototype.addReceiverIref(self.getVariableDataPrototypeInSystemInstanceRef(child_element))
-        child_element = element.find("./xmlns:SENDER-IREF", self.nsmap)
+        child_element = self.find(element, "SENDER-IREF")
         if child_element is not None:
             prototype.senderIRef = self.getVariableDataPrototypeInSystemInstanceRef(child_element)
         return prototype
     
-    def readEndToEndProtectionVariablePrototypes(self, element: ET.Element, parent: EndToEndProtection):
-        for child_element in element.findall("./xmlns:END-TO-END-PROTECTION-VARIABLE-PROTOTYPES/*", self.nsmap):
+    def readEndToEndProtectionEndToEndProtectionVariablePrototypes(self, element: ET.Element, protection: EndToEndProtection):
+        for child_element in self.findall(element, "END-TO-END-PROTECTION-VARIABLE-PROTOTYPES/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "END-TO-END-PROTECTION-VARIABLE-PROTOTYPE":
-                parent.addEndToEndProtectionVariablePrototype(self.getEndToEndProtectionVariablePrototype(child_element))
+                prototype = EndToEndProtectionVariablePrototype()
+                self.readEndToEndProtectionVariablePrototype(child_element, prototype)
+                protection.addEndToEndProtectionVariablePrototype(prototype)
             else:
                 self.raiseError("Unsupported End To End Protection Variable Prototype <%s>" % tag_name)
 
+    def readEndToEndProtectionISignalIPdu(self, element: ET.Element, ipdu: EndToEndProtectionISignalIPdu):
+        ipdu.setDataOffset(self.getChildElementOptionalIntegerValue(element, "DATA-OFFSET")) \
+            .setISignalGroupRef(self.getChildElementOptionalRefType(element, "I-SIGNAL-GROUP-REF")) \
+            .setISignalIPduRef(self.getChildElementOptionalRefType(element, "I-SIGNAL-I-PDU-REF"))
+
+    def readEndToEndProtectionEndToEndProtectionISignalIPdus(self, element: ET.Element, protection: EndToEndProtection):
+        for child_element in self.findall(element, "END-TO-END-PROTECTION-I-SIGNAL-I-PDUS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "END-TO-END-PROTECTION-I-SIGNAL-I-PDU":
+                ipdu = EndToEndProtectionISignalIPdu()
+                self.readEndToEndProtectionISignalIPdu(child_element, ipdu)
+                protection.addEndToEndProtectionISignalIPdu(ipdu)
+            else:
+                self.notImplemented("Unsupported EndToEndProtectionISignalIPdu <%s>" % tag_name)
+
     def readEndToEndProtection(self, element: ET.Element, parent: EndToEndProtectionSet):
         short_name = self.getShortName(element)
         self.logger.debug("readEndToEndProtection %s" % short_name)
         protection = parent.createEndToEndProtection(short_name)
         self.readIdentifiable(element, protection)
-        protection.endToEndProfile = self.getEndToEndDescription(element, "END-TO-END-PROFILE")
-        self.readEndToEndProtectionVariablePrototypes(element, protection)
+        protection.setEndToEndProfile(self.getEndToEndDescription(element, "END-TO-END-PROFILE"))
+        self.readEndToEndProtectionEndToEndProtectionISignalIPdus(element, protection)
+        self.readEndToEndProtectionEndToEndProtectionVariablePrototypes(element, protection)
 
     def readEndToEndProtections(self, element: ET.Element, parent: EndToEndProtectionSet):
-        for child_element in self.findall(element, "END-TO-END-PROTECTIONS/*", self.nsmap):
+        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)
@@ -2156,10 +2535,6 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, protection_set)
         self.readEndToEndProtections(element, protection_set)
 
-    def readAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
-        self.readIdentifiable(element, data_type)
-        data_type.swDataDefProps = self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS")
-
     def readImplementationProps(self, element: ET.Element, props: ImplementationProps):
         props.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
 
@@ -2187,22 +2562,24 @@ class ARXMLParser(AbstractARXMLParser):
         prototype.typeTRef = self.getChildElementOptionalRefType(element, "TYPE-TREF")
 
     def readApplicationArrayElement(self, element: ET.Element, parent: ApplicationArrayDataType):
-        child_element = element.find("./xmlns:ELEMENT", self.nsmap)
+        child_element = self.find(element, "ELEMENT")
         if child_element is not None:
             short_name = self.getShortName(child_element)
-            self.logger.debug("readApplicationArrayElement %s" % short_name)
+            self.logger.debug("Read ApplicationArrayElement %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, data_type: ApplicationArrayDataType):
-        self.logger.debug("Read ApplicationArrayDataType <%s>" % data_type)
+        self.logger.debug("Read ApplicationArrayDataType <%s>" % data_type.getShortName())
         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:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         layout_v = None
         if child_element is not None:
             layout_v = SwRecordLayoutV()
@@ -2212,9 +2589,15 @@ class ARXMLParser(AbstractARXMLParser):
                     .setSwRecordLayoutVProp(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-PROP")) \
                     .setSwRecordLayoutVIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-INDEX"))
         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)
+        child_element = self.find(element, key)
         group = None
         if child_element is not None:
             group = SwRecordLayoutGroup()
@@ -2224,17 +2607,9 @@ class ARXMLParser(AbstractARXMLParser):
                  .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")) \
+                 .setSwRecordLayoutGroupTo(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO"))
+            self.readSwRecordLayoutGroupSwRecordLayoutGroupContentType(child_element, group)
             
-            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)
-
         return group
 
     def readSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
@@ -2245,7 +2620,7 @@ class ARXMLParser(AbstractARXMLParser):
     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")) 
+        method.setMemoryAllocationKeywordPolicy(self.getChildElementOptionalLiteral(element, "MEMORY-ALLOCATION-KEYWORD-POLICY"))
         for option in self.getChildElementLiteralValueList(element, "OPTIONS/OPTION"):
             method.addOption(option)
         method.setSectionInitializationPolicy(self.getChildElementOptionalLiteral(element, "SECTION-INITIALIZATION-POLICY")) \
@@ -2319,6 +2694,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readTimingExtension(element, timing)
 
     def readFrameTriggering(self, element: ET.Element, triggering: FrameTriggering):
+        self.readIdentifiable(element, triggering)
         for ref in self.getChildElementRefTypeList(element, 'FRAME-PORT-REFS/FRAME-PORT-REF'):
             triggering.addFramePortRef(ref)
         triggering.setFrameRef(self.getChildElementOptionalRefType(element, "FRAME-REF"))
@@ -2327,7 +2703,6 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readCanFrameTriggering(self, element: ET.Element, triggering: CanFrameTriggering):
         self.logger.debug("Read CanFrameTriggering %s" % triggering.getShortName())
-        self.readIdentifiable(element, triggering)
         self.readFrameTriggering(element, triggering)
         triggering.setCanAddressingMode(self.getChildElementOptionalLiteral(element, "CAN-ADDRESSING-MODE")) \
                   .setCanFdFrameSupport(self.getChildElementOptionalBooleanValue(element, "CAN-FD-FRAME-SUPPORT")) \
@@ -2336,13 +2711,52 @@ class ARXMLParser(AbstractARXMLParser):
                   .setIdentifier(self.getChildElementOptionalNumericalValue(element, "IDENTIFIER")) \
                   .setRxIdentifierRange(self.getChildElementRxIdentifierRange(element, "RX-IDENTIFIER-RANGE"))
 
-
     def readLinFrameTriggering(self, element: ET.Element, triggering: LinFrameTriggering):
         self.logger.debug("Read LinFrameTriggering %s" % triggering.getShortName())
-        self.readIdentifiable(element, triggering)
         self.readFrameTriggering(element, triggering)
         triggering.setIdentifier(self.getChildElementOptionalNumericalValue(element, "IDENTIFIER")) \
                   .setLinChecksum(self.getChildElementOptionalLiteral(element, "LIN-CHECKSUM"))
+        
+    def readCommunicationCycle(self, element: ET.Element, cycle: CommunicationCycle):
+        self.readARObjectAttributes(element, cycle)
+        
+    def readCycleRepetition(self, element: ET.Element, cycle: CycleRepetition):
+        self.readCommunicationCycle(element, cycle)
+        cycle.setBaseCycle(self.getChildElementOptionalIntegerValue(element, "BASE-CYCLE")) \
+             .setCycleRepetition(self.getChildElementOptionalLiteral(element, "CYCLE-REPETITION"))
+        
+    def readFlexrayAbsolutelyScheduledTimingCommunicationCycle(self, element: ET.Element, timing: FlexrayAbsolutelyScheduledTiming):
+        for child_element in self.findall(element, "COMMUNICATION-CYCLE/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CYCLE-REPETITION":
+                repetition = CycleRepetition()
+                self.readCycleRepetition(child_element, repetition)
+                timing.setCommunicationCycle(repetition)
+            else:
+                self.notImplemented("Unsupported CommunicationCycle <%s>" % tag_name)
+        
+    def readFlexrayAbsolutelyScheduledTiming(self, element: ET.Element, timing: FlexrayAbsolutelyScheduledTiming):
+        self.readARObjectAttributes(element, timing)
+        self.readFlexrayAbsolutelyScheduledTimingCommunicationCycle(element, timing)
+        timing.setSlotID(self.getChildElementOptionalPositiveInteger(element, "SLOT-ID"))
+        
+    def readFlexrayFrameTriggeringAbsolutelyScheduledTimings(self, element: ET.Element, triggering: FlexrayFrameTriggering):
+        for child_element in self.findall(element, "ABSOLUTELY-SCHEDULED-TIMINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "FLEXRAY-ABSOLUTELY-SCHEDULED-TIMING":
+                timing = FlexrayAbsolutelyScheduledTiming()
+                self.readFlexrayAbsolutelyScheduledTiming(child_element, timing)
+                triggering.addAbsolutelyScheduledTiming(timing)
+            else:
+                self.notImplemented("Unsupported AbsolutelyScheduledTiming <%s>" % tag_name)
+        
+    def readFlexrayFrameTriggering(self, element: ET.Element, triggering: FlexrayFrameTriggering):
+        self.logger.debug("Read FlexrayFrameTriggering %s" % triggering.getShortName())
+        self.readFrameTriggering(element, triggering)
+        self.readFlexrayFrameTriggeringAbsolutelyScheduledTimings(element, triggering)
+        triggering.setAllowDynamicLSduLength(self.getChildElementOptionalBooleanValue(element, "ALLOW-DYNAMIC-L-SDU-LENGTH")) \
+                  .setMessageId(self.getChildElementOptionalPositiveInteger(element, "MESSAGE-ID")) \
+                  .setPayloadPreambleIndicator(self.getChildElementOptionalBooleanValue(element, "PAYLOAD-PREAMBLE-INDICATOR"))
 
     def readISignalTriggering(self, element: ET.Element, triggering: ISignalTriggering):
         self.logger.debug("Read ISignalTriggering %s" % triggering.getShortName())
@@ -2361,10 +2775,11 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in self.findall(element, 'I-SIGNAL-TRIGGERINGS/I-SIGNAL-TRIGGERING-REF-CONDITIONAL'):
             triggering.addISignalTriggeringRef(self.getChildElementOptionalRefType(child_element, "I-SIGNAL-TRIGGERING-REF"))
 
-    def readPhysicalChannel(self, element: ET.Element, channel: PhysicalChannel):
+    def readPhysicalChannelCommConnectorRefs(self, element: ET.Element, channel: PhysicalChannel):
         for child_element in self.findall(element, 'COMM-CONNECTORS/COMMUNICATION-CONNECTOR-REF-CONDITIONAL'):
             channel.addCommConnectorRef(self.getChildElementOptionalRefType(child_element, "COMMUNICATION-CONNECTOR-REF"))
-        
+
+    def readPhysicalChannelFrameTriggerings(self, element: ET.Element, channel: PhysicalChannel):
         for child_element in self.findall(element, "FRAME-TRIGGERINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "CAN-FRAME-TRIGGERING":
@@ -2373,9 +2788,13 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "LIN-FRAME-TRIGGERING":
                 triggering = channel.createLinFrameTriggering(self.getShortName(child_element))
                 self.readLinFrameTriggering(child_element, triggering)
+            elif tag_name == "FLEXRAY-FRAME-TRIGGERING":
+                triggering = channel.createFlexrayFrameTriggering(self.getShortName(child_element))
+                self.readFlexrayFrameTriggering(child_element, triggering)
             else:
                 self.notImplemented("Unsupported Frame Triggering <%s>" % tag_name)
-            
+
+    def readPhysicalChannelISignalTriggerings(self, element: ET.Element, channel: PhysicalChannel):
         for child_element in self.findall(element, "I-SIGNAL-TRIGGERINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "I-SIGNAL-TRIGGERING":
@@ -2383,7 +2802,8 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readISignalTriggering(child_element, triggering)
             else:
                 self.notImplemented("Unsupported Frame Triggering <%s>" % tag_name)
-            
+
+    def readPhysicalChannelPduTriggerings(self, element, channel):
         for child_element in self.findall(element, "PDU-TRIGGERINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "PDU-TRIGGERING":
@@ -2392,8 +2812,15 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported Frame Triggering <%s>" % tag_name)
 
-    def readCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
+    def readPhysicalChannel(self, element: ET.Element, channel: PhysicalChannel):
         self.readIdentifiable(element, channel)
+
+        self.readPhysicalChannelCommConnectorRefs(element, channel)
+        self.readPhysicalChannelFrameTriggerings(element, channel)
+        self.readPhysicalChannelISignalTriggerings(element, channel)
+        self.readPhysicalChannelPduTriggerings(element, channel)
+
+    def readCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
         self.readPhysicalChannel(element, channel)
 
     def readScheduleTableEntry(self, element: ET.Element, entry: ScheduleTableEntry):
@@ -2432,7 +2859,6 @@ class ARXMLParser(AbstractARXMLParser):
                 self.notImplemented("Unsupported Schedule Table <%s>" % tag_name)
 
     def readLinPhysicalChannel(self, element: ET.Element, channel: LinPhysicalChannel):
-        self.readIdentifiable(element, channel)
         self.readPhysicalChannel(element, channel)
         self.readLinPhysicalChannelScheduleTables(element, channel)
 
@@ -2457,7 +2883,7 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported Network EndPoint Address <%s>" % tag_name)
 
-    def getDoIpEntity(self, element: ET.Element, key:str) -> DoIpEntity:
+    def getDoIpEntity(self, element: ET.Element, key: str) -> DoIpEntity:
         entity = None
         child_element = self.find(element, key)
         if child_element is not None:
@@ -2465,7 +2891,7 @@ class ARXMLParser(AbstractARXMLParser):
             entity.setDoIpEntityRole(self.getChildElementOptionalLiteral(child_element, "DO-IP-ENTITY-ROLE"))
         return entity
 
-    def getInfrastructureServices(self, element: ET.Element, key:str) -> InfrastructureServices:
+    def getInfrastructureServices(self, element: ET.Element, key: str) -> InfrastructureServices:
         services = None
         child_element = self.find(element, key)
         if child_element is not None:
@@ -2511,7 +2937,7 @@ class ARXMLParser(AbstractARXMLParser):
             connection = SocketConnection()
             connection.setClientIpAddrFromConnectionRequest(self.getChildElementOptionalBooleanValue(element, "CLIENT-IP-ADDR-FROM-CONNECTION-REQUEST")) \
                       .setClientPortFromConnectionRequest(self.getChildElementOptionalBooleanValue(element, "CLIENT-PORT-FROM-CONNECTION-REQUEST")) \
-                      .setClientPortRef(self.getChildElementOptionalRefType(element, "CLIENT-PORT-REF"))
+                      .setClientPortRef(self.getChildElementOptionalRefType(element, "CLIENT-PORT-REF"))            # NOQA E501
             for pdu in self.getSocketConnectionPdus(element):
                 connection.addPdu(pdu)
             connection.setPduCollectionMaxBufferSize(self.getChildElementOptionalPositiveInteger(element, "PDU-COLLECTION-MAX-BUFFER-SIZE")) \
@@ -2526,7 +2952,7 @@ class ARXMLParser(AbstractARXMLParser):
             tag_name = self.getTagName(child_element)
             if tag_name == "SOCKET-CONNECTION":
                 bundle.addBundledConnection(self.getSocketConnection(child_element))
-            else: 
+            else:
                 self.notImplemented("Unsupported Bundled Connection <%s>" % tag_name)
 
     def readSocketConnectionBundle(self, element: ET.Element, bundle: SocketConnectionBundle):
@@ -2556,12 +2982,11 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readTcpTp(self, element: ET.Element, tp: TcpTp):
         tp.setKeepAliveInterval(self.getChildElementOptionalTimeValue(element, "KEEP-ALIVE-INTERVAL")) \
-                     .setKeepAliveProbesMax(self.getChildElementOptionalPositiveInteger(element, "KEEP-ALIVE-PROBES-MAX")) \
-                     .setKeepAliveTime(self.getChildElementOptionalTimeValue(element, "KEEP-ALIVE-TIME")) \
-                     .setKeepAlives(self.getChildElementOptionalBooleanValue(element, "KEEP-ALIVES")) \
-                     .setNaglesAlgorithm(self.getChildElementOptionalLiteral(element, "NAGLES-ALGORITHM")) \
-                     .setTcpTpPort(self.getTpPort(element, "TCP-TP-PORT"))
-
+          .setKeepAliveProbesMax(self.getChildElementOptionalPositiveInteger(element, "KEEP-ALIVE-PROBES-MAX")) \
+          .setKeepAliveTime(self.getChildElementOptionalTimeValue(element, "KEEP-ALIVE-TIME")) \
+          .setKeepAlives(self.getChildElementOptionalBooleanValue(element, "KEEP-ALIVES")) \
+          .setNaglesAlgorithm(self.getChildElementOptionalLiteral(element, "NAGLES-ALGORITHM")) \
+          .setTcpTpPort(self.getTpPort(element, "TCP-TP-PORT"))
 
     def readGenericTp(self, element: ET.Element, tp: GenericTp):
         tp.setTpAddress(self.getChildElementOptionalLiteral(element, "TP-ADDRESS")) \
@@ -2597,17 +3022,6 @@ class ARXMLParser(AbstractARXMLParser):
             delay.setMaxValue(self.getChildElementOptionalTimeValue(child_element, "MAX-VALUE")) \
                  .setMinValue(self.getChildElementOptionalTimeValue(child_element, "MIN-VALUE"))
         return delay
-    
-    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 getSdClientConfig(self, element: ET.Element, key: str) -> SdClientConfig:
         config = None
@@ -2662,7 +3076,7 @@ class ARXMLParser(AbstractARXMLParser):
                   .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)
@@ -2684,7 +3098,7 @@ class ARXMLParser(AbstractARXMLParser):
         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")) \
+        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/*"):
@@ -2725,7 +3139,6 @@ class ARXMLParser(AbstractARXMLParser):
         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)
@@ -2733,7 +3146,7 @@ class ARXMLParser(AbstractARXMLParser):
         address.setConnectorRef(self.getChildElementOptionalRefType(element, "CONNECTOR-REF")) \
                .setPortAddress(self.getChildElementOptionalPositiveInteger(element, "PORT-ADDRESS"))
 
-    def readSoAdConfigSocketAddresses(self, element: ET.Element, config: SoAdConfig):   
+    def readSoAdConfigSocketAddresses(self, element: ET.Element, config: SoAdConfig):
         for child_element in self.findall(element, "SOCKET-ADDRESSS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "SOCKET-ADDRESS":
@@ -2758,12 +3171,15 @@ class ARXMLParser(AbstractARXMLParser):
             vlan.setVlanIdentifier(self.getChildElementOptionalPositiveInteger(child_element, "VLAN-IDENTIFIER"))
 
     def readEthernetPhysicalChannel(self, element: ET.Element, channel: EthernetPhysicalChannel):
-        self.readIdentifiable(element, channel)
         self.readPhysicalChannel(element, channel)
         self.readEthernetPhysicalChannelNetworkEndPoints(element, channel)
         channel.setSoAdConfig(self.getSoAdConfig(element, "SO-AD-CONFIG"))
         self.readEthernetPhysicalChannelVlan(element, channel)
 
+    def readFlexrayPhysicalChannel(self, element: ET.Element, channel: FlexrayPhysicalChannel):
+        self.readPhysicalChannel(element, channel)
+        channel.setChannelName(self.getChildElementOptionalLiteral(element, "CHANNEL-NAME"))
+
     def readCommunicationClusterPhysicalChannels(self, element: ET.Element, cluster: CommunicationCluster):
         for child_element in self.findall(element, "PHYSICAL-CHANNELS/*"):
             tag_name = self.getTagName(child_element)
@@ -2776,12 +3192,14 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "ETHERNET-PHYSICAL-CHANNEL":
                 channel = cluster.createEthernetPhysicalChannel(self.getShortName(child_element))
                 self.readEthernetPhysicalChannel(child_element, channel)
+            elif tag_name == "FLEXRAY-PHYSICAL-CHANNEL":
+                channel = cluster.createFlexrayPhysicalChannel(self.getShortName(child_element))
+                self.readFlexrayPhysicalChannel(child_element, channel)
             else:
                 self.notImplemented("Unsupported Physical Channel <%s>" % tag_name)
 
-
     def readCommunicationCluster(self, element: ET.Element, cluster: CommunicationCluster):
-        cluster.setBaudrate(self.getChildElementOptionalNumericalValue(element, "BAUDRATE")) 
+        cluster.setBaudrate(self.getChildElementOptionalNumericalValue(element, "BAUDRATE"))
         self.readCommunicationClusterPhysicalChannels(element, cluster)
         cluster.setProtocolName(self.getChildElementOptionalLiteral(element, "PROTOCOL-NAME")) \
                .setProtocolVersion(self.getChildElementOptionalLiteral(element, "PROTOCOL-VERSION"))
@@ -2797,6 +3215,7 @@ class ARXMLParser(AbstractARXMLParser):
         return recovery
         
     def readAbstractCanCluster(self, element: ET.Element, cluster: AbstractCanCluster):
+        self.readCommunicationCluster(element, cluster)
         cluster.setBusOffRecovery(self.getCanClusterBusOffRecovery(element, "BUS-OFF-RECOVERY")) \
                .setCanFdBaudrate(self.getChildElementOptionalNumericalValue(element, "CAN-FD-BAUDRATE")) \
                .setSpeed(self.getChildElementOptionalNumericalValue(element, "SPEED"))
@@ -2813,9 +3232,47 @@ class ARXMLParser(AbstractARXMLParser):
         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 readFlexrayCluster(self, element: ET.Element, cluster: FlexrayCluster):
+        self.logger.debug("Read FlexrayCluster <%s>" % cluster.getShortName())
+        self.readIdentifiable(element, cluster)
+        child_element = self.find(element, "FLEXRAY-CLUSTER-VARIANTS/FLEXRAY-CLUSTER-CONDITIONAL")
+        if child_element is not None:
+            self.readCommunicationCluster(child_element, cluster)
+            cluster.setActionPointOffset(self.getChildElementOptionalIntegerValue(child_element, "ACTION-POINT-OFFSET")) \
+                   .setBit(self.getChildElementOptionalTimeValue(child_element, "BIT")) \
+                   .setCasRxLowMax(self.getChildElementOptionalIntegerValue(child_element, "CAS-RX-LOW-MAX")) \
+                   .setColdStartAttempts(self.getChildElementOptionalIntegerValue(child_element, "COLD-START-ATTEMPTS")) \
+                   .setCycle(self.getChildElementOptionalTimeValue(child_element, "CYCLE")) \
+                   .setCycleCountMax(self.getChildElementOptionalIntegerValue(child_element, "CYCLE-COUNT-MAX")) \
+                   .setDetectNitError(self.getChildElementOptionalBooleanValue(child_element, "DETECT-NIT-ERROR")) \
+                   .setDynamicSlotIdlePhase(self.getChildElementOptionalIntegerValue(child_element, "DYNAMIC-SLOT-IDLE-PHASE")) \
+                   .setIgnoreAfterTx(self.getChildElementOptionalIntegerValue(child_element, "IGNORE-AFTER-TX")) \
+                   .setListenNoise(self.getChildElementOptionalIntegerValue(child_element, "LISTEN-NOISE")) \
+                   .setMacroPerCycle(self.getChildElementOptionalIntegerValue(child_element, "MACRO-PER-CYCLE")) \
+                   .setMacrotickDuration(self.getChildElementOptionalTimeValue(child_element, "MACROTICK-DURATION")) \
+                   .setMaxWithoutClockCorrectionFatal(self.getChildElementOptionalIntegerValue(child_element, "MAX-WITHOUT-CLOCK-CORRECTION-FATAL")) \
+                   .setMaxWithoutClockCorrectionPassive(self.getChildElementOptionalIntegerValue(child_element, "MAX-WITHOUT-CLOCK-CORRECTION-PASSIVE")) \
+                   .setMinislotActionPointOffset(self.getChildElementOptionalIntegerValue(child_element, "MINISLOT-ACTION-POINT-OFFSET")) \
+                   .setMinislotDuration(self.getChildElementOptionalIntegerValue(child_element, "MINISLOT-DURATION")) \
+                   .setNetworkIdleTime(self.getChildElementOptionalIntegerValue(child_element, "NETWORK-IDLE-TIME")) \
+                   .setNetworkManagementVectorLength(self.getChildElementOptionalIntegerValue(child_element, "NETWORK-MANAGEMENT-VECTOR-LENGTH")) \
+                   .setNumberOfMinislots(self.getChildElementOptionalIntegerValue(child_element, "NUMBER-OF-MINISLOTS")) \
+                   .setNumberOfStaticSlots(self.getChildElementOptionalIntegerValue(child_element, "NUMBER-OF-STATIC-SLOTS")) \
+                   .setOffsetCorrectionStart(self.getChildElementOptionalIntegerValue(child_element, "OFFSET-CORRECTION-START")) \
+                   .setPayloadLengthStatic(self.getChildElementOptionalIntegerValue(child_element, "PAYLOAD-LENGTH-STATIC")) \
+                   .setSafetyMargin(self.getChildElementOptionalIntegerValue(child_element, "SAFETY-MARGIN")) \
+                   .setSampleClockPeriod(self.getChildElementOptionalTimeValue(child_element, "SAMPLE-CLOCK-PERIOD")) \
+                   .setStaticSlotDuration(self.getChildElementOptionalIntegerValue(child_element, "STATIC-SLOT-DURATION")) \
+                   .setSyncFrameIdCountMax(self.getChildElementOptionalIntegerValue(child_element, "SYNC-FRAME-ID-COUNT-MAX")) \
+                   .setTransmissionStartSequenceDuration(self.getChildElementOptionalIntegerValue(child_element, "TRANSMISSION-START-SEQUENCE-DURATION")) \
+                   .setWakeupRxIdle(self.getChildElementOptionalIntegerValue(child_element, "WAKEUP-RX-IDLE")) \
+                   .setWakeupRxLow(self.getChildElementOptionalIntegerValue(child_element, "WAKEUP-RX-LOW")) \
+                   .setWakeupRxWindow(self.getChildElementOptionalIntegerValue(child_element, "WAKEUP-RX-WINDOW")) \
+                   .setWakeupTxActive(self.getChildElementOptionalIntegerValue(child_element, "WAKEUP-TX-ACTIVE")) \
+                   .setWakeupTxIdle(self.getChildElementOptionalIntegerValue(child_element, "WAKEUP-TX-IDLE"))            # noqa E501
+
     def readMacMulticastGroup(self, element: ET.Element, group: MacMulticastGroup):
         self.readIdentifiable(element, group)
         group.setMacMulticastAddress(self.getChildElementOptionalLiteral(element, "MAC-MULTICAST-ADDRESS",))
@@ -2858,37 +3315,216 @@ class ARXMLParser(AbstractARXMLParser):
         self.readDiagnosticServiceTableDiagnosticConnectionRefs(element, table)
         table.setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF"))
 
-    def readMultiplexedIPdu(self, element: ET.Element, i_pdu: MultiplexedIPdu):
-        self.logger.debug("Read MultiplexedIPdu <%s>" % i_pdu.getShortName())
-        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 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 readMultiplexedPart(self, element: ET.Element, part: MultiplexedPart):
+        self.readMultiplexedPartSegmentPositions(element, part)
+
+    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 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 readUserDefinedIPdu(self, element: ET.Element, i_pdu: UserDefinedIPdu):
-        self.logger.debug("Read UserDefinedIPdu <%s>" % i_pdu.getShortName())
-        self.readIdentifiable(element, i_pdu)
+    def readDynamicPart(self, element: ET.Element, part: DynamicPart):
+        self.readMultiplexedPart(element, part)
+        self.readDynamicPartDynamicPartAlternatives(element, part)
+
+    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 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.readIdentifiable(element, pdu)
+        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.readIdentifiable(element, pdu)
+        self.readPdu(element, pdu)
 
     def readGeneralPurposeIPdu(self, element: ET.Element, i_pdu: GeneralPurposeIPdu):
         self.logger.debug("Read GeneralPurposeIPdu <%s>" % i_pdu.getShortName())
-        self.readIdentifiable(element, i_pdu)
+        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.readIdentifiable(element, config)
+        self.readTpConfig(element, config)
+        self.readDoIpTpConfigDoIpLogicAddresses(element, config)
+        self.readDoIpTpConfigTpConnections(element, config)
+
+    def readHwDescriptionEntityHwCategoryRefs(self, element: ET.Element, entity: HwDescriptionEntity):
+        for ref in self.getChildElementRefTypeList(element, "HW-CATEGORY-REFS/HW-CATEGORY-REF"):
+            entity.addHwCategoryRef(ref)
+
+    def readHwDescriptionEntity(self, element: ET.Element, entity: HwDescriptionEntity):
+        self.readARElement(element, entity)
+        self.readHwDescriptionEntityHwCategoryRefs(element, entity)
+
+    def readHwPinGroup(self, element: ET.SubElement, pin_group: HwPinGroup):
+        self.readHwDescriptionEntity(element, pin_group)
+
+    def readHwElementHwPinGroups(self, element: ET.Element, hw_element: HwElement):
+        for child_element in self.findall(element, "HW-PIN-GROUPS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "HW-PIN-GROUP":
+                pin_group = hw_element.createHwPinGroup(self.getShortName(child_element))
+                self.readHwPinGroup(child_element, pin_group)
+            else:
+                self.notImplemented("Unsupported Hw Pin Group <%s>" % tag_name)
+
+    def readHwElement(self, element: ET.Element, hw_element: HwElement):
+        self.logger.debug("Read HwElement <%s>" % hw_element.getShortName())
+        self.readHwDescriptionEntity(element, hw_element)
+        self.readHwElementHwPinGroups(element, hw_element)
+
+    def readHwAttributeDef(self, element: ET.Element, attribute_def: HwAttributeDef):
+        self.readIdentifiable(element, attribute_def)
+        attribute_def.setUnitRef(self.getChildElementOptionalRefType(element, "UNIT-REF"))
+
+    def readHwCategoryHwAttributeDef(self, element: ET.Element, hw_category: HwCategory):
+        for child_element in self.findall(element, "HW-ATTRIBUTE-DEFS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "HW-ATTRIBUTE-DEF":
+                pin_group = hw_category.createHwAttributeDef(self.getShortName(child_element))
+                self.readHwAttributeDef(child_element, pin_group)
+            else:
+                self.notImplemented("Unsupported Hw Attribute Defs <%s>" % tag_name)
+
+    def readHwCategory(self, element: ET.Element, hw_category: HwCategory):
+        self.logger.debug("Read HwCategory <%s>" % hw_category.getShortName())
+        self.readARElement(element, hw_category)
+        self.readHwCategoryHwAttributeDef(element, hw_category)
+
+    def readHwType(self, element: ET.Element, type: HwType):
+        self.logger.debug("Read HwType <%s>" % type.getShortName())
+        self.readARElement(element, type)
 
     def readPduToFrameMappings(self, element: ET.Element, parent: Frame):
         for child_element in self.findall(element, "PDU-TO-FRAME-MAPPINGS/PDU-TO-FRAME-MAPPING"):
@@ -2909,82 +3545,124 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("Read LinUnconditionalFrame <%s>" % frame.getShortName())
         self.readFrame(element, frame)
 
+    def readPdu(self, element: ET.Element, pdu: Pdu):
+        self.readIdentifiable(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 readNmPdu(self, element: ET.Element, pdu: NmPdu):
         self.logger.debug("Read NmPdu <%s>" % pdu.getShortName())
-        self.readIPdu(element, pdu)
+        self.readPdu(element, pdu)
+        self.readNmPduISignalToIPduMappings(element, pdu)
+        pdu.setUnusedBitPattern(self.getChildElementOptionalIntegerValue(element, "UNUSED-BIT-PATTERN"))
+
+    def readIPdu(self, element: ET.Element, pdu: IPdu):
+        self.readPdu(element, pdu)
 
     def readNPdu(self, element: ET.Element, pdu: NPdu):
         self.logger.debug("Read NPdu <%s>" % pdu.getShortName())
         self.readIPdu(element, pdu)
 
-    def readIPdu(self, element: ET.Element, pdu: IPdu):
-        self.readIdentifiable(element, pdu)
-        pdu.setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH"))
-        
     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"))            # NOQA E501
+        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()
-        
+        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":
@@ -2995,6 +3673,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")) \
@@ -3002,12 +3681,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")) \
@@ -3023,40 +3699,380 @@ 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.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, 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 readTpConfig(self, element: ET.Element, config: TpConfig):
+        self.readIdentifiable(element, config)
+        config.setCommunicationClusterRef(self.getChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF"))
+
+    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.readIdentifiable(element, config)
+        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.readIdentifiable(element, config)
+        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 readFlexrayFrame(self, element: ET.Element, frame: FlexrayFrame):
+        self.logger.debug("Read FlexrayFrame <%s>" % frame.getShortName())
+        self.readFrame(element, frame)
+   
+    def readFlexrayCommunicationController(self, element: ET.Element, controller: FlexrayCommunicationController):
+        self.logger.debug("Read CommunicationController <%s>" % controller.getShortName())
+        self.readIdentifiable(element, controller)
+        child_element = self.find(element, "FLEXRAY-COMMUNICATION-CONTROLLER-VARIANTS/FLEXRAY-COMMUNICATION-CONTROLLER-CONDITIONAL")
+        if child_element is not None:
+            self.readCommunicationController(element, controller)
+            controller.setAcceptedStartupRange(self.getChildElementOptionalIntegerValue(child_element, "ACCEPTED-STARTUP-RANGE")) \
+                      .setAllowHaltDueToClock(self.getChildElementOptionalBooleanValue(child_element, "ALLOW-HALT-DUE-TO-CLOCK")) \
+                      .setAllowPassiveToActive(self.getChildElementOptionalIntegerValue(child_element, "ALLOW-PASSIVE-TO-ACTIVE")) \
+                      .setClusterDriftDamping(self.getChildElementOptionalIntegerValue(child_element, "CLUSTER-DRIFT-DAMPING")) \
+                      .setDecodingCorrection(self.getChildElementOptionalIntegerValue(child_element, "DECODING-CORRECTION")) \
+                      .setDelayCompensationA(self.getChildElementOptionalIntegerValue(child_element, "DELAY-COMPENSATION-A")) \
+                      .setDelayCompensationB(self.getChildElementOptionalIntegerValue(child_element, "DELAY-COMPENSATION-B")) \
+                      .setKeySlotOnlyEnabled(self.getChildElementOptionalBooleanValue(child_element, "KEY-SLOT-ONLY-ENABLED")) \
+                      .setKeySlotUsedForStartUp(self.getChildElementOptionalBooleanValue(child_element, "KEY-SLOT-USED-FOR-START-UP")) \
+                      .setKeySlotUsedForSync(self.getChildElementOptionalBooleanValue(child_element, "KEY-SLOT-USED-FOR-SYNC")) \
+                      .setLatestTX(self.getChildElementOptionalIntegerValue(child_element, "LATEST-TX")) \
+                      .setListenTimeout(self.getChildElementOptionalIntegerValue(child_element, "LISTEN-TIMEOUT")) \
+                      .setMacroInitialOffsetA(self.getChildElementOptionalIntegerValue(child_element, "MACRO-INITIAL-OFFSET-A")) \
+                      .setMacroInitialOffsetB(self.getChildElementOptionalIntegerValue(child_element, "MACRO-INITIAL-OFFSET-B")) \
+                      .setMaximumDynamicPayloadLength(self.getChildElementOptionalIntegerValue(child_element, "MAXIMUM-DYNAMIC-PAYLOAD-LENGTH")) \
+                      .setMicroInitialOffsetA(self.getChildElementOptionalIntegerValue(child_element, "MICRO-INITIAL-OFFSET-A")) \
+                      .setMicroInitialOffsetB(self.getChildElementOptionalIntegerValue(child_element, "MICRO-INITIAL-OFFSET-B")) \
+                      .setMicroPerCycle(self.getChildElementOptionalIntegerValue(child_element, "MICRO-PER-CYCLE")) \
+                      .setMicrotickDuration(self.getChildElementOptionalTimeValue(child_element, "MICROTICK-DURATION")) \
+                      .setOffsetCorrectionOut(self.getChildElementOptionalIntegerValue(child_element, "OFFSET-CORRECTION-OUT")) \
+                      .setRateCorrectionOut(self.getChildElementOptionalIntegerValue(child_element, "RATE-CORRECTION-OUT")) \
+                      .setSamplesPerMicrotick(self.getChildElementOptionalIntegerValue(child_element, "SAMPLES-PER-MICROTICK")) \
+                      .setWakeUpPattern(self.getChildElementOptionalIntegerValue(child_element, "WAKE-UP-PATTERN"))
+
+    def readDataTransformationTransformerChainRefs(self, element: ET.Element, dtf: DataTransformation):
+        for ref in self.getChildElementRefTypeList(element, "TRANSFORMER-CHAIN-REFS/TRANSFORMER-CHAIN-REF"):
+            dtf.addTransformerChainRef(ref)
+
+    def readDataTransformation(self, element: ET.Element, dtf: DataTransformation):
+        self.readIdentifiable(element, dtf)
+        dtf.setExecuteDespiteDataUnavailability(self.getChildElementOptionalBooleanValue(element, "EXECUTE-DESPITE-DATA-UNAVAILABILITY"))
+        self.readDataTransformationTransformerChainRefs(element, dtf)
+
+    def readDataTransformationSetDataTransformations(self, element: ET.Element, dtf_set: DataTransformationSet):
+        for child_element in self.findall(element, "DATA-TRANSFORMATIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DATA-TRANSFORMATION":
+                dtf = dtf_set.createDataTransformation(self.getShortName(child_element))
+                self.readDataTransformation(child_element, dtf)
+            else:
+                self.notImplemented("Unsupported DataTransformation <%s>" % tag_name)
+
+    def readBufferPropertiesBufferComputation(self, element: ET.Element, properties: BufferProperties):
+        child_element = self.find(element, "BUFFER-COMPUTATION")
+        if child_element is not None:
+            scale = CompuScale()
+            self.readCompuScale(child_element, scale)
+            properties.setBufferComputation(scale)
+
+    def getBufferProperties(self, element: ET.Element, key: str) -> BufferProperties:
+        properties = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            properties = BufferProperties()
+            self.readBufferPropertiesBufferComputation(child_element, properties)
+            properties.setHeaderLength(self.getChildElementOptionalIntegerValue(child_element, "HEADER-LENGTH")) \
+                      .setInPlace(self.getChildElementOptionalBooleanValue(child_element, "IN-PLACE"))
+        return properties
+    
+    def readDescribable(self, element: ET.Element, desc: Describable):
+        self.readARObjectAttributes(element, desc)
+    
+    def readTransformationDescription(self, element: ET.Element, desc: TransformationDescription):
+        self.readDescribable(element, desc)
+    
+    def readEndToEndTransformationDescription(self, element: ET.Element, desc: EndToEndTransformationDescription):
+        self.readTransformationDescription(element, desc)
+        desc.setDataIdMode(self.getChildElementOptionalLiteral(element, "DATA-ID-MODE")) \
+            .setMaxDeltaCounter(self.getChildElementOptionalPositiveInteger(element, "MAX-DELTA-COUNTER")) \
+            .setMaxErrorStateInit(self.getChildElementOptionalPositiveInteger(element, "MAX-ERROR-STATE-INIT")) \
+            .setMaxErrorStateInvalid(self.getChildElementOptionalPositiveInteger(element, "MAX-ERROR-STATE-INVALID")) \
+            .setMaxErrorStateValid(self.getChildElementOptionalPositiveInteger(element, "MAX-ERROR-STATE-VALID")) \
+            .setMaxNoNewOrRepeatedData(self.getChildElementOptionalPositiveInteger(element, "MAX-NO-NEW-OR-REPEATED-DATA")) \
+            .setMinOkStateInit(self.getChildElementOptionalPositiveInteger(element, "MIN-OK-STATE-INIT")) \
+            .setMinOkStateInvalid(self.getChildElementOptionalPositiveInteger(element, "MIN-OK-STATE-INVALID")) \
+            .setMinOkStateValid(self.getChildElementOptionalPositiveInteger(element, "MIN-OK-STATE-VALID")) \
+            .setProfileBehavior(self.getChildElementOptionalLiteral(element, "PROFILE-BEHAVIOR")) \
+            .setProfileName(self.getChildElementOptionalLiteral(element, "PROFILE-NAME")) \
+            .setSyncCounterInit(self.getChildElementOptionalPositiveInteger(element, "SYNC-COUNTER-INIT")) \
+            .setUpperHeaderBitsToShift(self.getChildElementOptionalPositiveInteger(element, "UPPER-HEADER-BITS-TO-SHIFT")) \
+            .setWindowSizeInit(self.getChildElementOptionalPositiveInteger(element, "WINDOW-SIZE-INIT")) \
+            .setWindowSizeInvalid(self.getChildElementOptionalPositiveInteger(element, "WINDOW-SIZE-INVALID")) \
+            .setWindowSizeValid(self.getChildElementOptionalPositiveInteger(element, "WINDOW-SIZE-VALID"))
+
+    def readTransformationTechnologyTransformationDescriptions(self, element: ET.Element, tech: TransformationTechnology):
+        for child_element in self.findall(element, "TRANSFORMATION-DESCRIPTIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "END-TO-END-TRANSFORMATION-DESCRIPTION":
+                desc = EndToEndTransformationDescription()
+                self.readEndToEndTransformationDescription(child_element, desc)
+                tech.setTransformationDescription(desc)
+            else:
+                self.notImplemented("Unsupported TransformationDescription <%s>" % tag_name)
+
+    def readTransformationTechnology(self, element: ET.Element, tech: TransformationTechnology):
+        self.readIdentifiable(element, tech)
+        tech.setBufferProperties(self.getBufferProperties(element, "BUFFER-PROPERTIES")) \
+            .setNeedsOriginalData(self.getChildElementOptionalBooleanValue(element, "NEEDS-ORIGINAL-DATA")) \
+            .setProtocol(self.getChildElementOptionalLiteral(element, "PROTOCOL"))
+        self.readTransformationTechnologyTransformationDescriptions(element, tech)
+        tech.setTransformerClass(self.getChildElementOptionalLiteral(element, "TRANSFORMER-CLASS")) \
+            .setVersion(self.getChildElementOptionalLiteral(element, "VERSION"))
+
+    def readDataTransformationSetTransformationTechnologies(self, element: ET.Element, dtf_set: DataTransformationSet):
+        for child_element in self.findall(element, "TRANSFORMATION-TECHNOLOGYS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "TRANSFORMATION-TECHNOLOGY":
+                tech = dtf_set.createTransformationTechnology(self.getShortName(child_element))
+                self.readTransformationTechnology(child_element, tech)
+            else:
+                self.notImplemented("Unsupported TransformationTechnology <%s>" % tag_name)
+
+    def readDataTransformationSet(self, element: ET.Element, dtf_set: DataTransformationSet):
+        self.logger.debug("Read DataTransformationSet <%s>" % dtf_set.getShortName())
+        self.readIdentifiable(element, dtf_set)
+        self.readDataTransformationSetDataTransformations(element, dtf_set)
+        self.readDataTransformationSetTransformationTechnologies(element, dtf_set)
+
     def readCommunicationController(self, element: ET.Element, controller: CommunicationController):
         controller.setWakeUpByControllerSupported(self.getChildElementOptionalBooleanValue(element, "WAKE-UP-BY-CONTROLLER-SUPPORTED"))
 
@@ -3065,7 +4081,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, key)
         if child_element is not None:
             configuration = CanControllerFdConfiguration()
-            #TODO: need to implemented
+            # TODO: need to implemented
         return configuration
     
     def getCanControllerFdConfigurationRequirements(self, element: ET.Element, key: str) -> CanControllerFdConfigurationRequirements:
@@ -3081,7 +4097,7 @@ class ARXMLParser(AbstractARXMLParser):
                         .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"))
+                        .setTxBitRateSwitch(self.getChildElementOptionalBooleanValue(child_element, "TX-BIT-RATE-SWITCH"))      # NOQA E501
         return requirements
 
     def readAbstractCanCommunicationControllerAttributes(self, element: ET.Element, attributes: AbstractCanCommunicationControllerAttributes):
@@ -3171,9 +4187,9 @@ class ARXMLParser(AbstractARXMLParser):
         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)
+                membership = VlanMembership()
+                self.readVlanMembership(child_element, membership)
+                port.addVlanMembership(membership)
             else:
                 self.notImplemented("Unsupported VlanMembership <%s>" % tag_name)
 
@@ -3212,7 +4228,6 @@ class ARXMLParser(AbstractARXMLParser):
             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())
@@ -3227,6 +4242,9 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "LIN-MASTER":
                 controller = instance.createLinMaster(self.getShortName(child_element))
                 self.readLinMaster(child_element, controller)
+            elif tag_name == "FLEXRAY-COMMUNICATION-CONTROLLER":
+                controller = instance.createFlexrayCommunicationController(self.getShortName(child_element))
+                self.readFlexrayCommunicationController(child_element, controller)
             else:
                 self.raiseError("Unsupported Communication Controller <%s>" % tag_name)
 
@@ -3241,7 +4259,7 @@ class ARXMLParser(AbstractARXMLParser):
         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")) \
+            .setUseAuthDataFreshness(self.getChildElementOptionalBooleanValue(element, "USE-AUTH-DATA-FRESHNESS"))
 
     def readISignalPort(self, element: ET.Element, port: ISignalPort):
         self.readCommConnectorPort(element, port)
@@ -3261,7 +4279,7 @@ 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)
@@ -3272,13 +4290,21 @@ class ARXMLParser(AbstractARXMLParser):
     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)
 
+    def readFlexrayCommunicationConnector(self, element: ET.Element, connector: FlexrayCommunicationConnector):
+        self.readCommunicationConnector(element, connector)
+
     def readEcuInstanceConnectors(self, element: ET.Element, instance: EcuInstance):
         self.logger.debug("readEcuInstanceCommControllers %s" % instance.getShortName())
         for child_element in self.findall(element, "CONNECTORS/*"):
@@ -3292,6 +4318,9 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "LIN-COMMUNICATION-CONNECTOR":
                 connector = instance.createLinCommunicationConnector(self.getShortName(child_element))
                 self.readLinCommunicationConnector(child_element, connector)
+            elif tag_name == "FLEXRAY-COMMUNICATION-CONNECTOR":
+                connector = instance.createFlexrayCommunicationConnector(self.getShortName(child_element))
+                self.readFlexrayCommunicationConnector(child_element, connector)
             else:
                 self.notImplemented("Unsupported Communication Connector <%s>" % tag_name)
 
@@ -3309,7 +4338,8 @@ class ARXMLParser(AbstractARXMLParser):
                 .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"))
 
     '''
@@ -3370,7 +4400,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readEcucValueCollectionEcucValues(self, element: ET.Element, parent: EcucValueCollection):
         for child_element in self.findall(element, "ECUC-VALUES/ECUC-MODULE-CONFIGURATION-VALUES-REF-CONDITIONAL"):
-            ref = self.getChildElementOptionalRefType(child_element, "ECUC-MODULE-CONFIGURATION-VALUES-REF") 
+            ref = self.getChildElementOptionalRefType(child_element, "ECUC-MODULE-CONFIGURATION-VALUES-REF")
             if (ref is not None):
                 parent.addEcucValueRef(ref)
             self.logger.debug("EcucValue <%s> of EcucValueCollection <%s> has been added", ref.value, parent.getShortName())
@@ -3424,7 +4454,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, key)
         if child_element is not None:
             instance_ref = AnyInstanceRef()
-            instance_ref.setBaseRef(self.getChildElementOptionalRefType(child_element, "BASE-REF")) 
+            instance_ref.setBaseRef(self.getChildElementOptionalRefType(child_element, "BASE-REF"))
             for ref in self.getChildElementRefTypeList(child_element, "CONTEXT-ELEMENT-REF"):
                 instance_ref.addContextElementRef(ref)
             instance_ref.setTargetRef(self.getChildElementOptionalRefType(child_element, "TARGET-REF"))
@@ -3465,7 +4495,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "ECUC-CONTAINER-VALUE":
                 self.readEcucContainerValueEcucContainerValue(child_element, parent)
             else:
-                self.notImplemented("Unsupported Sub Container %s" % tag_name) 
+                self.notImplemented("Unsupported Sub Container %s" % tag_name)
 
     def readEcucModuleConfigurationValuesEcucContainerValue(self, element: ET.Element, parent: EcucModuleConfigurationValues):
         short_name = self.getShortName(element)
@@ -3479,7 +4509,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "ECUC-CONTAINER-VALUE":
                 self.readEcucModuleConfigurationValuesEcucContainerValue(child_element, values)
             else:
-                self.notImplemented("Unsupported Container %s" % tag_name) 
+                self.notImplemented("Unsupported Container %s" % tag_name)
 
     def readEcucModuleConfigurationValues(self, element: ET.Element, values: EcucModuleConfigurationValues):
         self.logger.debug("Read EcucModuleConfigurationValues %s" % values.getShortName())
@@ -3492,9 +4522,12 @@ class ARXMLParser(AbstractARXMLParser):
     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]:
@@ -3507,12 +4540,47 @@ class ARXMLParser(AbstractARXMLParser):
         return mappings
     '''
 
+    def readISignalGroupISignalRef(self, element: ET.Element, group: ISignalGroup):
+        for ref_type in self.getChildElementRefTypeList(element, "I-SIGNAL-REFS/I-SIGNAL-REF"):
+            group.addISignalRef(ref_type)
+
+    def readISignalGroupComBasedSignalGroupTransformation(self, element: ET.Element, group: ISignalGroup):
+        for ref in self.getChildElementRefTypeList(element, "COM-BASED-SIGNAL-GROUP-TRANSFORMATIONS/DATA-TRANSFORMATION-REF-CONDITIONAL/DATA-TRANSFORMATION-REF"):      # noqa E501
+            group.addComBasedSignalGroupTransformationRef(ref)
+
+    def readTransformationISignalProps(self, element: ET.Element, props: TransformationISignalProps):
+        self.readDescribable(element, props)
+
+    def readEndToEndTransformationISignalPropsDataIds(self, element: ET.Element, props: EndToEndTransformationISignalProps):
+        child_element = self.find(element, "DATA-IDS")
+        if child_element is not None:
+            props.addDataId(self.getChildElementOptionalPositiveInteger(child_element, "DATA-ID"))
+
+    def readEndToEndTransformationISignalProps(self, element: ET.Element, props: EndToEndTransformationISignalProps):
+        child_element = self.find(element, "END-TO-END-TRANSFORMATION-I-SIGNAL-PROPS-VARIANTS/END-TO-END-TRANSFORMATION-I-SIGNAL-PROPS-CONDITIONAL")
+        if child_element is not None:
+            self.readTransformationISignalProps(child_element, props)
+            props.setTransformerRef(self.getChildElementOptionalRefType(child_element, "TRANSFORMER-REF"))
+            self.readEndToEndTransformationISignalPropsDataIds(child_element, props)
+            props.setDataLength(self.getChildElementOptionalPositiveInteger(child_element, "DATA-LENGTH"))
+
+    def readISignalGroupTransformationISignalProps(self, element: ET.Element, group: ISignalGroup):
+        for child_element in self.findall(element, "TRANSFORMATION-I-SIGNAL-PROPSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "END-TO-END-TRANSFORMATION-I-SIGNAL-PROPS":
+                props = EndToEndTransformationISignalProps()
+                self.readEndToEndTransformationISignalProps(child_element, props)
+                group.setTransformationISignalProps(props)
+            else:
+                self.notImplemented("Unsupported TransformationISignalProps %s" % tag_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")
+        self.readISignalGroupComBasedSignalGroupTransformation(element, group)
+        self.readISignalGroupISignalRef(element, group)
+        group.setSystemSignalGroupRef(self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-GROUP-REF"))
+        self.readISignalGroupTransformationISignalProps(element, group)
 
     def readSystemSignal(self, element: ET.Element, signal: SystemSignal):
         self.logger.debug("Read SystemSignal <%s>" % signal.getShortName())
@@ -3543,7 +4611,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]:
@@ -3555,7 +4626,7 @@ class ARXMLParser(AbstractARXMLParser):
                      .setISignalInIPduRef(self.getChildElementOptionalRefType(child_element, "I-SIGNAL-IN-I-PDU-REF"))
             result.append(condition)
         return result
-    
+
     def getTimeRangeType(self, element: ET.Element, key: str) -> TimeRangeType:
         time_range = None
         child_element = self.find(element, key)
@@ -3563,7 +4634,7 @@ class ARXMLParser(AbstractARXMLParser):
             time_range = TimeRangeType()
             time_range.setValue(self.getChildElementOptionalTimeValue(child_element, "VALUE"))
         return time_range
-    
+
     def getCyclicTiming(self, element: ET.Element, key: str) -> CyclicTiming:
         timing = None
         child_element = self.find(element, key)
@@ -3595,11 +4666,12 @@ class ARXMLParser(AbstractARXMLParser):
     def getTransmissionModeDeclaration(self, element: ET.Element, key: str) -> TransmissionModeDeclaration:
         decl = None
         child_element = self.find(element, key)
-        if child_element != None:
+        if child_element is not None:
             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:
@@ -3611,16 +4683,16 @@ class ARXMLParser(AbstractARXMLParser):
                   .setTransmissionModeDeclaration(self.getTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION"))
         return timing
 
-    def readISignalIPdu(self, element: ET.Element, i_pdu: ISignalIPdu):
-        self.logger.debug("Read ISignalIPdu <%s>" % i_pdu.getShortName())
-        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 = [] 
+        ref_types = []
         for child_element in self.findall(element, "I-SIGNAL-I-PDUS/I-SIGNAL-I-PDU-REF-CONDITIONAL"):
             ref_types.append(self.getChildElementOptionalRefType(child_element, "I-SIGNAL-I-PDU-REF"))
         return ref_types
@@ -3635,26 +4707,61 @@ class ARXMLParser(AbstractARXMLParser):
         for ref_type in self.getISignalIPduRefs(element):
             group.addISignalIPduRef(ref_type)
 
-    def getSenderReceiverToSignalMapping(self, element: ET.Element) -> SenderReceiverToSignalMapping:
-        mapping = SenderReceiverToSignalMapping()
+    def readSenderReceiverToSignalMapping(self, element: ET.Element, mapping: SenderReceiverToSignalMapping):
         mapping.setCommunicationDirection(self.getChildElementOptionalLiteral(element, "COMMUNICATION-DIRECTION")) \
                .setDataElementIRef(self.getVariableDataPrototypeInSystemInstanceRef(self.find(element, "DATA-ELEMENT-IREF"))) \
                .setSystemSignalRef(self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF"))
-        return mapping
     
-    def getSenderReceiverToSignalGroupMapping(self, element: ET.Element) -> SenderReceiverToSignalGroupMapping:
-        mapping = SenderReceiverToSignalGroupMapping()
+    def readSenderRecCompositeTypeMapping(self, element: ET.Element, mapping: SenderRecCompositeTypeMapping):
+        self.readARObjectAttributes(element, mapping)
+
+    def readSenderRecRecordElementMapping(self, element: ET.Element, mapping: SenderRecRecordElementMapping):
+        self.readARObjectAttributes(element, mapping)
+        mapping.setApplicationRecordElementRef(self.getChildElementOptionalRefType(element, "APPLICATION-RECORD-ELEMENT-REF")) \
+               .setImplementationRecordElementRef(self.getChildElementOptionalRefType(element, "IMPLEMENTATION-RECORD-ELEMENT-REF")) \
+               .setSystemSignalRef(self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF"))
+
+    def readSenderRecArrayTypeMappingRecordElementMapping(self, element: ET.Element, mapping: SenderRecRecordTypeMapping):
+        for child_element in self.findall(element, "RECORD-ELEMENT-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SENDER-REC-RECORD-ELEMENT-MAPPING":
+                record_element_mapping = SenderRecRecordElementMapping()
+                self.readSenderRecRecordElementMapping(child_element, record_element_mapping)
+                mapping.addRecordElementMapping(record_element_mapping)
+            else:
+                self.notImplemented("Unsupported RecordElementMapping %s" % tag_name)
+    
+    def readSenderRecRecordTypeMapping(self, element: ET.Element, mapping: SenderRecRecordTypeMapping):
+        self.readSenderRecCompositeTypeMapping(element, mapping)
+        self.readSenderRecArrayTypeMappingRecordElementMapping(element, mapping)
+    
+    def readSenderReceiverToSignalGroupMappingTypeMapping(self, element: ET.Element, mapping: SenderReceiverToSignalGroupMapping):
+        child_element = self.find(element, "TYPE-MAPPING/*")
+        if child_element is not None:
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SENDER-REC-RECORD-TYPE-MAPPING":
+                type_mapping = SenderRecRecordTypeMapping()
+                self.readSenderRecRecordTypeMapping(child_element, type_mapping)
+                mapping.setTypeMapping(type_mapping)
+            else:
+                self.notImplemented("Unsupported Type Mapping %s" % tag_name)
+
+    def readSenderReceiverToSignalGroupMapping(self, element: ET.Element, mapping: SenderReceiverToSignalGroupMapping):
         mapping.setDataElementIRef(self.getVariableDataPrototypeInSystemInstanceRef(self.find(element, "DATA-ELEMENT-IREF")))
         mapping.setSignalGroupRef(self.getChildElementOptionalRefType(element, "SIGNAL-GROUP-REF"))
-        return mapping
-    
+        self.readSenderReceiverToSignalGroupMappingTypeMapping(element, mapping)
+
     def readSystemMappingDataMappings(self, element: ET.Element, mapping: SystemMapping):
         for child_element in self.findall(element, "DATA-MAPPINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "SENDER-RECEIVER-TO-SIGNAL-MAPPING":
-                mapping.addDataMapping(self.getSenderReceiverToSignalMapping(child_element))
+                signal_mapping = SenderReceiverToSignalMapping()
+                self.readSenderReceiverToSignalMapping(child_element, signal_mapping)
+                mapping.addDataMapping(signal_mapping)
             elif tag_name == "SENDER-RECEIVER-TO-SIGNAL-GROUP-MAPPING":
-                mapping.addDataMapping(self.getSenderReceiverToSignalGroupMapping(child_element))
+                signal_group_mapping = SenderReceiverToSignalGroupMapping()
+                self.readSenderReceiverToSignalGroupMapping(child_element, signal_group_mapping)
+                mapping.addDataMapping(signal_group_mapping)
             else:
                 self.notImplemented("Unsupported Data Mapping %s" % tag_name)
 
@@ -3664,31 +4771,62 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in self.findall(element, "COMPONENT-IREFS/COMPONENT-IREF"):
             mapping.addComponentIRef(self.getComponentInSystemInstanceRef(child_element))
         mapping.setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF"))
-            
+
     def readSystemMappingSwMappings(self, element: ET.Element, mapping: SystemMapping):
         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)
-            
+
     def readRootSwCompositionPrototype(self, element: ET.Element, system: System):
         child_element = self.find(element, "ROOT-SOFTWARE-COMPOSITIONS/ROOT-SW-COMPOSITION-PROTOTYPE")
         if child_element is not None:
@@ -3698,7 +4836,8 @@ 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)
@@ -3711,6 +4850,7 @@ class ARXMLParser(AbstractARXMLParser):
         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, frame: GenericEthernetFrame):
         self.logger.debug("Read GenericEthernetFrame <%s>" % frame.getShortName())
@@ -3779,7 +4919,7 @@ class ARXMLParser(AbstractARXMLParser):
                 type = parent.createComplexDeviceDriverSwComponentType(self.getShortName(child_element))
                 self.readComplexDeviceDriverSwComponentType(child_element, type)
             elif tag_name == "SWC-IMPLEMENTATION":
-                impl = parent.createSwcImplementation(self.getShortName(child_element))  
+                impl = parent.createSwcImplementation(self.getShortName(child_element))
                 self.readSwcImplementation(child_element, impl)
             elif tag_name == "APPLICATION-PRIMITIVE-DATA-TYPE":
                 data_type = parent.createApplicationPrimitiveDataType(self.getShortName(child_element))
@@ -3818,7 +4958,7 @@ class ARXMLParser(AbstractARXMLParser):
                 mapping = parent.createSwcBswMapping(self.getShortName(child_element))
                 self.readSwcBswMapping(child_element, mapping)
             elif tag_name == "BSW-IMPLEMENTATION":
-                impl = parent.createBswImplementation(self.getShortName(child_element))   
+                impl = parent.createBswImplementation(self.getShortName(child_element))
                 self.readBswImplementation(child_element, impl)
             elif tag_name == "IMPLEMENTATION-DATA-TYPE":
                 data_type = parent.createImplementationDataType(self.getShortName(child_element))
@@ -3881,7 +5021,7 @@ class ARXMLParser(AbstractARXMLParser):
                 i_pdu = parent.createSecuredIPdu(self.getShortName(child_element))
                 self.readSecuredIPdu(child_element, i_pdu)
             elif tag_name == "NM-CONFIG":
-                config = parent.createNmConfig(self.getShortName(child_element)) 
+                config = parent.createNmConfig(self.getShortName(child_element))
                 self.readNmConfig(child_element, config)
             elif tag_name == "CAN-TP-CONFIG":
                 config = parent.createCanTpConfig(self.getShortName(child_element))
@@ -3979,11 +5119,28 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "DO-IP-TP-CONFIG":
                 config = parent.createDoIpTpConfig(self.getShortName(child_element))
                 self.readDoIpTpConfig(child_element, config)
+            elif tag_name == "HW-ELEMENT":
+                hw_element = parent.createHwElement(self.getShortName(child_element))
+                self.readHwElement(child_element, hw_element)
+            elif tag_name == "HW-CATEGORY":
+                hw_category = parent.createHwCategory(self.getShortName(child_element))
+                self.readHwCategory(child_element, hw_category)
+            elif tag_name == "HW-TYPE":
+                type = parent.createHwType(self.getShortName(child_element))
+                self.readHwType(child_element, type)
+            elif tag_name == "FLEXRAY-FRAME":
+                frame = parent.createFlexrayFrame(self.getShortName(child_element))
+                self.readFlexrayFrame(child_element, frame)
+            elif tag_name == "FLEXRAY-CLUSTER":
+                cluster = parent.createFlexrayCluster(self.getShortName(child_element))
+                self.readFlexrayCluster(child_element, cluster)
+            elif tag_name == "DATA-TRANSFORMATION-SET":
+                transformation_set = parent.createDataTransformationSet(self.getShortName(child_element))
+                self.readDataTransformationSet(child_element, transformation_set)
             else:
                 self.notImplemented("Unsupported element type of ARPackage <%s>" % tag_name)
 
     def readReferenceBases(self, element: ET.Element, parent: ARPackage):
-        self.logger.debug("Read ReferenceBases")
         for child_element in self.findall(element, "REFERENCE-BASES/REFERENCE-BASE"):
             base = ReferenceBase()
             base.setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
@@ -3993,20 +5150,25 @@ class ARXMLParser(AbstractARXMLParser):
                 .setPackageRef(self.getChildElementOptionalRefType(child_element, "PACKAGE-REF"))
             parent.addReferenceBase(base)
 
-    def readARPackages(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:AR-PACKAGES/xmlns:AR-PACKAGE", self.nsmap):
-            short_name = self.getShortName(child_element)
-            ar_package = parent.createARPackage(short_name)
+    def readARPackage(self, element: ET.Element, ar_package: ARPackage):
+        self.logger.debug("Read ARPackages %s" % ar_package.getFullName())
 
-            self.logger.debug("readARPackages %s" % ar_package.full_name)
+        self.readIdentifiable(element, ar_package)
+        self.readARPackages(element, ar_package)
+        self.readARPackageElements(element, ar_package)
+        self.readReferenceBases(element, ar_package)
 
-            self.readIdentifiable(child_element, ar_package)
-            self.readARPackages(child_element, ar_package)
-            self.readARPackageElements(child_element, ar_package)
-            self.readReferenceBases(child_element, ar_package)
+    def readARPackages(self, element: ET.Element, parent: ARPackage):
+        for child_element in self.findall(element, "AR-PACKAGES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "AR-PACKAGE":
+                ar_package = parent.createARPackage(self.getShortName(child_element))
+                self.readARPackage(child_element, ar_package)
+            else:
+                self.notImplemented("Unsupported ARPackage <%s>" % tag_name)
 
     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()
@@ -4014,7 +5176,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.raiseError("Invalid ARXML file <%s>" % filename)
 
         self.getAUTOSARInfo(root, document)
-        document.setAdminData(self.getAdminData(root, "ADMIN-DATA")) 
+        document.setAdminData(self.getAdminData(root, "ADMIN-DATA"))
         self.readARPackages(root, document)
 
         document.reload()