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

armodel/parser/arxml_parser.py

@@ -2,14 +2,12 @@ from typing import List
 import xml.etree.ElementTree as ET
 import os
 
-from armodel.models.M2.AUTOSARTemplates.SystemTemplate.SWmapping import SwcToImplMapping
-
-
-
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition, 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
@@ -26,83 +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 BswBackgroundEvent, BswCalledEntity, BswDataReceivedEvent, BswExternalTriggerOccurredEvent, 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, Referrable
+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 AsynchronousServerCallReturnsEvent, BackgroundEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, ModeSwitchedAckEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationPrimitiveDataType, ApplicationRecordDataType, ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, AutosarDataType, DataTypeMap, DataTypeMappingSet
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionSet, EndToEndDescription, EndToEndProtection, EndToEndProtectionVariablePrototype
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.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, ModeSwitchedAckRequest, 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.ECUResourceMapping import ECUMapping
-from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmEcu, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmEcu, UdpNmNode
-from ..models.M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import ApplicationEntry, LinFrameTriggering, LinScheduleTable, LinUnconditionalFrame, ScheduleTableEntry
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinCommunicationController, LinMaster
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanClusterBusOffRecovery, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, CommunicationController, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import DcmIPdu, DynamicPart, DynamicPartAlternative, Frame, FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignal, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalToIPduMapping, ISignalTriggering, MultiplexedIPdu, MultiplexedPart, NPdu, NmPdu, Pdu, PduTriggering, SecureCommunicationAuthenticationProps, SecureCommunicationFreshnessProps, SecureCommunicationProps, SecureCommunicationPropsSet, SecuredIPdu, SegmentPosition, StaticPart, SystemSignal, SystemSignalGroup, UserDefinedIPdu, UserDefinedPdu
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import CyclicTiming, EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
+from ..models.M2.AUTOSARTemplates.SystemTemplate.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 CanTpAddress, CanTpChannel, CanTpConfig, CanTpConnection, CanTpEcu, CanTpNode, DoIpLogicAddress, DoIpTpConfig, DoIpTpConnection, LinTpConfig, LinTpConnection, LinTpNode, TpAddress, TpConfig, TpConnection
+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)
@@ -115,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()
@@ -124,12 +219,12 @@ class ARXMLParser(AbstractARXMLParser):
             sd.setValue(child_element.text)
             sdg.addSd(sd)
 
-    def readSdgCaption(self, element: ET.Element, sdg:Sdg):
+    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):
+    def readSdgSdxRefs(self, element: ET.SubElement, sdg: Sdg):
         for ref in self.getChildElementRefTypeList(element, "SDX-REF"):
             sdg.addSdxRef(ref)
 
@@ -143,16 +238,20 @@ class ARXMLParser(AbstractARXMLParser):
             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"))
@@ -176,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"):
@@ -185,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:
@@ -203,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:
@@ -216,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"))
@@ -284,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"):
@@ -321,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)
@@ -381,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)
@@ -393,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()
@@ -439,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")) \
@@ -464,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")) \
@@ -502,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)
 
@@ -592,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 = []
@@ -624,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())
@@ -649,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":
@@ -665,13 +823,17 @@ class ARXMLParser(AbstractARXMLParser):
         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":
@@ -686,35 +848,110 @@ class ARXMLParser(AbstractARXMLParser):
             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"))
 
@@ -778,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")) \
@@ -830,7 +1067,8 @@ 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())
 
@@ -840,19 +1078,19 @@ class ARXMLParser(AbstractARXMLParser):
         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:
@@ -868,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):
@@ -903,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):
@@ -922,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":
@@ -932,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/*"):
@@ -983,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)
@@ -993,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)
@@ -1039,7 +1303,7 @@ 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, event: OperationInvokedEvent):
@@ -1051,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)
@@ -1072,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)
@@ -1090,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")) \
@@ -1195,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 = []
@@ -1204,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):
@@ -1235,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
@@ -1277,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:
@@ -1349,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"))
@@ -1363,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"):
@@ -1410,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:
@@ -1480,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
     
@@ -1514,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")) \
@@ -1543,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"))
@@ -1554,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")
@@ -1592,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))
@@ -1602,20 +1868,20 @@ class ARXMLParser(AbstractARXMLParser):
                 .setTransmissionAcknowledge(self.readTransmissionAcknowledgementRequest(element)) \
                 .setUsesEndToEndProtection(self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION"))
 
-    def getNonqueuedSenderComSpec(self, element:ET.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:ET.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:ET.Element) -> QueuedSenderComSpec:
+    def getQueuedSenderComSpec(self, element: ET.Element) -> QueuedSenderComSpec:
         com_spec = QueuedSenderComSpec()
         self.readSenderComSpec(element, com_spec)
         return com_spec
@@ -1652,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)
 
@@ -1678,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())
@@ -1711,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")) \
@@ -1721,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")
@@ -1741,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"))
 
-            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 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)
+
+    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")
@@ -1771,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):
@@ -1836,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"):
@@ -1866,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")
@@ -1883,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:
@@ -1979,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")
@@ -1986,13 +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")) \
-                           .setDesc(self.getMultiLanguageOverviewParagraph(child_element, "DESC")) \
-                           .setSymbol(self.getChildElementOptionalLiteral(child_element, "SYMBOL")) \
-                           .setUpperLimit(self.getChildLimitElement(child_element, "UPPER-LIMIT"))
-                self.readCompuScaleContents(child_element, compu_scale)
+                self.readCompuScale(child_element, compu_scale)
                 compu_scales.addCompuScale(compu_scale)
         return compu_scales
     
@@ -2002,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
 
@@ -2030,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")) \
@@ -2042,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")) \
@@ -2071,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":
@@ -2148,59 +2447,80 @@ 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/*"):
@@ -2215,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"))
 
@@ -2246,10 +2562,10 @@ 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"))
@@ -2257,13 +2573,13 @@ class ARXMLParser(AbstractARXMLParser):
             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()
@@ -2272,7 +2588,6 @@ class ARXMLParser(AbstractARXMLParser):
                     .setSwRecordLayoutVAxis(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-AXIS")) \
                     .setSwRecordLayoutVProp(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-PROP")) \
                     .setSwRecordLayoutVIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-INDEX"))
-            #print(layout_v.getShortLabel())
         return layout_v
     
     def readSwRecordLayoutGroupSwRecordLayoutGroupContentType(self, element: ET.Element, group: SwRecordLayoutGroup):
@@ -2282,19 +2597,19 @@ class ARXMLParser(AbstractARXMLParser):
         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()
             group.setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
-                 .setCategory(self.getChildElementOptionalLiteral(child_element, "CATEGORY")) 
-            self.readSwRecordLayoutGroupSwRecordLayoutGroupContentType(child_element, group)
-            group.setSwRecordLayoutGroupAxis(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS")) \
+                 .setCategory(self.getChildElementOptionalLiteral(child_element, "CATEGORY")) \
+                 .setSwRecordLayoutGroupAxis(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS")) \
                  .setSwRecordLayoutGroupIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-INDEX")) \
                  .setSwRecordLayoutGroupFrom(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-FROM")) \
                  .setSwRecordLayoutGroupStep(self.getChildElementOptionalIntegerValue(child_element, "SW-RECORD-LAYOUT-GROUP-STEP")) \
                  .setSwRecordLayoutGroupTo(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO"))
-            #print(group.getShortLabel())
+            self.readSwRecordLayoutGroupSwRecordLayoutGroupContentType(child_element, group)
+            
         return group
 
     def readSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
@@ -2305,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")) \
@@ -2379,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"))
@@ -2387,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")) \
@@ -2396,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())
@@ -2421,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":
@@ -2433,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":
@@ -2443,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":
@@ -2452,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):
@@ -2492,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)
 
@@ -2517,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:
@@ -2525,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:
@@ -2571,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")) \
@@ -2586,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):
@@ -2616,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")) \
@@ -2657,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
@@ -2722,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)
@@ -2744,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/*"):
@@ -2785,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)
@@ -2793,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":
@@ -2818,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)
@@ -2836,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"))
@@ -2857,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"))
@@ -2873,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",))
@@ -3082,6 +3479,53 @@ class ARXMLParser(AbstractARXMLParser):
         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"):
             short_name = self.getShortName(child_element)
@@ -3153,7 +3597,7 @@ class ARXMLParser(AbstractARXMLParser):
                  .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"))
+                 .setFreshnessValueTxLength(self.getChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-TX-LENGTH"))            # NOQA E501
         return props
 
     def readSecuredIPdu(self, element: ET.Element, i_pdu: SecuredIPdu):
@@ -3176,7 +3620,6 @@ class ARXMLParser(AbstractARXMLParser):
             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())
@@ -3205,7 +3648,7 @@ class ARXMLParser(AbstractARXMLParser):
                 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")) \
@@ -3401,7 +3844,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     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")) 
+              .setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF"))
 
     def readCanTpConfigTpEcus(self, element: ET.Element, config: CanTpConfig):
         for child_element in self.findall(element, "TP-ECUS/*"):
@@ -3457,7 +3900,7 @@ class ARXMLParser(AbstractARXMLParser):
         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")) 
+                  .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")) \
@@ -3502,6 +3945,134 @@ class ARXMLParser(AbstractARXMLParser):
         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"))
 
@@ -3510,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:
@@ -3526,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):
@@ -3616,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)
 
@@ -3657,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())
@@ -3672,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)
 
@@ -3686,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)
@@ -3706,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)
@@ -3729,6 +4302,9 @@ class ARXMLParser(AbstractARXMLParser):
     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/*"):
@@ -3742,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)
 
@@ -3821,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())
@@ -3875,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"))
@@ -3916,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)
@@ -3930,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())
@@ -3961,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())
@@ -3999,7 +4613,7 @@ class ARXMLParser(AbstractARXMLParser):
             filter = DataFilter()
             filter.setDataFilterType(self.getChildElementOptionalLiteral(child_element, "DATA-FILTER-TYPE")) \
                   .setMask(self.getChildElementOptionalIntegerValue(child_element, "MASK")) \
-                  .setX(self.getChildElementOptionalIntegerValue(child_element, "X")) 
+                  .setX(self.getChildElementOptionalIntegerValue(child_element, "X"))
 
         return filter
             
@@ -4012,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)
@@ -4020,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)
@@ -4052,7 +4666,7 @@ 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)
@@ -4078,7 +4692,7 @@ class ARXMLParser(AbstractARXMLParser):
         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
@@ -4093,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)
 
@@ -4122,7 +4771,7 @@ 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)
@@ -4135,7 +4784,7 @@ class ARXMLParser(AbstractARXMLParser):
     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")) 
+               .setEcuRef(self.getChildElementOptionalRefType(element, "ECU-REF"))
 
     def readSystemMappingEcuResourceMappings(self, element: ET.Element, mapping: SystemMapping):
         for child_element in self.findall(element, "ECU-RESOURCE-MAPPINGS/*"):
@@ -4177,7 +4826,7 @@ class ARXMLParser(AbstractARXMLParser):
                 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:
@@ -4188,7 +4837,7 @@ class ARXMLParser(AbstractARXMLParser):
             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)
@@ -4270,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))
@@ -4309,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))
@@ -4372,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))
@@ -4470,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")) \
@@ -4484,17 +5150,22 @@ 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("Loading %s ..." % os.path.realpath(filename))
@@ -4505,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()