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

armodel/writer/arxml_writer.py

@@ -1,13 +1,11 @@
 import xml.etree.cElementTree as ET
 from typing import List
 
-from armodel.models.M2.AUTOSARTemplates.SystemTemplate.ECUResourceMapping import ECUMapping
-from armodel.models.M2.AUTOSARTemplates.SystemTemplate.SWmapping import SwcToImplMapping
-
-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,87 +17,193 @@ from ..models.M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps, SwP
 from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayout, SwRecordLayoutGroup, SwRecordLayoutV
 from ..models.M2.MSR.DataDictionary.ServiceProcessTask import SwServiceArg
 from ..models.M2.MSR.Documentation.Annotation import Annotation
+from ..models.M2.MSR.Documentation.BlockElements.Figure import Graphic, MlFigure
+from ..models.M2.MSR.Documentation.TextModel.BlockElements.PaginationAndView import DocumentViewSelectable, Paginateable
 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.BlockElements.ListElements import ARList
 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, BswAsynchronousServerCallPoint, BswBackgroundEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswDataReceivedEvent, BswModuleCallPoint
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import 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, BswInternalTriggeringPoint
 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 BswBackgroundEvent, BswCalledEntity, BswDataReceivedEvent, BswEvent, BswExternalTriggerOccurredEvent, 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.BswModuleTemplate.BswInterfaces import BswModuleClientServerEntry, BswModuleEntry
+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 DiagnosticCapabilityElement, DtcStatusChangeNotificationNeeds
+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.StandardizationTemplate.Keyword import KeywordSet, Keyword
+from ..models.M2.AUTOSARTemplates.CommonStructure.StandardizationTemplate.BlueprintDedicated.PortPrototypeBlueprint import PortPrototypeBlueprint
+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.ElementCollection import Collection
 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, BackgroundEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, ModeSwitchedAckEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
+from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfo, LifeCycleInfoSet, LifeCyclePeriod
+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 ClientServerInterfaceMapping, ClientServerOperationMapping
+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, ModeSwitchedAckRequest, 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 DynamicPart, DynamicPartAlternative, FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalToIPduMapping, ISignalTriggering, MultiplexedIPdu, MultiplexedPart, Pdu, PduTriggering, SecureCommunicationAuthenticationProps, SecureCommunicationFreshnessProps, SecureCommunicationProps, SecureCommunicationPropsSet, SecuredIPdu, SegmentPosition, StaticPart, 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, NmEcu, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmEcu, UdpNmNode
-from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpAddress, CanTpChannel, CanTpConfig, CanTpConnection, CanTpEcu, CanTpNode, DoIpLogicAddress, DoIpTpConfig, DoIpTpConnection, LinTpConfig, LinTpConnection, LinTpNode, TpAddress, TpConfig, TpConnection
+from ..models.M2.AUTOSARTemplates.SystemTemplate.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)
@@ -113,7 +217,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):
@@ -217,17 +321,17 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setAnnotations(element, identifiable.getAnnotations())
         self.setMultiLanguageOverviewParagraph(element, "DESC", identifiable.getDesc())
         self.setChildElementOptionalLiteral(element, "CATEGORY", identifiable.getCategory())
-        self.setDocumentationBlock(element, "INTRODUCTION", identifiable.getIntroduction())
+        self.writeDocumentationBlock(element, "INTRODUCTION", identifiable.getIntroduction())
         self.setAdminData(element, identifiable.getAdminData())
 
     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.writeARObjectAttributes(child_element, acknowledge)
-            if acknowledge.timeout != None:
+            if acknowledge.timeout is not None:
                 self.setChildElementOptionalFloatValue(child_element, "TIMEOUT", acknowledge.timeout)
 
     def setSenderComSpec(self, element: ET.Element, com_spec: SenderComSpec):
@@ -241,18 +345,18 @@ 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.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.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")
@@ -283,14 +387,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")
@@ -335,28 +439,21 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
         if value_spec is not None:
             self.writeARObjectAttributes(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.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()
@@ -364,18 +461,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)
@@ -385,17 +482,17 @@ 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))
 
@@ -471,7 +568,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())
@@ -487,21 +584,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):
@@ -535,10 +635,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):
@@ -546,17 +643,19 @@ 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")
@@ -592,27 +691,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()
@@ -626,8 +721,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):
@@ -649,29 +744,59 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeLParagraphs(child_element, paragraph)
         return paragraphs
     
-    def setListElement(self, element: ET.Element, key: str, list: ListElement):
+    def setListElement(self, element: ET.Element, key: str, list: ARList):
         if list is not None:
             child_element = ET.SubElement(element, key)
             type = list.getType()
             if type is not None:
                 child_element.attrib['TYPE'] = type
             for item in list.getItems():
-                self.setDocumentationBlock(child_element, "ITEM", item)
+                self.writeDocumentationBlock(child_element, "ITEM", item)
 
