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

armodel/writer/arxml_writer.py

@@ -1,10 +1,11 @@
 import xml.etree.cElementTree as ET
 from typing import List
 
-from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfoSet
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition, SwBaseType
-from ..models.M2.MSR.AsamHdo.ComputationMethod import Compu, CompuConst, CompuConstContent, CompuConstFormulaContent, CompuConstNumericContent, CompuConstTextContent, CompuMethod, CompuNominatorDenominator, CompuScale, CompuScaleConstantContents, CompuScaleRationalFormula, CompuScales
+from ..models.M2.MSR.AsamHdo.ComputationMethod import Compu, CompuConst, CompuConstContent, CompuConstFormulaContent, CompuConstNumericContent
+from ..models.M2.MSR.AsamHdo.ComputationMethod import CompuConstTextContent, CompuMethod, CompuNominatorDenominator, CompuScale
+from ..models.M2.MSR.AsamHdo.ComputationMethod import CompuScaleConstantContents, CompuScaleRationalFormula, CompuScales
 from ..models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstr, InternalConstrs, PhysConstrs
 from ..models.M2.MSR.AsamHdo.SpecialData import Sdg
 from ..models.M2.MSR.AsamHdo.Units import PhysicalDimension, Unit
@@ -19,84 +20,181 @@ from ..models.M2.MSR.Documentation.Annotation import Annotation
 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, LPlainText, 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 BswApiOptions, BswBackgroundEvent, BswCalledEntity, BswDataReceivedEvent, BswInternalTriggerOccurredEvent, BswOperationInvokedEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswDataReceptionPolicy, BswEvent, BswExternalTriggerOccurredEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalBehavior, BswInterruptEntity, BswModeSenderPolicy, BswModuleEntity
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswQueuedDataReceptionPolicy, BswSchedulableEntity, BswScheduleEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswTimingEvent, BswVariableAccess
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswImplementation import BswImplementation
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswEvent, BswInternalBehavior, BswInterruptEntity, BswModeSenderPolicy, BswModuleEntity, BswSchedulableEntity, BswScheduleEvent, BswTimingEvent
-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.FlatMap import FlatInstanceDescriptor, FlatMap
 from ..models.M2.AUTOSARTemplates.CommonStructure.Filter import DataFilter
-from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
 from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import Code, Implementation, ImplementationProps
-from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingExtensions import SwcTiming, TimingExtension
-from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import EOCExecutableEntityRef, ExecutionOrderConstraint
-from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal, DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds, DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds, EcuStateMgrUserNeeds, NvBlockNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
-from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
 from ..models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
+from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
 from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
 from ..models.M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclaration, ModeDeclarationGroup, ModeDeclarationGroupPrototype
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import ResourceConsumption
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import RoughEstimateStackUsage, StackUsage
+from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
+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.Timing.TimingConstraint.TimingExtensions import SwcTiming, TimingExtension
+from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import EOCExecutableEntityRef
+from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import ExecutionOrderConstraint
+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.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
-from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable, MultilanguageReferrable, Referrable
+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.ARPackage import ARPackage, ReferenceBase
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
+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.PrimitiveTypes import RefType, ARLiteral, Limit
-
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption, PortDefinedArgumentValue
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
+from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfoSet
+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, PPortComSpec
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import ParameterRequireComSpec, QueuedReceiverComSpec, QueuedSenderComSpec
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import RPortComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import ApplicationSwComponentType, AtomicSwComponentType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import ComplexDeviceDriverSwComponentType, CompositionSwComponentType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import EcuAbstractionSwComponentType, PRPortPrototype, PortGroup, SwComponentType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import PPortPrototype, PortPrototype, RPortPrototype, SymbolProps
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import ServiceSwComponentType
+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, RVariableInAtomicSwcInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import AssemblySwConnector, DelegationSwConnector, SwComponentPrototype, SwConnector
+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.Datatype.DataPrototypes import ApplicationArrayElement
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationCompositeElementDataPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationRecordElement, AutosarDataPrototype, DataPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype, VariableDataPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationDataType, ApplicationPrimitiveDataType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationRecordDataType, AutosarDataType
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import DataTypeMappingSet
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndDescription, EndToEndProtection, EndToEndProtectionISignalIPdu
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionVariablePrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionSet
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ApplicationError, ArgumentDataPrototype, ClientServerInterface
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ClientServerOperation, DataInterface
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import DataPrototypeMapping, ModeSwitchInterface, ParameterInterface
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import PortInterface, PortInterfaceMappingSet, SenderReceiverInterface
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import TriggerInterface, VariableAndParameterInterfaceMapping
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface.InstanceRefs import ApplicationCompositeElementInPortInterfaceInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior import AsynchronousServerCallPoint, RunnableEntity, RunnableEntityArgument
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior import SwcInternalBehavior, SynchronousServerCallPoint
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AutosarVariableRef import AutosarVariableRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import 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.IncludedDataTypes import IncludedDataTypeSet
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType, AutosarDataType
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndDescription, EndToEndProtection, EndToEndProtectionVariablePrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, TransmissionAcknowledgementRequest
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, ApplicationSwComponentType, AtomicSwComponentType, ComplexDeviceDriverSwComponentType, CompositionSwComponentType, EcuAbstractionSwComponentType, PRPortPrototype, PortGroup, SwComponentType, PPortPrototype, PortPrototype, RPortPrototype, SymbolProps
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import InnerPortGroupInCompositionInstanceRef, PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef, RModeInAtomicSwcInstanceRef, RVariableInAtomicSwcInstanceRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior import AsynchronousServerCallPoint, RunnableEntity, RunnableEntityArgument, SwcInternalBehavior, SynchronousServerCallPoint
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AutosarVariableRef import AutosarVariableRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import ModeAccessPoint, ModeSwitchPoint
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import AssemblySwConnector, DelegationSwConnector, SwComponentPrototype, SwConnector
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface.InstanceRefs import ApplicationCompositeElementInPortInterfaceInstanceRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, VariableInAtomicSWCTypeInstanceRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import ClientComSpec, ModeSwitchReceiverComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, PPortComSpec, ParameterRequireComSpec,  QueuedReceiverComSpec, QueuedSenderComSpec, RPortComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationArrayElement, ApplicationCompositeElementDataPrototype, ApplicationRecordElement, AutosarDataPrototype, DataPrototype, ParameterDataPrototype, VariableDataPrototype
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import ServiceSwComponentType
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import DataTypeMappingSet
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionSet
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ApplicationError, ClientServerInterface, ClientServerOperation, DataPrototypeMapping, ModeSwitchInterface, ParameterInterface, PortInterface, PortInterfaceMappingSet, SenderReceiverInterface, TriggerInterface, VariableAndParameterInterfaceMapping
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcImplementation import SwcImplementation
 
 from ..models.M2.AUTOSARTemplates.SystemTemplate import SwcToEcuMapping, System, SystemMapping
-from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderReceiverToSignalGroupMapping, SenderReceiverToSignalMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderRecCompositeTypeMapping, SenderRecRecordElementMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderRecRecordTypeMapping, SenderReceiverToSignalGroupMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderReceiverToSignalMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.DiagnosticConnection import DiagnosticConnection
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalTriggering, MultiplexedIPdu, PduTriggering, SecureCommunicationPropsSet, SecuredIPdu, SystemSignal, DcmIPdu, Frame, ISignal, NPdu, NmPdu, SystemSignalGroup, UserDefinedIPdu, UserDefinedPdu
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import CyclicTiming, EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SoAdRoutingGroup, SocketConnection, SocketConnectionBundle, SocketConnectionIpduIdentifier
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetFrame import GenericEthernetFrame
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import CouplingPort, CouplingPortDetails, CouplingPortFifo, CouplingPortScheduler, CouplingPortStructuralElement, EthernetCluster, EthernetCommunicationConnector, EthernetCommunicationController, EthernetPriorityRegeneration, InitialSdDelayConfig, MacMulticastGroup, RequestResponseDelay, SdClientConfig, VlanMembership
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import DoIpEntity, InfrastructureServices, Ipv6Configuration, NetworkEndpoint, NetworkEndpointAddress
-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.Fibex4Multiplatform import Gateway, IPduMapping, ISignalMapping, TargetIPduRef
+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.Fibex4Lin.LinCommunication import ApplicationEntry, LinFrameTriggering, LinScheduleTable, LinUnconditionalFrame, ScheduleTableEntry
-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.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.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, NetworkEndpointAddress
+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.Fibex.FibexCore.CoreCommunication import DynamicPart, DynamicPartAlternative, FrameTriggering
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import ISignalGroup, ISignalIPdu, ISignalIPduGroup
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import ISignalToIPduMapping, ISignalTriggering, MultiplexedIPdu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import MultiplexedPart, Pdu, PduTriggering
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import 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, DcmIPdu, Frame, ISignal, NPdu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import NmPdu, SystemSignalGroup, UserDefinedIPdu, UserDefinedPdu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanClusterBusOffRecovery
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import FlexrayPhysicalChannel, CommunicationCycle, CycleRepetition
+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, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmNode
-from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpConfig, DoIpTpConfig, LinTpConfig
+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_writer import AbstractARXMLWriter
+
+
 class ARXMLWriter(AbstractARXMLWriter):
     def __init__(self, options=None) -> None:
         super().__init__(options)
@@ -110,7 +208,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setChildElementRxIdentifierRange(self, element: ET.Element, key: str, range: RxIdentifierRange):
         if range is not None:
             child_element = ET.SubElement(element, key)
-            self.setChildElementOptionalNumericalValue(child_element, "LOWER-CAN-ID", range.getLowerCanId()) 
+            self.setChildElementOptionalNumericalValue(child_element, "LOWER-CAN-ID", range.getLowerCanId())
             self.setChildElementOptionalNumericalValue(child_element, "UPPER-CAN-ID", range.getUpperCanId())
     
     def writeSds(self, parent: ET.Element, sdg: Sdg):
@@ -120,14 +218,26 @@ class ARXMLWriter(AbstractARXMLWriter):
                 sd_tag.attrib['GID'] = sd.gid
             sd_tag.text = sd.value
 
-    def setSdg(self, parent: ET.Element, sdg: Sdg):
+    def writeSdgCaption(self, element: ET.Element, sdg: Sdg):
+        caption = sdg.getSdgCaption()
+        if caption is not None:
+            child_element = ET.SubElement(element, "SDG-CAPTION")
+            self.writeMultilanguageReferrable(child_element, caption)
+
+    def writeSdgSdxRefs(self, element: ET.Element, sdg: Sdg):
+        for ref in sdg.getSdxRefs():
+            self.setChildElementOptionalRefType(element, "SDX-REF", ref)
+
+    def setSdg(self, element: ET.Element, sdg: Sdg):
         if sdg is not None:
-            sdg_tag = ET.SubElement(parent, "SDG")
+            child_element = ET.SubElement(element, "SDG")
             if sdg.gid is not None and sdg.gid != "":
-                sdg_tag.attrib['GID'] = sdg.gid
-            self.writeSds(sdg_tag, sdg)
+                child_element.attrib['GID'] = sdg.gid
+            self.writeSdgCaption(child_element, sdg)
+            self.writeSds(child_element, sdg)
             for sdg_item in sdg.getSdgContentsTypes():
-                self.setSdg(sdg_tag, sdg_item)
+                self.setSdg(child_element, sdg_item)
+            self.writeSdgSdxRefs(child_element, sdg)
             
     def writeSdgs(self, parent: ET.Element, admin_data: AdminData):
         sdgs = admin_data.getSdgs()
@@ -139,18 +249,18 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setChildLimitElement(self, element: ET.Element, key: str, limit: Limit):
         if limit is not None:
             limit_tag = ET.SubElement(element, key)
-            self.setARObjectAttributes(limit_tag, limit)
+            self.writeARObjectAttributes(limit_tag, limit)
             if limit.intervalType is not None:
                 limit_tag.attrib['INTERVAL-TYPE'] = limit.intervalType
             limit_tag.text = limit.value
     
     def writeReferrable(self, element: ET.Element, referrable: Referrable):
-        self.setARObjectAttributes(element, referrable)
+        self.writeARObjectAttributes(element, referrable)
         self.setShortName(element, referrable.getShortName())
 
     def setLanguageSpecific(self, element: ET.Element, key: str, specific: LanguageSpecific):
         child_element = ET.SubElement(element, key)
-        self.setARObjectAttributes(child_element, specific)
+        self.writeARObjectAttributes(child_element, specific)
         if specific.l is not None:
             child_element.attrib['L'] = specific.l
         child_element.text = specific.value
@@ -161,7 +271,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setMultiLongName(self, element: ET.Element, key: str, long_name: MultilanguageLongName):
         if long_name is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, long_name)
+            self.writeARObjectAttributes(child_element, long_name)
             for l4 in long_name.getL4s():
                 self.setLLongName(child_element, l4)
 
@@ -171,7 +281,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setMultiLanguageOverviewParagraph(self, element: ET.Element, key: str, paragraph: MultiLanguageOverviewParagraph):
         if paragraph is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, paragraph)
+            self.writeARObjectAttributes(child_element, paragraph)
             for l2 in paragraph.getL2s():
                 self.setLOverviewParagraph(child_element, l2)
 
@@ -186,7 +296,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setMultiLanguagePlainText(self, element: ET.Element, key: str, paragraph: MultiLanguagePlainText):
         if paragraph is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, paragraph)
+            self.writeARObjectAttributes(child_element, paragraph)
             for l10 in paragraph.getL10s():
                 self.setLPlainText(child_element, l10)
 
@@ -207,12 +317,12 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeARElement(self, parent: ET.Element, ar_element: ARElement):
         self.writeIdentifiable(parent, ar_element)
-    
+
     def setTransmissionAcknowledgementRequest(self, element: ET.Element, acknowledge: TransmissionAcknowledgementRequest):
-        if (acknowledge != None):
+        if (acknowledge is not None):
             child_element = ET.SubElement(element, "TRANSMISSION-ACKNOWLEDGE")
-            self.setARObjectAttributes(child_element, acknowledge)
-            if acknowledge.timeout != None:
+            self.writeARObjectAttributes(child_element, acknowledge)
+            if acknowledge.timeout is not None:
                 self.setChildElementOptionalFloatValue(child_element, "TIMEOUT", acknowledge.timeout)
 
     def setSenderComSpec(self, element: ET.Element, com_spec: SenderComSpec):
@@ -226,28 +336,35 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE", com_spec.getHandleOutOfRange())
         self.setTransmissionAcknowledgementRequest(element, com_spec.getTransmissionAcknowledge())
         self.setChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION", com_spec.getUsesEndToEndProtection())
-    
+
     def setNonqueuedSenderComSpec(self, element: ET.Element, com_spec: NonqueuedSenderComSpec):
         child_element = ET.SubElement(element, "NONQUEUED-SENDER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setSenderComSpec(child_element, com_spec)
         self.setValueSpecification(child_element, "INIT-VALUE", com_spec.getInitValue())
-            
+
     def setServerComSpec(self, element: ET.Element, com_spec: ServerComSpec):
         child_element = ET.SubElement(element, "SERVER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "OPERATION-REF", com_spec.getOperationRef())
-        self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH",    com_spec.getQueueLength())
+        self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH", com_spec.getQueueLength())
 
     def setQueuedSenderComSpec(self, element: ET.Element, com_spec: QueuedSenderComSpec):
         child_element = ET.SubElement(element, "QUEUED-SENDER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setSenderComSpec(child_element, com_spec)
 
+    def setModeSwitchedAckRequest(self, element: ET.Element, key: str, request: ModeSwitchedAckRequest):
+        if request is not None:
+            child_element = ET.SubElement(element, key)
+            self.writeARObjectAttributes(child_element, request)
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT", request.getTimeout())
+
     def setModeSwitchSenderComSpec(self, element: ET.Element, com_spec: ModeSwitchSenderComSpec):
         child_element = ET.SubElement(element, "MODE-SWITCH-SENDER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.getModeGroupRef())
+        self.setModeSwitchedAckRequest(child_element, "MODE-SWITCHED-ACK", com_spec.getModeSwitchedAck())
         self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH", com_spec.getQueueLength())
     
     def writePPortComSpec(self, com_specs_tag: ET.Element, com_spec: PPortComSpec):
@@ -261,14 +378,14 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setModeSwitchSenderComSpec(com_specs_tag, com_spec)
         else:
             self.notImplemented("Unsupported PPortComSpec %s" % type(com_spec))
-        
-    def setApplicationCompositeElementInPortInterfaceInstanceRef(self, element: ET.Element, key:str, iref: ApplicationCompositeElementInPortInterfaceInstanceRef):
+
+    def setApplicationCompositeElementInPortInterfaceInstanceRef(self, element: ET.Element, key: str, iref: ApplicationCompositeElementInPortInterfaceInstanceRef):     # noqa E501
         if iref is not None:
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalRefType(child_element, "ROOT-DATA-PROTOTYPE-REF", iref.root_data_prototype_ref)
             self.setChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF", iref.target_data_prototype_ref)
         return iref
-        
+
     def setCompositeNetworkRepresentation(self, element: ET.Element, representation: CompositeNetworkRepresentation):
         if representation is not None:
             self.logger.debug("setCompositeNetworkRepresentation")
@@ -291,7 +408,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setSwValues(self, element: ET.Element, key: str, sw_values: SwValues):
         if sw_values is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, sw_values)
+            self.writeARObjectAttributes(child_element, sw_values)
             for v in sw_values.getVs():
                 self.setChildElementOptionalFloatValue(child_element, "V", v)
             self.setChildElementOptionalLiteral(child_element, "VT", sw_values.vt)
@@ -299,42 +416,35 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setValueList(self, element: ET.Element, key: str, value_list: ValueList):
         if value_list is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, value_list)
+            self.writeARObjectAttributes(child_element, value_list)
             self.setChildElementOptionalFloatValue(child_element, "V", value_list.v)
 
     def writeSwValueCont(self, element: ET.Element, cont: SwValueCont):
         if cont is not None:
             child_element = ET.SubElement(element, "SW-VALUE-CONT")
-            self.setARObjectAttributes(child_element, cont)
+            self.writeARObjectAttributes(child_element, cont)
             self.setChildElementOptionalRefType(child_element, "UNIT-REF", cont.unitRef)
             self.setValueList(child_element, "SW-ARRAYSIZE", cont.swArraysize)
             self.setSwValues(child_element, "SW-VALUES-PHYS", cont.swValuesPhys)
 
     def writeValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
         if value_spec is not None:
-            self.setARObjectAttributes(element, value_spec)
-            self.setChildElementOptionalLiteral(element, "SHORT-LABEL", value_spec.getShortLabel())                                
-
-    def setApplicationValueSpecification(self, element: ET.Element, value_spec: ApplicationValueSpecification):
-        if value_spec is not None:
-            value_spec_tag = ET.SubElement(element, "APPLICATION-VALUE-SPECIFICATION")
-            self.writeValueSpecification(value_spec_tag, value_spec)
-            self.setChildElementOptionalLiteral(value_spec_tag, "CATEGORY", value_spec.getCategory())
-            self.writeSwValueCont(value_spec_tag, value_spec.getSwValueCont())
+            self.writeARObjectAttributes(element, value_spec)
+            self.setChildElementOptionalLiteral(element, "SHORT-LABEL", value_spec.getShortLabel())
 
-    def setTextValueSpecification(self, element: ET.Element, value_spec: TextValueSpecification):
+    def writeTextValueSpecification(self, element: ET.Element, value_spec: TextValueSpecification):
         if value_spec is not None:
             value_spec_tag = ET.SubElement(element, "TEXT-VALUE-SPECIFICATION")
             self.writeValueSpecification(value_spec_tag, value_spec)
             self.setChildElementOptionalLiteral(value_spec_tag, "VALUE", value_spec.getValue())
 
-    def setNumericalValueSpecification(self, element: ET.Element, value_spec: NumericalValueSpecification):
+    def writeNumericalValueSpecification(self, element: ET.Element, value_spec: NumericalValueSpecification):
         if value_spec is not None:
             value_spec_tag = ET.SubElement(element, "NUMERICAL-VALUE-SPECIFICATION")
             self.writeValueSpecification(value_spec_tag, value_spec)
             self.setChildElementOptionalFloatValue(value_spec_tag, "VALUE", value_spec.getValue())
 
-    def setArrayValueSpecification(self, element: ET.Element, value_spec: ArrayValueSpecification):
+    def writeArrayValueSpecification(self, element: ET.Element, value_spec: ArrayValueSpecification):
         value_spec_tag = ET.SubElement(element, "ARRAY-VALUE-SPECIFICATION")
         self.writeValueSpecification(value_spec_tag, value_spec)
         sub_elements = value_spec.getElements()
@@ -342,18 +452,18 @@ class ARXMLWriter(AbstractARXMLWriter):
             elements_tag = ET.SubElement(value_spec_tag, "ELEMENTS")
             for sub_element in sub_elements:
                 if isinstance(sub_element, NumericalValueSpecification):
-                    self.setNumericalValueSpecification(elements_tag, sub_element)
+                    self.writeNumericalValueSpecification(elements_tag, sub_element)
                 elif isinstance(sub_element, ApplicationValueSpecification):
-                    self.setApplicationValueSpecification(elements_tag, sub_element)
+                    self.writeApplicationValueSpecification(elements_tag, sub_element)
                 elif isinstance(sub_element, TextValueSpecification):
-                    self.setTextValueSpecification(elements_tag, sub_element)
+                    self.writeTextValueSpecification(elements_tag, sub_element)
                 elif isinstance(sub_element, ArrayValueSpecification):
-                    self.setArrayValueSpecification(elements_tag, sub_element)
+                    self.writeArrayValueSpecification(elements_tag, sub_element)
                 elif isinstance(sub_element, RecordValueSpecification):
-                    self.setRecordValueSpecification(elements_tag, sub_element)
+                    self.writeRecordValueSpecification(elements_tag, sub_element)
                 else:
                     self.notImplemented("Unsupported element type of <%s> of ArrayValueSpecification" % type(sub_element))
-                
+
     def setConstantReference(self, element: ET.Element, value_spec: ConstantReference):
         value_spec_tag = ET.SubElement(element, "CONSTANT-REFERENCE")
         self.writeValueSpecification(value_spec_tag, value_spec)
@@ -363,23 +473,23 @@ class ARXMLWriter(AbstractARXMLWriter):
         if value_spec is not None:
             child_element = ET.SubElement(element, key)
             if isinstance(value_spec, ApplicationValueSpecification):
-                self.setApplicationValueSpecification(child_element, value_spec)
+                self.writeApplicationValueSpecification(child_element, value_spec)
             elif isinstance(value_spec, TextValueSpecification):
-                self.setTextValueSpecification(child_element, value_spec)
+                self.writeTextValueSpecification(child_element, value_spec)
             elif isinstance(value_spec, ConstantReference):
                 self.setConstantReference(child_element, value_spec)
             elif isinstance(value_spec, NumericalValueSpecification):
-                self.setNumericalValueSpecification(child_element, value_spec)
+                self.writeNumericalValueSpecification(child_element, value_spec)
             elif isinstance(value_spec, ArrayValueSpecification):
-                self.setArrayValueSpecification(child_element, value_spec)
+                self.writeArrayValueSpecification(child_element, value_spec)
             elif isinstance(value_spec, RecordValueSpecification):
-                self.setRecordValueSpecification(child_element, value_spec)
+                self.writeRecordValueSpecification(child_element, value_spec)
             else:
                 self.notImplemented("Unsupported ValueSpecification %s" % type(value_spec))
 
     def writeNonqueuedReceiverComSpec(self, element: ET.Element, com_spec: NonqueuedReceiverComSpec):
         child_element = ET.SubElement(element, "NONQUEUED-RECEIVER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.writeReceiverComSpec(child_element, com_spec)
         self.setChildElementOptionalFloatValue(child_element, "ALIVE-TIMEOUT", com_spec.getAliveTimeout())
         self.setChildElementOptionalBooleanValue(child_element, "ENABLE-UPDATE", com_spec.getEnableUpdated())
@@ -390,27 +500,27 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeQueuedReceiverComSpec(self, element: ET.Element, com_spec: QueuedReceiverComSpec):
         child_element = ET.SubElement(element, "QUEUED-RECEIVER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.writeReceiverComSpec(child_element, com_spec)
         self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH", com_spec.queueLength)
     
     def writeClientComSpec(self, element: ET.Element, com_spec: ClientComSpec):
         self.logger.debug("writeClientComSpec")
         child_element = ET.SubElement(element, "CLIENT-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "OPERATION-REF", com_spec.getOperationRef())
 
     def writeParameterRequireComSpec(self, element: ET.Element, com_spec: ParameterRequireComSpec):
         self.logger.debug("writeParameterRequireComSpec")
         child_element = ET.SubElement(element, "PARAMETER-REQUIRE-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "PARAMETER-REF", com_spec.getParameterRef())
         self.setValueSpecification(child_element, "INIT-VALUE", com_spec.getInitValue())
 
     def setModeSwitchReceiverComSpec(self, element: ET.Element, com_spec: ModeSwitchReceiverComSpec):
         self.logger.debug("writeModeSwitchReceiverComSpec")
         child_element = ET.SubElement(element, "MODE-SWITCH-RECEIVER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalBooleanValue(child_element, "ENHANCED-MODE-API", com_spec.getEnhancedModeApi())
         self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.getModeGroupRef())
         self.setChildElementOptionalBooleanValue(child_element, "SUPPORTS-ASYNCHRONOUS-MODE-SWITCH", com_spec.getSupportsAsynchronousModeSwitch())
@@ -449,7 +559,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         if len(com_specs) > 0:
             com_specs_tag = ET.SubElement(element, "REQUIRED-COM-SPECS")
             for com_spec in com_specs:
-                self.writeRPortComSpec(com_specs_tag, com_spec)  
+                self.writeRPortComSpec(com_specs_tag, com_spec)
 
     def writeRPortPrototype(self, ports_tag: ET.Element, prototype: RPortPrototype):
         self.logger.debug("write RPortPrototype %s" % prototype.getShortName())
@@ -465,21 +575,24 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setAbstractProvidedPortPrototype(prototype_tag, prototype)
         self.setAbstractRequiredPortPrototype(prototype_tag, prototype)
         self.setChildElementOptionalRefType(prototype_tag, "PROVIDED-REQUIRED-INTERFACE-TREF", prototype.getProvidedRequiredInterface())
-    
-    def writePortPrototypes(self, ports_tag: ET.Element, port_prototypes: List[PortPrototype]):
-        for port_prototype in port_prototypes:
-            if isinstance(port_prototype, PPortPrototype):
-                self.writePPortPrototype(ports_tag, port_prototype)
-            elif isinstance(port_prototype, RPortPrototype):
-                self.writeRPortPrototype(ports_tag, port_prototype)
-            elif isinstance(port_prototype, PRPortPrototype):
-                self.writePRPortPrototype(ports_tag, port_prototype)
-            else:
-                self._raiseError("Invalid PortPrototype")
+
+    def writeSwComponentTypePorts(self, element: ET.Element, sw_component: SwComponentType):
+        ports = sw_component.getPorts()
+        if len(ports) > 0:
+            child_element = ET.SubElement(element, "PORTS")
+            for port in ports:
+                if isinstance(port, PPortPrototype):
+                    self.writePPortPrototype(child_element, port)
+                elif isinstance(port, RPortPrototype):
+                    self.writeRPortPrototype(child_element, port)
+                elif isinstance(port, PRPortPrototype):
+                    self.writePRPortPrototype(child_element, port)
+                else:
+                    self.notImplemented("Unsupported Port Prototype <%s>" % type(port))
 
     def writeInnerGroupIRef(self, element: ET.Element, inner_group_iref: InnerPortGroupInCompositionInstanceRef):
         child_element = ET.SubElement(element, "INNER-GROUP-IREF")
-        #self.setChildElementOptionalRefType(child_element, "CONTEXT-REF", inner_group_iref.contextRef)
+        # self.setChildElementOptionalRefType(child_element, "CONTEXT-REF", inner_group_iref.contextRef)
         self.setChildElementOptionalRefType(child_element, "TARGET-REF", inner_group_iref.getTargetRef())
 
     def writePortGroupInnerGroupIRefs(self, element: ET.Element, parent: PortGroup):
@@ -513,10 +626,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     
     def writeSwComponentType(self, element: ET.Element, sw_component: SwComponentType):
         self.writeIdentifiable(element, sw_component)
-        port_prototypes = sw_component.getPortPrototypes()
-        if len(port_prototypes) > 0:
-            ports_tag = ET.SubElement(element, "PORTS")
-            self.writePortPrototypes(ports_tag, port_prototypes)
+        self.writeSwComponentTypePorts(element, sw_component)
         self.writeSwComponentTypePortGroups(element, sw_component)
 
     def writeSwComponentPrototype(self, element: ET.Element, prototype: SwComponentPrototype):
@@ -524,29 +634,31 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeIdentifiable(prototype_tag, prototype)
         self.setChildElementOptionalRefType(prototype_tag, "TYPE-TREF", prototype.getTypeTRef())
 
-    def writeSwComponentPrototypes(self, element: ET.Element, sw_component: CompositionSwComponentType):
-        prototypes = sw_component.getSwComponentPrototypes()
-        if len(prototypes) > 0:
+    def writeCompositionSwComponentTypeComponents(self, element: ET.Element, sw_component: CompositionSwComponentType):
+        components = sw_component.getComponents()
+        if len(components) > 0:
             components_tag = ET.SubElement(element, "COMPONENTS")
-        for prototype in prototypes:
-            self.writeSwComponentPrototype(components_tag, prototype)
+            for component in components:
+                if isinstance(component, SwComponentPrototype):
+                    self.writeSwComponentPrototype(components_tag, component)
+                else:
+                    self.notImplemented("Unsupported Component <%s>" % type(component))
 
     def writeAssemblySwConnector(self, element: ET.Element, sw_connector: AssemblySwConnector):
         child_element = ET.SubElement(element, "ASSEMBLY-SW-CONNECTOR")
-        self.writeIdentifiable(child_element, sw_connector)
-        self.setChildElementOptionalRefType(child_element, "MAPPING-REF", sw_connector.getMappingRef())
+        self.writeSwConnector(child_element, sw_connector)
 
         if sw_connector.getProviderIRef() is not None:
             provider_iref_tag = ET.SubElement(child_element, "PROVIDER-IREF")
             provider_iref = sw_connector.getProviderIRef()
-            self.setARObjectAttributes(provider_iref_tag, provider_iref)
+            self.writeARObjectAttributes(provider_iref_tag, provider_iref)
             self.setChildElementOptionalRefType(provider_iref_tag, "CONTEXT-COMPONENT-REF", provider_iref.getContextComponentRef())
             self.setChildElementOptionalRefType(provider_iref_tag, "TARGET-P-PORT-REF", provider_iref.getTargetPPortRef())
 
         if sw_connector.getRequesterIRef() is not None:
             requester_iref_tag = ET.SubElement(child_element, "REQUESTER-IREF")
             requester_iref = sw_connector.getRequesterIRef()
-            self.setARObjectAttributes(requester_iref_tag, requester_iref)
+            self.writeARObjectAttributes(requester_iref_tag, requester_iref)
             self.setChildElementOptionalRefType(requester_iref_tag, "CONTEXT-COMPONENT-REF", requester_iref.getContextComponentRef())
             self.setChildElementOptionalRefType(requester_iref_tag, "TARGET-R-PORT-REF", requester_iref.getTargetRPortRef())
 
@@ -570,27 +682,23 @@ class ARXMLWriter(AbstractARXMLWriter):
 
         if sw_connector.getOuterPortRef() is not None:
             self.setChildElementOptionalRefType(connector_tag, "OUTER-PORT-REF", sw_connector.getOuterPortRef())
-            #self.writeChildOptionalRefElement(requester_iref_tag, "TARGET-R-PORT-REF", sw_connector.requester_iref.target_r_port_ref)
+            # self.writeChildOptionalRefElement(requester_iref_tag, "TARGET-R-PORT-REF", sw_connector.requester_iref.target_r_port_ref)
         
     def writeSwConnector(self, element: ET.Element, sw_connector: SwConnector):
-        if isinstance(sw_connector, AssemblySwConnector):
-            self.writeAssemblySwConnector(element, sw_connector)
-        elif isinstance(sw_connector, DelegationSwConnector):
-            self.writeDelegationSwConnector(element, sw_connector)
-        else:
-            self.notImplemented("Unsupported Sw Connector %s")
+        self.writeIdentifiable(element, sw_connector)
+        self.setChildElementOptionalRefType(element, "MAPPING-REF", sw_connector.getMappingRef())
 
-    def writeSwConnectors(self, element: ET.Element, sw_component: CompositionSwComponentType):
+    def writeCompositionSwComponentTypeSwConnectors(self, element: ET.Element, sw_component: CompositionSwComponentType):
         sw_connectors = sw_component.getSwConnectors()
         if len(sw_connectors) > 0:
-            connectors_tag = ET.SubElement(element, "CONNECTORS")
-            # Change the implementation to compatible with AUTOSAR builder
+            child_element = ET.SubElement(element, "CONNECTORS")
             for sw_connector in sw_connectors:
-                self.writeSwConnector(connectors_tag, sw_connector)
-            #for sw_connector in sw_component.getAssemblySwConnectors():
-            #    self.writeSwConnector(connectors_tag, sw_connector)
-            #for sw_connector in sw_component.getDelegationSwConnectors():
-            #    self.writeSwConnector(connectors_tag, sw_connector)
+                if isinstance(sw_connector, AssemblySwConnector):
+                    self.writeAssemblySwConnector(child_element, sw_connector)
+                elif isinstance(sw_connector, DelegationSwConnector):
+                    self.writeDelegationSwConnector(child_element, sw_connector)
+                else:
+                    self.notImplemented("Unsupported Sw Connector %s" % type(sw_connector))
 
     def writeCompositionSwComponentTypeDataTypeMappingSet(self, element: ET.Element, parent: CompositionSwComponentType):
         data_type_mappings = parent.getDataTypeMappings()
@@ -604,8 +712,8 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(parent, "COMPOSITION-SW-COMPONENT-TYPE")
 
         self.writeSwComponentType(child_element, sw_component)
-        self.writeSwComponentPrototypes(child_element, sw_component)
-        self.writeSwConnectors(child_element, sw_component)
+        self.writeCompositionSwComponentTypeComponents(child_element, sw_component)
+        self.writeCompositionSwComponentTypeSwConnectors(child_element, sw_component)
         self.writeCompositionSwComponentTypeDataTypeMappingSet(child_element, sw_component)
 
     def writeCompositionSwComponentTypes(self, element: ET.Element, ar_package: ARPackage):
@@ -615,7 +723,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeLParagraphs(self, element: ET.Element, paragraph: MultiLanguageParagraph):
         for l1 in paragraph.getL1s():
             l1_tag = ET.SubElement(element, "L-1")
-            self.setARObjectAttributes(l1_tag, l1)
+            self.writeARObjectAttributes(l1_tag, l1)
             if l1.l is not None:
                 l1_tag.attrib['L'] = l1.l
                 l1_tag.text = l1.value
@@ -623,7 +731,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setMultiLanguageParagraphs(self, element: ET.Element, key: str, paragraphs: List[MultiLanguageParagraph]):
         for paragraph in paragraphs:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, paragraph)
+            self.writeARObjectAttributes(child_element, paragraph)
             self.writeLParagraphs(child_element, paragraph)
         return paragraphs
     
@@ -639,7 +747,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setDocumentationBlock(self, element: ET.Element, key: str, block: DocumentationBlock):
         if block is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, block)
+            self.writeARObjectAttributes(child_element, block)
             self.setMultiLanguageParagraphs(child_element, "P", block.getPs())
             for list in block.getLists():
                 self.setListElement(child_element, "LIST", list)
@@ -649,7 +757,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(element, "ANNOTATION-ORIGIN", annotation.getAnnotationOrigin())
         self.setDocumentationBlock(element, "ANNOTATION-TEXT", annotation.getAnnotationText())
 
-    def setAnnotations(self, element: ET.Element, annotations: List[Annotation]) :
+    def setAnnotations(self, element: ET.Element, annotations: List[Annotation]):
         if len(annotations) > 0:
             annotations_tag = ET.SubElement(element, "ANNOTATIONS")
             for annotation in annotations:
@@ -658,16 +766,16 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setSwAxisIndividual(self, element: ET.Element, props: SwAxisIndividual):
         child_element = ET.SubElement(element, "SW-AXIS-INDIVIDUAL")
-        self.setARObjectAttributes(child_element, props)
+        self.writeARObjectAttributes(child_element, props)
         self.setChildElementOptionalRefType(child_element, "INPUT-VARIABLE-TYPE-REF", props.getInputVariableTypeRef())
         self.setChildElementOptionalRefType(child_element, "COMPU-METHOD-REF", props.getCompuMethodRef())
-        self.setChildElementOptionalNumericalValue(child_element, "SW-MAX-AXIS-POINTS", props.getSwMaxAxisPoints()) 
+        self.setChildElementOptionalNumericalValue(child_element, "SW-MAX-AXIS-POINTS", props.getSwMaxAxisPoints())
         self.setChildElementOptionalNumericalValue(child_element, "SW-MIN-AXIS-POINTS", props.getSwMinAxisPoints())
         self.setChildElementOptionalRefType(child_element, "DATA-CONSTR-REF", props.getDataConstrRef())
 
     def setSwAxisGrouped(self, element: ET.Element, props: SwAxisGrouped):
         child_element = ET.SubElement(element, "SW-AXIS-GROUPED")
-        self.setARObjectAttributes(child_element, props)
+        self.writeARObjectAttributes(child_element, props)
         self.setChildElementOptionalRefType(child_element, "SHARED-AXIS-TYPE-REF", props.sharedAxisTypeRef)
 
     def setSwCalprmAxis(self, element: ET.Element, axis: SwCalprmAxis):
@@ -681,7 +789,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 elif isinstance(axis.sw_calprm_axis_type_props, SwAxisGrouped):
                     self.setSwAxisGrouped(child_element, axis.sw_calprm_axis_type_props)
                 else:
-                    self._raiseError("Unsupported SwCalprmAxisTypeProps %s" % type(axis.sw_calprm_axis_type_props))
+                    self.notImplemented("Unsupported SwCalprmAxisTypeProps %s" % type(axis.sw_calprm_axis_type_props))
 
     def setSwCalprmAxisSet(self, element: ET.Element, key: str, set: SwCalprmAxisSet):
         axises = set.getSwCalprmAxises()
@@ -699,20 +807,19 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setSwDataDefProps(self, element: ET.Element, key: str, props: SwDataDefProps):
         if props is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, props)
+            self.writeARObjectAttributes(child_element, props)
             sw_data_def_props_variants_tag = ET.SubElement(child_element, "SW-DATA-DEF-PROPS-VARIANTS")
             conditional_tag = ET.SubElement(sw_data_def_props_variants_tag, "SW-DATA-DEF-PROPS-CONDITIONAL")
-            self.setARObjectAttributes(conditional_tag, props.conditional)
+            self.writeARObjectAttributes(conditional_tag, props.conditional)
             self.setAnnotations(conditional_tag, props.getAnnotations())
             self.setChildElementOptionalRefType(conditional_tag, "BASE-TYPE-REF", props.getBaseTypeRef())
+            self.setChildElementOptionalLiteral(conditional_tag, "SW-CALIBRATION-ACCESS", props.getSwCalibrationAccess())
             self.setChildElementOptionalRefType(conditional_tag, "COMPU-METHOD-REF", props.getCompuMethodRef())
-            
             self.setValueSpecification(conditional_tag, "INVALID-VALUE", props.getInvalidValue())
-            self.setChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF", props.getImplementationDataTypeRef())
             self.setChildElementOptionalFloatValue(conditional_tag, "STEP-SIZE", props.getStepSize())
             self.setChildElementOptionalRefType(conditional_tag, "SW-ADDR-METHOD-REF", props.getSwAddrMethodRef())
-            self.setChildElementOptionalLiteral(conditional_tag, "SW-CALIBRATION-ACCESS", props.getSwCalibrationAccess())
             self.setChildElementOptionalRefType(conditional_tag, "DATA-CONSTR-REF", props.getDataConstrRef())
+            self.setChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF", props.getImplementationDataTypeRef())
             self.setSwCalprmAxisSet(conditional_tag, "SW-CALPRM-AXIS-SET", props.getSwCalprmAxisSet())
             self.setChildElementOptionalLiteral(conditional_tag, "SW-IMPL-POLICY", props.getSwImplPolicy())
             self.setChildElementOptionalNumericalValue(conditional_tag, "SW-INTENDED-RESOLUTION", props.getSwIntendedResolution())
@@ -736,29 +843,32 @@ class ARXMLWriter(AbstractARXMLWriter):
         data_type_tag = ET.SubElement(element, "APPLICATION-PRIMITIVE-DATA-TYPE")
         self.setApplicationDataType(data_type_tag, data_type)
 
-    def setDataPrototype(self, element: ET.Element, prototype: DataPrototype):
+    def writeDataPrototype(self, element: ET.Element, prototype: DataPrototype):
+        self.writeIdentifiable(element, prototype)
         self.setSwDataDefProps(element, "SW-DATA-DEF-PROPS", prototype.getSwDataDefProps())
 
-    def setApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
-        self.writeIdentifiable(element, prototype)
-        self.setDataPrototype(element, prototype)
+    def writeApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
+        self.writeDataPrototype(element, prototype)
         self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.typeTRef)
 
-    def setApplicationRecordElement(self, element: ET.Element, prototype: ApplicationRecordElement):
-        self.setApplicationCompositeElementDataPrototype(element, prototype)
-
-    def writeApplicationRecordElements(self, element: ET.Element, data_type: ApplicationRecordDataType):
-        records = data_type.getApplicationRecordElements()
-        if len(records) > 0:
-            elements_tag = ET.SubElement(element, "ELEMENTS")
-            for record in records:
-                child_element = ET.SubElement(elements_tag, "APPLICATION-RECORD-ELEMENT")
-                self.setApplicationRecordElement(child_element, record)
+    def writeApplicationRecordElement(self, element: ET.Element, prototype: ApplicationRecordElement):
+        child_element = ET.SubElement(element, "APPLICATION-RECORD-ELEMENT")
+        self.writeApplicationCompositeElementDataPrototype(child_element, prototype)
+
+    def writeApplicationRecordDataTypeElements(self, element: ET.Element, data_type: ApplicationRecordDataType):
+        record_elements = data_type.getApplicationRecordElements()
+        if len(record_elements) > 0:
+            child_element = ET.SubElement(element, "ELEMENTS")
+            for record_element in record_elements:
+                if isinstance(record_element, ApplicationRecordElement):
+                    self.writeApplicationRecordElement(child_element, record_element)
+                else:
+                    self.notImplemented("Unsupported ApplicationRecordDataType Element <%s>" % type(record_element))
 
     def writeApplicationRecordDataType(self, element: ET.Element, data_type: ApplicationRecordDataType):
         data_type_tag = ET.SubElement(element, "APPLICATION-RECORD-DATA-TYPE")
         self.setApplicationDataType(data_type_tag, data_type)
-        self.writeApplicationRecordElements(data_type_tag, data_type)
+        self.writeApplicationRecordDataTypeElements(data_type_tag, data_type)
 
     def writeApplicationDataTypes(self, parent: ET.Element, ar_package: ARPackage):
         for data_type in ar_package.getApplicationDataType():
@@ -819,28 +929,33 @@ class ARXMLWriter(AbstractARXMLWriter):
             else:
                 self.notImplemented("Unsupported CompuConstContent <%s>" % type(content))
 
+    def setCompuScale(self, element: ET.Element, key: str, compu_scale: CompuScale):
+        if compu_scale is not None:
+            child_element = ET.SubElement(element, key)
+            self.writeARObjectAttributes(child_element, compu_scale)
+            self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", compu_scale.getShortLabel())
+            self.setChildElementOptionalLiteral(child_element, "SYMBOL", compu_scale.getSymbol())
+            self.setMultiLanguageOverviewParagraph(child_element, "DESC", compu_scale.getDesc())
+            self.setChildLimitElement(child_element, "LOWER-LIMIT", compu_scale.getLowerLimit())
+            self.setChildLimitElement(child_element, "UPPER-LIMIT", compu_scale.getUpperLimit())
+            self.writeCompuScaleContents(child_element, compu_scale)
+
     def setCompuScales(self, element: ET.Element, compu_scales: CompuScales):
         if compu_scales is not None:
-            compu_scales_tag = ET.SubElement(element, "COMPU-SCALES")
+            child_element = ET.SubElement(element, "COMPU-SCALES")
             for compu_scale in compu_scales.getCompuScales():
-                child_element = ET.SubElement(compu_scales_tag, "COMPU-SCALE")
-                self.setARObjectAttributes(child_element, compu_scale)
-                self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", compu_scale.getShortLabel())
-                self.setChildElementOptionalLiteral(child_element, "SYMBOL", compu_scale.getSymbol())
-                self.setChildLimitElement(child_element, "LOWER-LIMIT", compu_scale.getLowerLimit())
-                self.setChildLimitElement(child_element, "UPPER-LIMIT", compu_scale.getUpperLimit())
-                self.writeCompuScaleContents(child_element, compu_scale)
+                self.setCompuScale(child_element, "COMPU-SCALE", compu_scale)
 
     def setCompuConst(self, element: ET.Element, key: str, compu_const: CompuConst):
         if compu_const is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, compu_const)
+            self.writeARObjectAttributes(child_element, compu_const)
             self.setCompuConstContent(child_element, compu_const.getCompuConstContentType())
 
     def setCompu(self, element: ET.Element, key: str, compu: Compu):
-        if  compu is not None:
+        if compu is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, compu)
+            self.writeARObjectAttributes(child_element, compu)
             self.setCompuScales(child_element, compu.getCompuContent())
             self.setCompuConst(child_element, "COMPU-DEFAULT-VALUE", compu.getCompuDefaultValue())
 
@@ -852,30 +967,31 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setCompu(child_element, "COMPU-INTERNAL-TO-PHYS", compu_method.getCompuInternalToPhys())
         self.setCompu(child_element, "COMPU-PHYS-TO-INTERNAL", compu_method.getCompuPhysToInternal())
 
-    def setApplicationValueSpecification(self, element: ET.Element, spec: ApplicationValueSpecification):
-        spec_tag = ET.SubElement(element, "APPLICATION-VALUE-SPECIFICATION")
-        self.setChildElementOptionalLiteral(spec_tag, "SHORT-LABEL", spec.getShortLabel())
-        self.setChildElementOptionalLiteral(spec_tag, "CATEGORY", spec.category)
-        self.writeSwValueCont(spec_tag, spec.getSwValueCont())
+    def writeApplicationValueSpecification(self, element: ET.Element, value_spec: ApplicationValueSpecification):
+        if value_spec is not None:
+            child_element = ET.SubElement(element, "APPLICATION-VALUE-SPECIFICATION")
+            self.writeValueSpecification(child_element, value_spec)
+            self.setChildElementOptionalLiteral(child_element, "CATEGORY", value_spec.getCategory())
+            self.writeSwValueCont(child_element, value_spec.getSwValueCont())
 
-    def setRecordValueSpecification(self, element: ET.Element, spec: RecordValueSpecification):
+    def writeRecordValueSpecification(self, element: ET.Element, spec: RecordValueSpecification):
         child_element = ET.SubElement(element, "RECORD-VALUE-SPECIFICATION")
-        self.setARObjectAttributes(child_element, spec)
+        self.writeARObjectAttributes(child_element, spec)
         self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", spec.getShortLabel())
         fields = spec.getFields()
         if len(fields) > 0:
             fields_tag = ET.SubElement(child_element, "FIELDS")
             for field in fields:
                 if isinstance(field, ApplicationValueSpecification):
-                    self.setApplicationValueSpecification(fields_tag, field)
+                    self.writeApplicationValueSpecification(fields_tag, field)
                 elif isinstance(field, NumericalValueSpecification):
-                    self.setNumericalValueSpecification(fields_tag, field)
+                    self.writeNumericalValueSpecification(fields_tag, field)
                 elif isinstance(field, TextValueSpecification):
-                    self.setTextValueSpecification(fields_tag, field)
+                    self.writeTextValueSpecification(fields_tag, field)
                 elif isinstance(field, ArrayValueSpecification):
-                    self.setArrayValueSpecification(fields_tag, field)
+                    self.writeArrayValueSpecification(fields_tag, field)
                 elif isinstance(field, RecordValueSpecification):
-                    self.setRecordValueSpecification(fields_tag, field)
+                    self.writeRecordValueSpecification(fields_tag, field)
                 else:
                     self.notImplemented("Unsupported Field <%s>" % type(field))
 
@@ -889,7 +1005,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setInternalConstrs(self, element: ET.Element, constrs: InternalConstrs):
         if constrs is not None:
             constrs_tag = ET.SubElement(element, "INTERNAL-CONSTRS")
-            self.setARObjectAttributes(constrs_tag, constrs)
+            self.writeARObjectAttributes(constrs_tag, constrs)
             if constrs.lower_limit is not None:
                 self.setChildLimitElement(constrs_tag, "LOWER-LIMIT", constrs.lower_limit)
             if constrs.upper_limit is not None:
@@ -898,7 +1014,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setPhysConstrs(self, element: ET.Element, constrs: PhysConstrs):
         if constrs is not None:
             child_element = ET.SubElement(element, "PHYS-CONSTRS")
-            self.setARObjectAttributes(child_element, constrs)
+            self.writeARObjectAttributes(child_element, constrs)
             if constrs.lower_limit is not None:
                 self.setChildLimitElement(child_element, "LOWER-LIMIT", constrs.lower_limit)
             if constrs.upper_limit is not None:
@@ -911,7 +1027,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             rules_tag = ET.SubElement(element, "DATA-CONSTR-RULES")
             for rule in rules:
                 child_element = ET.SubElement(rules_tag, "DATA-CONSTR-RULE")
-                self.setARObjectAttributes(child_element, rule)
+                self.writeARObjectAttributes(child_element, rule)
                 self.setChildElementOptionalNumericalValue(child_element, "CONSTR-LEVEL", rule.constrLevel)
                 self.setPhysConstrs(child_element, rule.physConstrs)
                 self.setInternalConstrs(child_element, rule.internalConstrs)
@@ -919,7 +1035,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeDataConstr(self, element: ET.Element, constr: DataConstr):
         child_element = ET.SubElement(element, "DATA-CONSTR")
         self.writeIdentifiable(child_element, constr)
-        self.writeDataConstrRules(child_element, constr) 
+        self.writeDataConstrRules(child_element, constr)
 
     def writeUnit(self, element: ET.Element, unit: Unit):
         self.logger.debug("writeUnit %s" % unit.getShortName())
@@ -932,16 +1048,16 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setRModeInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: RModeInAtomicSwcInstanceRef):
         child_element = ET.SubElement(element, key)
-        self.setARObjectAttributes(child_element, iref)
+        self.writeARObjectAttributes(child_element, iref)
         self.setChildElementOptionalRefType(child_element, "BASE", iref.getBaseRef())
         self.setChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF", iref.getContextPortRef())
-        self.setChildElementOptionalRefType(child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF", iref.getContextModeDeclarationGroupPrototypeRef())
+        self.setChildElementOptionalRefType(child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF", iref.getContextModeDeclarationGroupPrototypeRef())   # noqa E501
         self.setChildElementOptionalRefType(child_element, "TARGET-MODE-DECLARATION-REF", iref.getTargetModeDeclarationRef())
 
     def setPOperationInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: POperationInAtomicSwcInstanceRef):
         if iref is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, iref)
+            self.writeARObjectAttributes(child_element, iref)
             self.setChildElementOptionalRefType(child_element, "CONTEXT-P-PORT-REF", iref.getContextPPortRef())
             self.setChildElementOptionalRefType(child_element, "TARGET-PROVIDED-OPERATION-REF", iref.getTargetProvidedOperationRef())
 
@@ -954,20 +1070,20 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setRModeInAtomicSwcInstanceRef(child_element, "DISABLED-MODE-IREF", iref)
         self.setChildElementOptionalRefType(element, "START-ON-EVENT-REF", event.startOnEventRef)
 
-    def setTimingEvent(self, element: ET.Element, event: TimingEvent):
+    def writeTimingEvent(self, element: ET.Element, event: TimingEvent):
         if event is not None:
             child_element = ET.SubElement(element, "TIMING-EVENT")
             self.setRTEEvent(child_element, event)
             self.setChildElementOptionalTimeValue(child_element, "OFFSET", event.getOffset())
             self.setChildElementOptionalTimeValue(child_element, "PERIOD", event.getPeriod())
 
-    def setOperationInvokedEvent(self, element: ET.Element, event: OperationInvokedEvent):
+    def writeOperationInvokedEvent(self, element: ET.Element, event: OperationInvokedEvent):
         if event is not None:
             child_element = ET.SubElement(element, "OPERATION-INVOKED-EVENT")
             self.setRTEEvent(child_element, event)
             self.setPOperationInAtomicSwcInstanceRef(child_element, "OPERATION-IREF", event.operationIRef)
 
-    def setSwcModeSwitchEvent(self, element: ET.Element, event: SwcModeSwitchEvent):
+    def writeSwcModeSwitchEvent(self, element: ET.Element, event: SwcModeSwitchEvent):
         if event is not None:
             child_element = ET.SubElement(element, "SWC-MODE-SWITCH-EVENT")
             self.setRTEEvent(child_element, event)
@@ -984,46 +1100,61 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF", iref.getContextRPortRef())
             self.setChildElementOptionalRefType(child_element, "TARGET-DATA-ELEMENT-REF", iref.getTargetDataElementRef())
 
-    def setDataReceivedEvent(self, element: ET.Element, event: DataReceivedEvent):
+    def writeDataReceivedEvent(self, element: ET.Element, event: DataReceivedEvent):
         if event is not None:
             child_element = ET.SubElement(element, "DATA-RECEIVED-EVENT")
             self.setRTEEvent(child_element, event)
             self.setRVariableInAtomicSwcInstanceRef(child_element, event.dataIRef)
 
-    def setInternalTriggerOccurredEvent(self, element: ET.Element, event: DataReceivedEvent):
+    def writeInternalTriggerOccurredEvent(self, element: ET.Element, event: DataReceivedEvent):
         pass
 
-    def setInitEvent(self, element: ET.Element, event: InitEvent):
+    def writeInitEvent(self, element: ET.Element, event: InitEvent):
         if event is not None:
             child_element = ET.SubElement(element, "INIT-EVENT")
             self.setRTEEvent(child_element, event)
 
-    def setAsynchronousServerCallReturnsEvent(self, element: ET.Element, event: InitEvent):
+    def writeAsynchronousServerCallReturnsEvent(self, element: ET.Element, event: InitEvent):
         if event is not None:
             child_element = ET.SubElement(element, "ASYNCHRONOUS-SERVER-CALL-RETURNS-EVENT")
             self.setRTEEvent(child_element, event)
             self.setChildElementOptionalRefType(child_element, "EVENT-SOURCE-REF", event.getActivationReasonRepresentationRef())
 
-    def writeRTEEvents(self, element: ET.Element, parent: SwcInternalBehavior):
+    def writeModeSwitchedAckEvent(self, element: ET.Element, event: ModeSwitchedAckEvent):
+        if event is not None:
+            child_element = ET.SubElement(element, "MODE-SWITCHED-ACK-EVENT")
+            self.setRTEEvent(child_element, event)
+            self.setChildElementOptionalRefType(child_element, "EVENT-SOURCE-REF", event.getEventSourceRef())
+
+    def writeBackgroundEvent(self, element: ET.Element, event: BackgroundEvent):
+        if event is not None:
+            child_element = ET.SubElement(element, "BACKGROUND-EVENT")
+            self.setRTEEvent(child_element, event)
+
+    def writeSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
         events = parent.getRteEvents()
         if len(events) > 0:
             child_element = ET.SubElement(element, "EVENTS")
             
             for event in events:
                 if isinstance(event, TimingEvent):
-                    self.setTimingEvent(child_element, event)
+                    self.writeTimingEvent(child_element, event)
                 elif isinstance(event, OperationInvokedEvent):
-                    self.setOperationInvokedEvent(child_element, event)
+                    self.writeOperationInvokedEvent(child_element, event)
                 elif isinstance(event, SwcModeSwitchEvent):
-                    self.setSwcModeSwitchEvent(child_element, event)
+                    self.writeSwcModeSwitchEvent(child_element, event)
                 elif isinstance(event, DataReceivedEvent):
-                    self.setDataReceivedEvent(child_element, event)
+                    self.writeDataReceivedEvent(child_element, event)
                 elif isinstance(event, InternalTriggerOccurredEvent):
-                    self.setInternalTriggerOccurredEvent(child_element, event)
+                    self.writeInternalTriggerOccurredEvent(child_element, event)
                 elif isinstance(event, InitEvent):
-                    self.setInitEvent(child_element, event)
+                    self.writeInitEvent(child_element, event)
                 elif isinstance(event, AsynchronousServerCallReturnsEvent):
-                    self.setAsynchronousServerCallReturnsEvent(child_element, event)
+                    self.writeAsynchronousServerCallReturnsEvent(child_element, event)
+                elif isinstance(event, ModeSwitchedAckEvent):
+                    self.writeModeSwitchedAckEvent(child_element, event)
+                elif isinstance(event, BackgroundEvent):
+                    self.writeBackgroundEvent(child_element, event)
                 else:
                     self.notImplemented("Unsupported Event <%s>" % type(event))
                 
@@ -1042,27 +1173,36 @@ class ARXMLWriter(AbstractARXMLWriter):
             for ref in refs:
                 self.setChildElementOptionalRefType(refs_tag, "DATA-TYPE-MAPPING-REF", ref)
 
+    def writeInternalBehaviorStaticMemories(self, element: ET.Element, behavior: InternalBehavior):
+        memories = behavior.getStaticMemories()
+        if len(memories) > 0:
+            child_element = ET.SubElement(element, "STATIC-MEMORYS")
+            for memory in memories:
+                if isinstance(memory, VariableDataPrototype):
+                    self.writeVariableDataPrototype(child_element, memory)
+
     def writeInternalBehavior(self, element: ET.Element, behavior: InternalBehavior):
         self.writeIdentifiable(element, behavior)
-        self.setParameterDataPrototypes(element, "CONSTANT-MEMORYS", behavior.getConstantMemories())
+        self.writeSwcInternalBehaviorParameterDataPrototypes(element, "CONSTANT-MEMORYS", behavior.getConstantMemories())
         self.writeDataTypeMappingRefs(element, behavior)
         self.writeExclusiveAreas(element, behavior)
+        self.writeInternalBehaviorStaticMemories(element, behavior)
 
     def setAutosarVariableRef(self, element: ET.Element, key: str, ref: AutosarVariableRef):
         if ref is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, ref)
+            self.writeARObjectAttributes(child_element, ref)
             if ref.getAutosarVariableIRef() is not None:
                 child_element = ET.SubElement(child_element, "AUTOSAR-VARIABLE-IREF")
-                #self.setARObjectAttributes(child_element, ref)
+                # self.setARObjectAttributes(child_element, ref)
                 self.setChildElementOptionalRefType(child_element, "PORT-PROTOTYPE-REF", ref.getAutosarVariableIRef().getPortPrototypeRef())
-                self.setChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF", ref.getAutosarVariableIRef().getTargetDataPrototypeRef())
+                self.setChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF", ref.getAutosarVariableIRef().getTargetDataPrototypeRef())   # noqa E501
             self.setChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF", ref.getLocalVariableRef())
 
     def setComponentInSystemInstanceRef(self, element: ET.Element, tag_name: str, ref: ComponentInSystemInstanceRef):
         if ref is not None:
             child_element = ET.SubElement(element, tag_name)
-            self.setARObjectAttributes(child_element, ref)
+            self.writeARObjectAttributes(child_element, ref)
             self.setChildElementOptionalRefType(child_element, "BASE-REF", ref.getBaseRef())
             self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPOSITION-REF", ref.getContextCompositionRef())
             self.setChildElementOptionalRefType(child_element, "TARGET-COMPONENT-REF", ref.getTargetComponentRef())
@@ -1082,42 +1222,42 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeIdentifiable(child_element, parameter_access)
         self.setAutosarParameterRef(child_element, "ACCESSED-PARAMETER", parameter_access.getAccessedParameter())
 
-    def writeParameterAccesses(self, element: ET.Element, entity: RunnableEntity):
+    def writeRunnableEntityParameterAccesses(self, element: ET.Element, entity: RunnableEntity):
         parameter_accesses = entity.getParameterAccesses()
         if len(parameter_accesses) > 0:
             child_element = ET.SubElement(element, "PARAMETER-ACCESSS")
             for parameter_access in parameter_accesses:
                 self.writeParameterAccess(child_element, parameter_access)
         
-    def writeDataReceivePointByArguments(self, element: ET.Element, entity: RunnableEntity):
+    def writeRunnableEntityDataReceivePointByArguments(self, element: ET.Element, entity: RunnableEntity):
         accesses = entity.getDataReceivePointByArguments()
         if len(accesses) > 0:
             child_element = ET.SubElement(element, "DATA-RECEIVE-POINT-BY-ARGUMENTS")
             for access in accesses:
                 self.setVariableAccess(child_element, access)
 
-    def writeDataSendPoints(self, element: ET.Element, entity: RunnableEntity):
+    def writeRunnableEntityDataSendPoints(self, element: ET.Element, entity: RunnableEntity):
         points = entity.getDataSendPoints()
         if len(points) > 0:
             child_element = ET.SubElement(element, "DATA-SEND-POINTS")
             for point in points:
                 self.setVariableAccess(child_element, point)
 
-    def writeDataReadAccesses(self, element: ET.Element, entity: RunnableEntity):
+    def writeRunnableEntityDataReadAccesses(self, element: ET.Element, entity: RunnableEntity):
         accesses = entity.getDataReadAccesses()
         if len(accesses) > 0:
             child_element = ET.SubElement(element, "DATA-READ-ACCESSS")
             for access in accesses:
                 self.setVariableAccess(child_element, access)
 
-    def writeDataWriteAccesses(self, element: ET.Element, entity: RunnableEntity):
+    def writeRunnableEntityDataWriteAccesses(self, element: ET.Element, entity: RunnableEntity):
         accesses = entity.getDataWriteAccesses()
         if len(accesses) > 0:
             child_element = ET.SubElement(element, "DATA-WRITE-ACCESSS")
             for access in accesses:
                 self.setVariableAccess(child_element, access)
 
-    def writeReadLocalVariables(self, element: ET.Element, entity: RunnableEntity):
+    def writeRunnableEntityReadLocalVariables(self, element: ET.Element, entity: RunnableEntity):
         variables = entity.getReadLocalVariables()
         if len(variables) > 0:
             child_element = ET.SubElement(element, "READ-LOCAL-VARIABLES")
@@ -1127,7 +1267,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setROperationInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: ROperationInAtomicSwcInstanceRef):
         if iref is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, iref)
+            self.writeARObjectAttributes(child_element, iref)
             self.setChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF", iref.getContextRPortRef())
             self.setChildElementOptionalRefType(child_element, "TARGET-REQUIRED-OPERATION-REF", iref.getTargetRequiredOperationRef())
         
@@ -1145,7 +1285,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeIdentifiable(child_element, call_point)
         self.setServerCallPoint(child_element, call_point)
 
-    def writeServerCallPoints(self, element: ET.Element, entity: RunnableEntity):
+    def writeRunnableEntityServerCallPoints(self, element: ET.Element, entity: RunnableEntity):
         call_points = entity.getServerCallPoints()
         if len(call_points) > 0:
             child_element = ET.SubElement(element, "SERVER-CALL-POINTS")
@@ -1155,44 +1295,81 @@ class ARXMLWriter(AbstractARXMLWriter):
                 elif isinstance(call_point, AsynchronousServerCallPoint):
                     self.setAsynchronousServerCallPoint(child_element, call_point)
                 else:
-                    self._raiseError("Unsupported ServerCallPoint type <%s>" % type(call_point))
+                    self.notImplemented("Unsupported ServerCallPoint type <%s>" % type(call_point))
 
-    def writeWrittenLocalVariable(self, element: ET.Element, entity: RunnableEntity):
+    def writeRunnableEntityWrittenLocalVariable(self, element: ET.Element, entity: RunnableEntity):
         variables = entity.getWrittenLocalVariables()
         if len(variables) > 0:
             child_element = ET.SubElement(element, "WRITTEN-LOCAL-VARIABLES")
             for access in variables:
                 self.setVariableAccess(child_element, access)
 
-    def setRModeGroupInAtomicSWCInstanceRef(self, element: ET.Element, tag: str, iref: RModeGroupInAtomicSWCInstanceRef):
-        if iref is not None:
-            child_element = ET.SubElement(element, tag)
-            instance_ref_tag = ET.SubElement(child_element, "R-MODE-GROUP-IN-ATOMIC-SWC-INSTANCE-REF")
-            self.setChildElementOptionalRefType(instance_ref_tag, "CONTEXT-R-PORT-REF", iref.getContextRPortRef())
-            self.setChildElementOptionalRefType(instance_ref_tag, "TARGET-MODE-GROUP-REF", iref.getTargetModeGroupRef())
+    def writeModeGroupInAtomicSwcInstanceRef(self, element: ET.Element, instance_ref: ModeGroupInAtomicSwcInstanceRef):
+        self.setChildElementOptionalRefType(element, "BASE-REF", instance_ref.getBaseRef())
+        self.setChildElementOptionalRefType(element, "CONTEXT-PORT-REF", instance_ref.getContextPortRef())
 
-    def setPModeGroupInAtomicSWCInstanceRef(self, element: ET.Element, tag: str, iref: PModeGroupInAtomicSwcInstanceRef):
-        if iref is not None:
-            child_element = ET.SubElement(element, tag)
-            self.setChildElementOptionalRefType(child_element, "CONTEXT-P-PORT-REF", iref.getContextPPortRef())
-            self.setChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF", iref.getTargetModeGroupRef())
+    def writeRModeGroupInAtomicSWCInstanceRef(self, element: ET.Element, instance_ref: RModeGroupInAtomicSWCInstanceRef):
+        if instance_ref is not None:
+            child_element = ET.SubElement(element, "R-MODE-GROUP-IN-ATOMIC-SWC-INSTANCE-REF")
+            self.writeModeGroupInAtomicSwcInstanceRef(child_element, instance_ref)
+            self.setChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF", instance_ref.getContextRPortRef())
+            self.setChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF", instance_ref.getTargetModeGroupRef())
+
+    def writePModeGroupInAtomicSWCInstanceRef(self, element: ET.Element, instance_ref: PModeGroupInAtomicSwcInstanceRef):
+        if instance_ref is not None:
+            child_element = ET.SubElement(element, "P-MODE-GROUP-IN-ATOMIC-SWC-INSTANCE-REF")
+            self.writeModeGroupInAtomicSwcInstanceRef(child_element, instance_ref)
+            self.setChildElementOptionalRefType(child_element, "CONTEXT-P-PORT-REF", instance_ref.getContextPPortRef())
+            self.setChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF", instance_ref.getTargetModeGroupRef())
 
-    def writeModeAccessPoints(self, element: ET.Element, entity: RunnableEntity):
+    def setModeGroupIRef(self, element: ET.Element, key: str, instance_ref: ModeGroupInAtomicSwcInstanceRef):
+        if instance_ref is not None:
+            child_element = ET.SubElement(element, key)
+            if isinstance(instance_ref, PModeGroupInAtomicSwcInstanceRef):
+                self.writePModeGroupInAtomicSWCInstanceRef(child_element, instance_ref)
+            elif isinstance(instance_ref, RModeGroupInAtomicSWCInstanceRef):
+                self.writeRModeGroupInAtomicSWCInstanceRef(child_element, instance_ref)
+            else:
+                self.notImplemented("Unsupported Mode Group IRef <%s>" % type(instance_ref))
+        return instance_ref
+
+    def writeModeAccessPoint(self, element: ET.Element, point: ModeAccessPoint):
+        if point is not None:
+            child_element = ET.SubElement(element, "MODE-ACCESS-POINT")
+            self.setModeGroupIRef(child_element, "MODE-GROUP-IREF", point.getModeGroupIRef())
+
+    def writeRunnableEntityModeAccessPoints(self, element: ET.Element, entity: RunnableEntity):
         points = entity.getModeAccessPoints()
         if len(points) > 0:
-            mode_access_points_tag = ET.SubElement(element, "MODE-ACCESS-POINTS")
+            child_element = ET.SubElement(element, "MODE-ACCESS-POINTS")
             for point in points:
-                child_element = ET.SubElement(mode_access_points_tag, "MODE-ACCESS-POINT")
-                self.setRModeGroupInAtomicSWCInstanceRef(child_element, "MODE-GROUP-IREF", point.getModeGroupIRef())
-
-    def writeModeSwitchPoints(self, element: ET.Element, entity: RunnableEntity):
+                if isinstance(point, ModeAccessPoint):
+                    self.writeModeAccessPoint(child_element, point)
+                else:
+                    self.notImplemented("Unsupported Mode Access Points <%s>" % type(point))
+
+    def writeModeSwitchPointModeGroupIRef(self, element: ET.Element, point: ModeSwitchPoint):
+        if point is not None:
+            child_element = ET.SubElement(element, "MODE-GROUP-IREF")
+            instance_ref = point.getModeGroupIRef()
+            self.setChildElementOptionalRefType(child_element, "CONTEXT-P-PORT-REF", instance_ref.getContextPPortRef())
+            self.setChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF", instance_ref.getTargetModeGroupRef())
+
+    def writeModeSwitchPoint(self, element: ET.Element, point: ModeSwitchPoint):
+        if point is not None:
+            child_element = ET.SubElement(element, "MODE-SWITCH-POINT")
+            self.writeIdentifiable(child_element, point)
+            self.writeModeSwitchPointModeGroupIRef(child_element, point)
+
+    def writeRunnableEntityModeSwitchPoints(self, element: ET.Element, entity: RunnableEntity):
         points = entity.getModeSwitchPoints()
         if len(points) > 0:
-            mode_access_points_tag = ET.SubElement(element, "MODE-SWITCH-POINTS")
+            child_element = ET.SubElement(element, "MODE-SWITCH-POINTS")
             for point in points:
-                child_element = ET.SubElement(mode_access_points_tag, "MODE-SWITCH-POINT")
-                self.writeIdentifiable(child_element, point)
-                self.setPModeGroupInAtomicSWCInstanceRef(child_element, "MODE-GROUP-IREF", point.getModeGroupIRef())
+                if isinstance(point, ModeSwitchPoint):
+                    self.writeModeSwitchPoint(child_element, point)
+                else:
+                    self.notImplemented("unsupported Mode Switch Point <%s>" % type(point))
 
     def setRunnableEntityArgument(self, element: ET.Element, argument: RunnableEntityArgument):
         child_element = ET.SubElement(element, "RUNNABLE-ENTITY-ARGUMENT")
@@ -1208,7 +1385,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported argument of Runnable Entity <%s>" % type(argument))
 
-    def writeAsynchronousServerCallResultPoint(self, element: ET.Element, entity: RunnableEntity):
+    def writeRunnableEntityAsynchronousServerCallResultPoint(self, element: ET.Element, entity: RunnableEntity):
         points = entity.getAsynchronousServerCallResultPoints()
         if len(points) > 0:
             points_tag = ET.SubElement(element, "ASYNCHRONOUS-SERVER-CALL-RESULT-POINTS")
@@ -1220,23 +1397,23 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeRunnableEntity(self, element: ET.Element, entity: RunnableEntity):
         if entity is not None:
             child_element = ET.SubElement(element, "RUNNABLE-ENTITY")
-            self.setExecutableEntity(child_element, entity)
+            self.writeExecutableEntity(child_element, entity)
             self.writeRunnableEntityArguments(child_element, entity)
-            self.writeAsynchronousServerCallResultPoint(child_element, entity)
+            self.writeRunnableEntityAsynchronousServerCallResultPoint(child_element, entity)
             self.setChildElementOptionalBooleanValue(child_element, "CAN-BE-INVOKED-CONCURRENTLY", entity.getCanBeInvokedConcurrently())
-            self.writeDataReadAccesses(child_element, entity)
-            self.writeDataReceivePointByArguments(child_element, entity)
-            self.writeDataSendPoints(child_element, entity)
-            self.writeDataWriteAccesses(child_element, entity)
-            self.writeModeAccessPoints(child_element, entity)
-            self.writeModeSwitchPoints(child_element, entity)
-            self.writeParameterAccesses(child_element, entity)
-            self.writeReadLocalVariables(child_element, entity)
-            self.writeServerCallPoints(child_element, entity)
+            self.writeRunnableEntityDataReadAccesses(child_element, entity)
+            self.writeRunnableEntityDataReceivePointByArguments(child_element, entity)
+            self.writeRunnableEntityDataSendPoints(child_element, entity)
+            self.writeRunnableEntityDataWriteAccesses(child_element, entity)
+            self.writeRunnableEntityModeAccessPoints(child_element, entity)
+            self.writeRunnableEntityModeSwitchPoints(child_element, entity)
+            self.writeRunnableEntityParameterAccesses(child_element, entity)
+            self.writeRunnableEntityReadLocalVariables(child_element, entity)
+            self.writeRunnableEntityServerCallPoints(child_element, entity)
             self.setChildElementOptionalLiteral(child_element, "SYMBOL", entity.symbol)
-            self.writeWrittenLocalVariable(child_element, entity)
+            self.writeRunnableEntityWrittenLocalVariable(child_element, entity)
 
-    def writeSwcInternalBehaviorRunnableEntities(self, element: ET.Element, behavior: SwcInternalBehavior):
+    def writeSwcInternalBehaviorRunnables(self, element: ET.Element, behavior: SwcInternalBehavior):
         entities = behavior.getRunnableEntities()
         if len(entities) > 0:
             runnables_tag = ET.SubElement(element, "RUNNABLES")
@@ -1254,9 +1431,9 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(prototype, VariableDataPrototype):
                     self.writeVariableDataPrototype(child_element, prototype)
                 else:
-                    self._raiseError("Unsupported ArTypedPerInstanceMemories <%s>" % type(prototype))
-                
-    def writeExplicitInterRunnableVariables(self, element: ET.Element, behavior: SwcInternalBehavior):
+                    self.notImplemented("Unsupported ArTypedPerInstanceMemories <%s>" % type(prototype))
+
+    def writeSwcInternalBehaviorExplicitInterRunnableVariables(self, element: ET.Element, behavior: SwcInternalBehavior):
         prototypes = behavior.getExplicitInterRunnableVariables()
         if len(prototypes) > 0:
             child_element = ET.SubElement(element, "EXPLICIT-INTER-RUNNABLE-VARIABLES")
@@ -1264,9 +1441,9 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(prototype, VariableDataPrototype):
                     self.writeVariableDataPrototype(child_element, prototype)
                 else:
-                    self._raiseError("Unsupported ExplicitInterRunnableVariables <%s>" % type(prototype))
+                    self.notImplemented("Unsupported ExplicitInterRunnableVariables <%s>" % type(prototype))
 
-    def writePerInstanceMemories(self, element: ET.Element, behavior: SwcInternalBehavior):
+    def writeSwcInternalBehaviorPerInstanceMemories(self, element: ET.Element, behavior: SwcInternalBehavior):
         memories = behavior.getPerInstanceMemories()
         if len(memories) > 0:
             memories_tag = ET.SubElement(element, "PER-INSTANCE-MEMORYS")
@@ -1276,21 +1453,20 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalLiteral(child_element, "INIT-VALUE", memory.getInitValue())
                 self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", memory.getSwDataDefProps())
                 self.setChildElementOptionalLiteral(child_element, "TYPE", memory.getType())
-                self.setChildElementOptionalLiteral (child_element, "TYPE-DEFINITION", memory.getTypeDefinition())
+                self.setChildElementOptionalLiteral(child_element, "TYPE-DEFINITION", memory.getTypeDefinition())
 
-    def setParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
+    def writeParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
         child_element = ET.SubElement(element, "PARAMETER-DATA-PROTOTYPE")
-        self.writeIdentifiable(child_element, prototype)
-        self.setAutosarDataPrototype(child_element, prototype)
+        self.writeAutosarDataPrototype(child_element, prototype)
         self.setValueSpecification(child_element, "INIT-VALUE", prototype.getInitValue())
 
-    def setParameterDataPrototypes(self, element: ET.Element, key: str, parameters: List[ParameterDataPrototype]):
+    def writeSwcInternalBehaviorParameterDataPrototypes(self, element: ET.Element, key: str, parameters: List[ParameterDataPrototype]):
         if len(parameters) > 0:
             child_element = ET.SubElement(element, key)
             for parameter in parameters:
-                self.setParameterDataPrototype(child_element, parameter)
+                self.writeParameterDataPrototype(child_element, parameter)
 
-    def writePortDefinedArgumentValues(self, element: ET.Element, argument_values: List[PortDefinedArgumentValue]) :
+    def writePortDefinedArgumentValues(self, element: ET.Element, argument_values: List[PortDefinedArgumentValue]):
         if len(argument_values) > 0:
             child_element = ET.SubElement(element, "PORT-ARG-VALUES")
             for argument_value in argument_values:
@@ -1299,7 +1475,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.setValueSpecification(child_element, "VALUE", argument_value.getValue())
                 self.setChildElementOptionalRefType(child_element, "VALUE-TYPE-TREF", argument_value.getValueTypeTRef())
 
-    def writePortAPIOptions(self, element: ET.Element, behavior: SwcInternalBehavior):
+    def writeSwcInternalBehaviorPortAPIOptions(self, element: ET.Element, behavior: SwcInternalBehavior):
         options = behavior.getPortAPIOptions()
         if len(options) > 0:
             port_api_options_tag = ET.SubElement(element, "PORT-API-OPTIONS")
@@ -1324,7 +1500,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(data, RoleBasedDataTypeAssignment):
                     self.writeRoleBasedDataTypeAssignment(child_element, data)
                 else:
-                    self._raiseError("Unsupported Assigned Data <%s>" % type(data))
+                    self.notImplemented("Unsupported Assigned Data <%s>" % type(data))
 
     def writeServiceDependency(self, element: ET.Element, dependency: ServiceDependency):
         self.writeIdentifiable(element, dependency)
@@ -1350,7 +1526,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(data, RoleBasedDataAssignment):
                     self.writeRoleBasedDataAssignment(child_element, data)
                 else:
-                    self._raiseError("Unsupported Assigned Data <%s>" % type(data))
+                    self.notImplemented("Unsupported Assigned Data <%s>" % type(data))
 
     def writeSwcServiceDependencyAssignedPorts(self, element: ET.Element, dependency: SwcServiceDependency):
         assigned_data = dependency.getAssignedPorts()
@@ -1360,7 +1536,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(data, RoleBasedPortAssignment):
                     self.writeRoleBasedPortAssignment(child_element, data)
                 else:
-                    self._raiseError("Unsupported Assigned Data <%s>" % type(data)) 
+                    self.notImplemented("Unsupported Assigned Data <%s>" % type(data))
 
     def setNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
         child_element = ET.SubElement(element, "NV-BLOCK-NEEDS")
@@ -1390,8 +1566,8 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS")
         self.logger.debug("write DiagnosticCommunicationManagerNeeds %s" % needs.getShortName())
         self.writeIdentifiable(child_element, needs)
-        self.setChildElementOptionalLiteral(child_element, "SERVICE-REQUEST-CALLBACK-TYPE", needs.getServiceRequestCallbackType()) 
-    
+        self.setChildElementOptionalLiteral(child_element, "SERVICE-REQUEST-CALLBACK-TYPE", needs.getServiceRequestCallbackType())
+
     def setDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-ROUTINE-NEEDS")
         self.logger.debug("write DiagnosticRoutineNeeds %s" % needs.getShortName())
@@ -1412,7 +1588,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setDiagEventDebounceMonitorInternal(self, element: ET.Element, algorithm: DiagEventDebounceMonitorInternal):
         child_element = ET.SubElement(element, "DIAG-EVENT-DEBOUNCE-MONITOR-INTERNAL")
         self.writeIdentifiable(child_element, algorithm)
-        
+
     def writeDiagEventDebounceAlgorithm(self, element: ET.Element, needs: DiagnosticEventNeeds):
         algorithm = needs.getDiagEventDebounceAlgorithm()
         if algorithm is not None:
@@ -1435,7 +1611,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
         self.writeIdentifiable(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
-    
+
     def setCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
         child_element = ET.SubElement(element, "CRYPTO-SERVICE-NEEDS")
         self.logger.debug("write CryptoServiceNeeds %s" % needs.getShortName())
@@ -1469,7 +1645,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 elif isinstance(need, EcuStateMgrUserNeeds):
                     self.setEcuStateMgrUserNeeds(child_element, need)
                 else:
-                    self.notImplemented("Unsupported service needs <%s>" % type(need))                  
+                    self.notImplemented("Unsupported service needs <%s>" % type(need))
 
     def writeSwcServiceDependency(self, element: ET.Element, dependency: SwcServiceDependency):
         child_element = ET.SubElement(element, "SWC-SERVICE-DEPENDENCY")
@@ -1486,37 +1662,57 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(dependency, SwcServiceDependency):
                     self.writeSwcServiceDependency(child_element, dependency)
                 else:
-                    self._raiseError("Unsupported ServiceDependency <%s>" % type(dependency))
+                    self.notImplemented("Unsupported ServiceDependency <%s>" % type(dependency))
 
     def setIncludedDataTypeSets(self, element: ET.Element, sets: List[IncludedDataTypeSet]):
         if len(sets) > 0:
             include_data_type_sets_tag = ET.SubElement(element, "INCLUDED-DATA-TYPE-SETS")
             for set in sets:
                 child_element = ET.SubElement(include_data_type_sets_tag, "INCLUDED-DATA-TYPE-SET")
-                self.setARObjectAttributes(child_element, set)
+                self.writeARObjectAttributes(child_element, set)
                 type_refs = set.getDataTypeRefs()
                 if len(type_refs) > 0:
                     data_type_refs_tag = ET.SubElement(child_element, "DATA-TYPE-REFS")
                     for type_ref in type_refs:
                         self.setChildElementOptionalRefType(data_type_refs_tag, "DATA-TYPE-REF", type_ref)
 
+    def writeIncludedModeDeclarationGroupSet(self, element: ET.Element, set: IncludedModeDeclarationGroupSet):
+        if set is not None:
+            child_element = ET.SubElement(element, "INCLUDED-MODE-DECLARATION-GROUP-SET")
+            refs = set.getModeDeclarationGroupRefs()
+            if len(refs) > 0:
+                refs_tag = ET.SubElement(child_element, "MODE-DECLARATION-GROUP-REFS")
+                for ref in refs:
+                    self.setChildElementOptionalRefType(refs_tag, "MODE-DECLARATION-GROUP-REF", ref)
+            self.setChildElementOptionalLiteral(child_element, "PREFIX", set.getPrefix())
+
+    def writeSwcInternalBehaviorIncludedModeDeclarationGroupSets(self, element: ET.Element, behavior: SwcInternalBehavior):
+        group_sets = behavior.getIncludedModeDeclarationGroupSets()
+        if len(group_sets) > 0:
+            child_element = ET.SubElement(element, "INCLUDED-MODE-DECLARATION-GROUP-SETS")
+            for group_set in group_sets:
+                if isinstance(group_set, IncludedModeDeclarationGroupSet):
+                    self.writeIncludedModeDeclarationGroupSet(child_element, group_set)
+                else:
+                    self.notImplemented("Unsupported IncludedModeDeclarationGroupSet <%s>" % type(group_set))
 
     def writeSwcInternalBehavior(self, element: ET.Element, behavior: SwcInternalBehavior):
         self.logger.debug("writeSwInternalBehavior %s" % behavior.getShortName())
-
         child_element = ET.SubElement(element, "SWC-INTERNAL-BEHAVIOR")
         self.writeInternalBehavior(child_element, behavior)
+
         self.writeSwcInternalBehaviorArTypedPerInstanceMemories(child_element, behavior)
-        self.writeRTEEvents(child_element, behavior)
-        self.writeExplicitInterRunnableVariables(child_element, behavior)
+        self.writeSwcInternalBehaviorEvents(child_element, behavior)
+        self.writeSwcInternalBehaviorExplicitInterRunnableVariables(child_element, behavior)
         self.setChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART", behavior.getHandleTerminationAndRestart())
         self.setIncludedDataTypeSets(child_element, behavior.getIncludedDataTypeSets())
-        self.writePerInstanceMemories(child_element, behavior)
-        self.setParameterDataPrototypes(child_element, "PER-INSTANCE-PARAMETERS", behavior.getPerInstanceParameters())
-        self.writePortAPIOptions(child_element, behavior)
-        self.writeSwcInternalBehaviorRunnableEntities(child_element, behavior)
+        self.writeSwcInternalBehaviorIncludedModeDeclarationGroupSets(child_element, behavior)
+        self.writeSwcInternalBehaviorPerInstanceMemories(child_element, behavior)
+        self.writeSwcInternalBehaviorParameterDataPrototypes(child_element, "PER-INSTANCE-PARAMETERS", behavior.getPerInstanceParameters())
+        self.writeSwcInternalBehaviorPortAPIOptions(child_element, behavior)
+        self.writeSwcInternalBehaviorRunnables(child_element, behavior)
         self.writeSwcInternalBehaviorServiceDependencies(child_element, behavior)
-        self.setParameterDataPrototypes(child_element, "SHARED-PARAMETERS", behavior.getSharedParameters())
+        self.writeSwcInternalBehaviorParameterDataPrototypes(child_element, "SHARED-PARAMETERS", behavior.getSharedParameters())
         self.setChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION", behavior.getSupportsMultipleInstantiation())
 
     def writeAtomicSwComponentTypeInternalBehaviors(self, element: ET.Element, behavior: InternalBehavior):
@@ -1525,11 +1721,11 @@ class ARXMLWriter(AbstractARXMLWriter):
             if isinstance(behavior, SwcInternalBehavior):
                 self.writeSwcInternalBehavior(behaviors_tag, behavior)
             else:
-                self._raiseError("Unsupported Internal Behaviors <%s>" % type(behavior))
+                self.notImplemented("Unsupported Internal Behaviors <%s>" % type(behavior))
 
     def writeAtomicSwComponentType(self, element: ET.Element, sw_component: AtomicSwComponentType):
         self.writeSwComponentType(element, sw_component)
-        self.writeAtomicSwComponentTypeInternalBehaviors(element, sw_component.internal_behavior)
+        self.writeAtomicSwComponentTypeInternalBehaviors(element, sw_component.getInternalBehavior())
 
     def writeComplexDeviceDriverSwComponentType(self, element: ET.Element, sw_component: ComplexDeviceDriverSwComponentType):
         self.logger.debug("writeComplexDeviceDriverSwComponentType %s" % sw_component.getShortName())
@@ -1543,7 +1739,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             for artifact_desc in artifact_descriptors:
                 artifact_desc_tag = ET.SubElement(artifact_descs_tag, "AUTOSAR-ENGINEERING-OBJECT")
                 self.logger.debug("writeArtifactDescriptor %s", artifact_desc.short_label)
-                self.setARObjectAttributes(artifact_desc_tag, artifact_desc)
+                self.writeARObjectAttributes(artifact_desc_tag, artifact_desc)
                 self.setChildElementOptionalLiteral(artifact_desc_tag, "SHORT-LABEL", artifact_desc.short_label)
                 self.setChildElementOptionalLiteral(artifact_desc_tag, "CATEGORY", artifact_desc.category)
 
@@ -1561,7 +1757,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(desc, Code):
                     self.setCode(child_element, desc)
                 else:
-                    self._raiseError("Unsupported Code Descriptor <%s>" % type(desc))
+                    self.notImplemented("Unsupported Code Descriptor <%s>" % type(desc))
 
     def setMemorySectionOptions(self, element: ET.Element, options: List[ARLiteral]):
         if len(options) > 0:
@@ -1626,7 +1822,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeImplementation(child_element, impl)
         self.setChildElementOptionalRefType(child_element, "BEHAVIOR-REF", impl.getBehaviorRef())
 
-    def writeEndToEndDescriptionDataId(self, element: ET.Element, parent: EndToEndDescription):
+    def writeEndToEndDescriptionDataIds(self, element: ET.Element, parent: EndToEndDescription):
         data_ids = parent.getDataIds()
         if len(data_ids) > 0:
             child_element = ET.SubElement(element, "DATA-IDS")
@@ -1636,24 +1832,28 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setEndToEndDescription(self, element: ET.Element, key: str, desc: EndToEndDescription):
         if desc is not None:
             child_element = ET.SubElement(element, key)
-            self.setChildElementOptionalLiteral(child_element, "CATEGORY", desc.category)
-            self.writeEndToEndDescriptionDataId(child_element, desc)
-            self.setChildElementOptionalNumericalValue(child_element, "DATA-ID-MODE", desc.getDataIdMode())
-            self.setChildElementOptionalNumericalValue(child_element, "MAX-DELTA-COUNTER-INIT", desc.getMaxDeltaCounterInit())
-            self.setChildElementOptionalNumericalValue(child_element, "CRC-OFFSET", desc.getCrcOffset())
-            self.setChildElementOptionalNumericalValue(child_element, "COUNTER-OFFSET", desc.getCounterOffset())
-
-    def setVariableDataPrototypeInSystemInstanceRef(self, element: ET.Element, key: str, iref: VariableDataPrototypeInSystemInstanceRef):
-        if iref is not None:
+            self.writeARObjectAttributes(child_element, desc)
+            self.setChildElementOptionalLiteral(child_element, "CATEGORY", desc.getCategory())
+            self.writeEndToEndDescriptionDataIds(child_element, desc)
+            self.setChildElementOptionalPositiveInteger(child_element, "DATA-ID-MODE", desc.getDataIdMode())
+            self.setChildElementOptionalPositiveInteger(child_element, "DATA-LENGTH", desc.getDataLength())
+            self.setChildElementOptionalPositiveInteger(child_element, "MAX-DELTA-COUNTER-INIT", desc.getMaxDeltaCounterInit())
+            self.setChildElementOptionalPositiveInteger(child_element, "CRC-OFFSET", desc.getCrcOffset())
+            self.setChildElementOptionalPositiveInteger(child_element, "COUNTER-OFFSET", desc.getCounterOffset())
+
+    def setVariableDataPrototypeInSystemInstanceRef(self, element: ET.Element, key: str, instance_ref: VariableDataPrototypeInSystemInstanceRef):
+        if instance_ref is not None:
             child_element = ET.SubElement(element, key)
-            #self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPONENT-REF", iref.getContextComponentRefs())        # TODO 
-            self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPOSITION-REF", iref.getContextCompositionRef())
-            self.setChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF", iref.getContextPortRef())
-            self.setChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF", iref.getTargetDataPrototypeRef())
+            for ref in instance_ref.getContextComponentRefs():
+                self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPONENT-REF", ref)
+            self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPOSITION-REF", instance_ref.getContextCompositionRef())
+            self.setChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF", instance_ref.getContextPortRef())
+            self.setChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF", instance_ref.getTargetDataPrototypeRef())
 
-    def setEndToEndProtectionVariablePrototype(self, element: ET.Element, key: str, prototype: EndToEndProtectionVariablePrototype):
+    def writeEndToEndProtectionVariablePrototype(self, element: ET.Element, prototype: EndToEndProtectionVariablePrototype):
         if prototype is not None:
-            child_element = ET.SubElement(element, key)
+            child_element = ET.SubElement(element, "END-TO-END-PROTECTION-VARIABLE-PROTOTYPE")
+            self.writeARObjectAttributes(child_element, prototype)
             irefs = prototype.getReceiverIrefs()
             if len(irefs) > 0:
                 child_element = ET.SubElement(child_element, "RECEIVER-IREFS")
@@ -1661,22 +1861,40 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.setVariableDataPrototypeInSystemInstanceRef(child_element, "RECEIVER-IREF", iref)
             self.setVariableDataPrototypeInSystemInstanceRef(child_element, "SENDER-IREF", prototype.senderIRef)
 
-    def writeEndToEndProtectionVariablePrototypes(self, element: ET.Element, parent: EndToEndProtection):
-        prototypes = parent.getEndToEndProtectionVariablePrototypes()
+    def writeEndToEndProtectionEndToEndProtectionVariablePrototypes(self, element: ET.Element, protection: EndToEndProtection):
+        prototypes = protection.getEndToEndProtectionVariablePrototypes()
         if len(prototypes) > 0:
             child_element = ET.SubElement(element, "END-TO-END-PROTECTION-VARIABLE-PROTOTYPES")
             for prototype in prototypes:
                 if isinstance(prototype, EndToEndProtectionVariablePrototype):
-                    self.setEndToEndProtectionVariablePrototype(child_element, "END-TO-END-PROTECTION-VARIABLE-PROTOTYPE", prototype)
+                    self.writeEndToEndProtectionVariablePrototype(child_element, prototype)
                 else:
-                    self._raiseError("Unsupported End To End Protection Variable Prototype <%s>" % type(prototype))
+                    self.notImplemented("Unsupported End To End Protection Variable Prototype <%s>" % type(prototype))
+
+    def writeEndToEndProtectionISignalIPdu(self, element: ET.Element, ipdu: EndToEndProtectionISignalIPdu):
+        if ipdu is not None:
+            child_element = ET.SubElement(element, "END-TO-END-PROTECTION-I-SIGNAL-I-PDU")
+            self.setChildElementOptionalIntegerValue(child_element, "DATA-OFFSET", ipdu.getDataOffset())
+            self.setChildElementOptionalRefType(child_element, "I-SIGNAL-GROUP-REF", ipdu.getISignalGroupRef())
+            self.setChildElementOptionalRefType(child_element, "I-SIGNAL-I-PDU-REF", ipdu.getISignalIPduRef())
+
+    def writeEndToEndProtectionEndToEndProtectionISignalIPdus(self, element: ET.Element, protection: EndToEndProtection):
+        ipdus = protection.getEndToEndProtectionISignalIPdus()
+        if len(ipdus) > 0:
+            child_element = ET.SubElement(element, "END-TO-END-PROTECTION-I-SIGNAL-I-PDUS")
+            for ipdu in ipdus:
+                if isinstance(ipdu, EndToEndProtectionISignalIPdu):
+                    self.writeEndToEndProtectionISignalIPdu(child_element, ipdu)
+                else:
+                    self.notImplemented("Unsupported EndToEndProtectionISignalIPdu <%s>" % type(ipdu))
 
-    def setEndToEndProtection(self, element: ET.Element, protection: EndToEndProtection):
+    def writeEndToEndProtection(self, element: ET.Element, protection: EndToEndProtection):
         if protection is not None:
             child_element = ET.SubElement(element, "END-TO-END-PROTECTION")
             self.writeIdentifiable(child_element, protection)
-            self.setEndToEndDescription(child_element, "END-TO-END-PROFILE", protection.endToEndProfile)
-            self.writeEndToEndProtectionVariablePrototypes(child_element, protection)
+            self.setEndToEndDescription(child_element, "END-TO-END-PROFILE", protection.getEndToEndProfile())
+            self.writeEndToEndProtectionEndToEndProtectionISignalIPdus(child_element, protection)
+            self.writeEndToEndProtectionEndToEndProtectionVariablePrototypes(child_element, protection)
 
     def writeEndToEndProtections(self, element: ET.Element, protection_set: EndToEndProtectionSet):
         protections = protection_set.getEndToEndProtections()
@@ -1684,7 +1902,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "END-TO-END-PROTECTIONS")
             for protection in protections:
                 if isinstance(protection, EndToEndProtection):