-    def setDocumentationBlock(self, element: ET.Element, key: str, block: DocumentationBlock):
+    def setGraphic(self, element: ET.Element, key: str, graphic: Graphic):
+        if graphic is not None:
+            child_element = ET.SubElement(element, key)
+            if graphic.getFilename() is not None:
+                child_element.attrib["FILENAME"] = graphic.getFilename()
+    
+    def writeMlFigureLGraphics(self, element: ET.Element, figure: MlFigure):
+        graphics = figure.getLGraphics()
+        for graphic in graphics:
+            child_element = ET.SubElement(element, "L-GRAPHIC")
+            if graphic.getL() is not None:
+                child_element.attrib["L"] = graphic.getL()
+            self.setGraphic(child_element, "GRAPHIC", graphic.getGraphic())
+
+    def writeDocumentViewSelectable(self, element: ET.Element, selectable: DocumentViewSelectable):
+        self.writeARObjectAttributes(element, selectable)
+
+    def writePaginateable(self, element: ET.Element, paginateable: Paginateable):
+        self.writeDocumentViewSelectable(element, paginateable)
+    
+    def writeMlFigure(self, element: ET.Element, figure: MlFigure):
+        self.writePaginateable(element, figure)
+        self.writeMlFigureLGraphics(element, figure)
+
+    def setMlFigures(self, element: ET.Element, key: str, figures: List[MlFigure]):
+        for figure in figures:
+            child_element = ET.SubElement(element, key)
+            self.writeMlFigure(child_element, figure)
+
+    def writeDocumentationBlock(self, element: ET.Element, key: str, block: DocumentationBlock):
         if block is not None:
             child_element = ET.SubElement(element, key)
             self.writeARObjectAttributes(child_element, block)
             self.setMultiLanguageParagraphs(child_element, "P", block.getPs())
             for list in block.getLists():
                 self.setListElement(child_element, "LIST", list)
+            self.setMlFigures(child_element, "FIGURE", block.getFigures())
 
     def writeGeneralAnnotation(self, element: ET.Element, annotation: Annotation):
         self.setMultiLongName(element, "LABEL", annotation.getLabel())
         self.setChildElementOptionalLiteral(element, "ANNOTATION-ORIGIN", annotation.getAnnotationOrigin())
-        self.setDocumentationBlock(element, "ANNOTATION-TEXT", annotation.getAnnotationText())
+        self.writeDocumentationBlock(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:
@@ -683,7 +808,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         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())
 
@@ -703,7 +828,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()
@@ -727,11 +852,11 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeARObjectAttributes(conditional_tag, props.conditional)
             self.setAnnotations(conditional_tag, props.getAnnotations())
             self.setChildElementOptionalRefType(conditional_tag, "BASE-TYPE-REF", props.getBaseTypeRef())
+            self.setChildElementOptionalRefType(conditional_tag, "SW-ADDR-METHOD-REF", props.getSwAddrMethodRef())
+            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.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())
@@ -757,29 +882,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():
@@ -840,18 +968,22 @@ 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.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)
+                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:
@@ -860,7 +992,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             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.writeARObjectAttributes(child_element, compu)
             self.setCompuScales(child_element, compu.getCompuContent())
@@ -874,13 +1006,14 @@ 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.writeARObjectAttributes(child_element, spec)
         self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", spec.getShortLabel())
@@ -889,15 +1022,15 @@ class ARXMLWriter(AbstractARXMLWriter):
             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))
 
@@ -941,7 +1074,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())
@@ -957,7 +1090,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         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):
@@ -1037,7 +1170,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "BACKGROUND-EVENT")
             self.setRTEEvent(child_element, event)
 
-    def writeRTEEvents(self, element: ET.Element, parent: SwcInternalBehavior):
+    def writeSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
         events = parent.getRteEvents()
         if len(events) > 0:
             child_element = ET.SubElement(element, "EVENTS")
@@ -1079,11 +1212,20 @@ 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:
@@ -1091,9 +1233,9 @@ class ARXMLWriter(AbstractARXMLWriter):
             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):
@@ -1119,42 +1261,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")
@@ -1182,7 +1324,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")
@@ -1192,44 +1334,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")
@@ -1245,7 +1424,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")
@@ -1257,23 +1436,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")
@@ -1291,9 +1470,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")
@@ -1301,9 +1480,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")
@@ -1313,21 +1492,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:
@@ -1336,7 +1514,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")
@@ -1361,7 +1539,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)
@@ -1387,7 +1565,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()
@@ -1397,9 +1575,9 @@ 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):
+    def writeNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
         child_element = ET.SubElement(element, "NV-BLOCK-NEEDS")
         self.logger.debug("write NvBlockNeeds %s" % needs.getShortName())
         self.writeIdentifiable(child_element, needs)
@@ -1423,23 +1601,26 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalPositiveInteger(child_element, "WRITING-FREQUENCY", needs.getWritingFrequency())
         self.setChildElementOptionalLiteral(child_element, "WRITING-PRIORITY", needs.getWritingPriority())
 