-                    self.setEndToEndProtection(child_element, protection)
+                    self.writeEndToEndProtection(child_element, protection)
 
     def writeEndToEndProtectionSet(self, element: ET.Element, protection_set: EndToEndProtectionSet):
         self.logger.debug("writeEndToEndProtectionSet %s" % protection_set.getShortName())
@@ -1692,15 +1910,14 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeIdentifiable(child_element, protection_set)
         self.writeEndToEndProtections(child_element, protection_set)
 
-    def setAutosarDataPrototype(self, element: ET.Element, prototype: AutosarDataPrototype):
-        self.setDataPrototype(element, prototype)
+    def writeAutosarDataPrototype(self, element: ET.Element, prototype: AutosarDataPrototype):
+        self.writeDataPrototype(element, prototype)
         self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.typeTRef)
 
     def writeVariableDataPrototype(self, element: ET.Element, prototype: VariableDataPrototype):
         self.logger.debug("writeVariableDataPrototype %s" % prototype.getShortName())
         child_element = ET.SubElement(element, "VARIABLE-DATA-PROTOTYPE")
-        self.writeIdentifiable(child_element, prototype)
-        self.setAutosarDataPrototype(child_element, prototype)
+        self.writeAutosarDataPrototype(child_element, prototype)
         self.setValueSpecification(child_element, "INIT-VALUE", prototype.getInitValue())
 
     def writeSenderReceiverInterfaceDataElements(self, element: ET.Element, sr_interface: SenderReceiverInterface):
@@ -1711,7 +1928,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(data_element, VariableDataPrototype):
                     self.writeVariableDataPrototype(data_elements_tag, data_element)
                 else:
-                    self._raiseError("Unsupported Data Element <%s>" % type(data_element))
+                    self.notImplemented("Unsupported Data Element <%s>" % type(data_element))
 
     def writeSenderReceiverInterfaceInvalidationPolicies(self, element: ET.Element, sr_interface: SenderReceiverInterface):
         policies = sr_interface.getInvalidationPolicies()
@@ -1730,25 +1947,38 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeSenderReceiverInterfaceDataElements(child_element, sr_interface)
         self.writeSenderReceiverInterfaceInvalidationPolicies(child_element, sr_interface)
 
-    def writerBswModuleDescriptionImplementedEntry(self, element: ET.Element, desc: BswModuleDescription):
-        entries = desc.getImplementedEntries()
-        if len(entries) > 0:
+    def writeBswModuleDescriptionImplementedEntryRefs(self, element: ET.Element, desc: BswModuleDescription):
+        refs = desc.getImplementedEntryRefs()
+        if len(refs) > 0:
             entries_tag = ET.SubElement(element, "PROVIDED-ENTRYS")
-            for entry in entries:
+            for ref in refs:
                 entry_tag = ET.SubElement(entries_tag, "BSW-MODULE-ENTRY-REF-CONDITIONAL")
-                self.setChildElementOptionalRefType(entry_tag, "BSW-MODULE-ENTRY-REF", entry)
+                self.setChildElementOptionalRefType(entry_tag, "BSW-MODULE-ENTRY-REF", ref)
 
-    def setModeDeclarationGroupPrototype(self, element: ET.Element, prototype: ModeDeclarationGroupPrototype):
-        self.writeIdentifiable(element, prototype)
-        self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.type_tref)
+    def writeModeDeclarationGroupPrototype(self, element: ET.Element, prototype: ModeDeclarationGroupPrototype):
+        child_element = ET.SubElement(element, "MODE-DECLARATION-GROUP-PROTOTYPE")
+        self.writeIdentifiable(child_element, prototype)
+        self.setChildElementOptionalRefType(child_element, "TYPE-TREF", prototype.getTypeTRef())
 
-    def writeProvidedModeGroup(self, element: ET.Element, parent: BswModuleDescription):
+    def writeBswModuleDescriptionProvidedModeGroups(self, element: ET.Element, parent: BswModuleDescription):
         mode_groups = parent.getProvidedModeGroups()
         if len(mode_groups) > 0:
-            mode_groups_tag = ET.SubElement(element, "PROVIDED-MODE-GROUPS")
+            child_element = ET.SubElement(element, "PROVIDED-MODE-GROUPS")
             for mode_group in mode_groups:
-                child_element = ET.SubElement(mode_groups_tag, "MODE-DECLARATION-GROUP-PROTOTYPE") 
-                self.setModeDeclarationGroupPrototype(child_element, mode_group)
+                if isinstance(mode_group, ModeDeclarationGroupPrototype):
+                    self.writeModeDeclarationGroupPrototype(child_element, mode_group)
+                else:
+                    self.notImplemented("Unsupported ProvidedModeGroup <%s>" % type(mode_group))
+
+    def writeBswModuleDescriptionRequiredModeGroups(self, element: ET.Element, desc: BswModuleDescription):
+        mode_groups = desc.getRequiredModeGroups()
+        if len(mode_groups) > 0:
+            child_element = ET.SubElement(element, "REQUIRED-MODE-GROUPS")
+            for mode_group in mode_groups:
+                if isinstance(mode_group, ModeDeclarationGroupPrototype):
+                    self.writeModeDeclarationGroupPrototype(child_element, mode_group)
+                else:
+                    self.notImplemented("Unsupported ProvidedModeGroup <%s>" % type(mode_group))
 
     def writeCanEnterExclusiveAreaRefs(self, element: ET.Element, entity: ExecutableEntity):
         refs = entity.getCanEnterExclusiveAreaRefs()
@@ -1757,13 +1987,13 @@ class ARXMLWriter(AbstractARXMLWriter):
             for ref in refs:
                 self.setChildElementOptionalRefType(child_element, "CAN-ENTER-EXCLUSIVE-AREA-REF", ref)
 
-    def setExecutableEntity(self, element: ET.Element, entity: ExecutableEntity):
+    def writeExecutableEntity(self, element: ET.Element, entity: ExecutableEntity):
         self.writeIdentifiable(element, entity)
         self.writeCanEnterExclusiveAreaRefs(element, entity)
         self.setChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL", entity.getMinimumStartInterval())
         self.setChildElementOptionalRefType(element, "SW-ADDR-METHOD-REF", entity.getSwAddrMethodRef())
 
-    def writeBswModuleEntityManagedModeGroup(self, element: ET.Element, entity: BswModuleEntity):
+    def writeBswModuleEntityManagedModeGroups(self, element: ET.Element, entity: BswModuleEntity):
         mode_group_refs = entity.getManagedModeGroupRefs()
         if len(mode_group_refs) > 0:
             mode_groups_tag = ET.SubElement(element, "MANAGED-MODE-GROUPS")
@@ -1771,64 +2001,142 @@ class ARXMLWriter(AbstractARXMLWriter):
                 child_element = ET.SubElement(mode_groups_tag, "MODE-DECLARATION-GROUP-PROTOTYPE-REF-CONDITIONAL")
                 self.setChildElementOptionalRefType(child_element, "MODE-DECLARATION-GROUP-PROTOTYPE-REF", mode_group_ref)
 
-    def setBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
-        self.setExecutableEntity(element, entity)
+    def writeBswVariableAccess(self, element: ET.Element, access: BswVariableAccess):
+        if access is not None:
+            child_element = ET.SubElement(element, "BSW-VARIABLE-ACCESS")
+            self.writeReferrable(child_element, access)
+            self.setChildElementOptionalRefType(child_element, "ACCESSED-VARIABLE-REF", access.getAccessedVariableRef())
+    
+    def writeBswModuleEntityDataSendPoints(self, element: ET.Element, entity: BswModuleEntity):
+        points = entity.getDataSendPoints()
+        if len(points) > 0:
+            child_element = ET.SubElement(element, "DATA-SEND-POINTS")
+            for point in points:
+                if isinstance(point, BswVariableAccess):
+                    self.writeBswVariableAccess(child_element, point)
+                else:
+                    self.notImplemented("Unsupported Data Send Point <%s>" % type(point))
+
+    def writeBswModuleEntityDataReceivePoints(self, element: ET.Element, entity: BswModuleEntity):
+        points = entity.getDataReceivePoints()
+        if len(points) > 0:
+            child_element = ET.SubElement(element, "DATA-RECEIVE-POINTS")
+            for point in points:
+                if isinstance(point, BswVariableAccess):
+                    self.writeBswVariableAccess(child_element, point)
+                else:
+                    self.notImplemented("Unsupported Data Receive Point <%s>" % type(point))
+
+    def writeBswModuleEntityIssuedTriggerRefs(self, element: ET.Element, entity: BswModuleEntity):
+        refs = entity.getIssuedTriggerRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "ISSUED-TRIGGERS")
+            for ref in refs:
+                cond_tag = ET.SubElement(child_element, "TRIGGER-REF-CONDITIONAL")
+                self.setChildElementOptionalRefType(cond_tag, "TRIGGER-REF", ref)
+
+    def writeBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
+        self.writeExecutableEntity(element, entity)
+        self.writeBswModuleEntityDataSendPoints(element, entity)
+        self.writeBswModuleEntityDataReceivePoints(element, entity)
         self.setChildElementOptionalRefType(element, "IMPLEMENTED-ENTRY-REF", entity.implementedEntryRef)
-        self.writeBswModuleEntityManagedModeGroup(element, entity)
+        self.writeBswModuleEntityManagedModeGroups(element, entity)
+        self.writeBswModuleEntityIssuedTriggerRefs(element, entity)
 
-    def setBswCalledEntity(self, element: ET.Element, entity: BswCalledEntity):
-        self.logger.debug("setBswCalledEntity %s" % entity.getShortName())
+    def writeBswCalledEntity(self, element: ET.Element, entity: BswCalledEntity):
+        self.logger.debug("Write BswCalledEntity <%s>" % entity.getShortName())
         child_element = ET.SubElement(element, "BSW-CALLED-ENTITY")
-        self.setBswModuleEntity(child_element, entity)
+        self.writeBswModuleEntity(child_element, entity)
 
-    def setBswSchedulableEntity(self, element: ET.Element, entity: BswSchedulableEntity):
-        self.logger.debug("set BswSchedulableEntity %s" % entity.getShortName())
+    def writeBswSchedulableEntity(self, element: ET.Element, entity: BswSchedulableEntity):
+        self.logger.debug("Write BswSchedulableEntity <%s>" % entity.getShortName())
         child_element = ET.SubElement(element, "BSW-SCHEDULABLE-ENTITY")
-        self.setBswModuleEntity(child_element, entity)
+        self.writeBswModuleEntity(child_element, entity)
 
     def setBswInterruptEntity(self, element: ET.Element, entity: BswInterruptEntity):
-        self.logger.debug("read BswInterruptEntity %s" % entity.getShortName())
+        self.logger.debug("Write BswInterruptEntity <%s>" % entity.getShortName())
         child_element = ET.SubElement(element, "BSW-INTERRUPT-ENTITY")
-        self.setBswModuleEntity(child_element, entity)
+        self.writeBswModuleEntity(child_element, entity)
         self.setChildElementOptionalLiteral(child_element, "INTERRUPT-CATEGORY", entity.getInterruptCategory())
         self.setChildElementOptionalLiteral(child_element, "INTERRUPT-SOURCE", entity.getInterruptSource())
 
     def writeBswInternalBehaviorBswModuleEntities(self, element: ET.Element, parent: BswInternalBehavior):
-        entities = parent.getBswModuleEntities()    
+        entities = parent.getBswModuleEntities()
         if len(entities) > 0:
             child_element = ET.SubElement(element, "ENTITYS")
             for entity in entities:
                 if isinstance(entity, BswCalledEntity):
-                    self.setBswCalledEntity(child_element, entity)
+                    self.writeBswCalledEntity(child_element, entity)
                 elif isinstance(entity, BswSchedulableEntity):
-                    self.setBswSchedulableEntity(child_element, entity)
+                    self.writeBswSchedulableEntity(child_element, entity)
                 elif isinstance(entity, BswInterruptEntity):
                     self.setBswInterruptEntity(child_element, entity)
                 else:
                     self.notImplemented("Unsupported BswModuleEntity <%s>" % type(entity))
 
-    def setBswEvent(self, element: ET.Element, event: BswEvent):
+    def writeBswEvent(self, element: ET.Element, event: BswEvent):
         self.writeIdentifiable(element, event)
         self.setChildElementOptionalRefType(element, "STARTS-ON-EVENT-REF", event.startsOnEventRef)
 
-    def setBswScheduleEvent(self, element: ET.Element, event: BswScheduleEvent):
-        self.setBswEvent(element, event)
+    def writeBswScheduleEvent(self, element: ET.Element, event: BswScheduleEvent):
+        self.writeBswEvent(element, event)
 
-    def setBswTimingEvent(self, element: ET.Element, event: BswTimingEvent):
-        self.logger.debug("setBswTimingEvent %s" % event.getShortName())
+    def writeBswTimingEvent(self, element: ET.Element, event: BswTimingEvent):
+        self.logger.debug("Write BswTimingEvent <%s>" % event.getShortName())
         child_element = ET.SubElement(element, "BSW-TIMING-EVENT")
-        self.setBswScheduleEvent(child_element, event)
+        self.writeBswScheduleEvent(child_element, event)
         self.setChildElementOptionalTimeValue(child_element, "PERIOD", event.getPeriod())
 
+    def writeBswBackgroundEvent(self, element: ET.Element, event: BswBackgroundEvent):
+        self.logger.debug("Write BswTimingEvent <%s>" % event.getShortName())
+        child_element = ET.SubElement(element, "BSW-BACKGROUND-EVENT")
+        self.writeBswScheduleEvent(child_element, event)
+
+    def writeBswInternalTriggerOccurredEvent(self, element: ET.Element, event: BswInternalTriggerOccurredEvent):
+        self.logger.debug("Write BswInternalTriggerOccurredEvent <%s>" % event.getShortName())
+        child_element = ET.SubElement(element, "BSW-INTERNAL-TRIGGER-OCCURRED-EVENT")
+        self.writeBswScheduleEvent(child_element, event)
+        self.setChildElementOptionalRefType(child_element, "EVENT-SOURCE-REF", event.getEventSourceRef())
+
+    def writeBswExternalTriggerOccurredEvent(self, element: ET.Element, event: BswExternalTriggerOccurredEvent):
+        self.logger.debug("Write BswExternalTriggerOccurredEvent <%s>" % event.getShortName())
+        child_element = ET.SubElement(element, "BSW-EXTERNAL-TRIGGER-OCCURRED-EVENT")
+        self.writeBswScheduleEvent(child_element, event)
+        self.setChildElementOptionalRefType(child_element, "TRIGGER-REF", event.getTriggerRef())
+
+    def writeBswDataReceivedEvent(self, element: ET.Element, event: BswDataReceivedEvent):
+        self.logger.debug("Write BswDataReceivedEvent <%s>" % event.getShortName())
+        # Read the Inherit BswScheduleEvent
+        child_element = ET.SubElement(element, "BSW-DATA-RECEIVED-EVENT")
+        self.writeBswScheduleEvent(child_element, event)
+        self.setChildElementOptionalRefType(child_element, "DATA-REF", event.getDataRef())
+
+    def writeBswOperationInvokedEvent(self, element: ET.Element, event: BswOperationInvokedEvent):
+        self.logger.debug("Write BswOperationInvokedEvent <%s>" % event.getShortName())
+        # Read the Inherit BswScheduleEvent
+        child_element = ET.SubElement(element, "BSW-OPERATION-INVOKED-EVENT")
+        self.writeBswEvent(child_element, event)
+        self.setChildElementOptionalRefType(child_element, "ENTRY-REF", event.getEntryRef())
+
     def writeBswInternalBehaviorBswEvents(self, element: ET.Element, parent: BswInternalBehavior):
         events = parent.getBswEvents()
         if len(events) > 0:
             child_element = ET.SubElement(element, "EVENTS")
             for event in events:
                 if isinstance(event, BswTimingEvent):
-                    self.setBswTimingEvent(child_element, event)
+                    self.writeBswTimingEvent(child_element, event)
+                elif isinstance(event, BswBackgroundEvent):
+                    self.writeBswBackgroundEvent(child_element, event)
+                elif isinstance(event, BswInternalTriggerOccurredEvent):
+                    self.writeBswInternalTriggerOccurredEvent(child_element, event)
+                elif isinstance(event, BswExternalTriggerOccurredEvent):
+                    self.writeBswExternalTriggerOccurredEvent(child_element, event)
+                elif isinstance(event, BswDataReceivedEvent):
+                    self.writeBswDataReceivedEvent(child_element, event)
+                elif isinstance(event, BswOperationInvokedEvent):
+                    self.writeBswOperationInvokedEvent(child_element, event)
                 else:
-                    self._raiseError("Unsupported BswModuleEntity <%s>" % type(event))
+                    self.notImplemented("Unsupported BswModuleEntity <%s>" % type(event))
 
     def setBswModeSenderPolicy(self, element: ET.Element, policy: BswModeSenderPolicy):
         child_element = ET.SubElement(element, "BSW-MODE-SENDER-POLICY")
@@ -1843,52 +2151,114 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(policy, BswModeSenderPolicy):
                     self.setBswModeSenderPolicy(child_element, policy)
                 else:
-                    self._raiseError("Unsupported ModeSenderPolicy type <%s>." % type(policy))
-
-    def setIncludedModeDeclarationGroupSet(self, element: ET.Element, group_set: IncludedModeDeclarationGroupSet):
-        child_element = ET.SubElement(element, "INCLUDED-MODE-DECLARATION-GROUP-SET")
+                    self.notImplemented("Unsupported ModeSenderPolicy type <%s>." % type(policy))
 
     def writeBswInternalBehaviorIncludedModeDeclarationGroupSets(self, element: ET.Element, behavior: BswInternalBehavior):
         group_sets = behavior.getIncludedModeDeclarationGroupSets()
         if len(group_sets) > 0:
             child_element = ET.SubElement(element, "INCLUDED-MODE-DECLARATION-GROUP-SETS")
             for group_set in group_sets:
-                self.setIncludedModeDeclarationGroupSet(child_element, group_set)
+                self.writeIncludedModeDeclarationGroupSet(child_element, group_set)
+
+    def writeBswApiOptions(self, element: ET.Element, options: BswApiOptions):
+        self.writeARObjectAttributes(element, options)
+        self.setChildElementOptionalBooleanValue(element, "ENABLE-TAKE-ADDRESS", options.getEnableTakeAddress())
+
+    def writeBswDataReceptionPolicy(self, element: ET.Element, policy: BswDataReceptionPolicy):
+        self.writeBswApiOptions(element, policy)
+        self.setChildElementOptionalRefType(element, "RECEIVED-DATA-REF", policy.getReceivedDataRef())
+
+    def writeBswQueuedDataReceptionPolicy(self, element: ET.Element, policy: BswQueuedDataReceptionPolicy):
+        child_element = ET.SubElement(element, "BSW-QUEUED-DATA-RECEPTION-POLICY")
+        self.writeBswDataReceptionPolicy(child_element, policy)
+        self.setChildElementOptionalPositiveInteger(child_element, "QUEUE-LENGTH", policy.getQueueLength())
 
-    def setBswInternalBehavior(self, element: ET.Element, behavior: BswInternalBehavior):
+    def writeBswInternalBehaviorReceptionPolicies(self, element: ET.Element, behavior: BswInternalBehavior):
+        policies = behavior.getReceptionPolicies()
+        if len(policies) > 0:
+            child_element = ET.SubElement(element, "RECEPTION-POLICYS")
+            for policy in policies:
+                if isinstance(policy, BswQueuedDataReceptionPolicy):
+                    self.writeBswQueuedDataReceptionPolicy(child_element, policy)
+                else:
+                    self.notImplemented("Unsupported Reception Policies <%s>" % type(policy))
+
+    def writeBswInternalBehavior(self, element: ET.Element, behavior: BswInternalBehavior):
         child_element = ET.SubElement(element, "BSW-INTERNAL-BEHAVIOR")
         self.writeInternalBehavior(child_element, behavior)
         self.writeBswInternalBehaviorBswModuleEntities(child_element, behavior)
         self.writeBswInternalBehaviorBswEvents(child_element, behavior)
         self.writeBswInternalBehaviorModeSenderPolicy(child_element, behavior)
         self.writeBswInternalBehaviorIncludedModeDeclarationGroupSets(child_element, behavior)
+        self.writeBswInternalBehaviorReceptionPolicies(child_element, behavior)
 
-    def writeBswModuleDescriptionInternalBehaviors(self, element: ET.Element, behaviors: List[InternalBehavior]):
+    def writeBswModuleDescriptionInternalBehaviors(self, element: ET.Element, desc: BswModuleDescription):
+        behaviors = desc.getInternalBehaviors()
         if len(behaviors) > 0:
             child_element = ET.SubElement(element, "INTERNAL-BEHAVIORS")
             for behavior in behaviors:
                 if isinstance(behavior, BswInternalBehavior):
-                    self.setBswInternalBehavior(child_element, behavior)
+                    self.writeBswInternalBehavior(child_element, behavior)
                 else:
-                    self._raiseError("Unsupported BswInternalBehavior <%s>" % type(behavior))
-
+                    self.notImplemented("Unsupported Internal Behavior <%s>" % type(behavior))
+
+    def writeTrigger(self, element: ET.Element, trigger: Trigger):
+        child_element = ET.SubElement(element, "TRIGGER")
+        self.writeIdentifiable(child_element, trigger)
+
+    def writeBswModuleDescriptionReleasedTriggers(self, element: ET.Element, desc: BswModuleDescription):
+        triggers = desc.getReleasedTriggers()
+        if len(triggers) > 0:
+            child_element = ET.SubElement(element, "RELEASED-TRIGGERS")
+            for trigger in triggers:
+                if isinstance(trigger, Trigger):
+                    self.writeTrigger(child_element, trigger)
+                else:
+                    self.notImplemented("Unsupported Released Trigger <%s>" % type(trigger))
+
+    def writeBswModuleDescriptionRequiredTriggers(self, element: ET.Element, desc: BswModuleDescription):
+        triggers = desc.getRequiredTriggers()
+        if len(triggers) > 0:
+            child_element = ET.SubElement(element, "REQUIRED-TRIGGERS")
+            for trigger in triggers:
+                if isinstance(trigger, Trigger):
+                    self.writeTrigger(child_element, trigger)
+                else:
+                    self.notImplemented("Unsupported Required Trigger <%s>" % type(trigger))
+
+    def writeBswModuleDescriptionProvidedDatas(self, element: ET.Element, desc: BswModuleDescription):
+        datas = desc.getProvidedDatas()
+        if len(datas) > 0:
+            child_element = ET.SubElement(element, "PROVIDED-DATAS")
+            for data in datas:
+                if isinstance(data, VariableDataPrototype):
+                    self.writeVariableDataPrototype(child_element, data)
+                else:
+                    self.notImplemented("Unsupported Provided Data <%s>" % type(data))
+
+    def writeBswModuleDescriptionRequiredDatas(self, element: ET.Element, desc: BswModuleDescription):
+        datas = desc.getRequiredDatas()
+        if len(datas) > 0:
+            child_element = ET.SubElement(element, "REQUIRED-DATAS")
+            for data in datas:
+                if isinstance(data, VariableDataPrototype):
+                    self.writeVariableDataPrototype(child_element, data)
+                else:
+                    self.notImplemented("Unsupported Required Data <%s>" % type(data))
+    
     def writeBswModuleDescription(self, element: ET.Element, desc: BswModuleDescription):
         self.logger.debug("writeBswModuleDescription %s" % desc.getShortName())
         child_element = ET.SubElement(element, "BSW-MODULE-DESCRIPTION")
         self.writeIdentifiable(child_element, desc)
         self.setChildElementOptionalNumericalValue(child_element, "MODULE-ID", desc.getModuleId())
-        self.writerBswModuleDescriptionImplementedEntry(child_element, desc)
-        self.writeProvidedModeGroup(child_element, desc)
-        #self.readRequiredModeGroup(element, bsw_module_description)
-        self.writeBswModuleDescriptionInternalBehaviors(child_element, desc.getBswInternalBehaviors())
-
-    def writeBswModuleEntityManagedModeGroup(self, element: ET.Element, entity: BswModuleEntity):
-        mode_group_refs = entity.getManagedModeGroupRefs()
-        if len(mode_group_refs) > 0:
-            mode_groups_tag = ET.SubElement(element, "MANAGED-MODE-GROUPS")
-            for mode_group_ref in mode_group_refs:
-                child_element = ET.SubElement(mode_groups_tag, "MODE-DECLARATION-GROUP-PROTOTYPE-REF-CONDITIONAL")
-                self.setChildElementOptionalRefType(child_element, "MODE-DECLARATION-GROUP-PROTOTYPE-REF", mode_group_ref)
+        self.writeBswModuleDescriptionImplementedEntryRefs(child_element, desc)
+        self.writeBswModuleDescriptionProvidedModeGroups(child_element, desc)
+        self.writeBswModuleDescriptionRequiredModeGroups(child_element, desc)
+        self.writeBswModuleDescriptionReleasedTriggers(child_element, desc)
+        self.writeBswModuleDescriptionRequiredTriggers(child_element, desc)
+        self.writeBswModuleDescriptionProvidedDatas(child_element, desc)
+        self.writeBswModuleDescriptionRequiredDatas(child_element, desc)
+        self.writeBswModuleDescriptionInternalBehaviors(child_element, desc)
 
     def setSwServiceArg(self, element: ET.Element, arg: SwServiceArg):
         self.logger.debug("Set SwServiceArg <%s>" % arg.getShortName())
@@ -1930,7 +2300,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(mapping, SwcBswRunnableMapping):
                     self.setSwcBswRunnableMapping(child_element, mapping)
                 else:
-                    self._raiseError("Unsupported Runnable Mapping <%s>" % type(mapping))
+                    self.notImplemented("Unsupported Runnable Mapping <%s>" % type(mapping))
 
     def writeSwcBswMapping(self, element: ET.Element, mapping: SwcBswMapping):
         self.logger.debug("writeBswModuleDescription %s" % mapping.getShortName())
@@ -1941,7 +2311,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRefType(child_element, "SWC-BEHAVIOR-REF", mapping.getSwcBehaviorRef())
 
     def writeEngineeringObject(self, element: ET.Element, engineering_obj: EngineeringObject):
-        self.setARObjectAttributes(element, engineering_obj)
+        self.writeARObjectAttributes(element, engineering_obj)
         self.setChildElementOptionalLiteral(element, "SHORT-LABEL", engineering_obj.short_label)
         self.setChildElementOptionalLiteral(element, "CATEGORY", engineering_obj.category)
         
@@ -1958,13 +2328,13 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(artifact_desc, AutosarEngineeringObject):
                     self.setAutosarEngineeringObject(child_element, artifact_desc)
                 else:
-                    self._raiseError("Unsupported Artifact descriptor <%s>" % type(artifact_desc))
+                    self.notImplemented("Unsupported Artifact descriptor <%s>" % type(artifact_desc))
 
     def writeBswImplementationVendorSpecificModuleDefRefs(self, element: ET.Element, parent: BswImplementation):
         refs = parent.getVendorSpecificModuleDefRefs()
         if len(refs) > 0:
             child_element = ET.SubElement(element, "VENDOR-SPECIFIC-MODULE-DEF-REFS")
-            if child_element != None:
+            if child_element is not None:
                 for ref in refs:
                     self.setChildElementOptionalRefType(child_element, "VENDOR-SPECIFIC-MODULE-DEF-REF", ref)
 
@@ -1974,6 +2344,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeImplementation(child_element, impl)
         self.setChildElementOptionalLiteral(child_element, "AR-RELEASE-VERSION", impl.getArReleaseVersion())
         self.setChildElementOptionalRefType(child_element, "BEHAVIOR-REF", impl.getBehaviorRef())
+        self.setChildElementOptionalLiteral(child_element, "VENDOR-API-INFIX", impl.getVendorApiInfix())
         self.writeBswImplementationVendorSpecificModuleDefRefs(child_element, impl)
 
     def writeImplementationDataTypeElements(self, element: ET.Element, parent: ImplementationDataType):
@@ -2010,33 +2381,37 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeImplementationDataTypeSymbolProps(child_element, data_type)
         self.setChildElementOptionalLiteral(child_element, "TYPE-EMITTER", data_type.getTypeEmitter())
 
-    def writeArgumentDataPrototypes(self, element: ET.Element, parent: ClientServerOperation):
-        arguments = parent.getArgumentDataPrototypes()
+    def writeArgumentDataPrototype(self, element: ET.Element, prototype: ArgumentDataPrototype):
+        child_element = ET.SubElement(element, "ARGUMENT-DATA-PROTOTYPE")
+        self.writeAutosarDataPrototype(child_element, prototype)
+        self.setChildElementOptionalLiteral(child_element, "DIRECTION", prototype.getDirection())
+        self.setChildElementOptionalLiteral(child_element, "SERVER-ARGUMENT-IMPL-POLICY", prototype.getServerArgumentImplPolicy())
+
+    def writeClientServerOperationArguments(self, element: ET.Element, parent: ClientServerOperation):
+        arguments = parent.getArguments()
         if len(arguments) > 0:
-            arguments_tag = ET.SubElement(element, "ARGUMENTS")
-            for prototype in arguments:
-                child_element = ET.SubElement(arguments_tag, "ARGUMENT-DATA-PROTOTYPE")
-                self.writeIdentifiable(child_element, prototype)
-                self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", prototype.swDataDefProps)
-                self.setChildElementOptionalRefType(child_element, "TYPE-TREF", prototype.typeTRef)
-                self.setChildElementOptionalLiteral(child_element, "DIRECTION", prototype.direction)
-                self.setChildElementOptionalLiteral(child_element, "SERVER-ARGUMENT-IMPL-POLICY", prototype.serverArgumentImplPolicy)
-
-    def writePossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
-        error_refs = parent.getPossbileErrorRefs()
+            child_element = ET.SubElement(element, "ARGUMENTS")
+            for argument in arguments:
+                if isinstance(argument, ArgumentDataPrototype):
+                    self.writeArgumentDataPrototype(child_element, argument)
+                else:
+                    self.notImplemented("Unsupported Argument <%s>" % type(argument))
+
+    def writeClientServerOperationPossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
+        error_refs = parent.getPossibleErrorRefs()
         if len(error_refs) > 0:
-            error_refs_tag = ET.SubElement(element, "POSSIBLE-ERROR-REFS")
+            child_element = ET.SubElement(element, "POSSIBLE-ERROR-REFS")
             for error_ref in error_refs:
-                self.setChildElementOptionalRefType(error_refs_tag, "POSSIBLE-ERROR-REF", error_ref)
+                self.setChildElementOptionalRefType(child_element, "POSSIBLE-ERROR-REF", error_ref)
 
     def writeClientServerOperation(self, element: ET.Element, operation: ClientServerOperation):
         self.logger.debug("writeClientServerOperation %s" % operation.getShortName())
         child_element = ET.SubElement(element, "CLIENT-SERVER-OPERATION")
         self.writeIdentifiable(child_element, operation)
-        self.writeArgumentDataPrototypes(child_element, operation)
-        self.writePossibleErrorRefs(child_element, operation)
+        self.writeClientServerOperationArguments(child_element, operation)
+        self.writeClientServerOperationPossibleErrorRefs(child_element, operation)
 
-    def writeOperations(self, element: ET.Element, parent: ClientServerInterface):
+    def writeClientServerInterfaceOperations(self, element: ET.Element, parent: ClientServerInterface):
         operations = parent.getOperations()
         if len(operations) > 0:
             operations_tag = ET.SubElement(element, "OPERATIONS")
@@ -2044,7 +2419,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(operation, ClientServerOperation):
                     self.writeClientServerOperation(operations_tag, operation)
                 else:
-                    self._raiseError("Unsupported Operation <%s>" % type(operation))
+                    self.notImplemented("Unsupported Operation <%s>" % type(operation))
 
     def writeApplicationError(self, element: ET.Element, error: ApplicationError):
         self.logger.debug("writeApplicationError %s" % error.getShortName())
@@ -2060,24 +2435,27 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(error, ApplicationError):
                     self.writeApplicationError(errors_tag, error)
                 else:
-                    self._raiseError("Unsupported PossibleError %s" % type(error))
+                    self.notImplemented("Unsupported PossibleError %s" % type(error))
 
-    def setPortInterface(self, element: ET.Element, port_interface: PortInterface):
+    def writePortInterface(self, element: ET.Element, port_interface: PortInterface):
         self.writeIdentifiable(element, port_interface)
         self.setChildElementOptionalBooleanValue(element, "IS-SERVICE", port_interface.isService)
         self.setChildElementOptionalLiteral(element, "SERVICE-KIND", port_interface.serviceKind)
 
-    def writeParameterInterface(self, element: ET.Element, param_interface: ParameterInterface):
-        self.logger.debug("Write ParameterInterface %s" % param_interface.getShortName())
+    def writeDataInterface(self, element: ET.Element, interface: DataInterface):
+        self.writePortInterface(element, interface)
+
+    def writeParameterInterface(self, element: ET.Element, interface: ParameterInterface):
+        self.logger.debug("Write ParameterInterface %s" % interface.getShortName())
         child_element = ET.SubElement(element, "PARAMETER-INTERFACE")
-        self.setPortInterface(child_element, param_interface)
-        self.setParameterDataPrototypes(child_element, "PARAMETERS", param_interface.getParameters())
+        self.writeDataInterface(child_element, interface)
+        self.writeSwcInternalBehaviorParameterDataPrototypes(child_element, "PARAMETERS", interface.getParameters())
 
     def writeClientServerInterface(self, element: ET.Element, cs_interface: ClientServerInterface):
         self.logger.debug("writeClientServerInterface %s" % cs_interface.getShortName())
         child_element = ET.SubElement(element, "CLIENT-SERVER-INTERFACE")
-        self.setPortInterface(child_element, cs_interface)
-        self.writeOperations(child_element, cs_interface)
+        self.writePortInterface(child_element, cs_interface)
+        self.writeClientServerInterfaceOperations(child_element, cs_interface)
         self.writePossibleErrors(child_element, cs_interface)
 
     def writeApplicationSwComponentType(self, element: ET.Element, sw_component: ApplicationSwComponentType):
@@ -2090,17 +2468,19 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "ECU-ABSTRACTION-SW-COMPONENT-TYPE")
         self.writeAtomicSwComponentType(child_element, sw_component)
 
-    def setApplicationArrayElement(self, element: ET.Element, prototype: ApplicationArrayElement):
-        if prototype is not None:
+    def setApplicationArrayElement(self, element: ET.Element, array_element: ApplicationArrayElement):
+        if array_element is not None:
             child_element = ET.SubElement(element, "ELEMENT")
-            self.setApplicationCompositeElementDataPrototype(child_element, prototype)
-            self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS", prototype.arraySizeSemantics)
-            self.setChildElementOptionalNumericalValue(child_element, "MAX-NUMBER-OF-ELEMENTS", prototype.maxNumberOfElements)
+            self.writeApplicationCompositeElementDataPrototype(child_element, array_element)
+            self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE-HANDLING", array_element.getArraySizeHandling())
+            self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS", array_element.getArraySizeSemantics())
+            self.setChildElementOptionalNumericalValue(child_element, "MAX-NUMBER-OF-ELEMENTS", array_element.getMaxNumberOfElements())
 
     def writeApplicationArrayDataType(self, element: ET.Element, data_type: ApplicationArrayDataType):
         self.logger.debug("writeApplicationArrayDataType %s" % data_type.getShortName())
         child_element = ET.SubElement(element, "APPLICATION-ARRAY-DATA-TYPE")
         self.setApplicationCompositeDataType(child_element, data_type)
+        self.setChildElementOptionalLiteral(child_element, "DYNAMIC-ARRAY-SIZE-PROFILE", data_type.getDynamicArraySizeProfile())
         self.setApplicationArrayElement(child_element, data_type.element)
 
     def setSwRecordLayoutV(self, element: ET.Element, key: str, layout_v: SwRecordLayoutV):
@@ -2112,6 +2492,11 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-PROP", layout_v.getSwRecordLayoutVProp())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-INDEX", layout_v.getSwRecordLayoutVIndex())
 
+    def writeSwRecordLayoutGroupSwRecordLayoutGroupContentType(self, element: ET.Element, group: SwRecordLayoutGroup):
+        content = group.getSwRecordLayoutGroupContentType()
+        self.setSwRecordLayoutGroup(element, "SW-RECORD-LAYOUT-GROUP", content.getSwRecordLayoutGroup())
+        self.setSwRecordLayoutV(element, "SW-RECORD-LAYOUT-V", content.getSwRecordLayoutV())
+
     def setSwRecordLayoutGroup(self, element: ET.Element, key: str, group: SwRecordLayoutGroup):
         if group is not None:
             child_element = ET.SubElement(element, key)
@@ -2122,9 +2507,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-FROM", group.getSwRecordLayoutGroupFrom())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO", group.getSwRecordLayoutGroupTo())
             self.setChildElementOptionalIntegerValue(child_element, "SW-RECORD-LAYOUT-GROUP-STEP", group.getSwRecordLayoutGroupStep())
-            #self.setSwRecordLayoutV(child_element, "SW-RECORD-LAYOUT-V", group.swRecordLayoutGroupContentType.swRecordLayoutV)
-            #self.setSwRecordLayoutGroup(child_element, "SW-RECORD-LAYOUT-GROUP", group.swRecordLayoutGroupContentType.swRecordLayoutGroup)
-        return group
+            self.writeSwRecordLayoutGroupSwRecordLayoutGroupContentType(child_element, group)
 
     def writeSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
         self.logger.debug("writeSwRecordLayout %s" % layout.getShortName())
@@ -2147,7 +2530,8 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeTriggerInterface(self, element: ET.Element, trigger_if: TriggerInterface):
         self.logger.debug("writeTriggerInterface %s" % trigger_if.getShortName())
-        child_element = ET.SubElement(element, "TRIGGER-INTERFACE")
+        # child_element = ET.SubElement(element, "TRIGGER-INTERFACE")
+        # self.writePortInterface()
 
     def writeServiceSwComponentType(self, element: ET.Element, sw_component: ServiceSwComponentType):
         self.logger.debug("writeServiceSwComponentType %s" % sw_component.getShortName())
@@ -2160,7 +2544,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             maps_tag = ET.SubElement(element, "DATA-TYPE-MAPS")
             for map in maps:
                 child_element = ET.SubElement(maps_tag, "DATA-TYPE-MAP")
-                self.setARObjectAttributes(child_element, map)
+                self.writeARObjectAttributes(child_element, map)
                 self.setChildElementOptionalRefType(child_element, "APPLICATION-DATA-TYPE-REF", map.getApplicationDataTypeRef())
                 self.setChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF", map.getImplementationDataTypeRef())
 
@@ -2170,7 +2554,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             maps_tag = ET.SubElement(element, "MODE-REQUEST-TYPE-MAPS")
             for map in maps:
                 child_element = ET.SubElement(maps_tag, "MODE-REQUEST-TYPE-MAP")
-                self.setARObjectAttributes(child_element, map)
+                self.writeARObjectAttributes(child_element, map)
                 self.setChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF", map.getImplementationDataTypeRef())
                 self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", map.getModeGroupRef())
 
@@ -2212,7 +2596,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeModeSwitchInterface(self, element: ET.Element, mode_interface: ModeSwitchInterface):
         self.logger.debug("writeModeSwitchInterface %s" % mode_interface.getShortName())
         child_element = ET.SubElement(element, "MODE-SWITCH-INTERFACE")
-        self.setPortInterface(child_element, mode_interface)
+        self.writePortInterface(child_element, mode_interface)
         self.writeModeSwitchInterfaceModeGroup(child_element, mode_interface)
 
     def setEOCExecutableEntityRefSuccessorRefs(self, element: ET.Element, successor_refs: List[RefType]):
@@ -2234,7 +2618,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(order_element, EOCExecutableEntityRef):
                     self.writeEOCExecutableEntityRef(child_element, order_element)
                 else:
-                    self._raiseError("Unsupported order element <%s>" % type(order_element))
+                    self.notImplemented("Unsupported order element <%s>" % type(order_element))
 
     def writeExecutionOrderConstraint(self, element: ET.Element, constraint: ExecutionOrderConstraint):
         self.logger.debug("writeExecutionOrderConstraint %s" % constraint.getShortName())
@@ -2250,7 +2634,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(requirement, ExecutionOrderConstraint):
                     self.writeExecutionOrderConstraint(child_element, requirement)
                 else:
-                    self._raiseError("Unsupported timing requirement <%s>" % type(requirement))
+                    self.notImplemented("Unsupported timing requirement <%s>" % type(requirement))
 
     def writeTimingExtension(self, element: ET.Element, extension: TimingExtension):
         self.writeTimingRequirements(element, extension)
@@ -2274,7 +2658,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeFrame(self, element: ET.Element, frame: Frame):
         self.writeIdentifiable(element, frame)
-        self.setChildElementOptionalNumericalValue(element, "FRAME-LENGTH",  frame.frameLength)
+        self.setChildElementOptionalNumericalValue(element, "FRAME-LENGTH", frame.frameLength)
         self.writePduToFrameMappings(element, frame)
 
     def writeLinUnconditionalFrame(self, element: ET.Element, frame: LinUnconditionalFrame):
@@ -2283,8 +2667,10 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeFrame(child_element, frame)
 
     def writeNmNode(self, element: ET.Element, nm_node: NmNode):
+        self.writeIdentifiable(element, nm_node)
         self.setChildElementOptionalRefType(element, "CONTROLLER-REF", nm_node.getControllerRef())
         self.setChildElementOptionalRefType(element, "NM-IF-ECU-REF", nm_node.getNmIfEcuRef())
+        self.setChildElementOptionalBooleanValue(element, "NM-PASSIVE-MODE-ENABLED", nm_node.getNmPassiveModeEnabled())
         self.setChildElementOptionalNumericalValue(element, "NM-NODE-ID", nm_node.getNmNodeId())
 
         refs = nm_node.getRxNmPduRefs()
@@ -2302,9 +2688,8 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeCanNmNode(self, element: ET.Element, nm_node: CanNmNode):
         self.logger.debug("write CanNmNode %s" % nm_node.getShortName())
         child_element = ET.SubElement(element, "CAN-NM-NODE")
-        self.writeIdentifiable(child_element, nm_node)
         self.writeNmNode(child_element, nm_node)
-
+        self.setChildElementOptionalBooleanValue(child_element, "NM-CAR-WAKE-UP-RX-ENABLED", nm_node.getNmCarWakeUpRxEnabled())
         self.setChildElementOptionalFloatValue(child_element, "NM-MSG-CYCLE-OFFSET", nm_node.getNmMsgCycleOffset())
         self.setChildElementOptionalFloatValue(child_element, "NM-MSG-REDUCED-TIME", nm_node.getNmMsgReducedTime())
         self.setChildElementRxIdentifierRange(child_element, "NM-RANGE-CONFIG", nm_node.getNmRangeConfig())
@@ -2312,8 +2697,8 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeUdpNmNode(self, element: ET.Element, nm_node: UdpNmNode):
         self.logger.debug("write UdpNmNode %s" % nm_node.getShortName())
         child_element = ET.SubElement(element, "UDP-NM-NODE")
-        self.writeIdentifiable(child_element, nm_node)
         self.writeNmNode(child_element, nm_node)
+        self.setChildElementOptionalTimeValue(child_element, "NM-MSG-CYCLE-OFFSET", nm_node.getNmMsgCycleOffset())
 
     def writeNmClusterNmNodes(self, element: ET.Element, parent: NmCluster):
         nodes = parent.getNmNodes()
@@ -2334,18 +2719,23 @@ class ARXMLWriter(AbstractARXMLWriter):
             refs_tag = ET.SubElement(child_element, "COUPLED-CLUSTER-REFS")
             for ref in refs:
                 self.setChildElementOptionalRefType(refs_tag, "COUPLED-CLUSTER-REF", ref)
-
         self.setChildElementOptionalBooleanValue(child_element, "NM-BUSLOAD-REDUCTION-ENABLED", coupling.getNmBusloadReductionEnabled())
         self.setChildElementOptionalBooleanValue(child_element, "NM-IMMEDIATE-RESTART-ENABLED", coupling.getNmImmediateRestartEnabled())
 
     def writeUdpNmClusterCoupling(self, element: ET.Element, coupling: UdpNmClusterCoupling):
         child_element = ET.SubElement(element, "UDP-NM-CLUSTER-COUPLING")