-    def setDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
+    def writeDiagnosticCapabilityElement(self, element: ET.Element, needs: DiagnosticCapabilityElement):
+        self.writeIdentifiable(element, needs)
+
+    def writeDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
         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()) 
-    
-    def setDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
+        self.writeDiagnosticCapabilityElement(child_element, needs)
+        self.setChildElementOptionalLiteral(child_element, "SERVICE-REQUEST-CALLBACK-TYPE", needs.getServiceRequestCallbackType())
+
+    def writeDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-ROUTINE-NEEDS")
         self.logger.debug("write DiagnosticRoutineNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeDiagnosticCapabilityElement(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DIAG-ROUTINE-TYPE", needs.getDiagRoutineType())
         self.setChildElementOptionalIntegerValue(child_element, "RID-NUMBER", needs.getRidNumber())
 
-    def setDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
+    def writeDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-VALUE-NEEDS")
         self.logger.debug("write DiagnosticValueNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeDiagnosticCapabilityElement(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "DATA-LENGTH", needs.getDataLength())
         self.setChildElementOptionalLiteral(child_element, "DIAGNOSTIC-VALUE-ACCESS", needs.getDiagnosticValueAccess())
         self.setChildElementOptionalIntegerValue(child_element, "DID-NUMBER", needs.getDidNumber())
@@ -1448,8 +1629,8 @@ 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)
-        
+        self.writeDiagnosticCapabilityElement(child_element, algorithm)
+
     def writeDiagEventDebounceAlgorithm(self, element: ET.Element, needs: DiagnosticEventNeeds):
         algorithm = needs.getDiagEventDebounceAlgorithm()
         if algorithm is not None:
@@ -1459,54 +1640,63 @@ class ARXMLWriter(AbstractARXMLWriter):
             else:
                 self.notImplemented("Unsupported DiagEventDebounceAlgorithm <%s>" % type(algorithm))
 
-    def setDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
+    def writeDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
+        # self.logger.debug("Write DiagnosticEventNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "DIAGNOSTIC-EVENT-NEEDS")
-        self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeDiagnosticCapabilityElement(child_element, needs)
         self.writeDiagEventDebounceAlgorithm(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DTC-KIND", needs.getDtcKind())
         self.setChildElementOptionalIntegerValue(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
 
-    def setDiagnosticEventInfoNeeds(self, element: ET.Element, needs: DiagnosticEventInfoNeeds):
+    def writeDiagnosticEventInfoNeeds(self, element: ET.Element, needs: DiagnosticEventInfoNeeds):
+        # self.logger.debug("Write DiagnosticEventNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "DIAGNOSTIC-EVENT-INFO-NEEDS")
-        self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeDiagnosticCapabilityElement(child_element, needs)
+        self.setChildElementOptionalLiteral(child_element, "DTC-KIND", needs.getDtcKind())
         self.setChildElementOptionalPositiveInteger(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
-    
-    def setCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
+
+    def writeCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
+        # self.logger.debug("Write CryptoServiceNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "CRYPTO-SERVICE-NEEDS")
-        self.logger.debug("write CryptoServiceNeeds %s" % needs.getShortName())
         self.writeIdentifiable(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "MAXIMUM-KEY-LENGTH", needs.getMaximumKeyLength())
 
-    def setEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
+    def writeEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
+        # self.logger.debug("write EcuStateMgrUserNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "ECU-STATE-MGR-USER-NEEDS")
-        self.logger.debug("write EcuStateMgrUserNeeds %s" % needs.getShortName())
         self.writeIdentifiable(child_element, needs)
 
+    def writeDtcStatusChangeNotificationNeeds(self, element: ET.Element, needs: DtcStatusChangeNotificationNeeds):
+        # self.logger.debug("Write DtcStatusChangeNotificationNeeds %s" % needs.getShortName())
+        child_element = ET.SubElement(element, "DTC-STATUS-CHANGE-NOTIFICATION-NEEDS")
+        self.writeDiagnosticCapabilityElement(child_element, needs)
+        self.setChildElementOptionalLiteral(child_element, "DTC-FORMAT-TYPE", needs.getDtcFormatType())
+
     def writeSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         needs = parent.getServiceNeeds()
         if len(needs) > 0:
             child_element = ET.SubElement(element, "SERVICE-NEEDS")
             for need in needs:
                 if isinstance(need, NvBlockNeeds):
-                    self.setNvBlockNeeds(child_element, need)
+                    self.writeNvBlockNeeds(child_element, need)
                 elif isinstance(need, DiagnosticCommunicationManagerNeeds):
-                    self.setDiagnosticCommunicationManagerNeeds(child_element, need)
+                    self.writeDiagnosticCommunicationManagerNeeds(child_element, need)
                 elif isinstance(need, DiagnosticRoutineNeeds):
-                    self.setDiagnosticRoutineNeeds(child_element, need)
+                    self.writeDiagnosticRoutineNeeds(child_element, need)
                 elif isinstance(need, DiagnosticValueNeeds):
-                    self.setDiagnosticValueNeeds(child_element, need)
+                    self.writeDiagnosticValueNeeds(child_element, need)
                 elif isinstance(need, DiagnosticEventNeeds):
-                    self.setDiagnosticEventNeeds(child_element, need)
+                    self.writeDiagnosticEventNeeds(child_element, need)
                 elif isinstance(need, DiagnosticEventInfoNeeds):
-                    self.setDiagnosticEventInfoNeeds(child_element, need)
+                    self.writeDiagnosticEventInfoNeeds(child_element, need)
                 elif isinstance(need, CryptoServiceNeeds):
-                    self.setCryptoServiceNeeds(child_element, need)
+                    self.writeCryptoServiceNeeds(child_element, need)
                 elif isinstance(need, EcuStateMgrUserNeeds):
-                    self.setEcuStateMgrUserNeeds(child_element, need)
+                    self.writeEcuStateMgrUserNeeds(child_element, need)
+                elif isinstance(need, DtcStatusChangeNotificationNeeds):
+                    self.writeDtcStatusChangeNotificationNeeds(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")
@@ -1523,7 +1713,7 @@ 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:
@@ -1537,23 +1727,43 @@ class ARXMLWriter(AbstractARXMLWriter):
                     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):
@@ -1562,7 +1772,7 @@ 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)
@@ -1584,8 +1794,8 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalLiteral(artifact_desc_tag, "SHORT-LABEL", artifact_desc.short_label)
                 self.setChildElementOptionalLiteral(artifact_desc_tag, "CATEGORY", artifact_desc.category)
 
-    def setCode(self, element: ET.SubElement, code_desc: Code):
-        self.logger.debug("setCode %s" % code_desc.getShortName())
+    def writeCode(self, element: ET.SubElement, code_desc: Code):
+        # self.logger.debug("Write Code %s" % code_desc.getShortName())
         child_element = ET.SubElement(element, "CODE")
         self.writeIdentifiable(child_element, code_desc)
         self.writeArtifactDescriptor(child_element, code_desc)
@@ -1596,9 +1806,9 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "CODE-DESCRIPTORS")
             for desc in descs:
                 if isinstance(desc, Code):
-                    self.setCode(child_element, desc)
+                    self.writeCode(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:
@@ -1663,7 +1873,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")
@@ -1673,24 +1883,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")
@@ -1698,22 +1912,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()
@@ -1721,7 +1953,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())
@@ -1729,15 +1961,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):
@@ -1748,7 +1979,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()
@@ -1767,25 +1998,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:
+                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:
-                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 writeCanEnterExclusiveAreaRefs(self, element: ET.Element, entity: ExecutableEntity):
         refs = entity.getCanEnterExclusiveAreaRefs()
@@ -1794,13 +2038,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")
@@ -1808,48 +2052,113 @@ 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 writeBswModuleEntityActivationPointRefs(self, element: ET.Element, entity: BswModuleEntity):
+        refs = entity.getActivationPointRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "ACTIVATION-POINTS")
+            for ref in refs:
+                cond_tag = ET.SubElement(child_element, "BSW-INTERNAL-TRIGGERING-POINT-REF-CONDITIONAL")
+                self.setChildElementOptionalRefType(cond_tag, "BSW-INTERNAL-TRIGGERING-POINT-REF", ref)
+
+    def writeBswModuleCallPoint(self, element: ET.Element, point: BswModuleCallPoint):
+        self.writeReferrable(element, point)
+
+    def writeBswAsynchronousServerCallPoint(self, element: ET.Element, point: BswAsynchronousServerCallPoint):
+        child_element = ET.SubElement(element, "BSW-ASYNCHRONOUS-SERVER-CALL-POINT")
+        self.writeBswModuleCallPoint(child_element, point)
+        self.setChildElementOptionalRefType(child_element, "CALLED-ENTRY-REF", point.getCalledEntryRef())
+
+    def writeBswModuleEntityCallPoints(self, element: ET.Element, entity: BswModuleEntity):
+        points = entity.getCallPoints()
+        if len(points) > 0:
+            child_element = ET.SubElement(element, "CALL-POINTS")
+            for point in points:
+                if isinstance(point, BswAsynchronousServerCallPoint):
+                    self.writeBswAsynchronousServerCallPoint(child_element, point)
+                else:
+                    self.notImplemented("Unsupported Call Point <%s>" % type(point))
+
+    def writeBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
+        self.writeExecutableEntity(element, entity)
+        self.writeBswModuleEntityActivationPointRefs(element, entity)
+        self.writeBswModuleEntityCallPoints(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()    
+    def writeBswInternalBehaviorEntities(self, element: ET.Element, parent: BswInternalBehavior):
+        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 writeBswScheduleEvent(self, element: ET.Element, event: BswScheduleEvent):
-        self.setBswEvent(element, event)
+        self.writeBswEvent(element, event)
 
     def writeBswTimingEvent(self, element: ET.Element, event: BswTimingEvent):
         self.logger.debug("Write BswTimingEvent <%s>" % event.getShortName())
@@ -1862,20 +2171,33 @@ class ARXMLWriter(AbstractARXMLWriter):
         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())