+        refs = coupling.getCoupledClusterRefs()
+        if len(refs) > 0:
+            refs_tag = ET.SubElement(child_element, "COUPLED-CLUSTER-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(refs_tag, "COUPLED-CLUSTER-REF", ref)
+        self.setChildElementOptionalBooleanValue(child_element, "NM-IMMEDIATE-RESTART-ENABLED", coupling.getNmImmediateRestartEnabled())
 
     def writeNmConfigNmClusterCouplings(self, element: ET.Element, config: NmConfig):
-        self.logger.debug("writeNmConfigNmClusterCouplings %s" % config.getShortName())
+        self.logger.debug("Write NmConfigNmClusterCouplings <%s>" % config.getShortName())
         couplings = config.getNmClusterCouplings()
         if len(couplings) > 0:
-            child_element= ET.SubElement(element, "NM-CLUSTER-COUPLINGS")
+            child_element = ET.SubElement(element, "NM-CLUSTER-COUPLINGS")
             for coupling in couplings:
                 if isinstance(coupling, CanNmClusterCoupling):
                     self.writeCanNmClusterCoupling(child_element, coupling)
@@ -2355,6 +2745,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.notImplemented("Unsupported Nm Cluster Coupling <%s>" % type(coupling))
 
     def writeNmCluster(self, element: ET.Element, cluster: NmCluster):
+        self.logger.debug("Write NmCluster <%s>" % cluster.getShortName())
         self.writeIdentifiable(element, cluster)
         self.setChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF", cluster.communicationClusterRef)
         self.setChildElementOptionalNumericalValue(element, "NM-CHANNEL-ID", cluster.nmChannelId)
@@ -2363,7 +2754,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalBooleanValue(element, "NM-SYNCHRONIZING-NETWORK", cluster.getNmSynchronizingNetwork())
 
     def writeCanNmCluster(self, element: ET.Element, cluster: CanNmCluster):
-        self.logger.debug("WriteCanNmCluster %s" % cluster.getShortName())
+        self.logger.debug("Write CanNmCluster <%s>" % cluster.getShortName())
         child_element = ET.SubElement(element, "CAN-NM-CLUSTER")
         self.writeNmCluster(child_element, cluster)
 
@@ -2382,10 +2773,22 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalNumericalValue(child_element, "NM-USER-DATA-LENGTH", cluster.getNmUserDataLength())
         self.setChildElementOptionalFloatValue(child_element, "NM-WAIT-BUS-SLEEP-TIME", cluster.getNmWaitBusSleepTime())
 
-    def writeUdpNmCluster(self, element: ET.Element, cluster: CanNmCluster):
-        self.logger.debug("Write UdpNmCluster %s" % cluster.getShortName())
+    def writeUdpNmCluster(self, element: ET.Element, cluster: UdpNmCluster):
+        self.logger.debug("Write UdpNmCluster <%s>" % cluster.getShortName())
         child_element = ET.SubElement(element, "UDP-NM-CLUSTER")
         self.writeNmCluster(child_element, cluster)
+        self.setChildElementOptionalIntegerValue(child_element, "NM-CBV-POSITION", cluster.getNmCbvPosition())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-CHANNEL-ACTIVE", cluster.getNmChannelActive())
+        self.setChildElementOptionalTimeValue(child_element, "NM-IMMEDIATE-NM-CYCLE-TIME", cluster.getNmImmediateNmCycleTime())
+        self.setChildElementOptionalPositiveInteger(child_element, "NM-IMMEDIATE-NM-TRANSMISSIONS", cluster.getNmImmediateNmTransmissions())
+        self.setChildElementOptionalTimeValue(child_element, "NM-MESSAGE-TIMEOUT-TIME", cluster.getNmMessageTimeoutTime())
+        self.setChildElementOptionalTimeValue(child_element, "NM-MSG-CYCLE-TIME", cluster.getNmMsgCycleTime())
+        self.setChildElementOptionalTimeValue(child_element, "NM-NETWORK-TIMEOUT", cluster.getNmNetworkTimeout())
+        self.setChildElementOptionalIntegerValue(child_element, "NM-NID-POSITION", cluster.getNmNidPosition())
+        self.setChildElementOptionalTimeValue(child_element, "NM-REMOTE-SLEEP-INDICATION-TIME", cluster.getNmRemoteSleepIndicationTime())
+        self.setChildElementOptionalTimeValue(child_element, "NM-REPEAT-MESSAGE-TIME", cluster.getNmRepeatMessageTime())
+        self.setChildElementOptionalTimeValue(child_element, "NM-WAIT-BUS-SLEEP-TIME", cluster.getNmWaitBusSleepTime())
+        self.setChildElementOptionalRefType(child_element, "VLAN-REF", cluster.getVlanRef())
 
     def writeNmConfigNmClusters(self, element: ET.Element, parent: NmConfig):
         clusters = parent.getNmClusters()
@@ -2399,52 +2802,313 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Nm Cluster <%s>" % type(cluster))
 
+    def writeUdpNmEcu(self, element: ET.Element, ecu: UdpNmEcu):
+        if ecu is not None:
+            child_element = ET.SubElement(element, "UDP-NM-ECU")
+            self.setChildElementOptionalBooleanValue(child_element, "NM-SYNCHRONIZATION-POINT-ENABLED", ecu.getNmSynchronizationPointEnabled())
+
+    def writeBusDependentNmEcus(self, element: ET.Element, nm_ecu: NmEcu):
+        dependent_nm_ecus = nm_ecu.getBusDependentNmEcus()
+        if len(dependent_nm_ecus) > 0:
+            child_element = ET.SubElement(element, "BUS-DEPENDENT-NM-ECUS")
+            for dependent_nm_ecu in dependent_nm_ecus:
+                if isinstance(dependent_nm_ecu, UdpNmEcu):
+                    self.writeUdpNmEcu(child_element, dependent_nm_ecu)
+                else:
+                    self.notImplemented("Unsupported BusDependentNmEcu <%s>" % type(dependent_nm_ecu))
+
+    def writeNmEcu(self, element: ET.Element, nm_ecu: NmEcu):
+        child_element = ET.SubElement(element, "NM-ECU")
+        self.writeIdentifiable(child_element, nm_ecu)
+        self.writeBusDependentNmEcus(child_element, nm_ecu)
+        self.setChildElementOptionalRefType(child_element, "ECU-INSTANCE-REF", nm_ecu.getEcuInstanceRef())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-BUS-SYNCHRONIZATION-ENABLED", nm_ecu.getNmBusSynchronizationEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-COM-CONTROL-ENABLED", nm_ecu.getNmComControlEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-NODE-DETECTION-ENABLED", nm_ecu.getNmNodeDetectionEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-NODE-ID-ENABLED", nm_ecu.getNmNodeIdEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-PDU-RX-INDICATION-ENABLED", nm_ecu.getNmPduRxIndicationEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-REMOTE-SLEEP-IND-ENABLED", nm_ecu.getNmRemoteSleepIndEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-REPEAT-MSG-IND-ENABLED", nm_ecu.getNmRepeatMsgIndEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-STATE-CHANGE-IND-ENABLED", nm_ecu.getNmStateChangeIndEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-USER-DATA-ENABLED", nm_ecu.getNmUserDataEnabled())
+
+    def writeNmConfigNmIfEcus(self, element: ET.Element, nm_config: NmConfig):
+        ecus = nm_config.getNmIfEcus()
+        if len(ecus) > 0:
+            child_element = ET.SubElement(element, "NM-IF-ECUS")
+            for ecu in ecus:
+                if isinstance(ecu, NmEcu):
+                    self.writeNmEcu(child_element, ecu)
+                else:
+                    self.notImplemented("Unsupported NmIfEcus <%s>" % type(ecu))
+
     def writeNmConfig(self, element: ET.Element, config: NmConfig):
         self.logger.debug("Write NmConfig <%s>" % config.getShortName())
         child_element = ET.SubElement(element, "NM-CONFIG")
         self.writeIdentifiable(child_element, config)
         self.writeNmConfigNmClusters(child_element, config)
         self.writeNmConfigNmClusterCouplings(child_element, config)
+        self.writeNmConfigNmIfEcus(child_element, config)
+
+    def writeISignalToIPduMapping(self, element: ET.Element, mapping: ISignalToIPduMapping):
+        if mapping is not None:
+            child_element = ET.SubElement(element, "I-SIGNAL-TO-I-PDU-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.setChildElementOptionalRefType(child_element, "I-SIGNAL-REF", mapping.getISignalRef())
+            self.setChildElementOptionalLiteral(child_element, "PACKING-BYTE-ORDER", mapping.getPackingByteOrder())
+            self.setChildElementOptionalIntegerValue(child_element, "START-POSITION", mapping.getStartPosition())
+            self.setChildElementOptionalLiteral(child_element, "TRANSFER-PROPERTY", mapping.getTransferProperty())
+        
+    def writeNmPduISignalToIPduMappings(self, element: ET.Element, pdu: NmPdu):
+        mappings = pdu.getISignalToIPduMappings()
+        if len(mappings) > 0:
+            child_element = ET.SubElement(element, "I-SIGNAL-TO-I-PDU-MAPPINGS")
+            for mapping in mappings:
+                if isinstance(mapping, ISignalToIPduMapping):
+                    self.writeISignalToIPduMapping(child_element, mapping)
+                else:
+                    self.notImplemented("Unsupported ISignalToIPduMapping <%s>" % type(mapping))
 
     def writeNmPdu(self, element: ET.Element, pdu: NmPdu):
         self.logger.debug("Write NmPdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "NM-PDU")
-        self.writeIdentifiable(child_element, pdu)
-        self.writeIPdu(child_element, pdu)
+        self.writePdu(child_element, pdu)
+        self.writeNmPduISignalToIPduMappings(child_element, pdu)
+        self.setChildElementOptionalIntegerValue(child_element, "UNUSED-BIT-PATTERN", pdu.getUnusedBitPattern())
 
     def writeNPdu(self, element: ET.Element, pdu: NPdu):
         self.logger.debug("Write NPdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "N-PDU")
-        self.writeIdentifiable(child_element, pdu)
-        self.writeIPdu(child_element, pdu)
-
-    def writeIPdu(self, element: ET.Element, pdu: IPdu):
-        self.setChildElementOptionalLiteral(element, "LENGTH", pdu.getLength())
+        self.writePdu(child_element, pdu)
 
     def writeDcmIPdu(self, element: ET.Element, pdu: DcmIPdu):
         self.logger.debug("Write DcmIPdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "DCM-I-PDU")
-        self.writeIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
         self.setChildElementOptionalLiteral(child_element, "DIAG-PDU-TYPE", pdu.getDiagPduType())
 
-    def writeSecuredIPdu(self, element: ET.Element, pdu: DcmIPdu):
-        self.logger.debug("Write SecuredIPdu <%s>" % pdu.getShortName())
+    def setSecureCommunicationProps(self, element: ET.Element, key: str, props: SecureCommunicationProps):
+        if props is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTH-DATA-FRESHNESS-LENGTH", props.getAuthDataFreshnessLength())
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTH-DATA-FRESHNESS-START-POSITION", props.getAuthDataFreshnessStartPosition())     # noqa E501
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTH-INFO-TX-LENGTH", props.getAuthInfoTxLength())
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTHENTICATION-BUILD-ATTEMPTS", props.getAuthenticationBuildAttempts())
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTHENTICATION-RETRIES", props.getAuthenticationRetries())
+            self.setChildElementOptionalPositiveInteger(child_element, "DATA-ID", props.getDataId())
+            self.setChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-ID", props.getFreshnessValueId())
+            self.setChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-LENGTH", props.getFreshnessValueLength())
+            self.setChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-TX-LENGTH", props.getFreshnessValueTxLength())
+
+    def writeSecuredIPdu(self, element: ET.Element, i_pdu: SecuredIPdu):
+        self.logger.debug("Write SecuredIPdu <%s>" % i_pdu.getShortName())
         child_element = ET.SubElement(element, "SECURED-I-PDU")
-        self.writeIdentifiable(child_element, pdu)
-        self.writeIPdu(child_element, pdu)
+        self.writeIPdu(child_element, i_pdu)
+        self.setChildElementOptionalRefType(child_element, "AUTHENTICATION-PROPS-REF", i_pdu.getAuthenticationPropsRef())
+        self.setChildElementOptionalRefType(child_element, "FRESHNESS-PROPS-REF", i_pdu.getFreshnessPropsRef())
+        self.setChildElementOptionalRefType(child_element, "PAYLOAD-REF", i_pdu.getPayloadRef())
+        self.setSecureCommunicationProps(child_element, "SECURE-COMMUNICATION-PROPS", i_pdu.getSecureCommunicationProps())
+        self.setChildElementOptionalBooleanValue(child_element, "USE-AS-CRYPTOGRAPHIC-I-PDU", i_pdu.getUseAsCryptographicIPdu())
+
+    def writeTpConfig(self, element: ET.Element, config: TpConfig):
+        self.writeIdentifiable(element, config)
+        self.setChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF", config.getCommunicationClusterRef())
+
+    def writeCanTpAddress(self, element: ET.Element, address: CanTpAddress):
+        if address is not None:
+            child_element = ET.SubElement(element, "CAN-TP-ADDRESS")
+            self.writeIdentifiable(child_element, address)
+            self.setChildElementOptionalIntegerValue(child_element, "TP-ADDRESS", address.getTpAddress())
+            self.setChildElementOptionalIntegerValue(child_element, "TP-ADDRESS-EXTENSION-VALUE", address.getTpAddressExtensionValue())
+
+    def writeCanTpConfigTpAddresses(self, element: ET.Element, config: CanTpConfig):
+        addresses = config.getTpAddresses()
+        if len(addresses) > 0:
+            child_element = ET.SubElement(element, "TP-ADDRESSS")
+            for address in addresses:
+                if isinstance(address, CanTpAddress):
+                    self.writeCanTpAddress(child_element, address)
+                else:
+                    self.notImplemented("Unsupported TpAddress <%s>" % type(address))
+
+    def writeCanTpChannel(self, element: ET.Element, channel: CanTpChannel):
+        if channel is not None:
+            child_element = ET.SubElement(element, "CAN-TP-CHANNEL")
+            self.writeIdentifiable(child_element, channel)
+            self.setChildElementOptionalPositiveInteger(child_element, "CHANNEL-ID", channel.getChannelId())
+            self.setChildElementOptionalLiteral(child_element, "CHANNEL-MODE", channel.getChannelMode())
+
+    def writeCanTpConfigTpChannels(self, element: ET.Element, config: CanTpConfig):
+        channels = config.getTpChannels()
+        if len(channels) > 0:
+            child_element = ET.SubElement(element, "TP-CHANNELS")
+            for channel in channels:
+                if isinstance(channel, CanTpChannel):
+                    self.writeCanTpChannel(child_element, channel)
+                else:
+                    self.notImplemented("Unsupported TpChannel <%s>" % type(channel))
+
+    def writeTpConnection(self, element: ET.Element, connection: TpConnection):
+        self.writeARObjectAttributes(element, connection)
+        ident = connection.getIdent()
+        if ident is not None:
+            child_element = ET.SubElement(element, "IDENT")
+            self.writeReferrable(child_element, ident)
+
+    def writeTpConnectionReceiverRefs(self, element: ET.Element, connection: CanTpConnection):
+        refs = connection.getReceiverRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "RECEIVER-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "RECEIVER-REF", ref)
+
+    def writeCanTpConnection(self, element: ET.Element, connection: CanTpConnection):
+        if connection is not None:
+            child_element = ET.SubElement(element, "CAN-TP-CONNECTION")
+            self.writeTpConnection(child_element, connection)
+            self.setChildElementOptionalLiteral(child_element, "ADDRESSING-FORMAT", connection.getAddressingFormat())
+            self.setChildElementOptionalRefType(child_element, "CAN-TP-CHANNEL-REF", connection.getCanTpChannelRef())
+            self.setChildElementOptionalBooleanValue(child_element, "CANCELLATION", connection.getCancellation())
+            self.setChildElementOptionalRefType(child_element, "DATA-PDU-REF", connection.getDataPduRef())
+            self.setChildElementOptionalRefType(child_element, "FLOW-CONTROL-PDU-REF", connection.getFlowControlPduRef())
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-BLOCK-SIZE", connection.getMaxBlockSize())
+            self.setChildElementOptionalRefType(child_element, "MULTICAST-REF", connection.getMulticastRef())
+            self.setChildElementOptionalBooleanValue(child_element, "PADDING-ACTIVATION", connection.getPaddingActivation())
+            self.writeTpConnectionReceiverRefs(child_element, connection)
+            self.setChildElementOptionalLiteral(child_element, "TA-TYPE", connection.getTaType())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-BR", connection.getTimeoutBr())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-BS", connection.getTimeoutBs())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-CR", connection.getTimeoutCr())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-CS", connection.getTimeoutCs())
+            self.setChildElementOptionalRefType(child_element, "TP-SDU-REF", connection.getTpSduRef())
+            self.setChildElementOptionalRefType(child_element, "TRANSMITTER-REF", connection.getTransmitterRef())
+
+    def writeCanTpConfigTpConnections(self, element: ET.Element, config: CanTpConfig):
+        connections = config.getTpConnections()
+        if len(connections) > 0:
+            child_element = ET.SubElement(element, "TP-CONNECTIONS")
+            for connection in connections:
+                if isinstance(connection, CanTpConnection):
+                    self.writeCanTpConnection(child_element, connection)
+                else:
+                    self.notImplemented("Unsupported TpConnection <%s>" % type(connection))
+
+    def writeCanTpEcu(self, element: ET.Element, tp_ecu: CanTpEcu):
+        if tp_ecu is not None:
+            child_element = ET.SubElement(element, "CAN-TP-ECU")
+            self.setChildElementOptionalTimeValue(child_element, "CYCLE-TIME-MAIN-FUNCTION", tp_ecu.getCycleTimeMainFunction())
+            self.setChildElementOptionalRefType(child_element, "ECU-INSTANCE-REF", tp_ecu.getEcuInstanceRef())
+
+    def writeCanTpConfigTpEcus(self, element: ET.Element, config: CanTpConfig):
+        tp_ecus = config.getTpEcus()
+        if len(tp_ecus) > 0:
+            child_element = ET.SubElement(element, "TP-ECUS")
+            for tp_ecu in tp_ecus:
+                if isinstance(tp_ecu, CanTpEcu):
+                    self.writeCanTpEcu(child_element, tp_ecu)
+                else:
+                    self.notImplemented("Unsupported TpEcu <%s>" % type(tp_ecu))
+
+    def writeCanTpNode(self, element: ET.Element, tp_node: CanTpNode):
+        if tp_node is not None:
+            child_element = ET.SubElement(element, "CAN-TP-NODE")
+            self.writeIdentifiable(child_element, tp_node)
+            self.setChildElementOptionalRefType(child_element, "CONNECTOR-REF", tp_node.getConnectorRef())
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-FC-WAIT", tp_node.getMaxFcWait())
+            self.setChildElementOptionalTimeValue(child_element, "ST-MIN", tp_node.getStMin())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-AR", tp_node.getTimeoutAr())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-AS", tp_node.getTimeoutAs())
+            self.setChildElementOptionalRefType(child_element, "TP-ADDRESS-REF", tp_node.getTpAddressRef())
+
+    def writeCanTpConfigTpNodes(self, element: ET.Element, config: CanTpConfig):
+        tp_nodes = config.getTpNodes()
+        if len(tp_nodes) > 0:
+            child_element = ET.SubElement(element, "TP-NODES")
+            for tp_node in tp_nodes:
+                if isinstance(tp_node, CanTpNode):
+                    self.writeCanTpNode(child_element, tp_node)
+                else:
+                    self.notImplemented("Unsupported TpNode <%s>" % type(tp_node))
 
     def writeCanTpConfig(self, element: ET.Element, config: CanTpConfig):
         self.logger.debug("Write CanTpConfig <%s>" % config.getShortName())
         child_element = ET.SubElement(element, "CAN-TP-CONFIG")
-        self.writeIdentifiable(child_element, config)
+        self.writeTpConfig(child_element, config)
+        self.writeCanTpConfigTpAddresses(child_element, config)
+        self.writeCanTpConfigTpChannels(child_element, config)
+        self.writeCanTpConfigTpConnections(child_element, config)
+        self.writeCanTpConfigTpEcus(child_element, config)
+        self.writeCanTpConfigTpNodes(child_element, config)
+
+    def writeTpAddress(self, element: ET.Element, address: TpAddress):
+        if address is not None:
+            child_element = ET.SubElement(element, "TP-ADDRESS")
+            self.writeIdentifiable(child_element, address)
+            self.setChildElementOptionalIntegerValue(child_element, "TP-ADDRESS", address.getTpAddress())
+
+    def writeLinTpConfigTpAddresses(self, element: ET.Element, config: CanTpConfig):
+        addresses = config.getTpAddresses()
+        if len(addresses) > 0:
+            child_element = ET.SubElement(element, "TP-ADDRESSS")
+            for address in addresses:
+                if isinstance(address, TpAddress):
+                    self.writeTpAddress(child_element, address)
+                else:
+                    self.notImplemented("Unsupported TpAddress <%s>" % type(address))
+
+    def writeLinTpConnection(self, element: ET.Element, connection: LinTpConnection):
+        if connection is not None:
+            child_element = ET.SubElement(element, "LIN-TP-CONNECTION")
+            self.writeTpConnection(child_element, connection)
+            self.setChildElementOptionalRefType(child_element, "DATA-PDU-REF", connection.getDataPduRef())
+            self.setChildElementOptionalRefType(child_element, "FLOW-CONTROL-REF", connection.getFlowControlRef())
+            self.setChildElementOptionalRefType(child_element, "LIN-TP-N-SDU-REF", connection.getLinTpNSduRef())
+            self.writeTpConnectionReceiverRefs(child_element, connection)
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-AS", connection.getTimeoutAs())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-CR", connection.getTimeoutCr())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-CS", connection.getTimeoutCs())
+            self.setChildElementOptionalRefType(child_element, "TRANSMITTER-REF", connection.getTransmitterRef())
+
+    def writeLinTpConfigTpConnections(self, element: ET.Element, config: LinTpConfig):
+        connections = config.getTpConnections()
+        if len(connections) > 0:
+            child_element = ET.SubElement(element, "TP-CONNECTIONS")
+            for connection in connections:
+                if isinstance(connection, LinTpConnection):
+                    self.writeLinTpConnection(child_element, connection)
+                else:
+                    self.notImplemented("Unsupported TpConnection <%s>" % type(connection))
+
+    def writeLinTpNode(self, element: ET.Element, tp_node: LinTpNode):
+        if tp_node is not None:
+            child_element = ET.SubElement(element, "LIN-TP-NODE")
+            self.writeIdentifiable(child_element, tp_node)
+            self.setChildElementOptionalRefType(child_element, "CONNECTOR-REF", tp_node.getConnectorRef())
+            self.setChildElementOptionalBooleanValue(element, "DROP-NOT-REQUESTED-NAD", tp_node.getDropNotRequestedNad())
+            self.setChildElementOptionalTimeValue(child_element, "P-2-MAX", tp_node.getP2Max())
+            self.setChildElementOptionalTimeValue(child_element, "P-2-TIMING", tp_node.getP2Timing())
+            self.setChildElementOptionalRefType(child_element, "TP-ADDRESS-REF", tp_node.getTpAddressRef())
+
+    def writeLinTpConfigTpNodes(self, element: ET.Element, config: LinTpConfig):
+        tp_nodes = config.getTpNodes()
+        if len(tp_nodes) > 0:
+            child_element = ET.SubElement(element, "TP-NODES")
+            for tp_node in tp_nodes:
+                if isinstance(tp_node, LinTpNode):
+                    self.writeLinTpNode(child_element, tp_node)
+                else:
+                    self.notImplemented("Unsupported TpNode <%s>" % type(tp_node))
 
     def writeLinTpConfig(self, element: ET.Element, config: LinTpConfig):
         self.logger.debug("Write LinTpConfig <%s>" % config.getShortName())
         child_element = ET.SubElement(element, "LIN-TP-CONFIG")
-        self.writeIdentifiable(child_element, config)
+        self.writeTpConfig(child_element, config)
+        self.writeLinTpConfigTpAddresses(child_element, config)
+        self.writeLinTpConfigTpConnections(child_element, config)
+        self.writeLinTpConfigTpNodes(child_element, config)
 
     def writeFrameTriggering(self, element: ET.Element, triggering: FrameTriggering):
+        self.writeIdentifiable(element, triggering)
         ref_list = triggering.getFramePortRefs()
         if len(ref_list) > 0:
             frame_port_refs_tag = ET.SubElement(element, "FRAME-PORT-REFS")
@@ -2456,13 +3120,12 @@ class ARXMLWriter(AbstractARXMLWriter):
         if len(refs) > 0:
             triggerings_tag = ET.SubElement(element, "PDU-TRIGGERINGS")
             for ref in refs:
-                 child_element = ET.SubElement(triggerings_tag, 'PDU-TRIGGERING-REF-CONDITIONAL')
-                 self.setChildElementOptionalRefType(child_element, "PDU-TRIGGERING-REF", ref)
+                child_element = ET.SubElement(triggerings_tag, 'PDU-TRIGGERING-REF-CONDITIONAL')
+                self.setChildElementOptionalRefType(child_element, "PDU-TRIGGERING-REF", ref)
 
     def writeCanFrameTriggering(self, element: ET.Element, triggering: CanFrameTriggering):
         self.logger.debug("WRite CanFrameTriggering %s" % triggering.getShortName())
         child_element = ET.SubElement(element, "CAN-FRAME-TRIGGERING")
-        self.writeIdentifiable(child_element, triggering)
         self.writeFrameTriggering(child_element, triggering)
         self.setChildElementOptionalLiteral(child_element, "CAN-ADDRESSING-MODE", triggering.getCanAddressingMode())
         self.setChildElementOptionalBooleanValue(child_element, "CAN-FD-FRAME-SUPPORT", triggering.getCanFdFrameSupport())
@@ -2474,11 +3137,55 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeLinFrameTriggering(self, element: ET.Element, triggering: LinFrameTriggering):
         self.logger.debug("Write LinFrameTriggering %s" % triggering.getShortName())
         child_element = ET.SubElement(element, "LIN-FRAME-TRIGGERING")
-        self.writeIdentifiable(child_element, triggering)
         self.writeFrameTriggering(child_element, triggering)
         self.setChildElementOptionalNumericalValue(child_element, "IDENTIFIER", triggering.getIdentifier())
         self.setChildElementOptionalLiteral(child_element, "LIN-CHECKSUM", triggering.getLinChecksum())
 
+    def writeCommunicationCycle(self, element: ET.Element, cycle: CommunicationCycle):
+        self.writeARObjectAttributes(element, cycle)
+
+    def writeCycleRepetition(self, element: ET.Element, cycle: CycleRepetition):
+        if cycle is not None:
+            child_element = ET.SubElement(element, "CYCLE-REPETITION")
+            self.writeCommunicationCycle(child_element, cycle)
+            self.setChildElementOptionalIntegerValue(child_element, "BASE-CYCLE", cycle.getBaseCycle())
+            self.setChildElementOptionalLiteral(child_element, "CYCLE-REPETITION", cycle.getCycleRepetition())
+        
+    def writeFlexrayAbsolutelyScheduledTimingCommunicationCycle(self, element: ET.Element, timing: FlexrayAbsolutelyScheduledTiming):
+        cycle = timing.getCommunicationCycle()
+        if cycle is not None:
+            child_element = ET.SubElement(element, "COMMUNICATION-CYCLE")
+            if isinstance(cycle, CycleRepetition):
+                self.writeCycleRepetition(child_element, cycle)
+            else:
+                self.notImplemented("Unsupported CommunicationCycle <%s>" % type(child_element))
+
+    def writeFlexrayAbsolutelyScheduledTiming(self, element: ET.Element, timing: FlexrayAbsolutelyScheduledTiming):
+        if timing is not None:
+            child_element = ET.SubElement(element, "FLEXRAY-ABSOLUTELY-SCHEDULED-TIMING")
+            self.writeARObjectAttributes(child_element, timing)
+            self.writeFlexrayAbsolutelyScheduledTimingCommunicationCycle(child_element, timing)
+            self.setChildElementOptionalPositiveInteger(child_element, "SLOT-ID", timing.getSlotID())
+
+    def writeFlexrayFrameTriggeringAbsolutelyScheduledTimings(self, element: ET.Element, triggering: FlexrayFrameTriggering):
+        timings = triggering.getAbsolutelyScheduledTimings()
+        if len(timings) > 0:
+            child_element = ET.SubElement(element, "ABSOLUTELY-SCHEDULED-TIMINGS")
+            for timing in timings:
+                if isinstance(timing, FlexrayAbsolutelyScheduledTiming):
+                    self.writeFlexrayAbsolutelyScheduledTiming(child_element, timing)
+                else:
+                    self.notImplemented("Unsupported AbsolutelyScheduledTiming <%s>" % type(timing))
+
+    def writeFlexrayFrameTriggering(self, element: ET.Element, triggering: FlexrayFrameTriggering):
+        self.logger.debug("Write FlexrayFrameTriggering %s" % triggering.getShortName())
+        child_element = ET.SubElement(element, "FLEXRAY-FRAME-TRIGGERING")
+        self.writeFrameTriggering(child_element, triggering)
+        self.writeFlexrayFrameTriggeringAbsolutelyScheduledTimings(child_element, triggering)
+        self.setChildElementOptionalBooleanValue(child_element, "ALLOW-DYNAMIC-L-SDU-LENGTH", triggering.getAllowDynamicLSduLength())
+        self.setChildElementOptionalPositiveInteger(child_element, "MESSAGE-ID", triggering.getMessageId())
+        self.setChildElementOptionalBooleanValue(child_element, "PAYLOAD-PREAMBLE-INDICATOR", triggering.getPayloadPreambleIndicator())
+
     def writeISignalTriggering(self, element: ET.Element, triggering: ISignalTriggering):
         self.logger.debug("Write ISignalTriggering %s" % triggering.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-TRIGGERING")
@@ -2506,17 +3213,18 @@ class ARXMLWriter(AbstractARXMLWriter):
         if len(refs) > 0:
             triggerings_tag = ET.SubElement(child_element, "I-SIGNAL-TRIGGERINGS")
             for ref in refs:
-                 child_element = ET.SubElement(triggerings_tag, 'I-SIGNAL-TRIGGERING-REF-CONDITIONAL')
-                 self.setChildElementOptionalRefType(child_element, "I-SIGNAL-TRIGGERING-REF", ref)
+                child_element = ET.SubElement(triggerings_tag, 'I-SIGNAL-TRIGGERING-REF-CONDITIONAL')
+                self.setChildElementOptionalRefType(child_element, "I-SIGNAL-TRIGGERING-REF", ref)
 
-    def writePhysicalChannel(self, element: ET.Element, channel: PhysicalChannel):
+    def writePhysicalChannelCommConnectorRefs(self, element, channel):
         connectors = channel.getCommConnectorRefs()
         if len(connectors) > 0:
             connectors_tag = ET.SubElement(element, "COMM-CONNECTORS")
             for connector in connectors:
-                 child_element = ET.SubElement(connectors_tag, 'COMMUNICATION-CONNECTOR-REF-CONDITIONAL')
-                 self.setChildElementOptionalRefType(child_element, "COMMUNICATION-CONNECTOR-REF", connector)
+                child_element = ET.SubElement(connectors_tag, 'COMMUNICATION-CONNECTOR-REF-CONDITIONAL')
+                self.setChildElementOptionalRefType(child_element, "COMMUNICATION-CONNECTOR-REF", connector)
 
+    def writePhysicalChannelFrameTriggerings(self, element, channel):
         triggerings = channel.getFrameTriggerings()
         if len(triggerings) > 0:
             triggerings_tag = ET.SubElement(element, "FRAME-TRIGGERINGS")
@@ -2525,9 +3233,12 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.writeCanFrameTriggering(triggerings_tag, triggering)
                 elif isinstance(triggering, LinFrameTriggering):
                     self.writeLinFrameTriggering(triggerings_tag, triggering)
+                elif isinstance(triggering, FlexrayFrameTriggering):
+                    self.writeFlexrayFrameTriggering(triggerings_tag, triggering)
                 else:
                     self.notImplemented("Unsupported Frame Triggering <%s>" % type(triggering))
-                
+
+    def writePhysicalChannelISignalTriggerings(self, element, channel):
         triggerings = channel.getISignalTriggerings()
         if len(triggerings) > 0:
             triggerings_tag = ET.SubElement(element, "I-SIGNAL-TRIGGERINGS")
@@ -2536,7 +3247,8 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.writeISignalTriggering(triggerings_tag, triggering)
                 else:
                     self.notImplemented("Unsupported ISignalTriggering <%s>" % type(triggering))
-                
+
+    def writePhysicalChannelPduTriggerings(self, element, channel):
         triggerings = channel.getPduTriggerings()
         if len(triggerings) > 0:
             triggerings_tag = ET.SubElement(element, "PDU-TRIGGERINGS")
@@ -2546,10 +3258,17 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported PduTriggering <%s>" % type(triggering))
 
+    def writePhysicalChannel(self, element: ET.Element, channel: PhysicalChannel):
+        self.writeIdentifiable(element, channel)
+
+        self.writePhysicalChannelCommConnectorRefs(element, channel)
+        self.writePhysicalChannelFrameTriggerings(element, channel)
+        self.writePhysicalChannelISignalTriggerings(element, channel)
+        self.writePhysicalChannelPduTriggerings(element, channel)
+
     def writeCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
         self.logger.debug("Set CanPhysicalChannel %s" % channel.getShortName())
         child_element = ET.SubElement(element, "CAN-PHYSICAL-CHANNEL")
-        self.writeIdentifiable(child_element, channel)
         self.writePhysicalChannel(child_element, channel)
 
     def writeScheduleTableEntry(self, element: ET.Element, entry: ScheduleTableEntry):
@@ -2592,7 +3311,6 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeLinPhysicalChannel(self, element: ET.Element, channel: LinPhysicalChannel):
         self.logger.debug("Set LinPhysicalChannel %s" % channel.getShortName())
         child_element = ET.SubElement(element, "LIN-PHYSICAL-CHANNEL")
-        self.writeIdentifiable(child_element, channel)
         self.writePhysicalChannel(child_element, channel)
         self.writeLinPhysicalChannelScheduleTables(child_element, channel)
 
@@ -2640,7 +3358,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             for end_point in end_points:
                 self.writeNetworkEndPoint(child_element, end_point)
 
-    def setSocketConnectionIpduIdentifier(self, element: ET.Element,identifier: SocketConnectionIpduIdentifier):
+    def setSocketConnectionIpduIdentifier(self, element: ET.Element, identifier: SocketConnectionIpduIdentifier):
         if identifier is not None:
             child_element = ET.SubElement(element, "SOCKET-CONNECTION-IPDU-IDENTIFIER")
             self.setChildElementOptionalPositiveInteger(child_element, "HEADER-ID", identifier.getHeaderId())
@@ -2661,8 +3379,8 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setSocketConnection(self, element: ET.Element, connection: SocketConnection):
         if connection is not None:
             child_element = ET.SubElement(element, "SOCKET-CONNECTION")
-            self.setChildElementOptionalBooleanValue(child_element, "CLIENT-IP-ADDR-FROM-CONNECTION-REQUEST", connection.getClientIpAddrFromConnectionRequest())
-            self.setChildElementOptionalBooleanValue(child_element, "CLIENT-PORT-FROM-CONNECTION-REQUEST", connection.getClientPortFromConnectionRequest())
+            self.setChildElementOptionalBooleanValue(child_element, "CLIENT-IP-ADDR-FROM-CONNECTION-REQUEST", connection.getClientIpAddrFromConnectionRequest())    # noqa E501
+            self.setChildElementOptionalBooleanValue(child_element, "CLIENT-PORT-FROM-CONNECTION-REQUEST", connection.getClientPortFromConnectionRequest())         # noqa E501
             self.setChildElementOptionalRefType(child_element, "CLIENT-PORT-REF", connection.getClientPortRef())
             self.setSocketConnectionPdus(child_element, "PDUS", connection.getPdus())
             self.setChildElementOptionalPositiveInteger(child_element, "PDU-COLLECTION-MAX-BUFFER-SIZE", connection.getPduCollectionMaxBufferSize())
@@ -2749,14 +3467,6 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalTimeValue(child_element, "MAX-VALUE", delay.getMaxValue())
             self.setChildElementOptionalTimeValue(child_element, "MIN-VALUE", delay.getMinValue())
 
-    def setInitialSdDelayConfig(self, element: ET.Element, key: str, config: InitialSdDelayConfig):
-        if config is not None:
-            child_element = ET.SubElement(element, key)
-            self.setChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MAX-VALUE", config.getInitialDelayMaxValue())
-            self.setChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MIN-VALUE", config.getInitialDelayMinValue())
-            self.setChildElementOptionalTimeValue(child_element, "INITIAL-REPETITIONS-BASE-DELAY", config.getInitialRepetitionsBaseDelay())
-            self.setChildElementOptionalPositiveInteger(child_element, "INITIAL-REPETITIONS-MAX", config.getInitialRepetitionsMax())
-
     def setSdClientConfig(self, element: ET.Element, key: str, config: SdClientConfig):
         if config is not None:
             child_element = ET.SubElement(element, key)
@@ -2784,7 +3494,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(group, ConsumedEventGroup):
                     self.writeConsumedEventGroup(child_element, group)
                 else:
-                    self.notImplemented("Unsupported ConsumedEventGroups <%s>" % type(group)) 
+                    self.notImplemented("Unsupported ConsumedEventGroups <%s>" % type(group))
     
     def writeConsumedServiceInstance(self, element: ET.Element, instance: ConsumedServiceInstance):
         if instance is not None:
@@ -2801,7 +3511,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             for instance in instances:
                 if isinstance(instance, ConsumedServiceInstance):
                     self.writeConsumedServiceInstance(child_element, instance)
-                else:   
+                else:
                     self.notImplemented("Unsupported ConsumedServiceInstances <%s>" % type(instance))
 
     def setInitialSdDelayConfig(self, element: ET.Element, key: str, config: InitialSdDelayConfig):
@@ -2895,7 +3605,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeIdentifiable(child_element, address)
         self.writeSocketAddressApplicationEndpoint(child_element, address)
         self.writeSocketAddressMulticastConnectorRefs(child_element, address)
-        self.setChildElementOptionalRefType(child_element, "CONNECTOR-REF", address.getConnectorRef()) 
+        self.setChildElementOptionalRefType(child_element, "CONNECTOR-REF", address.getConnectorRef())
         self.setChildElementOptionalPositiveInteger(child_element, "PORT-ADDRESS", address.getPortAddress())
 
     def writeSoAdConfigSocketAddresses(self, element: ET.Element, config: SoAdConfig):
@@ -2924,12 +3634,17 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeEthernetPhysicalChannel(self, element: ET.Element, channel: EthernetPhysicalChannel):
         self.logger.debug("Set EthernetPhysicalChannel %s" % channel.getShortName())
         child_element = ET.SubElement(element, "ETHERNET-PHYSICAL-CHANNEL")
-        self.writeIdentifiable(child_element, channel)
         self.writePhysicalChannel(child_element, channel)
         self.writeEthernetPhysicalChannelNetworkEndPoints(child_element, channel.getNetworkEndpoints())
         self.writeSoAdConfig(child_element, "SO-AD-CONFIG", channel.getSoAdConfig())
         self.writeEthernetPhysicalChannelVlan(child_element, channel)
 
+    def writeFlexrayPhysicalChannel(self, element: ET.Element, channel: FlexrayPhysicalChannel):
+        self.logger.debug("Set FlexrayPhysicalChannel %s" % channel.getShortName())
+        child_element = ET.SubElement(element, "FLEXRAY-PHYSICAL-CHANNEL")
+        self.writePhysicalChannel(child_element, channel)
+        self.setChildElementOptionalLiteral(child_element, "CHANNEL-NAME", channel.getChannelName())
+
     def writeCommunicationClusterPhysicalChannels(self, element: ET.Element, cluster: CommunicationCluster):
         channels = cluster.getPhysicalChannels()
         if len(channels) > 0:
@@ -2941,6 +3656,8 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.writeLinPhysicalChannel(child_element, channel)
                 elif isinstance(channel, EthernetPhysicalChannel):
                     self.writeEthernetPhysicalChannel(child_element, channel)
+                elif isinstance(channel, FlexrayPhysicalChannel):
+                    self.writeFlexrayPhysicalChannel(child_element, channel)
                 else:
                     self.notImplemented("Unsupported Physical Channel <%s>" % type(channel))
 
@@ -2963,22 +3680,68 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalNumericalValue(element, "SPEED", cluster.getSpeed())
 
     def writeLinCluster(self, element: ET.Element, cluster: LinCluster):
-        self.logger.debug("LinCluster %s" % cluster.getShortName())
-        child_element = ET.SubElement(element, "LIN-CLUSTER")
-        self.writeIdentifiable(child_element, cluster)
-        child_element = ET.SubElement(child_element, "LIN-CLUSTER-VARIANTS")
-        child_element = ET.SubElement(child_element, "LIN-CLUSTER-CONDITIONAL")
-        self.writeCommunicationCluster(child_element, cluster)
+        if cluster is not None:
+            self.logger.debug("LinCluster %s" % cluster.getShortName())
+            child_element = ET.SubElement(element, "LIN-CLUSTER")
+            self.writeIdentifiable(child_element, cluster)
+            
+            child_element = ET.SubElement(child_element, "LIN-CLUSTER-VARIANTS")
+            child_element = ET.SubElement(child_element, "LIN-CLUSTER-CONDITIONAL")
+            self.writeCommunicationCluster(child_element, cluster)
 
     def writeCanCluster(self, element: ET.Element, cluster: CanCluster):
-        self.logger.debug("CanCluster %s" % cluster.getShortName())
-        child_element = ET.SubElement(element, "CAN-CLUSTER")
-        self.writeIdentifiable(child_element, cluster)
-
-        child_element = ET.SubElement(child_element, "CAN-CLUSTER-VARIANTS")
-        child_element = ET.SubElement(child_element, "CAN-CLUSTER-CONDITIONAL")
-        self.writeCommunicationCluster(child_element, cluster)
-        self.writeAbstractCanCluster(child_element, cluster)
+        if cluster is not None:
+            self.logger.debug("CanCluster %s" % cluster.getShortName())
+            child_element = ET.SubElement(element, "CAN-CLUSTER")
+            self.writeIdentifiable(child_element, cluster)
+
+            child_element = ET.SubElement(child_element, "CAN-CLUSTER-VARIANTS")
+            child_element = ET.SubElement(child_element, "CAN-CLUSTER-CONDITIONAL")
+            self.writeCommunicationCluster(child_element, cluster)
+            self.writeAbstractCanCluster(child_element, cluster)
+
+    def writeFlexrayCluster(self, element: ET.Element, cluster: FlexrayCluster):
+        if cluster is not None:
+            self.logger.debug("Write FlexrayCluster <%s>" % cluster.getShortName())
+            child_element = ET.SubElement(element, "FLEXRAY-CLUSTER")
+            self.writeIdentifiable(child_element, cluster)
+
+            child_element = ET.SubElement(child_element, "FLEXRAY-CLUSTER-VARIANTS")
+            child_element = ET.SubElement(child_element, "FLEXRAY-CLUSTER-CONDITIONAL")
+            self.writeCommunicationCluster(child_element, cluster)
+
+            self.setChildElementOptionalIntegerValue(child_element, "ACTION-POINT-OFFSET", cluster.getActionPointOffset())
+            self.setChildElementOptionalTimeValue(child_element, "BIT", cluster.getBit())
+            self.setChildElementOptionalIntegerValue(child_element, "CAS-RX-LOW-MAX", cluster.getCasRxLowMax())
+            self.setChildElementOptionalIntegerValue(child_element, "COLD-START-ATTEMPTS", cluster.getColdStartAttempts())
+            self.setChildElementOptionalTimeValue(child_element, "CYCLE", cluster.getCycle())
+            self.setChildElementOptionalIntegerValue(child_element, "CYCLE-COUNT-MAX", cluster.getCycleCountMax())
+            self.setChildElementOptionalBooleanValue(child_element, "DETECT-NIT-ERROR", cluster.getDetectNitError())
+            self.setChildElementOptionalIntegerValue(child_element, "DYNAMIC-SLOT-IDLE-PHASE", cluster.getDynamicSlotIdlePhase())
+            self.setChildElementOptionalIntegerValue(child_element, "IGNORE-AFTER-TX", cluster.getIgnoreAfterTx())
+            self.setChildElementOptionalIntegerValue(child_element, "LISTEN-NOISE", cluster.getListenNoise())
+            self.setChildElementOptionalIntegerValue(child_element, "MACRO-PER-CYCLE", cluster.getMacroPerCycle())
+            self.setChildElementOptionalTimeValue(child_element, "MACROTICK-DURATION", cluster.getMacrotickDuration())
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-WITHOUT-CLOCK-CORRECTION-FATAL", cluster.getMaxWithoutClockCorrectionFatal())
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-WITHOUT-CLOCK-CORRECTION-PASSIVE", cluster.getMaxWithoutClockCorrectionPassive())  # noqa E501
+            self.setChildElementOptionalIntegerValue(child_element, "MINISLOT-ACTION-POINT-OFFSET", cluster.getMinislotActionPointOffset())
+            self.setChildElementOptionalIntegerValue(child_element, "MINISLOT-DURATION", cluster.getMinislotDuration())
+            self.setChildElementOptionalIntegerValue(child_element, "NETWORK-IDLE-TIME", cluster.getNetworkIdleTime())
+            self.setChildElementOptionalIntegerValue(child_element, "NETWORK-MANAGEMENT-VECTOR-LENGTH", cluster.getNetworkManagementVectorLength())
+            self.setChildElementOptionalIntegerValue(child_element, "NUMBER-OF-MINISLOTS", cluster.getNumberOfMinislots())
+            self.setChildElementOptionalIntegerValue(child_element, "NUMBER-OF-STATIC-SLOTS", cluster.getNumberOfStaticSlots())
+            self.setChildElementOptionalIntegerValue(child_element, "OFFSET-CORRECTION-START", cluster.getOffsetCorrectionStart())
+            self.setChildElementOptionalIntegerValue(child_element, "PAYLOAD-LENGTH-STATIC", cluster.getPayloadLengthStatic())
+            self.setChildElementOptionalIntegerValue(child_element, "SAFETY-MARGIN", cluster.getSafetyMargin())
+            self.setChildElementOptionalTimeValue(child_element, "SAMPLE-CLOCK-PERIOD", cluster.getSampleClockPeriod())
+            self.setChildElementOptionalIntegerValue(child_element, "STATIC-SLOT-DURATION", cluster.getStaticSlotDuration())
+            self.setChildElementOptionalIntegerValue(child_element, "SYNC-FRAME-ID-COUNT-MAX", cluster.getSyncFrameIdCountMax())
+            self.setChildElementOptionalIntegerValue(child_element, "TRANSMISSION-START-SEQUENCE-DURATION", cluster.getTransmissionStartSequenceDuration()) # noqa E501
+            self.setChildElementOptionalIntegerValue(child_element, "WAKEUP-RX-IDLE", cluster.getWakeupRxIdle())
+            self.setChildElementOptionalIntegerValue(child_element, "WAKEUP-RX-LOW", cluster.getWakeupRxLow())
+            self.setChildElementOptionalIntegerValue(child_element, "WAKEUP-RX-WINDOW", cluster.getWakeupRxWindow())
+            self.setChildElementOptionalIntegerValue(child_element, "WAKEUP-TX-ACTIVE", cluster.getWakeupTxActive())
+            self.setChildElementOptionalIntegerValue(child_element, "WAKEUP-TX-IDLE", cluster.getWakeupTxIdle())
 
     def writeMacMulticastGroup(self, element: ET.Element, group: MacMulticastGroup):
         if group is not None:
@@ -3044,27 +3807,28 @@ class ARXMLWriter(AbstractARXMLWriter):
                 elif isinstance(port, ISignalPort):
                     self.writeISignalPort(instances_tag, port)
                 else:
-                    self._raiseError("Unsupported CommConnectorPort <%s>" % type(port))  
+                    self.notImplemented("Unsupported CommConnectorPort <%s>" % type(port))
 
     def writeCommunicationController(self, element: ET.Element, controller: CommunicationController):
         self.setChildElementOptionalBooleanValue(element, "WAKE-UP-BY-CONTROLLER-SUPPORTED", controller.getWakeUpByControllerSupported())
 
     def setCanControllerFdConfiguration(self, element: ET.Element, key: str, configuration: CanControllerFdConfiguration):
         if configuration is not None:
-            child_element = ET.SubElement(element, key)
-            #TODO: need to implemented
+            pass
+            # child_element = ET.SubElement(element, key)
+            # TODO: need to implemented
     
     def setCanControllerFdConfigurationRequirements(self, element: ET.Element, key: str, requirements: CanControllerFdConfigurationRequirements):
         if requirements is not None:
             child_element = ET.SubElement(element, key)
-            self.setChildElementOptionalIntegerValue(child_element, "MAX-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMaxNumberOfTimeQuantaPerBit())
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMaxNumberOfTimeQuantaPerBit())     # noqa E501
             self.setChildElementOptionalFloatValue(child_element, "MAX-SAMPLE-POINT", requirements.getMaxSamplePoint())
             self.setChildElementOptionalFloatValue(child_element, "MAX-SYNC-JUMP-WIDTH", requirements.getMaxSyncJumpWidth())
-            self.setChildElementOptionalTimeValue(child_element, "MAX-TRCV-DELAY-COMPENSATION-OFFSET", requirements.getMaxTrcvDelayCompensationOffset())
-            self.setChildElementOptionalIntegerValue(child_element, "MIN-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMinNumberOfTimeQuantaPerBit())
+            self.setChildElementOptionalTimeValue(child_element, "MAX-TRCV-DELAY-COMPENSATION-OFFSET", requirements.getMaxTrcvDelayCompensationOffset())    # noqa E501
+            self.setChildElementOptionalIntegerValue(child_element, "MIN-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMinNumberOfTimeQuantaPerBit())     # noqa E501
             self.setChildElementOptionalFloatValue(child_element, "MIN-SAMPLE-POINT", requirements.getMinSamplePoint())
             self.setChildElementOptionalFloatValue(child_element, "MIN-SYNC-JUMP-WIDTH", requirements.getMinSyncJumpWidth())
-            self.setChildElementOptionalTimeValue(child_element, "MIN-TRCV-DELAY-COMPENSATION-OFFSET", requirements.getMinTrcvDelayCompensationOffset())
+            self.setChildElementOptionalTimeValue(child_element, "MIN-TRCV-DELAY-COMPENSATION-OFFSET", requirements.getMinTrcvDelayCompensationOffset())    # noqa E501
             self.setChildElementOptionalBooleanValue(child_element, "TX-BIT-RATE-SWITCH", requirements.getTxBitRateSwitch())
 
     def writeAbstractCanCommunicationControllerAttributes(self, element: ET.Element, attributes: AbstractCanCommunicationControllerAttributes):
@@ -3075,10 +3839,10 @@ class ARXMLWriter(AbstractARXMLWriter):
         if requirements is not None:
             child_element = ET.SubElement(element, "CAN-CONTROLLER-CONFIGURATION-REQUIREMENTS")
             self.writeAbstractCanCommunicationControllerAttributes(child_element, requirements)
-            self.setChildElementOptionalIntegerValue(child_element, "MAX-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMaxNumberOfTimeQuantaPerBit())
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMaxNumberOfTimeQuantaPerBit())     # noqa E501
             self.setChildElementOptionalFloatValue(child_element, "MAX-SAMPLE-POINT", requirements.getMaxSamplePoint())
             self.setChildElementOptionalFloatValue(child_element, "MAX-SYNC-JUMP-WIDTH", requirements.getMaxSyncJumpWidth())
-            self.setChildElementOptionalIntegerValue(child_element, "MIN-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMinNumberOfTimeQuantaPerBit())
+            self.setChildElementOptionalIntegerValue(child_element, "MIN-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMinNumberOfTimeQuantaPerBit())     # noqa E501
             self.setChildElementOptionalFloatValue(child_element, "MIN-SAMPLE-POINT", requirements.getMinSamplePoint())
             self.setChildElementOptionalFloatValue(child_element, "MIN-SYNC-JUMP-WIDTH", requirements.getMinSyncJumpWidth())
 
@@ -3089,7 +3853,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             if isinstance(attributes, CanControllerConfigurationRequirements):
                 self.writeCanControllerConfigurationRequirements(child_element, attributes)
             else:
-                self.notImplemented("Unsupported CanControllerAttributes <%s>" % type(attributes))    
+                self.notImplemented("Unsupported CanControllerAttributes <%s>" % type(attributes))
 
     def writeAbstractCanCommunicationController(self, element: ET.Element, controller: AbstractCanCommunicationController):
         self.writeCommunicationController(element, controller)
@@ -3148,10 +3912,10 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setCouplingPortDetails(self, element: ET.Element, key: str, details: CouplingPortDetails):
         if details is not None:
-             child_element = ET.SubElement(element, key)
-             self.writeCouplingPortDetailsCouplingPortStructuralElements(child_element, details)
-             self.writeCouplingPortDetailsEthernetPriorityRegenerations(child_element, details)
-             self.setChildElementOptionalRefType(child_element, "LAST-EGRESS-SCHEDULER-REF", details.getLastEgressSchedulerRef())
+            child_element = ET.SubElement(element, key)
+            self.writeCouplingPortDetailsCouplingPortStructuralElements(child_element, details)
+            self.writeCouplingPortDetailsEthernetPriorityRegenerations(child_element, details)
+            self.setChildElementOptionalRefType(child_element, "LAST-EGRESS-SCHEDULER-REF", details.getLastEgressSchedulerRef())
 
     def writeVlanMembership(self, element: ET.Element, membership: VlanMembership):
         if membership is not None:
@@ -3173,7 +3937,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "COUPLING-PORT")
         self.writeIdentifiable(child_element, port)
         self.setCouplingPortDetails(child_element, "COUPLING-PORT-DETAILS", port.getCouplingPortDetails())
-        self.setChildElementOptionalLiteral(child_element, "MAC-LAYER-TYPE", port.getMacAddressVlanAssignments())
+        self.setChildElementOptionalLiteral(child_element, "MAC-LAYER-TYPE", port.getMacLayerType())
         self.writeCouplingPortVlanMemberships(child_element, port)
 
     def writeEthernetCommunicationControllerCouplingPorts(self, element: ET.Element, controller: EthernetCommunicationController):
@@ -3206,6 +3970,8 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.writeEthernetCommunicationController(child_element, controller)
                 elif isinstance(controller, LinMaster):
                     self.writeLinMaster(child_element, controller)
+                elif isinstance(controller, FlexrayCommunicationController):
+                    self.writeFlexrayCommunicationController(child_element, controller)
                 else:
                     self.notImplemented("Unsupported Communication Controller <%s>" % type(controller))
 
@@ -3219,15 +3985,27 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.logger.debug("Write CanCommunicationConnector %s" % connector.getShortName())
         self.writeCommunicationConnector(element, connector)
 
+    def writeEthernetCommunicationConnectorNetworkEndpointRefs(self, element: ET.Element, connector: EthernetCommunicationConnector):
+        refs = connector.getNetworkEndpointRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "NETWORK-ENDPOINT-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "NETWORK-ENDPOINT-REF", ref)
+
     def writeEthernetCommunicationConnector(self, element: ET.Element, connector: EthernetCommunicationConnector):
         self.logger.debug("Write EthernetCommunicationConnector %s" % connector.getShortName())
         self.writeCommunicationConnector(element, connector)
         self.setChildElementOptionalPositiveInteger(element, "MAXIMUM-TRANSMISSION-UNIT", connector.getMaximumTransmissionUnit())
+        self.writeEthernetCommunicationConnectorNetworkEndpointRefs(element, connector)
 
     def writeLinCommunicationConnector(self, element: ET.Element, connector: LinCommunicationConnector):
         self.logger.debug("Write LinCommunicationConnector %s" % connector.getShortName())
         self.writeCommunicationConnector(element, connector)
 
+    def writeFlexrayCommunicationConnector(self, element: ET.Element, connector: FlexrayCommunicationConnector):
+        self.logger.debug("Write FlexrayCommunicationConnector %s" % connector.getShortName())
+        self.writeCommunicationConnector(element, connector)
+
     def writeEcuInstanceConnectors(self, element: ET.Element, instance: EcuInstance):
         connectors = instance.getConnectors()
         if len(connectors) > 0:
@@ -3242,8 +4020,11 @@ class ARXMLWriter(AbstractARXMLWriter):
                 elif isinstance(connector, LinCommunicationConnector):
                     child_element = ET.SubElement(connectors_tag, "LIN-COMMUNICATION-CONNECTOR")
                     self.writeLinCommunicationConnector(child_element, connector)
+                elif isinstance(connector, FlexrayCommunicationConnector):
+                    child_element = ET.SubElement(connectors_tag, "FLEXRAY-COMMUNICATION-CONNECTOR")
+                    self.writeFlexrayCommunicationConnector(child_element, connector)
                 else:
-                    self._raiseError("Unsupported Communication connector <%s>" % type(connector))
+                    self.notImplemented("Unsupported Communication connector <%s>" % type(connector))
 
     def writeEcuInstanceAssociatedComIPduGroupRefs(self, element: ET.Element, instance: EcuInstance):
         refs = instance.getAssociatedComIPduGroupRefs()
@@ -3260,9 +4041,10 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-GW-TIME-BASE", instance.getComConfigurationGwTimeBase())
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-RX-TIME-BASE", instance.getComConfigurationRxTimeBase())
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-TX-TIME-BASE", instance.getComConfigurationTxTimeBase())
-        self.setChildElementOptionalBooleanValue(child_element, "COM-ENABLE-MDT-FOR-CYCLIC-TRANSMISSION", instance.getComEnableMDTForCyclicTransmission())
+        self.setChildElementOptionalBooleanValue(child_element, "COM-ENABLE-MDT-FOR-CYCLIC-TRANSMISSION", instance.getComEnableMDTForCyclicTransmission())      # noqa E501
         self.writeEcuInstanceCommControllers(child_element, instance)
         self.writeEcuInstanceConnectors(child_element, instance)
+        self.setChildElementOptionalIntegerValue(child_element, "DIAGNOSTIC-ADDRESS", instance.getDiagnosticAddress())
         self.setChildElementOptionalBooleanValue(child_element, "SLEEP-MODE-SUPPORTED", instance.getSleepModeSupported())
         self.setChildElementOptionalBooleanValue(child_element, "WAKE-UP-OVER-BUS-SUPPORTED", instance.getWakeUpOverBusSupported())
 
@@ -3276,16 +4058,53 @@ class ARXMLWriter(AbstractARXMLWriter):
             for signal_ref in signal_refs:
                 self.setChildElementOptionalRefType(signal_refs_tag, "SYSTEM-SIGNAL-REF", signal_ref)
 
-    def setSenderReceiverToSignalMapping(self, element: ET.Element, mapping: SenderReceiverToSignalMapping):
+    def writeSenderReceiverToSignalMapping(self, element: ET.Element, mapping: SenderReceiverToSignalMapping):
         child_element = ET.SubElement(element, "SENDER-RECEIVER-TO-SIGNAL-MAPPING")
         self.setChildElementOptionalLiteral(child_element, "COMMUNICATION-DIRECTION", mapping.getCommunicationDirection())
         self.setVariableDataPrototypeInSystemInstanceRef(child_element, "DATA-ELEMENT-IREF", mapping.getDataElementIRef())
         self.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-REF", mapping.getSystemSignalRef())
 
-    def setSenderReceiverToSignalGroupMapping(self, element: ET.Element, mapping: SenderReceiverToSignalGroupMapping):
+    def writeSenderRecCompositeTypeMapping(self, element: ET.Element, mapping: SenderRecCompositeTypeMapping):
+        self.writeARObjectAttributes(element, mapping)
+
+    def writeSenderRecRecordElementMapping(self, element: ET.Element, mapping: SenderRecRecordElementMapping):
+        if mapping is not None:
+            child_element = ET.SubElement(element, "SENDER-REC-RECORD-ELEMENT-MAPPING")
+            self.writeARObjectAttributes(child_element, mapping)
+            self.setChildElementOptionalRefType(child_element, "APPLICATION-RECORD-ELEMENT-REF", mapping.getApplicationRecordElementRef())
+            self.setChildElementOptionalRefType(child_element, "IMPLEMENTATION-RECORD-ELEMENT-REF", mapping.getImplementationRecordElementRef())
+            self.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-REF", mapping.getSystemSignalRef())
+
+    def writeSenderRecArrayTypeMappingRecordElementMapping(self, element: ET.Element, mapping: SenderRecRecordTypeMapping):
+        record_element_mappings = mapping.getRecordElementMappings()
+        if len(record_element_mappings) > 0:
+            child_element = ET.SubElement(element, "RECORD-ELEMENT-MAPPINGS")
+            for record_element_mapping in record_element_mappings:
+                if isinstance(record_element_mapping, SenderRecRecordElementMapping):
+                    self.writeSenderRecRecordElementMapping(child_element, record_element_mapping)
+                else:
+                    self.notImplemented("Unsupported RecordElementMapping %s" % type(record_element_mapping))
+    
+    def writeSenderRecRecordTypeMapping(self, element: ET.Element, mapping: SenderRecRecordTypeMapping):
+        if mapping is not None:
+            child_element = ET.SubElement(element, "SENDER-REC-RECORD-TYPE-MAPPING")
+            self.writeSenderRecCompositeTypeMapping(child_element, mapping)
+            self.writeSenderRecArrayTypeMappingRecordElementMapping(child_element, mapping)
+
+    def writeSenderReceiverToSignalGroupMappingTypeMapping(self, element: ET.Element, mapping: SenderReceiverToSignalGroupMapping):
+        type_mapping = mapping.getTypeMapping()
+        if type_mapping is not None:
+            child_element = ET.SubElement(element, "TYPE-MAPPING")
+            if isinstance(type_mapping, SenderRecRecordTypeMapping):
+                self.writeSenderRecRecordTypeMapping(child_element, type_mapping)
+            else:
+                self.notImplemented("Unsupported Type Mapping %s" % type(type_mapping))
+
+    def writeSenderReceiverToSignalGroupMapping(self, element: ET.Element, mapping: SenderReceiverToSignalGroupMapping):
         child_element = ET.SubElement(element, "SENDER-RECEIVER-TO-SIGNAL-GROUP-MAPPING")
         self.setVariableDataPrototypeInSystemInstanceRef(child_element, "DATA-ELEMENT-IREF", mapping.getDataElementIRef())
         self.setChildElementOptionalRefType(child_element, "SIGNAL-GROUP-REF", mapping.getSignalGroupRef())
+        self.writeSenderReceiverToSignalGroupMappingTypeMapping(child_element, mapping)
     
     def writeSystemMappingDataMappings(self, element: ET.Element, system_mapping: SystemMapping):
         data_mappings = system_mapping.getDataMappings()
@@ -3293,9 +4112,9 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "DATA-MAPPINGS")
             for data_mapping in data_mappings:
                 if isinstance(data_mapping, SenderReceiverToSignalMapping):
-                    self.setSenderReceiverToSignalMapping(child_element, data_mapping)
+                    self.writeSenderReceiverToSignalMapping(child_element, data_mapping)
                 elif isinstance(data_mapping, SenderReceiverToSignalGroupMapping):
-                    self.setSenderReceiverToSignalGroupMapping(child_element, data_mapping)
+                    self.writeSenderReceiverToSignalGroupMapping(child_element, data_mapping)
                 else:
                     self.notImplemented("Unsupported Data Mapping %s" % type(data_mapping))
                 
@@ -3319,11 +4138,52 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Sw Mapping %s" % type(sw_mapping))
 
+    def writeEcuMapping(self, element: ET.Element, mapping: ECUMapping):
+        self.logger.debug("Write ECUMapping <%s>" % mapping.getShortName())
+        if mapping is not None:
+            child_element = ET.SubElement(element, "ECU-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.setChildElementOptionalRefType(child_element, "ECU-INSTANCE-REF", mapping.getEcuInstanceRef())
+            self.setChildElementOptionalRefType(child_element, "ECU-REF", mapping.getEcuRef())
+
+    def writeSystemMappingEcuResourceMappings(self, element: ET.Element, mapping: SystemMapping):
+        ecu_resource_mappings = mapping.getEcuResourceMappings()
+        if len(ecu_resource_mappings) > 0:
+            child_element = ET.SubElement(element, "ECU-RESOURCE-MAPPINGS")
+            for ecu_resource_mapping in ecu_resource_mappings:
+                if isinstance(ecu_resource_mapping, ECUMapping):
+                    self.writeEcuMapping(child_element, ecu_resource_mapping)
+                else:
+                    self.notImplemented("Unsupported Sw Mapping %s" % type(ecu_resource_mapping))
+
+    def writeSwcToImplMapping(self, element: ET.Element, mapping: SwcToImplMapping):
+        if mapping is not None:
+            child_element = ET.SubElement(element, "SWC-TO-IMPL-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.setChildElementOptionalRefType(child_element, "COMPONENT-IMPLEMENTATION-REF", mapping.getComponentImplementationRef())
+            irefs = mapping.getComponentIRefs()
+            if len(irefs) > 0:
+                irefs_tag = ET.SubElement(child_element, "COMPONENT-IREFS")
+                for iref in irefs:
+                    self.setComponentInSystemInstanceRef(irefs_tag, "COMPONENT-IREF", iref)
+
+    def writeSystemMappingSwImplMappings(self, element: ET.Element, mapping: SystemMapping):
+        sw_impl_mappings = mapping.getSwImplMappings()
+        if len(sw_impl_mappings) > 0:
+            child_element = ET.SubElement(element, "SW-IMPL-MAPPINGS")
+            for sw_impl_mapping in sw_impl_mappings:
+                if isinstance(sw_impl_mapping, SwcToImplMapping):
+                    self.writeSwcToImplMapping(child_element, sw_impl_mapping)
+                else:
+                    self.notImplemented("Unsupported SwImplMapping <%s>" % type(sw_impl_mapping))
+
     def writeSystemMapping(self, element: ET.Element, mapping: SystemMapping):
-        self.logger.debug("Write SystemMapping %s" % mapping.getShortName())
+        self.logger.debug("Write SystemMapping <%s>" % mapping.getShortName())
         child_element = ET.SubElement(element, "SYSTEM-MAPPING")
         self.writeIdentifiable(child_element, mapping)
         self.writeSystemMappingDataMappings(child_element, mapping)
+        self.writeSystemMappingEcuResourceMappings(child_element, mapping)
+        self.writeSystemMappingSwImplMappings(child_element, mapping)
         self.writeSystemMappingSwMappings(child_element, mapping)
 
     def writeSystemMappings(self, element: ET.Element, system: System):
@@ -3368,9 +4228,12 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.logger.debug("Set PhysicalDimension %s" % dimension.getShortName())
         child_element = ET.SubElement(element, "PHYSICAL-DIMENSION")
         self.writeARElement(child_element, dimension)
-        self.setChildElementOptionalNumericalValue(child_element, "CURRENT-EXP", dimension.getCurrentExp())
         self.setChildElementOptionalNumericalValue(child_element, "LENGTH-EXP", dimension.getLengthExp())
+        self.setChildElementOptionalNumericalValue(child_element, "LUMINOUS-INTENSITY-EXP", dimension.getLuminousIntensityExp())
+        self.setChildElementOptionalNumericalValue(child_element, "MASS-EXP", dimension.getMassExp())
+        self.setChildElementOptionalNumericalValue(child_element, "TEMPERATURE-EXP", dimension.getTemperatureExp())
         self.setChildElementOptionalNumericalValue(child_element, "TIME-EXP", dimension.getTimeExp())
+        self.setChildElementOptionalNumericalValue(child_element, "CURRENT-EXP", dimension.getCurrentExp())
 
     def setFlatInstanceDescriptor(self, element: ET.Element, desc: FlatInstanceDescriptor):
         self.logger.debug("Set FlatInstanceDescriptor %s" % desc.getShortName())
@@ -3474,7 +4337,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             ecuc_values_tag = ET.SubElement(element, "ECUC-VALUES")
             for value_ref in value_refs:
                 child_element = ET.SubElement(ecuc_values_tag, "ECUC-MODULE-CONFIGURATION-VALUES-REF-CONDITIONAL")
-                self.setChildElementOptionalRefType(child_element, "ECUC-MODULE-CONFIGURATION-VALUES-REF", value_ref) 
+                self.setChildElementOptionalRefType(child_element, "ECUC-MODULE-CONFIGURATION-VALUES-REF", value_ref)
 
     def writeEcucValueCollection(self, element: ET.Element, collection: EcucValueCollection):
         self.logger.debug("EcucValueCollection %s" % collection.getShortName())
@@ -3491,7 +4354,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(sub_container, EcucContainerValue):
                     self.writeEcucContainValue(sub_containers_tag, sub_container)
                 else:
-                    self.notImplemented("Unsupported Sub Container %s" % type(container)) 
+                    self.notImplemented("Unsupported Sub Container %s" % type(container))
                 
     def writeEcucParameterValue(self, element: ET.Element, param_value: EcucParameterValue):
         self.setChildElementOptionalRefType(element, "DEFINITION-REF", param_value.getDefinitionRef())
@@ -3510,7 +4373,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeEcucContainerValueParameterValues(self, element: ET.Element, container_value: EcucContainerValue):
         param_values = container_value.getParameterValues()
         if len(param_values) > 0:
-            child_element  = ET.SubElement(element, "PARAMETER-VALUES")
+            child_element = ET.SubElement(element, "PARAMETER-VALUES")
             for param_value in param_values:
                 if isinstance(param_value, EcucTextualParamValue):
                     self.setEcucTextualParamValue(child_element, param_value)
@@ -3523,7 +4386,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRefType(element, "DEFINITION-REF", value.getDefinitionRef())
         self.setAnnotations(element, value.getAnnotations())
 
-    def setEcucReferenceValue(self, element: ET.Element, value = EcucReferenceValue()):
+    def setEcucReferenceValue(self, element: ET.Element, value=EcucReferenceValue()):
         child_element = ET.SubElement(element, "ECUC-REFERENCE-VALUE")
         self.writeEcucAbstractReferenceValue(child_element, value)
         self.setChildElementOptionalRefType(child_element, "VALUE-REF", value.getValueRef())
@@ -3532,13 +4395,13 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setAnyInstanceRef(self, element: ET.Element, key, instance_ref: AnyInstanceRef):
         if instance_ref is not None:
             child_element = ET.SubElement(element, key)
-            self.setChildElementOptionalRefType(child_element, "BASE-REF", instance_ref.getBaseRef()) 
+            self.setChildElementOptionalRefType(child_element, "BASE-REF", instance_ref.getBaseRef())
             for ref in instance_ref.getContextElementRefs():
                 self.setChildElementOptionalRefType(child_element, "CONTEXT-ELEMENT-REF", ref)
             self.setChildElementOptionalRefType(child_element, "TARGET-REF", instance_ref.getTargetRef())
         return instance_ref
     
-    def setEcucInstanceReferenceValue(self, element: ET.Element, value : EcucInstanceReferenceValue):
+    def setEcucInstanceReferenceValue(self, element: ET.Element, value: EcucInstanceReferenceValue):
         child_element = ET.SubElement(element, "ECUC-INSTANCE-REFERENCE-VALUE")
         self.writeEcucAbstractReferenceValue(child_element, value)
         self.setAnyInstanceRef(child_element, "VALUE-IREF", value.getValueIRef())
@@ -3547,7 +4410,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeEcucContainerValueReferenceValues(self, element: ET.Element, container_value: EcucContainerValue):
         reference_values = container_value.getReferenceValues()
         if len(reference_values) > 0:
-            child_element  = ET.SubElement(element, "REFERENCE-VALUES")
+            child_element = ET.SubElement(element, "REFERENCE-VALUES")
             for reference_value in reference_values:
                 if isinstance(reference_value, EcucReferenceValue):
                     self.setEcucReferenceValue(child_element, reference_value)
@@ -3573,7 +4436,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(container, EcucContainerValue):
                     self.writeEcucContainValue(containers_tag, container)
                 else:
-                    self.notImplemented("Unsupported Container %s" % type(container)) 
+                    self.notImplemented("Unsupported Container %s" % type(container))
 
     def writeEcucModuleConfigurationValues(self, element: ET.Element, values: EcucModuleConfigurationValues):
         self.logger.debug("EcucModuleConfigurationValues %s" % values.getShortName())
@@ -3584,16 +4447,58 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRefType(child_element, "MODULE-DESCRIPTION-REF", values.getModuleDescriptionRef())
         self.writeEcucModuleConfigurationValuesContainers(child_element, values)
 
+    def writeISignalGroupISignalRef(self, element: ET.Element, group: ISignalGroup):
+        signal_refs = group.getISignalRefs()
+        if len(signal_refs) > 0:
+            child_element = ET.SubElement(element, "I-SIGNAL-REFS")
+            for signal_ref in signal_refs:
+                self.setChildElementOptionalRefType(child_element, "I-SIGNAL-REF", signal_ref)
+
+    def writeISignalGroupComBasedSignalGroupTransformation(self, element: ET.Element, group: ISignalGroup):
+        refs = group.getComBasedSignalGroupTransformationRefs()
+        if len(refs) > 0:
+            com_based_element = ET.SubElement(element, "COM-BASED-SIGNAL-GROUP-TRANSFORMATIONS")
+            cond_element = ET.SubElement(com_based_element, "DATA-TRANSFORMATION-REF-CONDITIONAL")
+            for ref in refs:
+                self.setChildElementOptionalRefType(cond_element, "DATA-TRANSFORMATION-REF", ref)
+
+    def writeTransformationISignalProps(self, element: ET.Element, props: TransformationISignalProps):
+        self.writeDescribable(element, props)
+
+    def writeEndToEndTransformationISignalPropsDataIds(self, element: ET.Element, props: EndToEndTransformationISignalProps):
+        ids = props.getDataIds()
+        if len(ids) > 0:
+            child_element = ET.SubElement(element, "DATA-IDS")
+            for id in ids:
+                self.setChildElementOptionalPositiveInteger(child_element, "DATA-ID", id)
+
+    def writeEndToEndTransformationISignalProps(self, element: ET.Element, props: EndToEndTransformationISignalProps):
+        if props is not None:
+            props_element = ET.SubElement(element, "END-TO-END-TRANSFORMATION-I-SIGNAL-PROPS")
+            variant_element = ET.SubElement(props_element, "END-TO-END-TRANSFORMATION-I-SIGNAL-PROPS-VARIANTS")
+            child_element = ET.SubElement(variant_element, "END-TO-END-TRANSFORMATION-I-SIGNAL-PROPS-CONDITIONAL")
+            self.writeTransformationISignalProps(child_element, props)
+            self.setChildElementOptionalRefType(child_element, "TRANSFORMER-REF", props.getTransformerRef())
+            self.writeEndToEndTransformationISignalPropsDataIds(child_element, props)
+            self.setChildElementOptionalPositiveInteger(child_element, "DATA-LENGTH", props.getDataLength())
+
+    def writeISignalGroupTransformationISignalProps(self, element: ET.Element, group: ISignalGroup):
+        props = group.getTransformationISignalProps()
+        if props is not None:
+            child_element = ET.SubElement(element, "TRANSFORMATION-I-SIGNAL-PROPSS")
+            if isinstance(props, EndToEndTransformationISignalProps):
+                self.writeEndToEndTransformationISignalProps(child_element, props)
+            else:
+                self.notImplemented("Unsupported TransformationISignalProps %s" % type(props))
+
     def writeISignalGroup(self, element: ET.Element, group: ISignalGroup):
         self.logger.debug("ISignalGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-GROUP")
         self.writeIdentifiable(child_element, group)
-        signal_refs = group.getISignalRefs()
-        if len(signal_refs) > 0:
-            signal_refs_tag = ET.SubElement(child_element, "I-SIGNAL-REFS")
-            for signal_ref in signal_refs:
-                self.setChildElementOptionalRefType(signal_refs_tag, "I-SIGNAL-REF", signal_ref)
+        self.writeISignalGroupComBasedSignalGroupTransformation(child_element, group)
+        self.writeISignalGroupISignalRef(child_element, group)
         self.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-GROUP-REF", group.getSystemSignalGroupRef())
+        self.writeISignalGroupTransformationISignalProps(child_element, group)
 
     def writeISignalIPduGroup(self, element: ET.Element, group: ISignalIPduGroup):
         self.logger.debug("Set ISignalIPduGroup %s" % group.getShortName())
@@ -3660,52 +4565,265 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeDiagnosticServiceTableDiagnosticConnectionRefs(child_element, table)
         self.setChildElementOptionalRefType(child_element, "ECU-INSTANCE-REF", table.getEcuInstanceRef())
 
-    def writeMultiplexedIPdu(self, element: ET.Element, i_pdu: MultiplexedIPdu):
-        self.logger.debug("Write MultiplexedIPdu %s" % i_pdu.getShortName())
-        child_element = ET.SubElement(element, "MULTIPLEXED-I-PDU")
-        self.writeIdentifiable(child_element, i_pdu)
+    def writePdu(self, element: ET.Element, pdu: Pdu):
+        self.writeIdentifiable(element, pdu)
+        self.setChildElementOptionalBooleanValue(element, "HAS-DYNAMIC-LENGTH", pdu.getHasDynamicLength())
+        self.setChildElementOptionalNumericalValue(element, "LENGTH", pdu.getLength())
 
-    def writeUserDefinedIPdu(self, element: ET.Element, i_pdu: UserDefinedIPdu):
-        self.logger.debug("Write UserDefinedIPdu %s" % i_pdu.getShortName())
+    def writeIPdu(self, element: ET.Element, pdu: IPdu):
+        self.writePdu(element, pdu)
+
+    def writeSegmentPosition(self, element: ET.Element, position: SegmentPosition):
+        if position is not None:
+            child_element = ET.SubElement(element, "SEGMENT-POSITION")
+            self.setChildElementOptionalLiteral(child_element, "SEGMENT-BYTE-ORDER", position.getSegmentByteOrder())
+            self.setChildElementOptionalIntegerValue(child_element, "SEGMENT-LENGTH", position.getSegmentLength())
+            self.setChildElementOptionalIntegerValue(child_element, "SEGMENT-POSITION", position.getSegmentPosition())
+
+    def writeMultiplexedPartSegmentPositions(self, element: ET.Element, part: MultiplexedPart):
+        positions = part.getSegmentPositions()
+        if len(positions) > 0:
+            child_element = ET.SubElement(element, "SEGMENT-POSITIONS")
+            for position in positions:
+                if isinstance(position, SegmentPosition):
+                    self.writeSegmentPosition(child_element, position)
+                else:
+                    self.notImplemented("Unsupported DynamicPart <%s>" % type(position))
+
+    def writeMultiplexedPart(self, element: ET.Element, part: MultiplexedPart):
+        self.writeMultiplexedPartSegmentPositions(element, part)
+
+    def writeDynamicPartAlternative(self, element: ET.Element, alternative: DynamicPartAlternative):
+        if alternative is not None:
+            child_element = ET.SubElement(element, "DYNAMIC-PART-ALTERNATIVE")
+            self.setChildElementOptionalRefType(child_element, "I-PDU-REF", alternative.getIPduRef())
+            self.setChildElementOptionalBooleanValue(child_element, "INITIAL-DYNAMIC-PART", alternative.getInitialDynamicPart())
+            self.setChildElementOptionalIntegerValue(child_element, "SELECTOR-FIELD-CODE", alternative.getSelectorFieldCode())
+
+    def writeDynamicPartDynamicPartAlternatives(self, element: ET.Element, part: DynamicPart):
+        alternatives = part.getDynamicPartAlternatives()
+        if len(alternatives) > 0:
+            child_element = ET.SubElement(element, "DYNAMIC-PART-ALTERNATIVES")
+            for alternative in alternatives:
+                if isinstance(alternative, DynamicPartAlternative):
+                    self.writeDynamicPartAlternative(child_element, alternative)
+                else:
+                    self.notImplemented("Unsupported DynamicPartAlternative <%s>" % type(alternative))
+
+    def writeDynamicPart(self, element: ET.Element, part: DynamicPart):
+        child_element = ET.SubElement(element, "DYNAMIC-PART")
+        self.writeMultiplexedPart(child_element, part)
+        self.writeDynamicPartDynamicPartAlternatives(child_element, part)
+
+    def writeMultiplexedIPduDynamicParts(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        part = ipdu.getDynamicPart()
+        if part is not None:
+            child_element = ET.SubElement(element, "DYNAMIC-PARTS")
+            if isinstance(part, DynamicPart):
+                self.writeDynamicPart(child_element, part)
+            else:
+                self.notImplemented("Unsupported DynamicPart <%s>" % type(part))
+
+    def writeStaticPart(self, element: ET.Element, part: StaticPart):
+        child_element = ET.SubElement(element, "STATIC-PART")
+        self.writeMultiplexedPart(child_element, part)
+        self.setChildElementOptionalRefType(child_element, "I-PDU-REF", part.getIPduRef())
+
+    def writeMultiplexedIPduStaticParts(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        part = ipdu.getStaticPart()
+        if part is not None:
+            child_element = ET.SubElement(element, "STATIC-PARTS")
+            if isinstance(part, StaticPart):
+                self.writeStaticPart(child_element, part)
+            else:
+                self.notImplemented("Unsupported StaticPart <%s>" % type(part))
+
+    def writeMultiplexedIPdu(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        self.logger.debug("Write MultiplexedIPdu <%s>" % ipdu.getShortName())
+        child_element = ET.SubElement(element, "MULTIPLEXED-I-PDU")
+        self.writeIPdu(child_element, ipdu)
+        self.writeMultiplexedIPduDynamicParts(child_element, ipdu)
+        self.setChildElementOptionalLiteral(child_element, "SELECTOR-FIELD-BYTE-ORDER", ipdu.getSelectorFieldByteOrder())
+        self.setChildElementOptionalIntegerValue(child_element, "SELECTOR-FIELD-LENGTH", ipdu.getSelectorFieldLength())
+        self.setChildElementOptionalIntegerValue(child_element, "SELECTOR-FIELD-START-POSITION", ipdu.getSelectorFieldStartPosition())
+        self.writeMultiplexedIPduStaticParts(child_element, ipdu)
+        self.setChildElementOptionalLiteral(child_element, "TRIGGER-MODE", ipdu.getTriggerMode())
+        self.setChildElementOptionalIntegerValue(child_element, "UNUSED-BIT-PATTERN", ipdu.getUnusedBitPattern())
+
+    def writeUserDefinedIPdu(self, element: ET.Element, ipdu: UserDefinedIPdu):
+        self.logger.debug("Write UserDefinedIPdu <%s>" % ipdu.getShortName())
         child_element = ET.SubElement(element, "USER-DEFINED-I-PDU")
-        self.writeIdentifiable(child_element, i_pdu)
+        self.writeIPdu(child_element, ipdu)
+        self.setChildElementOptionalLiteral(child_element, "CDD-TYPE", ipdu.getCddType())
 
     def writeUserDefinedPdu(self, element: ET.Element, pdu: UserDefinedPdu):
-        self.logger.debug("Write UserDefinedPdu %s" % pdu.getShortName())
+        self.logger.debug("Write UserDefinedPdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "USER-DEFINED-PDU")
-        self.writeIdentifiable(child_element, pdu)
+        self.writePdu(child_element, pdu)
+        self.setChildElementOptionalLiteral(child_element, "CDD-TYPE", pdu.getCddType())
 
     def writeGeneralPurposePdu(self, element: ET.Element, pdu: GeneralPurposePdu):
-        self.logger.debug("Write GeneralPurposePdu %s" % pdu.getShortName())
+        self.logger.debug("Write GeneralPurposePdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "GENERAL-PURPOSE-PDU")
-        self.writeIdentifiable(child_element, pdu)
+        self.writePdu(child_element, pdu)
 
     def writeGeneralPurposeIPdu(self, element: ET.Element, i_pdu: GeneralPurposeIPdu):
-        self.logger.debug("Write GeneralPurposeIPdu %s" % i_pdu.getShortName())
+        self.logger.debug("Write GeneralPurposeIPdu <%s>" % i_pdu.getShortName())
         child_element = ET.SubElement(element, "GENERAL-PURPOSE-I-PDU")
-        self.writeIdentifiable(child_element, i_pdu)
+        self.writeIPdu(child_element, i_pdu)
+
+    def writeSecureCommunicationAuthenticationProps(self, element: ET.Element, props: SecureCommunicationAuthenticationProps):
+        chile_element = ET.SubElement(element, "SECURE-COMMUNICATION-AUTHENTICATION-PROPS")
+        self.writeIdentifiable(chile_element, props)
+        self.setChildElementOptionalLiteral(chile_element, "AUTH-ALGORITHM", props.getAuthAlgorithm())
+        self.setChildElementOptionalPositiveInteger(chile_element, "AUTH-INFO-TX-LENGTH", props.getAuthInfoTxLength())
+
+    def writeSecureCommunicationPropsSetAuthenticationProps(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
+        propses = props_set.getAuthenticationProps()
+        if len(propses) > 0:
+            child_element = ET.SubElement(element, "AUTHENTICATION-PROPSS")
+            for props in propses:
+                if isinstance(props, SecureCommunicationAuthenticationProps):
+                    self.writeSecureCommunicationAuthenticationProps(child_element, props)
+                else:
+                    self.notImplemented("Unsupported AuthenticationProps <%s>" % type(props))
+
+    def writeSecureCommunicationFreshnessProps(self, element: ET.Element, props: SecureCommunicationFreshnessProps):
+        child_element = ET.SubElement(element, "SECURE-COMMUNICATION-FRESHNESS-PROPS")
+        self.writeIdentifiable(child_element, props)
+        self.setChildElementOptionalLiteral(child_element, "FRESHNESS-VALUE-LENGTH", props.getFreshnessValueLength())
+        self.setChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-TX-LENGTH", props.getFreshnessValueTxLength())
+
+    def writeSecureCommunicationPropsSetFreshnessProps(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
+        propses = props_set.getFreshnessProps()
+        if len(propses) > 0:
+            child_element = ET.SubElement(element, "FRESHNESS-PROPSS")
+            for props in propses:
+                if isinstance(props, SecureCommunicationFreshnessProps):
+                    self.writeSecureCommunicationFreshnessProps(child_element, props)
+                else:
+                    self.notImplemented("Unsupported FreshnessProps <%s>" % type(props))
 
     def writeSecureCommunicationPropsSet(self, element: ET.Element, set: SecureCommunicationPropsSet):
         self.logger.debug("Write SecureCommunicationPropsSet %s" % set.getShortName())
         child_element = ET.SubElement(element, "SECURE-COMMUNICATION-PROPS-SET")
         self.writeIdentifiable(child_element, set)
+        self.writeSecureCommunicationPropsSetAuthenticationProps(child_element, set)
+        self.writeSecureCommunicationPropsSetFreshnessProps(child_element, set)
 
     def writeSoAdRoutingGroup(self, element: ET.Element, group: SoAdRoutingGroup):
-        self.logger.debug("Write SoAdRoutingGroup %s" % group.getShortName())
+        self.logger.debug("Write SoAdRoutingGroup <%s>" % group.getShortName())
         child_element = ET.SubElement(element, "SO-AD-ROUTING-GROUP")
         self.writeIdentifiable(child_element, group)
+        self.setChildElementOptionalLiteral(child_element, "EVENT-GROUP-CONTROL-TYPE", group.getEventGroupControlType())
+
+    def writeDoIpLogicAddress(self, element: ET.Element, address: DoIpLogicAddress):
+        if address is not None:
+            child_element = ET.SubElement(element, "DO-IP-LOGIC-ADDRESS")
+            self.writeIdentifiable(child_element, address)
+            self.setChildElementOptionalIntegerValue(child_element, "ADDRESS", address.getAddress())
+
+    def writeDoIpTpConfigDoIpLogicAddresses(self, element: ET.Element, config: DoIpTpConfig):
+        addresses = config.getDoIpLogicAddresses()
+        if len(addresses) > 0:
+            child_element = ET.SubElement(element, "DO-IP-LOGIC-ADDRESSS")
+            for address in addresses:
+                if isinstance(address, DoIpLogicAddress):
+                    self.writeDoIpLogicAddress(child_element, address)
+                else:
+                    self.notImplemented("Unsupported DoIpLogicAddress <%s>" % type(address))
+
+    def writeDoIpTpConnection(self, element: ET.Element, connection: DoIpTpConnection):
+        if connection is not None:
+            child_element = ET.SubElement(element, "DO-IP-TP-CONNECTION")
+            self.writeTpConnection(child_element, connection)
+            self.setChildElementOptionalRefType(child_element, "DO-IP-SOURCE-ADDRESS-REF", connection.getDoIpSourceAddressRef())
+            self.setChildElementOptionalRefType(child_element, "DO-IP-TARGET-ADDRESS-REF", connection.getDoIpTargetAddressRef())
+            self.setChildElementOptionalRefType(child_element, "TP-SDU-REF", connection.getTpSduRef())
+
+    def writeDoIpTpConfigTpConnections(self, element: ET.Element, config: DoIpTpConfig):
+        connections = config.getTpConnections()
+        if len(connections) > 0:
+            child_element = ET.SubElement(element, "TP-CONNECTIONS")
+            for address in connections:
+                if isinstance(address, DoIpTpConnection):
+                    self.writeDoIpTpConnection(child_element, address)
+                else:
+                    self.notImplemented("Unsupported TpConnection <%s>" % type(address))
 
     def writeDoIpTpConfig(self, element: ET.Element, config: DoIpTpConfig):
-        self.logger.debug("Write DoIpTpConfig %s" % config.getShortName())
+        self.logger.debug("Write DoIpTpConfig <%s>" % config.getShortName())
         child_element = ET.SubElement(element, "DO-IP-TP-CONFIG")
-        self.writeIdentifiable(child_element, config)
+        self.writeTpConfig(child_element, config)
+        self.writeDoIpTpConfigDoIpLogicAddresses(child_element, config)
+        self.writeDoIpTpConfigTpConnections(child_element, config)
+
+    def writeHwDescriptionEntityHwCategoryRefs(self, element: ET.Element, entity: HwDescriptionEntity):
+        refs = entity.getHwCategoryRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "HW-CATEGORY-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "HW-CATEGORY-REF", ref)
+
+    def writeHwDescriptionEntity(self, element: ET.Element, entity: HwDescriptionEntity):
+        self.writeARElement(element, entity)
+        self.writeHwDescriptionEntityHwCategoryRefs(element, entity)
+
+    def writeHwPinGroup(self, element: ET.SubElement, pin_group: HwPinGroup):
+        if pin_group is not None:
+            child_element = ET.SubElement(element, "HW-PIN-GROUP")
+            self.writeHwDescriptionEntity(child_element, pin_group)
+
+    def writeHwElementHwPinGroups(self, element: ET.Element, hw_element: HwElement):
+        pin_groups = hw_element.getHwPinGroups()
+        if len(pin_groups) > 0:
+            child_element = ET.SubElement(element, "HW-PIN-GROUPS")
+            for pin_group in pin_groups:
+                if isinstance(pin_group, HwPinGroup):
+                    self.writeHwPinGroup(child_element, pin_group)
+                else:
+                    self.notImplemented("Unsupported Hw Pin Group <%s>" % type(pin_group))
+
+    def writeHwElement(self, element: ET.Element, hw_element: HwElement):
+        if hw_element is not None:
+            self.logger.debug("Write HwElement <%s>" % hw_element.getShortName())
+            child_element = ET.SubElement(element, "HW-ELEMENT")
+            self.writeHwDescriptionEntity(child_element, hw_element)
+            self.writeHwElementHwPinGroups(child_element, hw_element)
+
+    def writeHwAttributeDef(self, element: ET.Element, attribute_def: HwAttributeDef):
+        if attribute_def is not None:
+            child_element = ET.SubElement(element, "HW-ATTRIBUTE-DEF")
+            self.writeIdentifiable(child_element, attribute_def)
+            self.setChildElementOptionalRefType(child_element, "UNIT-REF", attribute_def.getUnitRef())
+
+    def writeHwCategoryHwAttributeDef(self, element: ET.Element, hw_category: HwCategory):
+        attribute_defs = hw_category.getHwAttributeDefs()
+        if len(attribute_defs) > 0:
+            child_element = ET.SubElement(element, "HW-ATTRIBUTE-DEFS")
+            for attribute_def in attribute_defs:
+                if isinstance(attribute_def, HwAttributeDef):
+                    self.writeHwAttributeDef(child_element, attribute_def)
+                else:
+                    self.notImplemented("Unsupported Hw Attribute Defs <%s>" % type(attribute_def))
+
+    def writeHwCategory(self, element: ET.Element, hw_category: HwCategory):
+        self.logger.debug("write HwCategory <%s>" % hw_category.getShortName())
+        child_element = ET.SubElement(element, "HW-CATEGORY")
+        self.writeARElement(child_element, hw_category)
+        self.writeHwCategoryHwAttributeDef(child_element, hw_category)
+
+    def writeHwType(self, element: ET.Element, type: HwType):
+        self.logger.debug("Write HwType <%s>" % type.getShortName())
+        child_element = ET.SubElement(element, "HW-TYPE")
+        self.writeARElement(child_element, type)
 
     def writeLinCommunicationController(self, element: ET.Element, controller: LinCommunicationController):
         self.writeCommunicationController(element, controller)
         self.setChildElementOptionalLiteral(element, "PROTOCOL-VERSION", controller.getProtocolVersion())
 
     def writeLinMaster(self, element: ET.Element, controller: LinMaster):
-        self.logger.debug("Write LinMaster %s" % controller.getShortName())
+        self.logger.debug("Write LinMaster <%s>" % controller.getShortName())
         child_element = ET.SubElement(element, "LIN-MASTER")
         self.writeIdentifiable(child_element, controller)
         variants_tag = ET.SubElement(child_element, "LIN-MASTER-VARIANTS")
@@ -3732,17 +4850,19 @@ class ARXMLWriter(AbstractARXMLWriter):
         if filter is not None:
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalLiteral(child_element, "DATA-FILTER-TYPE", filter.getDataFilterType())
+            self.setChildElementOptionalIntegerValue(child_element, "MASK", filter.getMask())
+            self.setChildElementOptionalIntegerValue(child_element, "X", filter.getX())
 
-    def setTransmissionModeConditions(self, element: ET.Element, conditions: List[TransmissionModeCondition]):
+    def setTransmissionModeConditions(self, element: ET.Element, key: str, conditions: List[TransmissionModeCondition]):
         if len(conditions) > 0:
-            conditions_tag = ET.SubElement(element, "TRANSMISSION-MODE-CONDITIONS")
+            conditions_tag = ET.SubElement(element, key)
             for condition in conditions:
                 child_element = ET.SubElement(conditions_tag, "TRANSMISSION-MODE-CONDITION")
                 self.setDataFilter(child_element, "DATA-FILTER", condition.getDataFilter())
                 self.setChildElementOptionalRefType(child_element, "I-SIGNAL-IN-I-PDU-REF", condition.getISignalInIPduRef())
 
     def setTimeRangeType(self, element: ET.Element, key: str, time_range: TimeRangeType):
-         if time_range is not None:
+        if time_range is not None:
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalTimeValue(child_element, "VALUE", time_range.getValue())
 
@@ -3751,12 +4871,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalIntegerValue(child_element, "NUMBER-OF-REPETITIONS", timing.getNumberOfRepetitions())
             self.setTimeRangeType(child_element, "REPETITION-PERIOD", timing.getRepetitionPeriod())
-
-    def setTimeRangeType(self, element: ET.Element, key: str, time_range: TimeRangeType):
-        if time_range is not None:
-            child_element = ET.SubElement(element, key)
-            self.setChildElementOptionalTimeValue(child_element, "VALUE", time_range.getValue())
-    
+            
     def setCyclicTiming(self, element: ET.Element, key: str, timing: CyclicTiming):
         if timing is not None:
             child_element = ET.SubElement(element, key)
@@ -3770,10 +4885,11 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setCyclicTiming(child_element, "CYCLIC-TIMING", timing.getCyclicTiming())
             self.setEventControlledTiming(child_element, "EVENT-CONTROLLED-TIMING", timing.getEventControlledTiming())
 
-    def setTransmissionModeDeclaration(self, element: ET.Element, key: str, decl : TransmissionModeDeclaration):
+    def setTransmissionModeDeclaration(self, element: ET.Element, key: str, decl: TransmissionModeDeclaration):
         if decl is not None:
             child_element = ET.SubElement(element, key)
-            self.setTransmissionModeConditions(child_element, decl.getTransmissionModeConditions())
+            self.setTransmissionModeConditions(child_element, "TRANSMISSION-MODE-CONDITIONS", decl.getTransmissionModeConditions())
+            self.setTransmissionModeTiming(child_element, "TRANSMISSION-MODE-FALSE-TIMING", decl.getTransmissionModeFalseTiming())
             self.setTransmissionModeTiming(child_element, "TRANSMISSION-MODE-TRUE-TIMING", decl.getTransmissionModeTrueTiming())
 
     def setISignalIPduIPduTimingSpecification(self, element: ET.Element, timing: IPduTiming):
@@ -3783,14 +4899,152 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalTimeValue(child_element, "MINIMUM-DELAY", timing.getMinimumDelay())
             self.setTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION", timing.getTransmissionModeDeclaration())
 
-    def writeISignalIPdu(self, element: ET.Element, i_pdu: ISignalIPdu):
-        self.logger.debug("ISignalIPdu %s" % i_pdu.getShortName())
+    def writeISignalIPdu(self, element: ET.Element, ipdu: ISignalIPdu):
+        self.logger.debug("ISignalIPdu %s" % ipdu.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-I-PDU")
-        self.writeIdentifiable(child_element, i_pdu)
-        self.setChildElementOptionalNumericalValue(child_element, "LENGTH", i_pdu.getLength())
-        self.setISignalIPduIPduTimingSpecification(child_element, i_pdu.getIPduTimingSpecification())
-        self.writeISignalToPduMappings(child_element, i_pdu)
-        self.setChildElementOptionalLiteral(child_element, "UNUSED-BIT-PATTERN", i_pdu.getUnusedBitPattern())
+        self.writeIdentifiable(child_element, ipdu)
+        self.setChildElementOptionalNumericalValue(child_element, "LENGTH", ipdu.getLength())
+        self.setISignalIPduIPduTimingSpecification(child_element, ipdu.getIPduTimingSpecification())
+        self.writeISignalToPduMappings(child_element, ipdu)
+        self.setChildElementOptionalIntegerValue(child_element, "UNUSED-BIT-PATTERN", ipdu.getUnusedBitPattern())
+
+    def writeFlexrayFrame(self, element: ET.Element, frame: FlexrayFrame):
+        if frame is not None:
+            self.logger.debug("Write FlexrayFrame <%s>" % frame.getShortName())
+            child_element = ET.SubElement(element, "FLEXRAY-FRAME")
+            self.writeFrame(child_element, frame)
+
+    def writeFlexrayCommunicationController(self, element: ET.Element, controller: FlexrayCommunicationController):
+        if controller is not None:
+            self.logger.debug("Write FlexrayCommunicationController <%s>" % controller.getShortName())
+            controller_element = ET.SubElement(element, "FLEXRAY-COMMUNICATION-CONTROLLER")
+            self.writeIdentifiable(controller_element, controller)
+            variant_element = ET.SubElement(controller_element, "FLEXRAY-COMMUNICATION-CONTROLLER-VARIANTS")
+            child_element = ET.SubElement(variant_element, "FLEXRAY-COMMUNICATION-CONTROLLER-CONDITIONAL")
+            self.writeCommunicationController(controller_element, controller)
+            self.setChildElementOptionalIntegerValue(child_element, "ACCEPTED-STARTUP-RANGE", controller.getAcceptedStartupRange())
+            self.setChildElementOptionalBooleanValue(child_element, "ALLOW-HALT-DUE-TO-CLOCK", controller.getAllowHaltDueToClock())
+            self.setChildElementOptionalIntegerValue(child_element, "ALLOW-PASSIVE-TO-ACTIVE", controller.getAllowPassiveToActive())
+            self.setChildElementOptionalIntegerValue(child_element, "CLUSTER-DRIFT-DAMPING", controller.getClusterDriftDamping())
+            self.setChildElementOptionalIntegerValue(child_element, "DECODING-CORRECTION", controller.getDecodingCorrection())
+            self.setChildElementOptionalIntegerValue(child_element, "DELAY-COMPENSATION-A", controller.getDelayCompensationA())
+            self.setChildElementOptionalIntegerValue(child_element, "DELAY-COMPENSATION-B", controller.getDelayCompensationB())
+            self.setChildElementOptionalBooleanValue(child_element, "KEY-SLOT-ONLY-ENABLED", controller.getKeySlotOnlyEnabled())
+            self.setChildElementOptionalBooleanValue(child_element, "KEY-SLOT-USED-FOR-START-UP", controller.getKeySlotUsedForStartUp())
+            self.setChildElementOptionalBooleanValue(child_element, "KEY-SLOT-USED-FOR-SYNC", controller.getKeySlotUsedForSync())
+            self.setChildElementOptionalIntegerValue(child_element, "LATEST-TX", controller.getLatestTX())
+            self.setChildElementOptionalIntegerValue(child_element, "LISTEN-TIMEOUT", controller.getListenTimeout())
+            self.setChildElementOptionalIntegerValue(child_element, "MACRO-INITIAL-OFFSET-A", controller.getMacroInitialOffsetA())
+            self.setChildElementOptionalIntegerValue(child_element, "MACRO-INITIAL-OFFSET-B", controller.getMacroInitialOffsetB())
+            self.setChildElementOptionalIntegerValue(child_element, "MAXIMUM-DYNAMIC-PAYLOAD-LENGTH", controller.getMaximumDynamicPayloadLength())
+            self.setChildElementOptionalIntegerValue(child_element, "MICRO-INITIAL-OFFSET-A", controller.getMicroInitialOffsetA())
+            self.setChildElementOptionalIntegerValue(child_element, "MICRO-INITIAL-OFFSET-B", controller.getMicroInitialOffsetB())
+            self.setChildElementOptionalIntegerValue(child_element, "MICRO-PER-CYCLE", controller.getMicroPerCycle())
+            self.setChildElementOptionalTimeValue(child_element, "MICROTICK-DURATION", controller.getMicrotickDuration())
+            self.setChildElementOptionalIntegerValue(child_element, "OFFSET-CORRECTION-OUT", controller.getOffsetCorrectionOut())
+            self.setChildElementOptionalIntegerValue(child_element, "RATE-CORRECTION-OUT", controller.getRateCorrectionOut())
+            self.setChildElementOptionalIntegerValue(child_element, "SAMPLES-PER-MICROTICK", controller.getSamplesPerMicrotick())
+            self.setChildElementOptionalIntegerValue(child_element, "WAKE-UP-PATTERN", controller.getWakeUpPattern())
+
+    def writeDataTransformationTransformerChainRefs(self, element: ET.Element, dtf: DataTransformation):
+        refs = dtf.getTransformerChainRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "TRANSFORMER-CHAIN-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "TRANSFORMER-CHAIN-REF", ref)
+
+    def writeDataTransformation(self, element: ET.Element, dtf: DataTransformation):
+        if dtf is not None:
+            child_element = ET.SubElement(element, "DATA-TRANSFORMATION")
+            self.writeIdentifiable(child_element, dtf)
+            self.setChildElementOptionalBooleanValue(child_element, "EXECUTE-DESPITE-DATA-UNAVAILABILITY", dtf.getExecuteDespiteDataUnavailability())
+            self.writeDataTransformationTransformerChainRefs(child_element, dtf)
+
+    def writeDataTransformationSetDataTransformations(self, element: ET.Element, dtf_set: DataTransformationSet):
+        dtfs = dtf_set.getDataTransformations()
+        if len(dtfs) > 0:
+            child_element = ET.SubElement(element, "DATA-TRANSFORMATIONS")
+            for dtf in dtfs:
+                if isinstance(dtf, DataTransformation):
+                    self.writeDataTransformation(child_element, dtf)
+                else:
+                    self.notImplemented("Unsupported DataTransformation <%s>" % type(dtf))
+
+    def writeDataTransformationSetTransformationTechnologies(self, element: ET.Element, dtf_set: DataTransformationSet):
+        techs = dtf_set.getTransformationTechnologies()
+        if len(techs) > 0:
+            child_element = ET.SubElement(element, "TRANSFORMATION-TECHNOLOGYS")
+            for tech in techs:
+                if isinstance(tech, TransformationTechnology):
+                    self.writeTransformationTechnology(child_element, tech)
+                else:
+                    self.notImplemented("Unsupported TransformationTechnology <%s>" % type(tech))
+
+    def writeBufferPropertiesBufferComputation(self, element: ET.Element, properties: BufferProperties):
+        computation = properties.getBufferComputation()
+        if computation is not None:
+            self.setCompuScale(element, "BUFFER-COMPUTATION", computation)
+
+    def setBufferProperties(self, element: ET.Element, key: str, properties: BufferProperties):
+        if properties is not None:
+            child_element = ET.SubElement(element, key)
+            self.writeBufferPropertiesBufferComputation(child_element, properties)
+            self.setChildElementOptionalIntegerValue(child_element, "HEADER-LENGTH", properties.getHeaderLength())
+            self.setChildElementOptionalBooleanValue(child_element, "IN-PLACE", properties.getInPlace())
+
+    def writeDescribable(self, element: ET.Element, desc: Describable):
+        self.writeARObjectAttributes(element, desc)
+    
+    def writeTransformationDescription(self, element: ET.Element, desc: TransformationDescription):
+        self.writeDescribable(element, desc)
+    
+    def writeEndToEndTransformationDescription(self, element: ET.Element, desc: EndToEndTransformationDescription):
+        if desc is not None:
+            child_element = ET.SubElement(element, "END-TO-END-TRANSFORMATION-DESCRIPTION")
+            self.writeTransformationDescription(child_element, desc)
+            self.setChildElementOptionalLiteral(child_element, "DATA-ID-MODE", desc.getDataIdMode())
+            self.setChildElementOptionalPositiveInteger(child_element, "MAX-DELTA-COUNTER", desc.getMaxDeltaCounter())
+            self.setChildElementOptionalPositiveInteger(child_element, "MAX-ERROR-STATE-INIT", desc.getMaxErrorStateInit())
+            self.setChildElementOptionalPositiveInteger(child_element, "MAX-ERROR-STATE-INVALID", desc.getMaxErrorStateInvalid())
+            self.setChildElementOptionalPositiveInteger(child_element, "MAX-ERROR-STATE-VALID", desc.getMaxErrorStateValid())
+            self.setChildElementOptionalPositiveInteger(child_element, "MAX-NO-NEW-OR-REPEATED-DATA", desc.getMaxNoNewOrRepeatedData())
+            self.setChildElementOptionalPositiveInteger(child_element, "MIN-OK-STATE-INIT", desc.getMinOkStateInit())
+            self.setChildElementOptionalPositiveInteger(child_element, "MIN-OK-STATE-INVALID", desc.getMinOkStateInvalid())
+            self.setChildElementOptionalPositiveInteger(child_element, "MIN-OK-STATE-VALID", desc.getMinOkStateValid())
+            self.setChildElementOptionalLiteral(child_element, "PROFILE-BEHAVIOR", desc.getProfileBehavior())
+            self.setChildElementOptionalLiteral(child_element, "PROFILE-NAME", desc.getProfileName())
+            self.setChildElementOptionalPositiveInteger(child_element, "SYNC-COUNTER-INIT", desc.getSyncCounterInit())
+            self.setChildElementOptionalPositiveInteger(child_element, "UPPER-HEADER-BITS-TO-SHIFT", desc.getUpperHeaderBitsToShift())
+            self.setChildElementOptionalPositiveInteger(child_element, "WINDOW-SIZE-INIT", desc.getWindowSizeInit())
+            self.setChildElementOptionalPositiveInteger(child_element, "WINDOW-SIZE-INVALID", desc.getWindowSizeInvalid())
+            self.setChildElementOptionalPositiveInteger(child_element, "WINDOW-SIZE-VALID", desc.getWindowSizeValid())
+
+    def writeTransformationTechnologyTransformationDescriptions(self, element: ET.Element, tech: TransformationTechnology):
+        desc = tech.getTransformationDescription()
+        if desc is not None:
+            child_element = ET.SubElement(element, "TRANSFORMATION-DESCRIPTIONS")
+            if isinstance(desc, EndToEndTransformationDescription):
+                self.writeEndToEndTransformationDescription(child_element, desc)
+            else:
+                self.notImplemented("Unsupported TransformationDescription <%s>" % type(desc))
+
+    def writeTransformationTechnology(self, element: ET.Element, tech: TransformationTechnology):
+        if tech is not None:
+            child_element = ET.SubElement(element, "TRANSFORMATION-TECHNOLOGY")
+            self.writeIdentifiable(child_element, tech)
+            self.setBufferProperties(child_element, "BUFFER-PROPERTIES", tech.getBufferProperties())
+            self.setChildElementOptionalBooleanValue(child_element, "NEEDS-ORIGINAL-DATA", tech.getNeedsOriginalData())
+            self.setChildElementOptionalLiteral(child_element, "PROTOCOL", tech.getProtocol())
+            self.writeTransformationTechnologyTransformationDescriptions(child_element, tech)
+            self.setChildElementOptionalLiteral(child_element, "TRANSFORMER-CLASS", tech.getTransformerClass())
+            self.setChildElementOptionalLiteral(child_element, "VERSION", tech.getVersion())
+
+    def writeDataTransformationSet(self, element: ET.Element, dtf_set: DataTransformationSet):
+        if dtf_set is not None:
+            child_element = ET.SubElement(element, "DATA-TRANSFORMATION-SET")
+            self.writeIdentifiable(child_element, dtf_set)
+            self.writeDataTransformationSetDataTransformations(child_element, dtf_set)
+            self.writeDataTransformationSetTransformationTechnologies(child_element, dtf_set)
 
     def writeARPackageElement(self, element: ET.Element, ar_element: ARElement):
         if isinstance(ar_element, ComplexDeviceDriverSwComponentType):
@@ -3921,9 +5175,25 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeSoAdRoutingGroup(element, ar_element)
         elif isinstance(ar_element, DoIpTpConfig):
             self.writeDoIpTpConfig(element, ar_element)
+        elif isinstance(ar_element, HwElement):
+            self.writeHwElement(element, ar_element)
+        elif isinstance(ar_element, HwCategory):
+            self.writeHwCategory(element, ar_element)
+        elif isinstance(ar_element, HwType):
+            self.writeHwType(element, ar_element)
+        elif isinstance(ar_element, DataTransformationSet):
+            self.writeDataTransformationSet(element, ar_element)
+        elif isinstance(ar_element, FlexrayFrame):
+            self.writeFlexrayFrame(element, ar_element)
+        elif isinstance(ar_element, ISignalGroup):
+            self.writeISignalGroup(element, ar_element)
+        elif isinstance(ar_element, SystemSignalGroup):
+            self.writeSystemSignalGroup(element, ar_element)
+        elif isinstance(ar_element, FlexrayCluster):
+            self.writeFlexrayCluster(element, ar_element)
         else:
             self.notImplemented("Unsupported Elements of ARPackage <%s>" % type(ar_element))
-        
+
     def writeReferenceBases(self, element: ET.Element, bases: List[ReferenceBase]):
         self.logger.debug("Write ReferenceBases")
         if len(bases) > 0:
@@ -3933,40 +5203,46 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", base.getShortLabel())
                 self.setChildElementOptionalBooleanValue(child_element, "IS-DEFAULT", base.getIsDefault())
                 self.setChildElementOptionalBooleanValue(child_element, "IS-GLOBAL", base.getIsDefault())
-                self.setChildElementOptionalBooleanValue(child_element,  "BASE-IS-THIS-PACKAGE", base.getBaseIsThisPackage())
+                self.setChildElementOptionalBooleanValue(child_element, "BASE-IS-THIS-PACKAGE", base.getBaseIsThisPackage())
                 self.setChildElementOptionalRefType(child_element, "PACKAGE-REF", base.getPackageRef())
-        
-    def writeARPackages(self, element: ET.Element, pkgs: List[ARPackage]):
-        if len(pkgs) > 0:
-            pkgs_tag = ET.SubElement(element, "AR-PACKAGES")
 
-            for pkg in pkgs:
-                pkg_tag  = ET.SubElement(pkgs_tag, "AR-PACKAGE")
-            
-                self.writeIdentifiable(pkg_tag, pkg)
-                self.logger.debug("writeARPackage %s" % pkg.full_name)
+    def writeARPackage(self, element: ET.Element, pkg: ARPackage):
+        self.logger.debug("Write ARPackage %s" % pkg.getFullName())
+        child_element = ET.SubElement(element, "AR-PACKAGE")
 
-                self.writeReferenceBases(pkg_tag, pkg.getReferenceBases())
+        self.writeIdentifiable(child_element, pkg)
+        self.writeReferenceBases(child_element, pkg.getReferenceBases())
+        self.writeARPackageElements(child_element, pkg)
+        self.writeARPackages(child_element, pkg.getARPackages())
 
-                if pkg.getTotalElement() > 0:
-                    elements_tag = ET.SubElement(pkg_tag, "ELEMENTS")
+    def writeARPackageElements(self, element: ET.Element, pkg: ARPackage):
+        if pkg.getTotalElement() > 0:
+            elements_tag = ET.SubElement(element, "ELEMENTS")
 
-                    for ar_element in pkg.getElements():
-                        if not isinstance(ar_element, ARPackage):
-                            self.writeARPackageElement(elements_tag, ar_element)
+            for ar_element in pkg.getElements():
+                if not isinstance(ar_element, ARPackage):
+                    self.writeARPackageElement(elements_tag, ar_element)
 
-                self.writeARPackages(pkg_tag, pkg.getARPackages())
-                
+    def writeARPackages(self, element: ET.Element, pkgs: List[ARPackage]):
+        if len(pkgs) > 0:
+            child_element = ET.SubElement(element, "AR-PACKAGES")
+            for pkg in pkgs:
+                if isinstance(pkg, ARPackage):
+                    self.writeARPackage(child_element, pkg)
+                else:
+                    self.notImplemented("Unsupported ARPackage <%s>" % type(pkg))
 
     def save(self, filename, document: AUTOSAR):
-        self.logger.info("Save %s ..." % filename)
+        self.logger.info("Saving %s ..." % filename)
 
         root = ET.Element("AUTOSAR", self.nsmap)
         root.attrib["xmlns:xsi"] = "http://www.w3.org/2001/XMLSchema-instance"
-        root.attrib["xsi:schemaLocation"] = document.schema_location
+        if document.schema_location is not None:
+            root.attrib["xsi:schemaLocation"] = document.schema_location
+        else:
+            root.attrib["xsi:schemaLocation"] = "http://autosar.org/schema/r4.0 AUTOSAR_4-0-3.xsd"
         
         self.setAdminData(root, document.getAdminData())
         self.writeARPackages(root, document.getARPackages())
 
         self.saveToFile(filename, root)
-