+        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())
+        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 writeBswInternalBehaviorBswEvents(self, element: ET.Element, parent: BswInternalBehavior):
+    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 writeBswInternalBehaviorEvents(self, element: ET.Element, parent: BswInternalBehavior):
         events = parent.getBswEvents()
         if len(events) > 0:
             child_element = ET.SubElement(element, "EVENTS")
@@ -1884,12 +2206,16 @@ class ARXMLWriter(AbstractARXMLWriter):
                     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")
@@ -1904,52 +2230,158 @@ 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 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 writeBswInternalTriggeringPoint(self, element: ET.Element, point: BswInternalTriggeringPoint):
+        child_element = ET.SubElement(element, "BSW-INTERNAL-TRIGGERING-POINT")
+        self.writeIdentifiable(child_element, point)
 
-    def setBswInternalBehavior(self, element: ET.Element, behavior: BswInternalBehavior):
+    def writeBswInternalBehaviorInternalTriggeringPoints(self, element: ET.Element, behavior: BswInternalBehavior):
+        points = behavior.getInternalTriggeringPoints()
+        if len(points) > 0:
+            child_element = ET.SubElement(element, "INTERNAL-TRIGGERING-POINTS")
+            for point in points:
+                if isinstance(point, BswInternalTriggeringPoint):
+                    self.writeBswInternalTriggeringPoint(child_element, point)
+                else:
+                    self.notImplemented("Unsupported Internal Triggering Points <%s>" % type(point))
+
+    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.writeBswInternalBehaviorInternalTriggeringPoints(child_element, behavior)
+        self.writeBswInternalBehaviorEntities(child_element, behavior)
+        self.writeBswInternalBehaviorEvents(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.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._raiseError("Unsupported BswInternalBehavior <%s>" % type(behavior))
+                    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 writeBswModuleClientServerEntry(self, element: ET.Element, entry: BswModuleClientServerEntry):
+        if entry is not None:
+            child_element = ET.SubElement(element, "BSW-MODULE-CLIENT-SERVER-ENTRY")
+            self.writeReferrable(child_element, entry)
+            self.setChildElementOptionalRefType(child_element, "ENCAPSULATED-ENTRY-REF", entry.getEncapsulatedEntryRef())
+            self.setChildElementOptionalBooleanValue(child_element, "IS-REENTRANT", entry.getIsReentrant())
+            self.setChildElementOptionalBooleanValue(child_element, "IS-SYNCHRONOUS", entry.getIsSynchronous())
+
+    def writeBswModuleDescriptionProvidedClientServerEntries(self, element: ET.Element, desc: BswModuleDescription):
+        entries = desc.getProvidedClientServerEntries()
+        if len(entries) > 0:
+            child_element = ET.SubElement(element, "PROVIDED-CLIENT-SERVER-ENTRYS")
+            for entry in entries:
+                if isinstance(entry, BswModuleClientServerEntry):
+                    self.writeBswModuleClientServerEntry(child_element, entry)
+                else:
+                    self.notImplemented("Unsupported Provided Client Server Entry <%s>" % type(entry))
+
+    def writeBswModuleDescriptionRequiredClientServerEntries(self, element: ET.Element, desc: BswModuleDescription):
+        entries = desc.getRequiredClientServerEntries()
+        if len(entries) > 0:
+            child_element = ET.SubElement(element, "REQUIRED-CLIENT-SERVER-ENTRYS")
+            for entry in entries:
+                if isinstance(entry, BswModuleClientServerEntry):
+                    self.writeBswModuleClientServerEntry(child_element, entry)
+                else:
+                    self.notImplemented("Unsupported Provided Client Server Entry <%s>" % type(entry))
 
     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.writeBswModuleDescriptionProvidedClientServerEntries(child_element, desc)
+        self.writeBswModuleDescriptionRequiredClientServerEntries(child_element, desc)
+        self.writeBswModuleDescriptionProvidedDatas(child_element, desc)
+        self.writeBswModuleDescriptionRequiredDatas(child_element, desc)
+        self.writeBswModuleDescriptionInternalBehaviors(child_element, desc)
+        self.writeBswModuleDescriptionReleasedTriggers(child_element, desc)
 
     def setSwServiceArg(self, element: ET.Element, arg: SwServiceArg):
         self.logger.debug("Set SwServiceArg <%s>" % arg.getShortName())
@@ -1991,7 +2423,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())
@@ -2006,8 +2438,8 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(element, "SHORT-LABEL", engineering_obj.short_label)
         self.setChildElementOptionalLiteral(element, "CATEGORY", engineering_obj.category)
         
-    def setAutosarEngineeringObject(self, element: ET.Element, obj: AutosarEngineeringObject):
-        self.logger.debug("readArtifactDescriptor %s", obj.short_label)
+    def writeAutosarEngineeringObject(self, element: ET.Element, obj: AutosarEngineeringObject):
+        # self.logger.debug("write ArtifactDescriptor %s", obj.short_label)
         child_element = ET.SubElement(element, "AUTOSAR-ENGINEERING-OBJECT")
         self.writeEngineeringObject(child_element, obj)
 
@@ -2017,15 +2449,15 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "ARTIFACT-DESCRIPTORS")
             for artifact_desc in artifact_descs:
                 if isinstance(artifact_desc, AutosarEngineeringObject):
-                    self.setAutosarEngineeringObject(child_element, artifact_desc)
+                    self.writeAutosarEngineeringObject(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)
 
@@ -2035,6 +2467,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):
@@ -2071,33 +2504,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")
@@ -2105,7 +2542,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())
@@ -2121,24 +2558,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):
@@ -2154,7 +2594,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     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, array_element)
+            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())
@@ -2185,12 +2625,12 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", group.getShortLabel())
             self.setChildElementOptionalLiteral(child_element, "CATEGORY", group.getCategory())
-            #self.writeSwRecordLayoutGroupSwRecordLayoutGroupContentType(child_element, group)
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS", group.getSwRecordLayoutGroupAxis())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-INDEX", group.getSwRecordLayoutGroupIndex())
             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.writeSwRecordLayoutGroupSwRecordLayoutGroupContentType(child_element, group)
 
     def writeSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
         self.logger.debug("writeSwRecordLayout %s" % layout.getShortName())
@@ -2213,7 +2653,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())
@@ -2278,7 +2719,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]):
@@ -2300,7 +2741,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())
@@ -2316,7 +2757,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)
@@ -2340,7 +2781,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):
@@ -2417,7 +2858,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         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)
@@ -2573,7 +3014,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         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())
+            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())
@@ -2712,7 +3153,6 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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")
@@ -2791,6 +3231,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         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")
@@ -2802,13 +3243,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())
@@ -2820,11 +3260,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")
@@ -2852,17 +3336,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")
@@ -2871,9 +3356,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")
@@ -2882,7 +3370,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")
@@ -2892,10 +3381,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):
@@ -2938,7 +3434,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)
 
@@ -2986,7 +3481,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())
@@ -3007,8 +3502,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())
@@ -3095,14 +3590,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)
@@ -3130,7 +3617,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:
@@ -3147,7 +3634,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):
@@ -3241,7 +3728,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):
@@ -3270,12 +3757,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:
@@ -3287,6 +3779,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))
 
@@ -3309,22 +3803,130 @@ 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)
+        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 writeCollectionElementRefs(self, element: ET.Element, collection: Collection):
+        refs = collection.getElementRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "ELEMENT-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "ELEMENT-REF", ref)
 
-        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 writeCollectionSourceElementRefs(self, element: ET.Element, collection: Collection):
+        refs = collection.getSourceElementRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "SOURCE-ELEMENT-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "SOURCE-ELEMENT-REF", ref)
+
+    def writeCollection(self, element: ET.Element, collection: Collection):
+        if collection is not None:
+            child_element = ET.SubElement(element, "COLLECTION")
+            self.writeARElement(child_element, collection)
+            self.setChildElementOptionalLiteral(child_element, "AUTO-COLLECT", collection.getAutoCollect())
+            self.setChildElementOptionalLiteral(child_element, "ELEMENT-ROLE", collection.getElementRole())
+            self.writeCollectionElementRefs(child_element, collection)
+            self.writeCollectionSourceElementRefs(child_element, collection)
+
+    def writeKeywordClassifications(self, element: ET.Element, keyword: Keyword):
+        classifications = keyword.getClassifications()
+        if len(classifications) > 0:
+            child_element = ET.SubElement(element, "CLASSIFICATIONS")
+            for classification in classifications:
+                self.setChildElementOptionalLiteral(child_element, "CLASSIFICATION", classification)
+
+    def writeKeyword(self, element: ET.Element, keyword: Keyword):
+        if keyword is not None:
+            # self.logger.debug("Write Keyword <%s>" % keyword.getShortName())
+            child_element = ET.SubElement(element, "KEYWORD")
+            self.writeIdentifiable(child_element, keyword)
+            self.setChildElementOptionalLiteral(child_element, "ABBR-NAME", keyword.getAbbrName())
+            self.writeKeywordClassifications(child_element, keyword)
+
+    def writeKeywordSetKeywords(self, element: ET.Element, keyword_set: KeywordSet):
+        keywords = keyword_set.getKeywords()
+        if len(keywords) > 0:
+            child_element = ET.SubElement(element, "KEYWORDS")
+            for keyword in keywords:
+                if isinstance(keyword, Keyword):
+                    self.writeKeyword(child_element, keyword)
+                else:
+                    self.notImplemented("Unsupported Keyword <%s>" % type(keyword))
+
+    def writeKeywordSet(self, element: ET.Element, keyword_set: KeywordSet):
+        if keyword_set is not None:
+            self.logger.debug("Write KeywordSet <%s>" % keyword_set.getShortName())
+            child_element = ET.SubElement(element, "KEYWORD-SET")
+            self.writeARElement(child_element, keyword_set)
+            self.writeKeywordSetKeywords(child_element, keyword_set)
+
+    def writePortPrototypeBlueprint(self, element: ET.Element, blueprint: PortPrototypeBlueprint):
+        if blueprint is not None:
+            self.logger.debug("Write PortPrototypeBlueprint <%s>" % blueprint.getShortName())
+            child_element = ET.SubElement(element, "PORT-PROTOTYPE-BLUEPRINT")
+            self.writeARElement(child_element, blueprint)
+            self.setChildElementOptionalRefType(child_element, "INTERFACE-REF", blueprint.getInterfaceRef())
 
     def writeMacMulticastGroup(self, element: ET.Element, group: MacMulticastGroup):
         if group is not None:
@@ -3390,27 +3992,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):
@@ -3421,10 +4024,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())
 
@@ -3435,7 +4038,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)
@@ -3494,10 +4097,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:
@@ -3519,7 +4122,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):
@@ -3552,6 +4155,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))
 
@@ -3582,6 +4187,10 @@ class ARXMLWriter(AbstractARXMLWriter):
         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:
@@ -3596,8 +4205,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()
@@ -3614,7 +4226,7 @@ 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())
@@ -3631,16 +4243,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()
@@ -3648,9 +4297,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))
                 
@@ -3767,6 +4416,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         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, "MOLAR-AMOUNT-EXP", dimension.getMolarAmountExp())
         self.setChildElementOptionalNumericalValue(child_element, "TEMPERATURE-EXP", dimension.getTemperatureExp())
         self.setChildElementOptionalNumericalValue(child_element, "TIME-EXP", dimension.getTimeExp())
         self.setChildElementOptionalNumericalValue(child_element, "CURRENT-EXP", dimension.getCurrentExp())
@@ -3805,19 +4455,43 @@ class ARXMLWriter(AbstractARXMLWriter):
             for mapping in mappings:
                 self.setDataPrototypeMapping(child_element, mapping)
 
-    def setVariableAndParameterInterfaceMapping(self, element: ET.Element, mapping: VariableAndParameterInterfaceMapping):
-        self.logger.debug("set VariableAndParameterInterfaceMapping %s" % mapping.getShortName())
+    def writeVariableAndParameterInterfaceMapping(self, element: ET.Element, mapping: VariableAndParameterInterfaceMapping):
+        # self.logger.debug("Write VariableAndParameterInterfaceMapping %s" % mapping.getShortName())
         child_element = ET.SubElement(element, "VARIABLE-AND-PARAMETER-INTERFACE-MAPPING")
         self.writeIdentifiable(child_element, mapping)
         self.setDataPrototypeMappings(child_element, "DATA-MAPPINGS", mapping.getDataMappings())
 
+    def writeClientServerOperationMapping(self, element: ET.Element, mapping: ClientServerOperationMapping):
+        child_element = ET.SubElement(element, "CLIENT-SERVER-OPERATION-MAPPING")
+        self.setChildElementOptionalRefType(child_element, "FIRST-OPERATION-REF", mapping.getFirstOperationRef())
+        self.setChildElementOptionalRefType(child_element, "SECOND-OPERATION-REF", mapping.getSecondOperationRef())
+
+    def writeClientServerInterfaceMappingOperationMappings(self, element: ET.Element, mapping: ClientServerInterfaceMapping):
+        operation_mappings = mapping.getOperationMappings()
+        if len(operation_mappings) > 0:
+            child_element = ET.SubElement(element, "OPERATION-MAPPINGS")
+            for operation_mapping in operation_mappings:
+                if isinstance(operation_mapping, ClientServerOperationMapping):
+                    self.writeClientServerOperationMapping(child_element, operation_mapping)
+                else:
+                    self.notImplemented("Unsupported Operation Mapping <%s>" % type(operation_mapping))
+
+    def writeClientServerInterfaceMapping(self, element: ET.Element, mapping: ClientServerInterfaceMapping):
+        # self.logger.debug("Read ClientServerInterfaceMapping %s" % mapping.getShortName())
+        if mapping is not None:
+            child_element = ET.SubElement(element, "CLIENT-SERVER-INTERFACE-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.writeClientServerInterfaceMappingOperationMappings(child_element, mapping)
+
     def writePortInterfaceMappings(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
         mappings = mapping_set.getPortInterfaceMappings()
         if len(mappings) > 0:
             child_element = ET.SubElement(element, "PORT-INTERFACE-MAPPINGS")
             for mapping in mappings:
                 if isinstance(mapping, VariableAndParameterInterfaceMapping):
-                    self.setVariableAndParameterInterfaceMapping(child_element, mapping)
+                    self.writeVariableAndParameterInterfaceMapping(child_element, mapping)
+                elif isinstance(mapping, ClientServerInterfaceMapping):
+                    self.writeClientServerInterfaceMapping(child_element, mapping)
                 else:
                     self.notImplemented("Unsupported PortInterfaceMapping <%s>" % type(mapping))
 
@@ -3873,7 +4547,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())
@@ -3890,7 +4564,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())
@@ -3909,7 +4583,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)
@@ -3922,7 +4596,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())
@@ -3931,13 +4605,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())
@@ -3946,7 +4620,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)
@@ -3972,7 +4646,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())
@@ -3983,16 +4657,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())
@@ -4024,10 +4740,47 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "ETHERNET-FRAME")
         self.writeFrame(child_element, frame)
 
-    def writeLifeCycleInfoSet(self, element: ET.Element, set: LifeCycleInfoSet):
-        self.logger.debug("Write LifeCycleInfoSet %s" % set.getShortName())
-        child_element = ET.SubElement(element, "LIFE-CYCLE-INFO-SET")
-        self.writeIdentifiable(child_element, set)
+    def setLifeCyclePeriod(self, element: ET.Element, key: str, period: LifeCyclePeriod):
+        if period is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalRevisionLabelString(child_element, "AR-RELEASE-VERSION", period.getArReleaseVersion())
+
+    def writeLifeCycleInfoUseInsteadRefs(self, element: ET.Element, info: LifeCycleInfo):
+        refs = info.getUseInsteadRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "USE-INSTEAD-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "USE-INSTEAD-REF", ref)
+
+    def writeLifeCycleInfo(self, element: ET.Element, info: LifeCycleInfo):
+        if info is not None:
+            child_element = ET.SubElement(element, "LIFE-CYCLE-INFO")
+            self.writeARObjectAttributes(child_element, info)
+            self.setChildElementOptionalRefType(child_element, "LC-OBJECT-REF", info.getLcObjectRef())
+            self.setChildElementOptionalRefType(child_element, "LC-STATE-REF", info.getLcStateRef())
+            self.setLifeCyclePeriod(child_element, "PERIOD-BEGIN", info.getPeriodBegin())
+            self.writeDocumentationBlock(child_element, "REMARK", info.getRemark())
+            self.writeLifeCycleInfoUseInsteadRefs(child_element, info)
+
+    def writeLifeCycleInfoSetLifeCycleInfos(self, element: ET.Element, info_set: LifeCycleInfoSet):
+        infos = info_set.getLifeCycleInfos()
+        if len(infos) > 0:
+            child_element = ET.SubElement(element, "LIFE-CYCLE-INFOS")
+            for info in infos:
+                if isinstance(info, LifeCycleInfo):
+                    self.writeLifeCycleInfo(child_element, info)
+                else:
+                    self.notImplemented("Unsupported Life Cycle Info <%s>" % type(info))
+
+    def writeLifeCycleInfoSet(self, element: ET.Element, info_set: LifeCycleInfoSet):
+        if info_set is not None:
+            self.logger.debug("Write LifeCycleInfoSet %s" % info_set.getShortName())
+            child_element = ET.SubElement(element, "LIFE-CYCLE-INFO-SET")
+            self.writeIdentifiable(child_element, info_set)
+            self.setChildElementOptionalRefType(child_element, "DEFAULT-LC-STATE-REF", info_set.getDefaultLcStateRef())
+            self.writeLifeCycleInfoSetLifeCycleInfos(child_element, info_set)
+            self.setChildElementOptionalRefType(child_element, "USED-LIFE-CYCLE-STATE-DEFINITION-GROUP-REF",
+                                                info_set.getUsedLifeCycleStateDefinitionGroupRef())
 
     def writeDiagnosticConnectionFunctionalRequestRefs(self, element: ET.Element, connection: DiagnosticConnection):
         refs = connection.getFunctionalRequestRefs()
@@ -4252,6 +5005,66 @@ class ARXMLWriter(AbstractARXMLWriter):
         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())
@@ -4296,7 +5109,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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())
 
@@ -4305,12 +5118,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)
@@ -4324,7 +5132,7 @@ 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, "TRANSMISSION-MODE-CONDITIONS", decl.getTransmissionModeConditions())
@@ -4347,6 +5155,144 @@ class ARXMLWriter(AbstractARXMLWriter):
         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):
             self.writeComplexDeviceDriverSwComponentType(element, ar_element)
@@ -4476,9 +5422,31 @@ 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)
+        elif isinstance(ar_element, Collection):
+            self.writeCollection(element, ar_element)
+        elif isinstance(ar_element, KeywordSet):
+            self.writeKeywordSet(element, ar_element)
+        elif isinstance(ar_element, PortPrototypeBlueprint):
+            self.writePortPrototypeBlueprint(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:
@@ -4488,40 +5456,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("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)
-