armodel 1.4.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

armodel/writer/arxml_writer.py

@@ -2,39 +2,62 @@ import xml.etree.cElementTree as ET
 
 from typing import List
 
-from armodel.writer.abstract_arxml_writer import AbstractARXMLWriter
+from ..models.m2.msr.data_dictionary.auxillary_objects import SwAddrMethod
+from ..models.m2.msr.data_dictionary.data_def_properties import SwDataDefProps
+from ..models.m2.msr.asam_hdo.units import PhysicalDimension
+from ..models.m2.msr.documentation.block_elements import DocumentationBlock
+from ..models.m2_msr import CompuConstTextContent, CompuMethod, CompuNominatorDenominator, CompuScale, CompuScaleConstantContents, CompuScaleRationalFormula, CompuScales
 
+from ..models.m2.autosar_templates.common_structure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, ConstantSpecification, NumericalValueSpecification, RecordValueSpecification, TextValueSpecification, ValueSpecification
+from ..models.m2.autosar_templates.sw_component_template.components.instance_refs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef, RModeInAtomicSwcInstanceRef, RVariableInAtomicSwcInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior import RunnableEntityArgument, SynchronousServerCallPoint
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.server_call import ServerCallPoint
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.data_elements import ParameterAccess, VariableAccess
+from ..models.m2.autosar_templates.ecuc_description_template import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue, EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue, EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
+from ..models.m2.autosar_templates.system_template.data_mapping import SenderReceiverToSignalGroupMapping, SenderReceiverToSignalMapping
+from ..models.m2.autosar_templates.system_template import System, SystemMapping
+from ..models.m2.autosar_templates.system_template.network_management import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode
+from ..models.m2.autosar_templates.system_template.transport_protocols import CanTpConfig
+from ..models.m2.autosar_templates.sw_component_template.communication import ClientComSpec, ModeSwitchReceiverComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, PPortComSpec,  QueuedReceiverComSpec, QueuedSenderComSpec, RPortComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
+
+from ..models.fibex.fibex_4_multiplatform import Gateway, ISignalMapping
+from ..models.fibex.can_communication import CanFrame, CanFrameTriggering, RxIdentifierRange
+from ..models.fibex.fibex_core.core_communication import FrameTriggering, IPdu, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalTriggering, PduTriggering, SecuredIPdu, SystemSignal, DcmIPdu, Frame, ISignal, NPdu, NmPdu, SystemSignalGroup
+from ..models.fibex.lin_communication import LinFrameTriggering, LinUnconditionalFrame
+from ..models.fibex.fibex_core.core_topology import AbstractCanCluster, CanCluster, EcuInstance, CanPhysicalChannel, CommunicationCluster, LinCluster, LinPhysicalChannel, PhysicalChannel
+
+from ..models.internal_behavior import IncludedDataTypeSet, InternalBehavior
+from ..models.timing import EOCExecutableEntityRef, ExecutionOrderConstraint, SwcTiming, TimingExtension
 from ..models.data_def_properties import ValueList
-from ..models.multilanguage_data import MultiLanguageOverviewParagraph, MultilanguageLongName
+from ..models.multilanguage_data import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultilanguageLongName
 from ..models.record_layout import SwRecordLayout, SwRecordLayoutGroup, SwRecordLayoutV
 from ..models.service_mapping import RoleBasedPortAssignment
 from ..models.service_needs import NvBlockNeeds, RoleBasedDataAssignment
 from ..models.data_prototype import ApplicationArrayElement, ApplicationCompositeElementDataPrototype, ApplicationRecordElement, AutosarDataPrototype, DataPrototype, ParameterDataPrototype, VariableDataPrototype
 from ..models.bsw_module_template import BswCalledEntity, BswEvent, BswInternalBehavior, BswModeSenderPolicy, BswModuleDescription, BswModuleEntity, BswModuleEntry, BswSchedulableEntity, BswScheduleEvent, BswTimingEvent
 from ..models.ar_package import AUTOSAR
-from ..models.sw_component import ApplicationSwComponentType, AtomicSwComponentType, ComplexDeviceDriverSwComponentType, DataReceivedEvent, EcuAbstractionSwComponentType, InternalTriggerOccurredEvent, OperationInvokedEvent, ParameterAccess, PortAPIOption, PortGroup, RTEEvent, ServerCallPoint, ServiceDependency, ServiceSwComponentType, SwcModeSwitchEvent, SwcServiceDependency, SynchronousServerCallPoint, VariableAccess
+from ..models.sw_component import ApplicationSwComponentType, AtomicSwComponentType, ComplexDeviceDriverSwComponentType, DataReceivedEvent, EcuAbstractionSwComponentType, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, PortAPIOption, PortGroup, RTEEvent, ServiceDependency, ServiceSwComponentType, SwcModeSwitchEvent, SwcServiceDependency
 from ..models.ar_package import ARPackage
-from ..models.ar_ref import ApplicationCompositeElementInPortInterfaceInstanceRef, AutosarParameterRef, AutosarVariableRef, InnerPortGroupInCompositionInstanceRef, POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, RModeInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef, RVariableInAtomicSwcInstanceRef, VariableDataPrototypeInSystemInstanceRef
+from ..models.ar_ref import AnyInstanceRef, ApplicationCompositeElementInPortInterfaceInstanceRef, AutosarParameterRef, AutosarVariableRef, InnerPortGroupInCompositionInstanceRef, POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef, RefType, VariableDataPrototypeInSystemInstanceRef
 from ..models.calibration import SwAxisGrouped, SwAxisIndividual, SwCalprmAxis, SwCalprmAxisSet, SwValueCont, SwValues
-from ..models.common_structure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, ModeDeclaration, ModeDeclarationGroup, ModeDeclarationGroupPrototype, NumericalValueSpecification, RecordValueSpecification, TextValueSpecification, ValueSpecification
+from ..models.common_structure import IncludedModeDeclarationGroupSet, ModeDeclaration, ModeDeclarationGroup, ModeDeclarationGroupPrototype
 from ..models.communication import CompositeNetworkRepresentation, TransmissionAcknowledgementRequest
-from ..models.data_dictionary import SwAddrMethod, SwDataDefProps
 from ..models.datatype import ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType, AutosarDataType, BaseTypeDirectDefinition, DataTypeMappingSet, ImplementationDataType, SwBaseType
 from ..models.general_structure import ARElement, AdminData, Identifiable, Limit, MultilanguageReferrable, Referrable, Sdg, SwcBswMapping, SwcBswRunnableMapping
-from ..models.m2_msr import CompuConstTextContent, CompuMethod, CompuNominatorDenominator, CompuScale, CompuScaleConstantContents, CompuScaleRationalFormula, CompuScales
-from ..models.port_prototype import ClientComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, PPortComSpec, PPortPrototype, PortPrototype, QueuedReceiverComSpec, RPortComSpec, RPortPrototype, ReceiverComSpec, SenderComSpec, ServerComSpec
+
+from ..models.port_prototype import PPortPrototype, PortPrototype, RPortPrototype
 from ..models.sw_component import AssemblySwConnector, CompositionSwComponentType, DelegationSwConnector, SwComponentPrototype, SwComponentType, SwConnector
 from ..models.annotation import Annotation
 from ..models.end_to_end_protection import EndToEndDescription, EndToEndProtection, EndToEndProtectionSet, EndToEndProtectionVariablePrototype
-from ..models.port_interface import ApplicationError, ClientServerInterface, ClientServerOperation, ModeSwitchInterface, PortInterface, SenderReceiverInterface, TriggerInterface
-from ..models.unit import Unit
+from ..models.m2.autosar_templates.sw_component_template.port_interface import ApplicationError, ClientServerInterface, ClientServerOperation, ModeSwitchInterface, PortInterface, SenderReceiverInterface, TriggerInterface
+from ..models.m2.msr.asam_hdo.units import Unit
 from ..models.implementation import AutosarEngineeringObject, BswImplementation, Code, EngineeringObject, Implementation, SwcImplementation
-from ..models.common_structure import ConstantSpecification, ExecutableEntity, InternalBehavior, ResourceConsumption
+from ..models.common_structure import ExecutableEntity, ResourceConsumption
 from ..models.sw_component import RunnableEntity, SwcInternalBehavior, TimingEvent
 from ..models.ar_object import ARLiteral
 from ..models.global_constraints import DataConstr, InternalConstrs, PhysConstrs
 
-
+from .abstract_arxml_writer import AbstractARXMLWriter
 class ARXMLWriter(AbstractARXMLWriter):
     def __init__(self, options=None) -> None:
         super().__init__(options)
@@ -45,20 +68,32 @@ class ARXMLWriter(AbstractARXMLWriter):
 
         return sub_element
     
-    def writeSd(self, parent: ET.Element, sdg: Sdg):
+    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, "UPPER-CAN-ID", range.getUpperCanId())
+    
+    def writeSds(self, parent: ET.Element, sdg: Sdg):
         for sd in sdg.getSds():
             sd_tag = ET.SubElement(parent, "SD")
             sd_tag.attrib['GID'] = sd.gid
             sd_tag.text = sd.value
-    
-    def writeSdg(self, parent: ET.Element, admin_data: AdminData):
+
+    def setSdg(self, parent: ET.Element, sdg: Sdg):
+        if sdg is not None:
+            sdg_tag = ET.SubElement(parent, "SDG")
+            sdg_tag.attrib['GID'] = sdg.gid
+            self.writeSds(sdg_tag, sdg)
+            for sdg_item in sdg.getSdgContentsTypes():
+                self.setSdg(sdg_tag, sdg_item)
+            
+    def writeSdgs(self, parent: ET.Element, admin_data: AdminData):
         sdgs = admin_data.getSdgs()
         if len(sdgs) > 0:
             sdgs_tag = ET.SubElement(parent, "SDGS")
             for sdg in sdgs:
-                sdg_tag = ET.SubElement(sdgs_tag, "SDG")
-                sdg_tag.attrib['GID'] = sdg.gid
-                self.writeSd(sdg_tag, sdg)
+                self.setSdg(sdgs_tag, sdg)
     
     def writeChildLimitElement(self, element: ET.Element, key: str, limit: Limit):
         if limit is not None:
@@ -68,7 +103,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 limit_tag.attrib['INTERVAL-TYPE'] = limit.intervalType
             limit_tag.text = limit.value
     
-    def writeReferable(self, element: ET.Element, referrable: Referrable):
+    def setReferable(self, element: ET.Element, referrable: Referrable):
         self.setARObjectAttributes(element, referrable)
         self.setShortName(element, referrable.short_name)
 
@@ -94,61 +129,77 @@ class ARXMLWriter(AbstractARXMLWriter):
                     l2_tag.attrib['L'] = l2.l
                 l2_tag.text = l2.value
 
-    def writeMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
-        self.writeReferable(element, referrable)
-        if referrable.long_name is not None:
-            self.setMultiLongName(element, "LONG-NAME", referrable.long_name)
+    def setMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
+        self.setReferable(element, referrable)
+        if referrable.longName is not None:
+            self.setMultiLongName(element, "LONG-NAME", referrable.longName)
 
-    def writeAdminData(self, element: ET.Element, admin_data: AdminData):
+    def setAdminData(self, element: ET.Element, admin_data: AdminData):
         element = ET.SubElement(element, "ADMIN-DATA")
-        self.writeSdg(element, admin_data)
-
-    def writeIdentifiable(self, element: ET.Element, identifiable: Identifiable):
-        self.writeMultilanguageReferrable(element, identifiable)
-        self.setMultiLanguageOverviewParagraph(element, "DESC", identifiable.desc)
-        self.setChildElementOptionalLiteral(element, "CATEGORY", identifiable.category)
-        if identifiable.admin_data is not None:
-            self.writeAdminData(element, identifiable.admin_data)
-
-    def writeARElement(self, parent: ET.Element, ar_element: ARElement):
-        self.writeIdentifiable(parent, ar_element)
+        self.writeSdgs(element, admin_data)
+
+    def setIdentifiable(self, element: ET.Element, identifiable: Identifiable):
+        self.setMultilanguageReferrable(element, identifiable)
+        self.setAnnotations(element, identifiable.getAnnotations())
+        self.setMultiLanguageOverviewParagraph(element, "DESC", identifiable.getDesc())
+        self.setChildElementOptionalLiteral(element, "CATEGORY", identifiable.getCategory())
+        if identifiable.getAdminData() is not None:
+            self.setAdminData(element, identifiable.getAdminData())
+
+    def setARElement(self, parent: ET.Element, ar_element: ARElement):
+        self.setIdentifiable(parent, ar_element)
     
-    def writeTransmissionAcknowledgementRequest(self, element: ET.Element, acknowledge: TransmissionAcknowledgementRequest):
+    def setTransmissionAcknowledgementRequest(self, element: ET.Element, acknowledge: TransmissionAcknowledgementRequest):
         if (acknowledge != None):
             child_element = ET.SubElement(element, "TRANSMISSION-ACKNOWLEDGE")
             self.setARObjectAttributes(child_element, acknowledge)
             if acknowledge.timeout != None:
                 self.setChildElementOptionalFloatValue(child_element, "TIMEOUT", acknowledge.timeout)
 
-    def writeSenderComSpec(self, element: ET.Element, com_spec: SenderComSpec):
+    def setSenderComSpec(self, element: ET.Element, com_spec: SenderComSpec):
         representations = com_spec.getCompositeNetworkRepresentations()
         if len(representations) > 0:
             child_element = ET.SubElement(element, "COMPOSITE-NETWORK-REPRESENTATIONS")
             for representation in representations:
                 self.setCompositeNetworkRepresentation(child_element, representation)
-        self.setChildElementOptionalRefType(element, "DATA-ELEMENT-REF", com_spec.data_element_ref)
-        self.setSwDataDefProps(element, "NETWORK-REPRESENTATION", com_spec.network_representation)
-        self.setChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE", com_spec.handle_out_of_range)
-        self.writeTransmissionAcknowledgementRequest(element, com_spec.transmission_acknowledge)
-        self.setChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION", com_spec.uses_end_to_end_protection)
+        self.setChildElementOptionalRefType(element, "DATA-ELEMENT-REF", com_spec.getDataElementRef())
+        self.setSwDataDefProps(element, "NETWORK-REPRESENTATION", com_spec.getNetworkRepresentation())
+        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 writeNonqueuedSenderComSpec(self, com_specs_tag: ET.Element, com_spec: NonqueuedSenderComSpec):
-        com_spec_tag = ET.SubElement(com_specs_tag, "NONQUEUED-SENDER-COM-SPEC")
-        self.setARObjectAttributes(com_spec_tag, com_spec)
-        self.writeSenderComSpec(com_spec_tag, com_spec)
-        self.setInitValue(com_spec_tag, com_spec.init_value)
+    def setNonqueuedSenderComSpec(self, element: ET.Element, com_spec: NonqueuedSenderComSpec):
+        child_element = ET.SubElement(element, "NONQUEUED-SENDER-COM-SPEC")
+        self.setARObjectAttributes(child_element, com_spec)
+        self.setSenderComSpec(child_element, com_spec)
+        self.setInitValue(child_element, com_spec.initValue)
             
-    def writeServerComSpec(self, com_specs_tag: ET.Element, com_spec: ServerComSpec):
-        com_spec_tag = ET.SubElement(com_specs_tag, "SERVER-COM-SPEC")
-        self.setARObjectAttributes(com_spec_tag, com_spec)
-        self.setChildElementOptionalRefType(com_spec_tag, "OPERATION-REF", com_spec.operation_ref)
-        self.setChildElementOptionalNumericalValue(com_spec_tag, "QUEUE-LENGTH",    com_spec.queue_length)
+    def setServerComSpec(self, element: ET.Element, com_spec: ServerComSpec):
+        child_element = ET.SubElement(element, "SERVER-COM-SPEC")
+        self.setARObjectAttributes(child_element, com_spec)
+        self.setChildElementOptionalRefType(child_element, "OPERATION-REF", com_spec.getOperationRef())
+        self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH",    com_spec.getQueueLength())
+
+    def setQueuedSenderComSpec(self, element: ET.Element, com_spec: QueuedSenderComSpec):
+        child_element = ET.SubElement(element, "QUEUED-SENDER-COM-SPEC")
+        self.setARObjectAttributes(child_element, com_spec)
+        self.setSenderComSpec(child_element, com_spec)
+
+    def setModeSwitchSenderComSpec(self, element: ET.Element, com_spec: ModeSwitchSenderComSpec):
+        child_element = ET.SubElement(element, "MODE-SWITCH-SENDER-COM-SPEC")
+        self.setARObjectAttributes(child_element, com_spec)
+        self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.getModeGroupRef())
+        self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH", com_spec.getQueueLength())
     
     def writePPortComSpec(self, com_specs_tag: ET.Element, com_spec: PPortComSpec):
         if isinstance(com_spec, NonqueuedSenderComSpec):
-            self.writeNonqueuedSenderComSpec(com_specs_tag, com_spec)
+            self.setNonqueuedSenderComSpec(com_specs_tag, com_spec)
         elif isinstance(com_spec, ServerComSpec):
-            self.writeServerComSpec(com_specs_tag, com_spec)
+            self.setServerComSpec(com_specs_tag, com_spec)
+        elif isinstance(com_spec, QueuedSenderComSpec):
+            self.setQueuedSenderComSpec(com_specs_tag, com_spec)
+        elif isinstance(com_spec, ModeSwitchSenderComSpec):
+            self.setModeSwitchSenderComSpec(com_specs_tag, com_spec)
         else:
             raise NotImplementedError("Unsupported PPortComSpec %s" % type(com_spec))
         
@@ -172,10 +223,10 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "COMPOSITE-NETWORK-REPRESENTATIONS")
             for representation in representations:
                 self.setCompositeNetworkRepresentation(child_element, representation)
-        self.setChildElementOptionalRefType(element, "DATA-ELEMENT-REF", com_spec.data_element_ref)
-        self.setSwDataDefProps(element, "NETWORK-REPRESENTATION", com_spec.network_representation)
-        self.setChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE", com_spec.handle_out_of_range)
-        self.setChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION", com_spec.uses_end_to_end_protection)
+        self.setChildElementOptionalRefType(element, "DATA-ELEMENT-REF", com_spec.dataElementRef)
+        self.setSwDataDefProps(element, "NETWORK-REPRESENTATION", com_spec.networkRepresentation)
+        self.setChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE", com_spec.handleOutOfRange)
+        self.setChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION", com_spec.usesEndToEndProtection)
 
     def setSwValues(self, element: ET.Element, key: str, sw_values: SwValues):
         if sw_values is not None:
@@ -236,7 +287,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setConstantReference(self, element: ET.Element, value_spec: ConstantReference):
         value_spec_tag = ET.SubElement(element, "CONSTANT-REFERENCE")
         self.writeValueSpecification(value_spec_tag, value_spec)
-        self.setChildElementOptionalRefType(value_spec_tag, "CONSTANT-REF", value_spec.constant_ref)
+        self.setChildElementOptionalRefType(value_spec_tag, "CONSTANT-REF", value_spec.getConstantRef())
 
     def setValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
         if value_spec is not None:
@@ -264,23 +315,29 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "NONQUEUED-RECEIVER-COM-SPEC")
         self.setARObjectAttributes(child_element, com_spec)
         self.writeReceiverComSpec(child_element, com_spec)
-        self.setChildElementOptionalFloatValue(child_element, "ALIVE-TIMEOUT", com_spec.alive_timeout)
-        self.setChildElementOptionalBooleanValue(child_element, "ENABLE-UPDATE", com_spec.enable_updated)
-        self.setChildElementOptionalBooleanValue(child_element, "HANDLE-NEVER-RECEIVED", com_spec.handle_never_received)
-        self.setChildElementOptionalLiteral(child_element, "HANDLE-TIMEOUT-TYPE", com_spec.handel_timeout_type)
-        self.setInitValue(child_element, com_spec.init_value)
+        self.setChildElementOptionalFloatValue(child_element, "ALIVE-TIMEOUT", com_spec.aliveTimeout)
+        self.setChildElementOptionalBooleanValue(child_element, "ENABLE-UPDATE", com_spec.enableUpdated)
+        self.setChildElementOptionalBooleanValue(child_element, "HANDLE-NEVER-RECEIVED", com_spec.handleNeverReceived)
+        self.setChildElementOptionalLiteral(child_element, "HANDLE-TIMEOUT-TYPE", com_spec.handleTimeoutType)
+        self.setInitValue(child_element, com_spec.initValue)
 
     def writeQueuedReceiverComSpec(self, element: ET.Element, com_spec: QueuedReceiverComSpec):
         child_element = ET.SubElement(element, "QUEUED-RECEIVER-COM-SPEC")
         self.setARObjectAttributes(child_element, com_spec)
         self.writeReceiverComSpec(child_element, com_spec)
-        self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH", com_spec.queue_length)
+        self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH", com_spec.queueLength)
     
     def writeClientComSpec(self, element: ET.Element, com_spec: ClientComSpec):
         self.logger.debug("writeClientComSpec")
         child_element = ET.SubElement(element, "CLIENT-COM-SPEC")
         self.setARObjectAttributes(child_element, com_spec)
-        self.setChildElementOptionalRefType(child_element, "OPERATION-REF", com_spec.operation_ref)
+        self.setChildElementOptionalRefType(child_element, "OPERATION-REF", com_spec.operationRef)
+
+    def writeModeSwitchReceiverComSpec(self, element: ET.Element, com_spec: ModeSwitchReceiverComSpec):
+        self.logger.debug("writeModeSwitchReceiverComSpec")
+        child_element = ET.SubElement(element, "MODE-SWITCH-RECEIVER-COM-SPEC")
+        self.setARObjectAttributes(child_element, com_spec)
+        self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.modeGroupRef)
 
     def writeRPortComSpec(self, element: ET.Element, com_spec: RPortComSpec):
         if isinstance(com_spec, NonqueuedReceiverComSpec):
@@ -289,13 +346,15 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeQueuedReceiverComSpec(element, com_spec)
         elif isinstance(com_spec, ClientComSpec):
             self.writeClientComSpec(element, com_spec)
+        elif isinstance(com_spec, ModeSwitchReceiverComSpec):
+            self.writeModeSwitchReceiverComSpec(element, com_spec)
         else:
             raise ValueError("Unsupported RPortComSpec %s" % type(com_spec))
     
     def writePPortPrototype(self, ports_tag: ET.Element, prototype: PPortPrototype):
         prototype_tag = ET.SubElement(ports_tag, "P-PORT-PROTOTYPE")
 
-        self.writeIdentifiable(prototype_tag, prototype)
+        self.setIdentifiable(prototype_tag, prototype)
         self.logger.debug("writePPortPrototype %s" % prototype.short_name)
 
         com_specs = prototype.getProvidedComSpecs()
@@ -309,7 +368,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeRPortPrototype(self, ports_tag: ET.Element, prototype: RPortPrototype):
         self.logger.debug("writeRPortPrototype %s" % prototype.short_name)
         prototype_tag = ET.SubElement(ports_tag, "R-PORT-PROTOTYPE")
-        self.writeIdentifiable(prototype_tag, prototype)
+        self.setIdentifiable(prototype_tag, prototype)
         com_specs = prototype.getRequiredComSpecs()
         if len(com_specs) > 0:
             com_specs_tag = ET.SubElement(prototype_tag, "REQUIRED-COM-SPECS")
@@ -349,7 +408,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writePortGroup(self, element: ET.Element, port_group: PortGroup):
         self.logger.debug("writePortGroup %s" % port_group.short_name)
         child_element = ET.SubElement(element, "PORT-GROUP")
-        self.writeIdentifiable(child_element, port_group)
+        self.setIdentifiable(child_element, port_group)
         self.writePortGroupInnerGroupIRefs(child_element, port_group)
         self.writePortGroupOuterPortRefs(child_element, port_group)
 
@@ -361,7 +420,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.writePortGroup(child_element, port_group)
     
     def writeSwComponentType(self, element: ET.Element, sw_component: SwComponentType):
-        self.writeIdentifiable(element, sw_component)
+        self.setIdentifiable(element, sw_component)
         port_prototypes = sw_component.getPortPrototypes()
         if len(port_prototypes) > 0:
             ports_tag = ET.SubElement(element, "PORTS")
@@ -370,7 +429,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeSwComponentPrototype(self, element: ET.Element, prototype: SwComponentPrototype):
         prototype_tag = ET.SubElement(element, "SW-COMPONENT-PROTOTYPE")
-        self.writeIdentifiable(prototype_tag, prototype)
+        self.setIdentifiable(prototype_tag, prototype)
         self.setChildElementOptionalRefType(prototype_tag, "TYPE-TREF", prototype.type_tref)
 
     def writeSwComponentPrototypes(self, element: ET.Element, sw_component: CompositionSwComponentType):
@@ -380,7 +439,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeAssemblySwConnector(self, element: ET.Element, sw_connector: AssemblySwConnector):
         connector_tag = ET.SubElement(element, "ASSEMBLY-SW-CONNECTOR")
-        self.writeIdentifiable(connector_tag, sw_connector)
+        self.setIdentifiable(connector_tag, sw_connector)
 
         if sw_connector.provider_iref is not None:
             provider_iref_tag = ET.SubElement(connector_tag, "PROVIDER-IREF")
@@ -396,7 +455,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeDelegationSwConnector(self, element: ET.Element, sw_connector: DelegationSwConnector):
         connector_tag = ET.SubElement(element, "DELEGATION-SW-CONNECTOR")
-        self.writeIdentifiable(connector_tag, sw_connector)
+        self.setIdentifiable(connector_tag, sw_connector)
 
         if sw_connector.inner_port_iref is not None:
             inner_port_iref_tag = ET.SubElement(connector_tag, "INNER-PORT-IREF")
@@ -450,11 +509,33 @@ class ARXMLWriter(AbstractARXMLWriter):
         for sw_component in ar_package.getCompositionSwComponentTypes():
             self.writeCompositionSwComponentType(element, sw_component)
 
+    def writeLParagraphs(self, element: ET.Element, paragraph: MultiLanguageParagraph):
+        for l1 in paragraph.getL1s():
+            l1_tag = ET.SubElement(element, "L-1")
+            self.setARObjectAttributes(l1_tag, l1)
+            if l1.l is not None:
+                l1_tag.attrib['L'] = l1.l
+                l1_tag.text = l1.value
+    
+    def setMultiLanguageParagraphs(self, element: ET.Element, key: str, paragraphs: List[MultiLanguageParagraph]):
+        for paragraph in paragraphs:
+            child_element = ET.SubElement(element, key)
+            self.setARObjectAttributes(child_element, paragraph)
+            self.writeLParagraphs(child_element, paragraph)
+        return paragraphs
+
+    def setDocumentationBlock(self, element: ET.Element, key: str, block: DocumentationBlock):
+        if block is not None:
+            child_element = ET.SubElement(element, key)
+            self.setARObjectAttributes(child_element, block)
+            self.setMultiLanguageParagraphs(child_element, "P", block.getPs())
+
     def writeGeneralAnnotation(self, element: ET.Element, annotation: Annotation):
-        self.setMultiLongName(element, "LABEL", annotation.label)
+        self.setMultiLongName(element, "LABEL", annotation.getLabel())
+        self.setChildElementOptionalLiteral(element, "ANNOTATION-ORIGIN", annotation.getAnnotationOrigin())
+        self.setDocumentationBlock(element, "ANNOTATION-TEXT", annotation.getAnnotationText())
 
-    def writeAnnotations(self, element: ET.Element, props: SwDataDefProps) :
-        annotations = props.getAnnotations()
+    def setAnnotations(self, element: ET.Element, annotations: List[Annotation]) :
         if len(annotations) > 0:
             annotations_tag = ET.SubElement(element, "ANNOTATIONS")
             for annotation in annotations:
@@ -495,6 +576,11 @@ class ARXMLWriter(AbstractARXMLWriter):
             for axis in axises:
                 self.setSwCalprmAxis(child_element, axis)
 
+    def writeSwDataDefProsInvalidValue(self, element: ET.Element, props: SwDataDefProps):
+        if props.getInvalidValue() is not None:
+            child_element = ET.SubElement(element, "INVALID-VALUE")
+            self.setValueSpecification(child_element, props.getInvalidValue()) 
+
     def setSwDataDefProps(self, element: ET.Element, key: str, sw_data_def_props: SwDataDefProps):
         if sw_data_def_props is not None:
             child_element = ET.SubElement(element, key)
@@ -502,18 +588,18 @@ class ARXMLWriter(AbstractARXMLWriter):
             sw_data_def_props_variants_tag = ET.SubElement(child_element, "SW-DATA-DEF-PROPS-VARIANTS")
             sw_data_def_props_conditional_tag = ET.SubElement(sw_data_def_props_variants_tag, "SW-DATA-DEF-PROPS-CONDITIONAL")
             self.setARObjectAttributes(sw_data_def_props_conditional_tag, sw_data_def_props.conditional)
-            self.writeAnnotations(sw_data_def_props_conditional_tag, sw_data_def_props)
-            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "BASE-TYPE-REF", sw_data_def_props.baseTypeRef)
-            self.setChildElementOptionalLiteral(sw_data_def_props_conditional_tag, "SW-CALIBRATION-ACCESS", sw_data_def_props.swCalibrationAccess)
-            self.setSwCalprmAxisSet(sw_data_def_props_conditional_tag, "SW-CALPRM-AXIS-SET", sw_data_def_props.swCalprmAxisSet)
-            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "COMPU-METHOD-REF", sw_data_def_props.compuMethodRef)
-            self.setChildElementOptionalLiteral(sw_data_def_props_conditional_tag, "SW-IMPL-POLICY", sw_data_def_props.swImplPolicy)
-            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF", sw_data_def_props.implementationDataTypeRef)
-            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "DATA-CONSTR-REF", sw_data_def_props.dataConstrRef)
-            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "SW-RECORD-LAYOUT-REF", sw_data_def_props.swRecordLayoutRef)
-            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "VALUE-AXIS-DATA-TYPE-REF", sw_data_def_props.valueAxisDataTypeRef)
-            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "UNIT-REF", sw_data_def_props.unitRef)
-            
+            self.setAnnotations(sw_data_def_props_conditional_tag, sw_data_def_props.getAnnotations())
+            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "BASE-TYPE-REF", sw_data_def_props.getBaseTypeRef())
+            self.writeSwDataDefProsInvalidValue(sw_data_def_props_conditional_tag, sw_data_def_props)
+            self.setChildElementOptionalLiteral(sw_data_def_props_conditional_tag, "SW-CALIBRATION-ACCESS", sw_data_def_props.getSwCalibrationAccess())
+            self.setSwCalprmAxisSet(sw_data_def_props_conditional_tag, "SW-CALPRM-AXIS-SET", sw_data_def_props.getSwCalprmAxisSet())
+            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "COMPU-METHOD-REF", sw_data_def_props.getCompuMethodRef())
+            self.setChildElementOptionalLiteral(sw_data_def_props_conditional_tag, "SW-IMPL-POLICY", sw_data_def_props.getSwImplPolicy())
+            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF", sw_data_def_props.getImplementationDataTypeRef())
+            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "DATA-CONSTR-REF", sw_data_def_props.getDataConstrRef())
+            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "SW-RECORD-LAYOUT-REF", sw_data_def_props.getSwRecordLayoutRef())
+            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "VALUE-AXIS-DATA-TYPE-REF", sw_data_def_props.getValueAxisDataTypeRef())
+            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "UNIT-REF", sw_data_def_props.getUnitRef())
 
     def writeApplicationDataType(self, element: ET.Element, data_type: ApplicationDataType):
         self.writeAutosarDataType(element, data_type)
@@ -522,8 +608,8 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeApplicationDataType(element, data_type)
 
     def writeAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
-        self.writeARElement(element, data_type)
-        self.setSwDataDefProps(element, "SW-DATA-DEF-PROPS", data_type.sw_data_def_props)
+        self.setARElement(element, data_type)
+        self.setSwDataDefProps(element, "SW-DATA-DEF-PROPS", data_type.swDataDefProps)
 
     def writeApplicationPrimitiveDataType(self, element: ET.Element, data_type: ApplicationPrimitiveDataType):
         self.logger.debug("writeApplicationPrimitiveDataType %s" % data_type.short_name)
@@ -531,7 +617,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeApplicationDataType(data_type_tag, data_type)
 
     def setDataPrototype(self, element: ET.Element, prototype: DataPrototype):
-        self.writeIdentifiable(element, prototype)
+        self.setIdentifiable(element, prototype)
 
     def setApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
         self.setDataPrototype(element, prototype)
@@ -570,7 +656,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeSwBaseType(self, element: ET.Element, base_type: SwBaseType):
         data_type_tag = ET.SubElement(element, "SW-BASE-TYPE")
-        self.writeIdentifiable(data_type_tag, base_type)
+        self.setIdentifiable(data_type_tag, base_type)
         self.writeBaseTypeDirectDefinition(data_type_tag, base_type.baseTypeDefinition)
 
     def writeCompuScaleConstantContents(self, element: ET.Element, contents: CompuScaleConstantContents):
@@ -620,7 +706,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeCompuMethod(self, element: ET.Element, compu_method: CompuMethod):
         compu_method_tag = ET.SubElement(element, "COMPU-METHOD")
         self.logger.debug("writeCompuMethods %s" % compu_method.short_name)
-        self.writeIdentifiable(compu_method_tag, compu_method)
+        self.setIdentifiable(compu_method_tag, compu_method)
         self.setChildElementOptionalRefType(compu_method_tag, "UNIT-REF", compu_method.unit_ref)
         self.writeCompuInternalToPhys(compu_method_tag, compu_method)
 
@@ -651,11 +737,11 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeConstantSpecification(self, element: ET.Element, spec: ConstantSpecification):
         spec_tag = ET.SubElement(element, "CONSTANT-SPECIFICATION")
-        self.writeIdentifiable(spec_tag, spec)
+        self.setIdentifiable(spec_tag, spec)
 
-        if spec.value_spec is not None:
+        if spec.getValueSpec() is not None:
             value_spec_tag = ET.SubElement(spec_tag, "VALUE-SPEC")
-            self.setValueSpecification(value_spec_tag, spec.value_spec)
+            self.setValueSpecification(value_spec_tag, spec.getValueSpec())
                 
     def setInternalConstrs(self, element: ET.Element, constrs: InternalConstrs):
         if constrs is not None:
@@ -689,21 +775,24 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeDataConstr(self, element: ET.Element, constr: DataConstr):
         child_element = ET.SubElement(element, "DATA-CONSTR")
-        self.writeIdentifiable(child_element, constr)
+        self.setIdentifiable(child_element, constr)
         self.writeDataConstrRules(child_element, constr) 
 
     def writeUnit(self, element: ET.Element, unit: Unit):
         self.logger.debug("writeUnit %s" % unit.short_name)
         child_element = ET.SubElement(element, "UNIT")
-        self.writeIdentifiable(child_element, unit)
-        self.setChildElementOptionalLiteral(child_element, "DISPLAY-NAME", unit.display_name)
+        self.setIdentifiable(child_element, unit)
+        self.setChildElementOptionalLiteral(child_element, "DISPLAY-NAME", unit.getDisplayName())
+        self.setChildElementOptionalFloatValue(child_element, "FACTOR-SI-TO-UNIT", unit.getFactorSiToUnit())
+        self.setChildElementOptionalFloatValue(child_element, "OFFSET-SI-TO-UNIT", unit.getOffsetSiToUnit())
+        self.setChildElementOptionalRefType(child_element, "PHYSICAL-DIMENSION-REF", unit.getPhysicalDimensionRef())
 
     def setRModeInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: RModeInAtomicSwcInstanceRef):
         child_element = ET.SubElement(element, key)
-        self.setChildElementOptionalRefType(child_element, "BASE", iref.base_ref)
-        self.setChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF", iref.context_port_ref)
-        self.setChildElementOptionalRefType(child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF", iref.context_mode_declaration_group_prototype_ref)
-        self.setChildElementOptionalRefType(child_element, "TARGET-MODE-DECLARATION-REF", iref.target_mode_declaration_ref)
+        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, "TARGET-MODE-DECLARATION-REF", iref.getTargetModeDeclarationRef())
 
     def setPOperationInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: POperationInAtomicSwcInstanceRef):
         child_element = ET.SubElement(element, key)
@@ -711,7 +800,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRefType(child_element, "TARGET-PROVIDED-OPERATION-REF", iref.target_provided_operation_ref)
 
     def setRTEEvent(self, element: ET.Element, event: RTEEvent):
-        self.writeIdentifiable(element, event)
+        self.setIdentifiable(element, event)
         irefs = event.getDisabledModeIRefs()
         if len(irefs) > 0:
             child_element = ET.SubElement(element, "DISABLED-MODE-IREFS")
@@ -745,18 +834,23 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setRVariableInAtomicSwcInstanceRef(self, element: ET.Element, iref: RVariableInAtomicSwcInstanceRef):
         if iref is not None:
             child_element = ET.SubElement(element, "DATA-IREF")
-            self.setChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF", iref.context_r_port_ref)
-            self.setChildElementOptionalRefType(child_element, "TARGET-DATA-ELEMENT-REF", iref.target_data_element_ref)
+            self.setChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF", iref.getContextRPortRef())
+            self.setChildElementOptionalRefType(child_element, "TARGET-DATA-ELEMENT-REF", iref.getTargetDataElementRef())
 
     def setDataReceivedEvent(self, element: ET.Element, event: DataReceivedEvent):
         if event is not None:
             child_element = ET.SubElement(element, "DATA-RECEIVED-EVENT")
             self.setRTEEvent(child_element, event)
-            self.setRVariableInAtomicSwcInstanceRef(child_element, event.data_iref)
+            self.setRVariableInAtomicSwcInstanceRef(child_element, event.dataIRef)
 
     def setInternalTriggerOccurredEvent(self, element: ET.Element, event: DataReceivedEvent):
         pass
 
+    def setInitEvent(self, element: ET.Element, event: InitEvent):
+        if event is not None:
+            child_element = ET.SubElement(element, "INIT-EVENT")
+            self.setRTEEvent(child_element, event)
+
     def writeRTEEvents(self, element: ET.Element, parent: SwcInternalBehavior):
         events = parent.getRteEvents()
         if len(events) > 0:
@@ -773,6 +867,8 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.setDataReceivedEvent(child_element, event)
                 elif isinstance(event, InternalTriggerOccurredEvent):
                     self.setInternalTriggerOccurredEvent(child_element, event)
+                elif isinstance(event, InitEvent):
+                    self.setInitEvent(child_element, event)
                 else:
                     raise NotImplementedError("Unsupported Event <%s>" % type(event))
                 
@@ -782,7 +878,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             areas_tag = ET.SubElement(element, "EXCLUSIVE-AREAS")
             for area in areas:
                 child_element = ET.SubElement(areas_tag, "EXCLUSIVE-AREA")
-                self.writeIdentifiable(child_element, area)
+                self.setIdentifiable(child_element, area)
 
     def writeDataTypeMappingRefs(self, element: ET.Element, behavior: InternalBehavior):
         refs = behavior.getDataTypeMappingRefs()
@@ -790,30 +886,34 @@ class ARXMLWriter(AbstractARXMLWriter):
             refs_tag = ET.SubElement(element, "DATA-TYPE-MAPPING-REFS")
             for ref in refs:
                 self.setChildElementOptionalRefType(refs_tag, "DATA-TYPE-MAPPING-REF", ref)
+
+    def writeInternalBehaviorConstantMemories(self, element: ET.Element, behavior: InternalBehavior):
+        memories = behavior.getConstantMemorys()
+        if len(memories) > 0:
+            child_element = ET.SubElement(element, "CONSTANT-MEMORYS")
+            for memory in memories:
+                self.writeParameterDataPrototype(child_element, memory)
            
     def writeInternalBehavior(self, element: ET.Element, behavior: InternalBehavior):
-        self.writeIdentifiable(element, behavior)
+        self.setIdentifiable(element, behavior)
+        self.writeInternalBehaviorConstantMemories(element, behavior)
         self.writeDataTypeMappingRefs(element, behavior)
         self.writeExclusiveAreas(element, behavior)
 
-    def writeExecutableEntity(self, element: ET.Element, entity: ExecutableEntity):
-        if entity is not None:
-            self.setChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL", entity.minimum_start_interval)
-
     def setAutosarVariableRef(self, element: ET.Element, ref: AutosarVariableRef):
         if ref is not None:
             child_element = ET.SubElement(element, "ACCESSED-VARIABLE")
-            if ref.autosar_variable_iref is not None:
+            self.setARObjectAttributes(child_element, ref)
+            if ref.getAutosarVariableIRef() is not None:
                 child_element = ET.SubElement(child_element, "AUTOSAR-VARIABLE-IREF")
-                self.setChildElementOptionalRefType(child_element, "PORT-PROTOTYPE-REF", ref.autosar_variable_iref.port_prototype_ref)
-                self.setChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF", ref.autosar_variable_iref.target_data_prototype_ref)
-            if ref.local_variable_ref is not None:
-                self.setChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF", ref.local_variable_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, "LOCAL-VARIABLE-REF", ref.getLocalVariableRef())
 
     def setVariableAccess(self, element: ET.Element, access: VariableAccess):
         child_element = ET.SubElement(element, "VARIABLE-ACCESS")
-        self.writeIdentifiable(child_element, access)
-        self.setAutosarVariableRef(child_element, access.accessed_variable_ref)
+        self.setIdentifiable(child_element, access)
+        self.setAutosarVariableRef(child_element, access.getAccessedVariableRef())
 
     def writeDataReadAccesses(self, element: ET.Element, entity: RunnableEntity):
         #accesses = entity.getDataReadAccesses():
@@ -826,7 +926,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeParameterAccess(self, element: ET.Element, parameter_access: ParameterAccess):
         child_element = ET.SubElement(element, "PARAMETER-ACCESS")
-        self.writeIdentifiable(child_element, parameter_access)
+        self.setIdentifiable(child_element, parameter_access)
         self.setAutosarParameterRef(child_element, "ACCESSED-PARAMETER", parameter_access.accessed_parameter)
 
     def writeParameterAccesses(self, element: ET.Element, entity: RunnableEntity):
@@ -864,20 +964,20 @@ class ARXMLWriter(AbstractARXMLWriter):
             for access in variables:
                 self.setVariableAccess(child_element, access)
 
-    def writeROperationInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: ROperationInAtomicSwcInstanceRef):
+    def setROperationInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: ROperationInAtomicSwcInstanceRef):
         if iref is not None:
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF", iref.context_r_port_ref)
             self.setChildElementOptionalRefType(child_element, "TARGET-REQUIRED-OPERATION-REF", iref.target_required_operation_ref)
         
-    def writeServerCallPoint(self, element: ET.Element, call_point: ServerCallPoint):
-        self.writeROperationInAtomicSwcInstanceRef(element, "OPERATION-IREF", call_point.operation_iref)
+    def setServerCallPoint(self, element: ET.Element, call_point: ServerCallPoint):
+        self.setROperationInAtomicSwcInstanceRef(element, "OPERATION-IREF", call_point.getOperationIRef())
         self.setChildElementOptionalFloatValue(element, "TIMEOUT", call_point.timeout)
 
-    def writeSynchronousServerCallPoint(self, element: ET.Element, call_point: SynchronousServerCallPoint):
+    def setSynchronousServerCallPoint(self, element: ET.Element, call_point: SynchronousServerCallPoint):
         child_element = ET.SubElement(element, "SYNCHRONOUS-SERVER-CALL-POINT")
-        self.writeIdentifiable(child_element, call_point)
-        self.writeServerCallPoint(child_element, call_point)
+        self.setIdentifiable(child_element, call_point)
+        self.setServerCallPoint(child_element, call_point)
 
     def writeServerCallPoints(self, element: ET.Element, entity: RunnableEntity):
         call_points = entity.getServerCallPoints()
@@ -885,7 +985,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "SERVER-CALL-POINTS")
             for call_point in call_points:
                 if isinstance(call_point, SynchronousServerCallPoint):
-                    self.writeSynchronousServerCallPoint(child_element, call_point)
+                    self.setSynchronousServerCallPoint(child_element, call_point)
                 else:
                     self._raiseError("Unsupported ServerCallPoint type <%s>" % type(call_point))
 
@@ -896,16 +996,62 @@ class ARXMLWriter(AbstractARXMLWriter):
             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 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 writeModeAccessPoints(self, element: ET.Element, entity: RunnableEntity):
+        points = entity.getModeAccessPoints()
+        if len(points) > 0:
+            mode_access_points_tag = 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):
+        points = entity.getModeSwitchPoints()
+        if len(points) > 0:
+            mode_access_points_tag = ET.SubElement(element, "MODE-SWITCH-POINTS")
+            for point in points:
+                child_element = ET.SubElement(mode_access_points_tag, "MODE-SWITCH-POINT")
+                self.setIdentifiable(child_element, point)
+                self.setPModeGroupInAtomicSWCInstanceRef(child_element, "MODE-GROUP-IREF", point.getModeGroupIRef())
+
+    def setRunnableEntityArgument(self, element: ET.Element, argument: RunnableEntityArgument):
+        child_element = ET.SubElement(element, "RUNNABLE-ENTITY-ARGUMENT")
+        self.setChildElementOptionalLiteral(child_element, "SYMBOL", argument.getSymbol())
+
+    def writeRunnableEntityArguments(self, element: ET.Element, entity: RunnableEntity):
+        arguments = entity.getArguments()
+        if len(arguments) > 0:
+            child_element = ET.SubElement(element, "ARGUMENTS")
+            for argument in arguments:
+                if isinstance(argument, RunnableEntityArgument):
+                    self.setRunnableEntityArgument(child_element, argument)
+                else:
+                    raise NotImplementedError("Unsupported argument of Runnable Entity <%s>" % type(argument))
+
     def writeRunnableEntity(self, element: ET.Element, entity: RunnableEntity):
         if entity is not None:
             child_element = ET.SubElement(element, "RUNNABLE-ENTITY")
-            self.writeIdentifiable(child_element, entity)
-            self.writeExecutableEntity(child_element, entity)
-            self.setChildElementOptionalBooleanValue(child_element, "CAN-BE-INVOKED-CONCURRENTLY", entity.can_be_invoked_concurrently)
+            self.setExecutableEntity(child_element, entity)
+            self.writeRunnableEntityArguments(child_element, entity)
+            self.setChildElementOptionalBooleanValue(child_element, "CAN-BE-INVOKED-CONCURRENTLY", entity.getCanBeInvokedConcurrently())
             self.writeParameterAccesses(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.writeReadLocalVariables(child_element, entity)
             self.writeServerCallPoints(child_element, entity)
             self.setChildElementOptionalLiteral(child_element, "SYMBOL", entity.symbol)
@@ -937,20 +1083,20 @@ class ARXMLWriter(AbstractARXMLWriter):
             memories_tag = ET.SubElement(element, "PER-INSTANCE-MEMORYS")
             for memory in memories:
                 child_element = ET.SubElement(memories_tag, "PER-INSTANCE-MEMORY")
-                self.writeIdentifiable(child_element, memory)
-                self.setChildElementOptionalLiteral(child_element, "INIT-VALUE", memory.init_value)
-                self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", memory.sw_data_def_props)
+                self.setIdentifiable(child_element, memory)
+                self.setChildElementOptionalLiteral(child_element, "INIT-VALUE", memory.initValue)
+                self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", memory.swDataDefProps)
                 self.setChildElementOptionalLiteral(child_element, "TYPE", memory.type)
-                self.setChildElementOptionalLiteral (child_element, "TYPE-DEFINITION", memory.type_definition)
+                self.setChildElementOptionalLiteral (child_element, "TYPE-DEFINITION", memory.typeDefinition)
 
     def writeParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
         child_element = ET.SubElement(element, "PARAMETER-DATA-PROTOTYPE")
-        self.writeIdentifiable(child_element, prototype)
+        self.setIdentifiable(child_element, prototype)
         self.writeAutosarDataPrototype(child_element, prototype)
-        self.setInitValue(child_element, prototype.init_value)
+        self.setInitValue(child_element, prototype.initValue)
 
     def writeParameterDataPrototypes(self, element: ET.Element, behavior: SwcInternalBehavior):
-        prototypes = behavior.getParameterDataPrototypes()
+        prototypes = behavior.getPerInstanceParameters()
         if len(prototypes) > 0:
             child_element = ET.SubElement(element, "PER-INSTANCE-PARAMETERS")
             for prototype in prototypes:
@@ -979,7 +1125,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(child_element, "PORT-REF", option.port_ref)
 
     def writeServiceDependency(self, element: ET.Element, dependency: ServiceDependency):
-        self.writeIdentifiable(element, dependency)
+        self.setIdentifiable(element, dependency)
 
     def writeRoleBasedDataAssignment(self, element: ET.Element, assignment: RoleBasedDataAssignment):
         child_element = ET.SubElement(element, "ROLE-BASED-DATA-ASSIGNMENT")
@@ -1015,7 +1161,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
         child_element = ET.SubElement(element, "NV-BLOCK-NEEDS")
         self.logger.debug("writeNvBlockNeeds %s" % needs.short_name)
-        self.writeIdentifiable(child_element, needs)
+        self.setIdentifiable(child_element, needs)
         self.setChildElementOptionalBooleanValue(child_element, "CALC-RAM-BLOCK-CRC", needs.calc_ram_block_crc)
         self.setChildElementOptionalBooleanValue(child_element, "CHECK-STATIC-BLOCK-ID", needs.check_static_block_id)
         self.setChildElementOptionalNumericalValue(child_element, "N-DATA-SETS", needs.n_data_sets)
@@ -1056,6 +1202,18 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported ServiceDependency <%s>" % type(dependency))
 
+    def setIncludedDataTypeSets(self, element: ET.Element, sets: List[IncludedDataTypeSet]):
+        if len(sets) > 0:
+            include_data_type_sets_tag = ET.SubElement(element, "INCLUDED-DATA-TYPE-SETS")
+            for set in sets:
+                child_element = ET.SubElement(include_data_type_sets_tag, "INCLUDED-DATA-TYPE-SET")
+                self.setARObjectAttributes(child_element, set)
+                type_refs = set.getDataTypeRefs()
+                if len(type_refs) > 0:
+                    data_type_refs_tag = ET.SubElement(child_element, "DATA-TYPE-REFS")
+                    for type_ref in type_refs:
+                        self.setChildElementOptionalRefType(data_type_refs_tag, "DATA-TYPE-REF", type_ref)
+
     def writeSwcInternalBehavior(self, element: ET.Element, behavior: SwcInternalBehavior):
         self.logger.debug("writeSwInternalBehavior %s" % behavior.short_name)
 
@@ -1064,6 +1222,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeRTEEvents(child_element, behavior)
         self.writeExplicitInterRunnableVariables(child_element, behavior)
         self.setChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART", behavior.handle_termination_and_restart)
+        self.setIncludedDataTypeSets(child_element, behavior.getIncludedDataTypeSets())
         self.writePerInstanceMemories(child_element, behavior)
         self.writeParameterDataPrototypes(child_element, behavior)
         self.writePortAPIOptions(child_element, behavior)
@@ -1102,7 +1261,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setCode(self, element: ET.SubElement, code_desc: Code):
         self.logger.debug("setCode %s" % code_desc.short_name)
         child_element = ET.SubElement(element, "CODE")
-        self.writeIdentifiable(child_element, code_desc)
+        self.setIdentifiable(child_element, code_desc)
         self.writeArtifactDescriptor(child_element, code_desc)
 
     def writeCodeDescriptors(self, element: ET.Element, impl: Implementation):
@@ -1127,7 +1286,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             sections_tag = ET.SubElement(element, "MEMORY-SECTIONS")
             for memory_section in memory_sections:
                 child_element = ET.SubElement(sections_tag, "MEMORY-SECTION")
-                self.writeIdentifiable(child_element, memory_section)
+                self.setIdentifiable(child_element, memory_section)
                 self.setChildElementOptionalLiteral(child_element, "ALIGNMENT", memory_section.alignment)
                 self.setMemorySectionOptions(child_element, memory_section.getOptions())
                 self.setChildElementOptionalNumericalValue(child_element, "SIZE", memory_section.size)
@@ -1138,11 +1297,11 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setResourceConsumption(self, element: ET.Element, consumption: ResourceConsumption):
         if consumption is not None:
             child_element = ET.SubElement(element, "RESOURCE-CONSUMPTION")
-            self.writeIdentifiable(child_element, consumption)
+            self.setIdentifiable(child_element, consumption)
             self.writeMemorySections(child_element, consumption)
 
     def writeImplementation(self, element: ET.Element, impl: Implementation):
-        self.writeIdentifiable(element, impl)
+        self.setIdentifiable(element, impl)
         self.writeCodeDescriptors(element, impl)
         self.setChildElementOptionalLiteral(element, "PROGRAMMING-LANGUAGE", impl.programming_language)
         self.setResourceConsumption(element, impl.getResourceConsumption())
@@ -1177,10 +1336,10 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setVariableDataPrototypeInSystemInstanceRef(self, element: ET.Element, key: str, iref: VariableDataPrototypeInSystemInstanceRef):
         if iref is not None:
             child_element = ET.SubElement(element, key)
-            self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPONENT-REF", iref.contextComponentRef)
-            self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPOSITION-REF", iref.contextCompositionRef)
-            self.setChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF", iref.contextPortRef)
-            self.setChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF", iref.targetDataPrototypeRef)
+            self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPONENT-REF", iref.context_component_refs)
+            self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPOSITION-REF", iref.context_composition_ref)
+            self.setChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF", iref.context_port_ref)
+            self.setChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF", iref.target_data_prototype_ref)
 
     def setEndToEndProtectionVariablePrototype(self, element: ET.Element, key: str, prototype: EndToEndProtectionVariablePrototype):
         if prototype is not None:
@@ -1205,7 +1364,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setEndToEndProtection(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.setIdentifiable(child_element, protection)
             self.setEndToEndDescription(child_element, "END-TO-END-PROFILE", protection.endToEndProfile)
             self.writeEndToEndProtectionVariablePrototypes(child_element, protection)
 
@@ -1220,21 +1379,21 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeEndToEndProtectionSet(self, element: ET.Element, protection_set: EndToEndProtectionSet):
         self.logger.debug("writeEndToEndProtectionSet %s" % protection_set.short_name)
         child_element = ET.SubElement(element, "END-TO-END-PROTECTION-SET")
-        self.writeIdentifiable(child_element, protection_set)
+        self.setIdentifiable(child_element, protection_set)
         self.writeEndToEndProtections(child_element, protection_set)
 
     def writeAutosarDataPrototype(self, element: ET.Element, prototype: AutosarDataPrototype):
-        self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.type_tref)
+        self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.typeTRef)
 
     def writeVariableDataPrototype(self, element: ET.Element, prototype: VariableDataPrototype):
         self.logger.debug("writeVariableDataPrototype %s" % prototype.short_name)
         child_element = ET.SubElement(element, "VARIABLE-DATA-PROTOTYPE")
-        self.writeIdentifiable(child_element, prototype)
-        self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", prototype.sw_data_def_props)
+        self.setIdentifiable(child_element, prototype)
+        self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", prototype.swDataDefProps)
         self.writeAutosarDataPrototype(child_element, prototype)
-        self.setInitValue(child_element, prototype.init_value)
+        self.setInitValue(child_element, prototype.initValue)
 
-    def writeDataElements(self, element: ET.Element, sr_interface: SenderReceiverInterface):
+    def writeSenderReceiverInterfaceDataElements(self, element: ET.Element, sr_interface: SenderReceiverInterface):
         data_elements = sr_interface.getDataElements()
         if len(data_elements) > 0:
             data_elements_tag = ET.SubElement(element, "DATA-ELEMENTS")
@@ -1244,12 +1403,22 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported Data Element <%s>" % type(data_element))
 
+    def writeSenderReceiverInterfaceInvalidationPolicies(self, element: ET.Element, sr_interface: SenderReceiverInterface):
+        policies = sr_interface.getInvalidationPolicies()
+        if len(policies) > 0:
+            policies_tag = ET.SubElement(element, "INVALIDATION-POLICYS")
+            for policy in policies:
+                child_element = ET.SubElement(policies_tag, "INVALIDATION-POLICY")
+                self.setChildElementOptionalRefType(child_element, "DATA-ELEMENT-REF", policy.getDataElementRef())
+                self.setChildElementOptionalLiteral(child_element, "HANDLE-INVALID", policy.getHandleInvalid())
+
     def writeSenderReceiverInterface(self, element: ET.Element, sr_interface: SenderReceiverInterface):
         self.logger.debug("writeSenderReceiverInterface %s" % sr_interface.short_name)
         child_element = ET.SubElement(element, "SENDER-RECEIVER-INTERFACE")
-        self.writeIdentifiable(child_element, sr_interface)
-        self.setChildElementOptionalBooleanValue(child_element, "IS-SERVICE", sr_interface.is_service)
-        self.writeDataElements(child_element, sr_interface)
+        self.setIdentifiable(child_element, sr_interface)
+        self.setChildElementOptionalBooleanValue(child_element, "IS-SERVICE", sr_interface.isService)
+        self.writeSenderReceiverInterfaceDataElements(child_element, sr_interface)
+        self.writeSenderReceiverInterfaceInvalidationPolicies(child_element, sr_interface)
 
     def writerBswModuleDescriptionImplementedEntry(self, element: ET.Element, desc: BswModuleDescription):
         entries = desc.getImplementedEntries()
@@ -1260,7 +1429,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(entry_tag, "BSW-MODULE-ENTRY-REF", entry)
 
     def setModeDeclarationGroupPrototype(self, element: ET.Element, prototype: ModeDeclarationGroupPrototype):
-        self.writeIdentifiable(element, prototype)
+        self.setIdentifiable(element, prototype)
         self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.type_tref)
 
     def writeProvidedModeGroup(self, element: ET.Element, parent: BswModuleDescription):
@@ -1279,9 +1448,10 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(child_element, "CAN-ENTER-EXCLUSIVE-AREA-REF", ref)
 
     def setExecutableEntity(self, element: ET.Element, entity: ExecutableEntity):
-        self.writeIdentifiable(element, entity)
+        self.setIdentifiable(element, entity)
         self.writeCanEnterExclusiveAreaRefs(element, entity)
-        self.setChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL", entity.minimum_start_interval)
+        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):
         mode_group_refs = entity.getManagedModeGroupRefs()
@@ -1293,7 +1463,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
         self.setExecutableEntity(element, entity)
-        self.setChildElementOptionalRefType(element, "IMPLEMENTED-ENTRY-REF", entity.implemented_entry_ref)
+        self.setChildElementOptionalRefType(element, "IMPLEMENTED-ENTRY-REF", entity.implementedEntryRef)
         self.writeBswModuleEntityManagedModeGroup(element, entity)
 
     def setBswCalledEntity(self, element: ET.Element, entity: BswCalledEntity):
@@ -1319,7 +1489,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self._raiseError("Unsupported BswModuleEntity <%s>" % type(entity))
 
     def setBswEvent(self, element: ET.Element, event: BswEvent):
-        self.writeIdentifiable(element, event)
+        self.setIdentifiable(element, event)
         self.setChildElementOptionalRefType(element, "STARTS-ON-EVENT-REF", event.startsOnEventRef)
 
     def setBswScheduleEvent(self, element: ET.Element, event: BswScheduleEvent):
@@ -1356,12 +1526,23 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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")
+
+    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)
+
     def setBswInternalBehavior(self, element: ET.Element, behavior: BswInternalBehavior):
         child_element = ET.SubElement(element, "BSW-INTERNAL-BEHAVIOR")
         self.writeInternalBehavior(child_element, behavior)
         self.writeBswInternalBehaviorBswModuleEntities(child_element, behavior)
         self.writeBswInternalBehaviorBswEvents(child_element, behavior)
         self.writeBswInternalBehaviorModeSenderPolicy(child_element, behavior)
+        self.writeBswInternalBehaviorIncludedModeDeclarationGroupSets(child_element, behavior)
 
     def writeBswModuleDescriptionInternalBehaviors(self, element: ET.Element, behaviors: List[InternalBehavior]):
         if len(behaviors) > 0:
@@ -1375,7 +1556,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeBswModuleDescription(self, element: ET.Element, desc: BswModuleDescription):
         self.logger.debug("writeBswModuleDescription %s" % desc.short_name)
         child_element = ET.SubElement(element, "BSW-MODULE-DESCRIPTION")
-        self.writeIdentifiable(child_element, desc)
+        self.setIdentifiable(child_element, desc)
         self.setChildElementOptionalNumericalValue(child_element, "MODULE-ID", desc.module_id)
         self.writerBswModuleDescriptionImplementedEntry(child_element, desc)
         self.writeProvidedModeGroup(child_element, desc)
@@ -1393,7 +1574,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeBswModuleEntry(self, element: ET.Element, entry: BswModuleEntry):
         self.logger.debug("writeBswModuleDescription %s" % entry.short_name)
         child_element = ET.SubElement(element, "BSW-MODULE-ENTRY")
-        self.writeIdentifiable(child_element, entry)
+        self.setIdentifiable(child_element, entry)
         self.setChildElementOptionalNumericalValue(child_element, "SERVICE-ID", entry.service_id)
         self.setChildElementOptionalBooleanValue(child_element, "IS-REENTRANT", entry.is_reentrant)
         self.setChildElementOptionalBooleanValue(child_element, "IS-SYNCHRONOUS", entry.is_synchronous)
@@ -1420,7 +1601,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setSwcBswMapping(self, element: ET.Element, mapping: SwcBswMapping):
         self.logger.debug("writeBswModuleDescription %s" % mapping.short_name)
         child_element = ET.SubElement(element, "SWC-BSW-MAPPING")
-        self.writeIdentifiable(child_element, mapping)
+        self.setIdentifiable(child_element, mapping)
         self.setChildElementOptionalRefType(child_element, "BSW-BEHAVIOR-REF", mapping.bswBehaviorRef)
         self.writeSwcBswRunnableMappings(child_element, mapping)
         self.setChildElementOptionalRefType(child_element, "SWC-BEHAVIOR-REF", mapping.swcBehaviorRef)
@@ -1467,15 +1648,17 @@ class ARXMLWriter(AbstractARXMLWriter):
             sub_elements_tag = ET.SubElement(element, "SUB-ELEMENTS")
             for type_element in sub_elements:
                 child_element = ET.SubElement(sub_elements_tag, "IMPLEMENTATION-DATA-TYPE-ELEMENT")
-                self.writeIdentifiable(child_element, type_element)
-                self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", type_element.sw_data_def_props)
+                self.setIdentifiable(child_element, type_element)
+                self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE", type_element.getArraySize())
+                self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS", type_element.getArraySizeSemantics())
+                self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", type_element.swDataDefProps)
 
     def writeImplementationDataType(self, element: ET.Element, data_type: ImplementationDataType):
         self.logger.debug("writeImplementationDataType %s" % data_type.short_name)
         child_element = ET.SubElement(element, "IMPLEMENTATION-DATA-TYPE")
         self.writeAutosarDataType(child_element, data_type)
-        self.setChildElementOptionalLiteral(child_element, "TYPE-EMITTER", data_type.getTypeEmitter())
         self.writeImplementationDataTypeElements(child_element, data_type)
+        self.setChildElementOptionalLiteral(child_element, "TYPE-EMITTER", data_type.getTypeEmitter())
 
     def writeArgumentDataPrototypes(self, element: ET.Element, parent: ClientServerOperation):
         arguments = parent.getArgumentDataPrototypes()
@@ -1483,8 +1666,9 @@ class ARXMLWriter(AbstractARXMLWriter):
             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.setChildElementOptionalRefType(child_element, "TYPE-TREF", prototype.type_tref)
+                self.setIdentifiable(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)
 
     def writePossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
@@ -1497,7 +1681,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeClientServerOperation(self, element: ET.Element, operation: ClientServerOperation):
         self.logger.debug("writeClientServerOperation %s" % operation.short_name)
         child_element = ET.SubElement(element, "CLIENT-SERVER-OPERATION")
-        self.writeIdentifiable(child_element, operation)
+        self.setIdentifiable(child_element, operation)
         self.writeArgumentDataPrototypes(child_element, operation)
         self.writePossibleErrorRefs(child_element, operation)
 
@@ -1514,7 +1698,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeApplicationError(self, element: ET.Element, error: ApplicationError):
         self.logger.debug("writeApplicationError %s" % error.short_name)
         child_element = ET.SubElement(element, "APPLICATION-ERROR")
-        self.writeIdentifiable(child_element, error)
+        self.setIdentifiable(child_element, error)
         self.setChildElementOptionalNumericalValue(child_element, "ERROR-CODE", error.error_code)
 
     def writePossibleErrors(self, element: ET.Element, parent: ClientServerInterface):
@@ -1528,8 +1712,8 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self._raiseError("Unsupported PossibleError %s" % type(error))
 
     def setPortInterface(self, element: ET.Element, port_interface: PortInterface):
-        self.writeIdentifiable(element, port_interface)
-        self.setChildElementOptionalBooleanValue(element, "IS-SERVICE", port_interface.is_service)
+        self.setIdentifiable(element, port_interface)
+        self.setChildElementOptionalBooleanValue(element, "IS-SERVICE", port_interface.isService)
         self.setChildElementOptionalLiteral(element, "SERVICE-KIND", port_interface.serviceKind)
 
     def writeClientServerInterface(self, element: ET.Element, cs_interface: ClientServerInterface):
@@ -1587,7 +1771,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
         self.logger.debug("writeSwRecordLayout %s" % layout.short_name)
         child_element = ET.SubElement(element, "SW-RECORD-LAYOUT")
-        self.writeIdentifiable(child_element, layout)
+        self.setIdentifiable(child_element, layout)
         self.setSwRecordLayoutGroup(child_element, "SW-RECORD-LAYOUT-GROUP", layout.swRecordLayoutGroup)
 
     def writeSwAddrMethod(self, element: ET.Element, method: SwAddrMethod):
@@ -1619,19 +1803,20 @@ class ARXMLWriter(AbstractARXMLWriter):
             maps_tag = ET.SubElement(element, "MODE-REQUEST-TYPE-MAPS")
             for map in maps:
                 child_element = ET.SubElement(maps_tag, "MODE-REQUEST-TYPE-MAP")
+                self.setARObjectAttributes(child_element, map)
                 self.setChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF", map.implementation_data_type_ref)
                 self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", map.mode_group_ref)
 
     def writeDataTypeMappingSet(self, element: ET.Element, mapping_set: DataTypeMappingSet):
         self.logger.debug("writeDataTypeMappingSet %s" % mapping_set.short_name)
         child_element = ET.SubElement(element, "DATA-TYPE-MAPPING-SET")
-        self.writeIdentifiable(child_element, mapping_set)
+        self.setIdentifiable(child_element, mapping_set)
         self.writeDataTypeMaps(child_element, mapping_set)
         self.writeModeRequestTypeMaps(child_element, mapping_set)
 
     def setModeDeclaration(self, element: ET.Element, mode_declaration: ModeDeclaration):
         child_element = ET.SubElement(element, "MODE-DECLARATION")
-        self.writeIdentifiable(child_element, mode_declaration)
+        self.setIdentifiable(child_element, mode_declaration)
         self.setChildElementOptionalNumericalValue(child_element, "VALUE", mode_declaration.getValue())
 
     def writeModeDeclarationGroupModeDeclaration(self, element: ET.Element, parent: ModeDeclarationGroup):
@@ -1644,7 +1829,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeModeDeclarationGroup(self, element: ET.Element, group: ModeDeclarationGroup):
         self.logger.debug("writeModeDeclarationGroup %s" % group.short_name)
         child_element = ET.SubElement(element, "MODE-DECLARATION-GROUP")
-        self.writeIdentifiable(child_element, group)
+        self.setIdentifiable(child_element, group)
         self.setChildElementOptionalRefType(child_element, "INITIAL-MODE-REF", group._initial_mode_ref)
         self.writeModeDeclarationGroupModeDeclaration(child_element, group)
         self.setChildElementOptionalNumericalValue(child_element, "ON-TRANSITION-VALUE", group.getOnTransitionValue())
@@ -1654,7 +1839,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         if len(mode_groups) > 0:
             mode_group = mode_groups[0]
             child_element = ET.SubElement(element, "MODE-GROUP")
-            self.writeIdentifiable(child_element, mode_group)
+            self.setIdentifiable(child_element, mode_group)
             self.setChildElementOptionalRefType(child_element, "TYPE-TREF", mode_group.type_tref)
 
     def writeModeSwitchInterface(self, element: ET.Element, mode_interface: ModeSwitchInterface):
@@ -1663,6 +1848,640 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setPortInterface(child_element, mode_interface)
         self.writeModeSwitchInterfaceModeGroup(child_element, mode_interface)
 
+    def setEOCExecutableEntityRefSuccessorRefs(self, element: ET.Element, successor_refs: List[RefType]):
+        if len(successor_refs) > 0:
+            child_element = ET.SubElement(element, "SUCCESSOR-REFS")
+            for successor_ref in successor_refs:
+                self.setChildElementOptionalRefType(child_element, "SUCCESSOR-REF", successor_ref)
+
+    def writeEOCExecutableEntityRef(self, element: ET.Element, entity_ref: EOCExecutableEntityRef):
+        child_element = ET.SubElement(element, "EOC-EXECUTABLE-ENTITY-REF")
+        self.setIdentifiable(child_element, entity_ref)
+        self.setEOCExecutableEntityRefSuccessorRefs(child_element, entity_ref.getSuccessorRefs())
+
+    def writeExecutionOrderConstraintOrderedElement(self, element: ET.Element, constraint: ExecutionOrderConstraint):
+        order_elements = constraint.getOrderedElements()
+        if len(order_elements) > 0:
+            child_element = ET.SubElement(element, "ORDERED-ELEMENTS")
+            for order_element in order_elements:
+                if isinstance(order_element, EOCExecutableEntityRef):
+                    self.writeEOCExecutableEntityRef(child_element, order_element)
+                else:
+                    self._raiseError("Unsupported order element <%s>" % type(order_element))
+
+    def writeExecutionOrderConstraint(self, element: ET.Element, constraint: ExecutionOrderConstraint):
+        self.logger.debug("writeExecutionOrderConstraint %s" % constraint.short_name)
+        child_element = ET.SubElement(element, "EXECUTION-ORDER-CONSTRAINT")
+        self.setIdentifiable(child_element, constraint)
+        self.writeExecutionOrderConstraintOrderedElement(child_element, constraint)
+
+    def writeTimingRequirements(self, element: ET.Element, extension: TimingExtension):
+        requirements = extension.getTimingRequirements()
+        if len(requirements) > 0:
+            child_element = ET.SubElement(element, "TIMING-REQUIREMENTS")
+            for requirement in requirements:
+                if isinstance(requirement, ExecutionOrderConstraint):
+                    self.writeExecutionOrderConstraint(child_element, requirement)
+                else:
+                    self._raiseError("Unsupported timing requirement <%s>" % type(requirement))
+
+    def writeTimingExtension(self, element: ET.Element, extension: TimingExtension):
+        self.writeTimingRequirements(element, extension)
+
+    def writeSwcTiming(self, element: ET.Element, timing: SwcTiming):
+        self.logger.debug("writeSWcTiming %s" % timing.short_name)
+        child_element = ET.SubElement(element, "SWC-TIMING")
+        self.setIdentifiable(child_element, timing)
+        self.writeTimingExtension(child_element, timing)
+
+    def writePduToFrameMappings(self, element: ET.Element, parent: Frame):
+        mappings = parent.getPduToFrameMappings()
+        if len(mappings) > 0:
+            mappings_tags = ET.SubElement(element, "PDU-TO-FRAME-MAPPINGS")
+            for mapping in mappings:
+                child_element = ET.SubElement(mappings_tags, "PDU-TO-FRAME-MAPPING")
+                self.setIdentifiable(child_element, mapping)
+                self.setChildElementOptionalLiteral(child_element, "PACKING-BYTE-ORDER", mapping.packingByteOrder)
+                self.setChildElementOptionalRefType(child_element, "PDU-REF", mapping.pduRef)
+                self.setChildElementOptionalNumericalValue(child_element, "START-POSITION", mapping.startPosition)
+
+    def writeFrame(self, element: ET.Element, frame: Frame):
+        self.setIdentifiable(element, frame)
+        self.setChildElementOptionalNumericalValue(element, "FRAME-LENGTH",  frame.frameLength)
+        self.writePduToFrameMappings(element, frame)
+
+    def writeLinUnconditionalFrame(self, element: ET.Element, frame: LinUnconditionalFrame):
+        self.logger.debug("LinUnconditionalFrame %s" % frame.short_name)
+        child_element = ET.SubElement(element, "LIN-UNCONDITIONAL-FRAME")
+        self.writeFrame(child_element, frame)
+
+    def writeNmNode(self, element: ET.Element, nm_node: NmNode):
+        self.setChildElementOptionalRefType(element, "CONTROLLER-REF", nm_node.getControllerRef())
+        self.setChildElementOptionalRefType(element, "NM-IF-ECU-REF", nm_node.getNmIfEcuRef())
+        self.setChildElementOptionalNumericalValue(element, "NM-NODE-ID", nm_node.getNmNodeId())
+
+        refs = nm_node.getRxNmPduRefs()
+        if len(refs) > 0:
+            refs_tag = ET.SubElement(element, "RX-NM-PDU-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(refs_tag, "RX-NM-PDU-REF", ref)
+
+        refs = nm_node.getTxNmPduRefs()
+        if len(refs) > 0:
+            refs_tag = ET.SubElement(element, "TX-NM-PDU-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(refs_tag, "TX-NM-PDU-REF", ref)
+
+    def writeCanNmNode(self, element: ET.Element, nm_node: CanNmNode):
+        self.logger.debug("writeCanNmNode %s" % nm_node.short_name)
+        child_element = ET.SubElement(element, "CAN-NM-NODE")
+        self.setIdentifiable(child_element, nm_node)
+        self.writeNmNode(child_element, nm_node)
+
+        self.setChildElementOptionalFloatValue(child_element, "NM-MSG-CYCLE-OFFSET", nm_node.getNmMsgCycleOffset())
+        self.setChildElementOptionalFloatValue(child_element, "NM-MSG-REDUCED-TIME", nm_node.getNmMsgReducedTime())
+        self.setChildElementRxIdentifierRange(child_element, "NM-RANGE-CONFIG", nm_node.getNmRangeConfig())
+
+    def writeNmClusterNmNodes(self, element: ET.Element, parent: NmCluster):
+        nodes = parent.getNmNodes()
+        if len(nodes) > 0:
+            child_element = ET.SubElement(element, "NM-NODES")
+            for node in nodes:
+                if isinstance(node, CanNmNode):
+                    self.writeCanNmNode(child_element, node)
+                else:
+                    self._raiseError("Unsupported Nm Node <%s>" % type(node))
+
+    def setCanNmClusterCoupling(self, element: ET.Element, coupling: CanNmClusterCoupling):
+        child_element = ET.SubElement(element, "CAN-NM-CLUSTER-COUPLING")
+        refs = coupling.getCoupledClusterRefs()
+        if len(refs) > 0:
+            refs_tag = ET.SubElement(child_element, "COUPLED-CLUSTER-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(refs_tag, "COUPLED-CLUSTER-REF", ref)
+
+        self.setChildElementOptionalBooleanValue(child_element, "NM-BUSLOAD-REDUCTION-ENABLED", coupling.getNmBusloadReductionEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-IMMEDIATE-RESTART-ENABLED", coupling.getNmImmediateRestartEnabled())
+
+    def writeNmConfigNmClusterCouplings(self, element: ET.Element, config: NmConfig):
+        self.logger.debug("writeNmConfigNmClusterCouplings %s" % config.getShortName())
+        couplings = config.getNmClusterCouplings()
+        if len(couplings) > 0:
+            child_element= ET.SubElement(element, "NM-CLUSTER-COUPLINGS")
+            for coupling in couplings:
+                if isinstance(coupling, CanNmClusterCoupling):
+                    self.setCanNmClusterCoupling(child_element, coupling)
+                else:
+                    self._raiseError("Unsupported Nm Cluster Coupling <%s>" % type(coupling))
+
+    def writeNmCluster(self, element: ET.Element, cluster: NmCluster):
+        self.setChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF", cluster.communicationClusterRef)
+        self.setChildElementOptionalNumericalValue(element, "NM-CHANNEL-ID", cluster.nmChannelId)
+        self.setChildElementOptionalBooleanValue(element, "NM-CHANNEL-SLEEP-MASTER", cluster.nmChannelSleepMaster)
+        self.writeNmClusterNmNodes(element, cluster)
+        self.setChildElementOptionalBooleanValue(element, "NM-SYNCHRONIZING-NETWORK", cluster.getNmSynchronizingNetwork())
+
+    def writeCanNmCluster(self, element: ET.Element, cluster: CanNmCluster):
+        self.logger.debug("WriteCanNmCluster %s" % cluster.short_name)
+        child_element = ET.SubElement(element, "CAN-NM-CLUSTER")
+        self.setIdentifiable(child_element, cluster)
+        self.writeNmCluster(child_element, cluster)
+
+        self.setChildElementOptionalBooleanValue(child_element, "NM-BUSLOAD-REDUCTION-ACTIVE", cluster.getNmBusloadReductionActive())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-CAR-WAKE-UP-RX-ENABLED", cluster.getNmCarWakeUpRxEnabled())
+        self.setChildElementOptionalNumericalValue(child_element, "NM-CBV-POSITION", cluster.getNmCbvPosition())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-CHANNEL-ACTIVE", cluster.getNmChannelActive())
+        self.setChildElementOptionalFloatValue(child_element, "NM-IMMEDIATE-NM-CYCLE-TIME", cluster.getNmImmediateNmCycleTime())
+        self.setChildElementOptionalNumericalValue(child_element, "NM-IMMEDIATE-NM-TRANSMISSIONS", cluster.getNmImmediateNmTransmissions())
+        self.setChildElementOptionalFloatValue(child_element, "NM-MESSAGE-TIMEOUT-TIME", cluster.getNmMessageTimeoutTime())
+        self.setChildElementOptionalFloatValue(child_element, "NM-MSG-CYCLE-TIME", cluster.getNmMsgCycleTime())
+        self.setChildElementOptionalFloatValue(child_element, "NM-NETWORK-TIMEOUT", cluster.getNmNetworkTimeout())
+        self.setChildElementOptionalNumericalValue(child_element, "NM-NID-POSITION", cluster.getNmNidPosition())
+        self.setChildElementOptionalFloatValue(child_element, "NM-REMOTE-SLEEP-INDICATION-TIME", cluster.getNmRemoteSleepIndicationTime())
+        self.setChildElementOptionalFloatValue(child_element, "NM-REPEAT-MESSAGE-TIME", cluster.getNmRepeatMessageTime())
+        self.setChildElementOptionalNumericalValue(child_element, "NM-USER-DATA-LENGTH", cluster.getNmUserDataLength())
+        self.setChildElementOptionalFloatValue(child_element, "NM-WAIT-BUS-SLEEP-TIME", cluster.getNmWaitBusSleepTime())
+
+    def writeNmConfigNmClusters(self, element: ET.Element, parent: NmConfig):
+        clusters = parent.getNmClusters()
+        if len(clusters) > 0:
+            child_element = ET.SubElement(element, "NM-CLUSTERS")
+            for cluster in clusters:
+                if isinstance(cluster, CanNmCluster):
+                    self.writeCanNmCluster(child_element, cluster)
+                else:
+                    self._raiseError("Unsupported Nm Cluster <%s>" % type(cluster))
+
+    def writeNmConfig(self, element: ET.Element, config: NmConfig):
+        self.logger.debug("WriteNmConfig %s" % config.short_name)
+        child_element = ET.SubElement(element, "NM-CONFIG")
+        self.setIdentifiable(child_element, config)
+        self.writeNmConfigNmClusters(child_element, config)
+        self.writeNmConfigNmClusterCouplings(child_element, config)
+
+    def writeNmPdu(self, element: ET.Element, pdu: NmPdu):
+        self.logger.debug("NmPdu %s" % pdu.short_name)
+        child_element = ET.SubElement(element, "NM-PDU")
+        self.setIdentifiable(child_element, pdu)
+        self.writeIPdu(child_element, pdu)
+
+    def writeNPdu(self, element: ET.Element, pdu: NPdu):
+        self.logger.debug("NPdu %s" % pdu.short_name)
+        child_element = ET.SubElement(element, "N-PDU")
+        self.setIdentifiable(child_element, pdu)
+        self.writeIPdu(child_element, pdu)
+
+    def writeIPdu(self, element: ET.Element, pdu: IPdu):
+        self.setChildElementOptionalLiteral(element, "LENGTH", pdu.getLength())
+
+    def writeDcmIPdu(self, element: ET.Element, pdu: DcmIPdu):
+        self.logger.debug("DcmIPdu %s" % pdu.short_name)
+        child_element = ET.SubElement(element, "DCM-I-PDU")
+        self.setIdentifiable(child_element, pdu)
+        self.writeIPdu(child_element, pdu)
+        self.setChildElementOptionalLiteral(child_element, "DIAG-PDU-TYPE", pdu.getDiagPduType())
+
+    def writeSecuredIPdu(self, element: ET.Element, pdu: DcmIPdu):
+        self.logger.debug("SecuredIPdu %s" % pdu.short_name)
+        child_element = ET.SubElement(element, "SECURED-I-PDU")
+        self.setIdentifiable(child_element, pdu)
+        self.writeIPdu(child_element, pdu)
+
+    def writeCanTpConfig(self, element: ET.Element, config: CanTpConfig):
+        self.logger.debug("CanTpConfig %s" % config.short_name)
+        child_element = ET.SubElement(element, "CAN-TP-CONFIG")
+        self.setIdentifiable(child_element, config)
+
+    def writeFrameTriggering(self, element: ET.Element, triggering: FrameTriggering):
+        ref_list = triggering.getFramePortRefs()
+        if len(ref_list) > 0:
+            frame_port_refs_tag = ET.SubElement(element, "FRAME-PORT-REFS")
+            for ref in ref_list:
+                self.setChildElementOptionalRefType(frame_port_refs_tag, "FRAME-PORT-REF", ref)
+        self.setChildElementOptionalRefType(element, "FRAME-REF", triggering.getFrameRef())
+
+        refs = triggering.getPduTriggeringRefs()
+        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)
+
+    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.setIdentifiable(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())
+        self.setChildElementOptionalLiteral(child_element, "CAN-FRAME-RX-BEHAVIOR", triggering.getCanFrameRxBehavior())
+        self.setChildElementOptionalLiteral(child_element, "CAN-FRAME-TX-BEHAVIOR", triggering.getCanFrameTxBehavior())
+        self.setChildElementOptionalNumericalValue(child_element, "IDENTIFIER", triggering.getIdentifier())
+        self.setChildElementRxIdentifierRange(child_element, "RX-IDENTIFIER-RANGE", triggering.getRxIdentifierRange())
+
+    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.setIdentifiable(child_element, triggering)
+        self.writeFrameTriggering(child_element, triggering)
+        self.setChildElementOptionalNumericalValue(child_element, "IDENTIFIER", triggering.getIdentifier())
+        self.setChildElementOptionalLiteral(child_element, "LIN-CHECKSUM", triggering.getLinChecksum())
+
+    def writeISignalTriggering(self, element: ET.Element, triggering: ISignalTriggering):
+        self.logger.debug("Write ISignalTriggering %s" % triggering.getShortName())
+        child_element = ET.SubElement(element, "I-SIGNAL-TRIGGERING")
+        self.setIdentifiable(child_element, triggering)
+        self.setChildElementOptionalRefType(child_element, "I-SIGNAL-GROUP-REF", triggering.getISignalGroupRef())
+        ref_list = triggering.getISignalPortRefs()
+        if len(ref_list) > 0:
+            i_signal_port_refs_tag = ET.SubElement(child_element, "I-SIGNAL-PORT-REFS")
+            for ref in ref_list:
+                self.setChildElementOptionalRefType(i_signal_port_refs_tag, "I-SIGNAL-PORT-REF", ref)
+        self.setChildElementOptionalRefType(child_element, "I-SIGNAL-REF", triggering.getISignalRef())
+
+    def writePduTriggering(self, element: ET.Element, triggering: PduTriggering):
+        self.logger.debug("Write PduTriggering %s" % triggering.getShortName())
+        child_element = ET.SubElement(element, "PDU-TRIGGERING")
+        self.setIdentifiable(child_element, triggering)
+        ref_list = triggering.getIPduPortRefs()
+        if len(ref_list) > 0:
+            i_signal_port_refs_tag = ET.SubElement(child_element, "I-PDU-PORT-REFS")
+            for ref in ref_list:
+                self.setChildElementOptionalRefType(i_signal_port_refs_tag, "I-PDU-PORT-REF", ref)
+        self.setChildElementOptionalRefType(child_element, "I-PDU-REF", triggering.getIPduRef())
+
+        refs = triggering.getISignalTriggeringRefs()
+        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)
+
+    def writePhysicalChannel(self, element: ET.Element, channel: PhysicalChannel):
+        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)
+
+        triggerings = channel.getFrameTriggerings()
+        if len(triggerings) > 0:
+            triggerings_tag = ET.SubElement(element, "FRAME-TRIGGERINGS")
+            for triggering in triggerings:
+                if isinstance(triggering, CanFrameTriggering):
+                    self.writeCanFrameTriggering(triggerings_tag, triggering)
+                elif isinstance(triggering, LinFrameTriggering):
+                    self.writeLinFrameTriggering(triggerings_tag, triggering)
+                else:
+                    raise NotImplementedError("Unsupported Frame Triggering <%s>" % type(triggering))
+                
+        triggerings = channel.getISignalTriggerings()
+        if len(triggerings) > 0:
+            triggerings_tag = ET.SubElement(element, "I-SIGNAL-TRIGGERINGS")
+            for triggering in triggerings:
+                if isinstance(triggering, ISignalTriggering):
+                    self.writeISignalTriggering(triggerings_tag, triggering)
+                else:
+                    raise NotImplementedError("Unsupported ISignalTriggering <%s>" % type(triggering))
+                
+        triggerings = channel.getPduTriggerings()
+        if len(triggerings) > 0:
+            triggerings_tag = ET.SubElement(element, "PDU-TRIGGERINGS")
+            for triggering in triggerings:
+                if isinstance(triggering, PduTriggering):
+                    self.writePduTriggering(triggerings_tag, triggering)
+                else:
+                    raise NotImplementedError("Unsupported PduTriggering <%s>" % type(triggering))
+
+    def writeCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
+        self.logger.debug("CanPhysicalChannel %s" % channel.short_name)
+        child_element = ET.SubElement(element, "CAN-PHYSICAL-CHANNEL")
+        self.setIdentifiable(child_element, channel)
+        self.writePhysicalChannel(child_element, channel)
+
+    def writeLinPhysicalChannel(self, element: ET.Element, channel: LinPhysicalChannel):
+        self.logger.debug("LinPhysicalChannel %s" % channel.short_name)
+        child_element = ET.SubElement(element, "LIN-PHYSICAL-CHANNEL")
+        self.setIdentifiable(child_element, channel)
+        self.writePhysicalChannel(child_element, channel)
+
+    def writeCommunicationClusterPhysicalChannels(self, element: ET.Element, cluster: CommunicationCluster):
+        channels = cluster.getPhysicalChannels()
+        if len(channels) > 0:
+            child_element = ET.SubElement(element, "PHYSICAL-CHANNELS")
+            for channel in channels:
+                if isinstance(channel, CanPhysicalChannel):
+                    self.writeCanPhysicalChannel(child_element, channel)
+                elif isinstance(channel, LinPhysicalChannel):
+                    self.writeLinPhysicalChannel(child_element, channel)
+                else:
+                    raise NotImplementedError("Unsupported Physical Channel <%s>" % type(channel))
+
+    def writeCommunicationCluster(self, element: ET.Element, cluster: CommunicationCluster):
+        self.setChildElementOptionalNumericalValue(element, "BAUDRATE", cluster.getBaudrate())
+        self.writeCommunicationClusterPhysicalChannels(element, cluster)
+        self.setChildElementOptionalLiteral(element, "PROTOCOL-NAME", cluster.getProtocolName())
+        self.setChildElementOptionalLiteral(element, "PROTOCOL-VERSION", cluster.getProtocolVersion())
+
+    def readAbstractCanCluster(self, element: ET.Element, cluster: AbstractCanCluster):
+        self.setChildElementOptionalNumericalValue(element, "CAN-FD-BAUDRATE", cluster.getCanFdBaudrate())
+
+    def writeLinCluster(self, element: ET.Element, cluster: LinCluster):
+        self.logger.debug("LinCluster %s" % cluster.short_name)
+        child_element = ET.SubElement(element, "LIN-CLUSTER")
+        self.setIdentifiable(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.short_name)
+        child_element = ET.SubElement(element, "CAN-CLUSTER")
+        self.setIdentifiable(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.readAbstractCanCluster(child_element, cluster)
+
+    def writeCanFrame(self, element: ET.Element, frame: CanFrame):
+        self.logger.debug("CanFrame %s" % frame.short_name)
+        child_element = ET.SubElement(element, "CAN-FRAME")
+        self.writeFrame(child_element, frame)
+
+    def writeEcuInstance(self, element: ET.Element, instance: EcuInstance):
+        self.logger.debug("EcuInstance %s" % instance.short_name)
+        child_element = ET.SubElement(element, "ECU-INSTANCE")
+        self.setIdentifiable(child_element, instance)
+
+    def writeSystemSignalGroup(self, element: ET.Element, group: SystemSignalGroup):
+        self.logger.debug("Write SystemSignalGroup %s" % group.short_name)
+        child_element = ET.SubElement(element, "SYSTEM-SIGNAL-GROUP")
+        self.setIdentifiable(child_element, group)
+        signal_refs = group.getSystemSignalRefs()
+        if len(signal_refs) > 0:
+            signal_refs_tag = ET.SubElement(child_element, "SYSTEM-SIGNAL-REFS")
+            for signal_ref in signal_refs:
+                self.setChildElementOptionalRefType(signal_refs_tag, "SYSTEM-SIGNAL-REF", signal_ref)
+
+    def setSenderReceiverToSignalMapping(self, element: ET.Element, mapping: SenderReceiverToSignalMapping):
+        child_element = ET.SubElement(element, "SENDER-RECEIVER-TO-SIGNAL-MAPPING")
+        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):
+        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())
+    
+    def writeSystemMappingDataMappings(self, element: ET.Element, system_mapping: SystemMapping):
+        data_mappings = system_mapping.getDataMappings()
+        if len(data_mappings) > 0:
+            child_element = ET.SubElement(element, "DATA-MAPPINGS")
+            for data_mapping in data_mappings:
+                if isinstance(data_mapping, SenderReceiverToSignalMapping):
+                    self.setSenderReceiverToSignalMapping(child_element, data_mapping)
+                elif isinstance(data_mapping, SenderReceiverToSignalGroupMapping):
+                    self.setSenderReceiverToSignalGroupMapping(child_element, data_mapping)
+                else:
+                    raise NotImplementedError("Unsupported Data Mapping %s" % type(data_mapping))
+
+    def writeSystemMapping(self, element: ET.Element, mapping: SystemMapping):
+        self.logger.debug("Write SystemMapping %s" % mapping.short_name)
+        child_element = ET.SubElement(element, "SYSTEM-MAPPING")
+        self.setIdentifiable(child_element, mapping)
+        self.writeSystemMappingDataMappings(child_element, mapping)
+
+    def writeSystemMappings(self, element: ET.Element, system: System):
+        mappings = system.getMappings()
+        if len(mappings) > 0:
+            mappings_tag = ET.SubElement(element, "MAPPINGS")
+            for mapping in mappings:
+                if isinstance(mapping, SystemMapping):
+                    self.writeSystemMapping(mappings_tag, mapping)
+                else:
+                    raise NotImplementedError("Unsupported Mapping %s" % type(mapping))
+                
+    def writeSystem(self, element: ET.Element, system: System):
+        self.logger.debug("Write System %s" % system.short_name)
+        child_element = ET.SubElement(element, "SYSTEM")
+        self.setARElement(child_element, system)
+
+        self.setChildElementOptionalLiteral(child_element, "ECU-EXTRACT-VERSION", system.getEcuExtractVersion())
+        refs = system.getFibexElementRefs()
+        if len(refs) > 0:
+            fibex_elements_tag = ET.SubElement(child_element, "FIBEX-ELEMENTS")
+            for ref in refs:
+                fibex_element_ref_conditional_tag = ET.SubElement(fibex_elements_tag, "FIBEX-ELEMENT-REF-CONDITIONAL")
+                self.setChildElementOptionalRefType(fibex_element_ref_conditional_tag, "FIBEX-ELEMENT-REF", ref)
+
+        self.writeSystemMappings(child_element, system)
+
+    def writePhysicalDimension(self, element: ET.Element, dimension: PhysicalDimension):
+        self.logger.debug("Write PhysicalDimension %s" % dimension.short_name)
+        child_element = ET.SubElement(element, "PHYSICAL-DIMENSION")
+        self.setARElement(child_element, dimension)
+        self.setChildElementOptionalNumericalValue(child_element, "CURRENT-EXP", dimension.getCurrentExp())
+        self.setChildElementOptionalNumericalValue(child_element, "LENGTH-EXP", dimension.getLengthExp())
+
+    def setISignalMappings(self, element: ET.Element, mappings: List[ISignalMapping]):
+        if len(mappings) > 0:
+            mappings_tag = ET.SubElement(element, "SIGNAL-MAPPINGS")
+            for mapping in mappings:
+                child_element = ET.SubElement(mappings_tag, "I-SIGNAL-MAPPING")
+                self.setChildElementOptionalRefType(child_element, "SOURCE-SIGNAL-REF", mapping.sourceSignalRef)
+                self.setChildElementOptionalRefType(child_element, "TARGET-SIGNAL-REF", mapping.targetSignalRef)
+
+    def writeGateway(self, element: ET.Element, gateway: Gateway):
+        self.logger.debug("Gateway %s" % gateway.short_name)
+        child_element = ET.SubElement(element, "GATEWAY")
+        self.setIdentifiable(child_element, gateway)
+        self.setChildElementOptionalRefType(child_element, "ECU-REF", gateway.ecuRef)
+        self.setISignalMappings(child_element, gateway.getSignalMappings())
+
+    def writeISignal(self, element: ET.Element, signal: ISignal):
+        self.logger.debug("ISignal %s" % signal.short_name)
+        child_element = ET.SubElement(element, "I-SIGNAL")
+        self.setIdentifiable(child_element, signal)
+        self.setChildElementOptionalLiteral(child_element, "DATA-TYPE-POLICY", signal.dataTypePolicy)
+        self.setInitValue(child_element, signal.initValue)
+        self.setChildElementOptionalNumericalValue(child_element, "LENGTH", signal.length)
+        self.setSwDataDefProps(child_element, "NETWORK-REPRESENTATION-PROPS", signal.networkRepresentationProps)
+        self.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-REF", signal.systemSignalRef)
+
+    def writeEcucValueCollectionEcucValues(self, element: ET.Element, collection: EcucValueCollection):
+        value_refs = collection.getEcucValueRefs()
+        if len(value_refs) > 0:
+            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) 
+
+    def writeEcucValueCollection(self, element: ET.Element, collection: EcucValueCollection):
+        self.logger.debug("EcucValueCollection %s" % collection.short_name)
+        child_element = ET.SubElement(element, "ECUC-VALUE-COLLECTION")
+        self.setIdentifiable(child_element, collection)
+        self.setChildElementOptionalRefType(child_element, "ECU-EXTRACT-REF", collection.getEcuExtractRef())
+        self.writeEcucValueCollectionEcucValues(child_element, collection)
+
+    def writeEcucContainerValueSubContainers(self, element: ET.Element, container: EcucContainerValue):
+        sub_containers = container.getSubContainers()
+        if len(sub_containers) > 0:
+            sub_containers_tag = ET.SubElement(element, "SUB-CONTAINERS")
+            for sub_container in sub_containers:
+                if isinstance(sub_container, EcucContainerValue):
+                    self.writeEcucContainValue(sub_containers_tag, sub_container)
+                else:
+                    raise NotImplementedError("Unsupported Sub Container %s" % type(container)) 
+                
+    def writeEcucParameterValue(self, element: ET.Element, param_value: EcucParameterValue):
+        self.setChildElementOptionalRefType(element, "DEFINITION-REF", param_value.getDefinitionRef())
+        self.setAnnotations(element, param_value.getAnnotations())
+
+    def setEcucTextualParamValue(self, element: ET.Element, param_value: EcucTextualParamValue):
+        child_element = ET.SubElement(element, "ECUC-TEXTUAL-PARAM-VALUE")
+        self.writeEcucParameterValue(child_element, param_value)
+        self.setChildElementOptionalLiteral(child_element, "VALUE", param_value.getValue())
+
+    def setEcucNumericalParamValue(self, element: ET.Element, param_value: EcucNumericalParamValue):
+        child_element = ET.SubElement(element, "ECUC-NUMERICAL-PARAM-VALUE")
+        self.writeEcucParameterValue(child_element, param_value)
+        self.setChildElementOptionalNumericalValue(child_element, "VALUE", param_value.getValue())
+                
+    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")
+            for param_value in param_values:
+                if isinstance(param_value, EcucTextualParamValue):
+                    self.setEcucTextualParamValue(child_element, param_value)
+                elif isinstance(param_value, EcucNumericalParamValue):
+                    self.setEcucNumericalParamValue(child_element, param_value)
+                else:
+                    raise NotImplementedError("Unsupported EcucParameterValue <%s>" % type(param_value))
+                
+    def writeEcucAbstractReferenceValue(self, element: ET.Element, value: EcucAbstractReferenceValue):
+        self.setChildElementOptionalRefType(element, "DEFINITION-REF", value.getDefinitionRef())
+        self.setAnnotations(element, value.getAnnotations())
+
+    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())
+        return value
+    
+    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, "CONTEXT-ELEMENT-REF", instance_ref.getContextElementRef())
+            self.setChildElementOptionalRefType(child_element, "TARGET-REF", instance_ref.getTargetRef())
+        return instance_ref
+    
+    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())
+        return value
+    
+    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")
+            for reference_value in reference_values:
+                if isinstance(reference_value, EcucReferenceValue):
+                    self.setEcucReferenceValue(child_element, reference_value)
+                elif isinstance(reference_value, EcucInstanceReferenceValue):
+                    self.setEcucInstanceReferenceValue(child_element, reference_value)
+                else:
+                    raise NotImplementedError("Unsupported EcucParameterValue <%s>" % type(reference_value))
+
+    def writeEcucContainValue(self, element: ET.Element, container_value: EcucContainerValue):
+        self.logger.debug("EcucContainerValue %s" % container_value.short_name)
+        child_element = ET.SubElement(element, "ECUC-CONTAINER-VALUE")
+        self.setIdentifiable(child_element, container_value)
+        self.setChildElementOptionalRefType(child_element, "DEFINITION-REF", container_value.getDefinitionRef())
+        self.writeEcucContainerValueParameterValues(child_element, container_value)
+        self.writeEcucContainerValueReferenceValues(child_element, container_value)
+        self.writeEcucContainerValueSubContainers(child_element, container_value)
+
+    def writeEcucModuleConfigurationValuesContainers(self, element: ET.Element, value: EcucModuleConfigurationValues):
+        containers = value.getContainers()
+        if len(containers) > 0:
+            containers_tag = ET.SubElement(element, "CONTAINERS")
+            for container in containers:
+                if isinstance(container, EcucContainerValue):
+                    self.writeEcucContainValue(containers_tag, container)
+                else:
+                    raise NotImplementedError("Unsupported Container %s" % type(container)) 
+
+    def writeEcucModuleConfigurationValues(self, element: ET.Element, values: EcucModuleConfigurationValues):
+        self.logger.debug("EcucModuleConfigurationValues %s" % values.short_name)
+        child_element = ET.SubElement(element, "ECUC-MODULE-CONFIGURATION-VALUES")
+        self.setIdentifiable(child_element, values)
+        self.setChildElementOptionalRefType(child_element, "DEFINITION-REF", values.getDefinitionRef())
+        self.setChildElementOptionalLiteral(child_element, "IMPLEMENTATION-CONFIG-VARIANT", values.getImplementationConfigVariant())
+        self.setChildElementOptionalRefType(child_element, "MODULE-DESCRIPTION-REF", values.getModuleDescriptionRef())
+        self.writeEcucModuleConfigurationValuesContainers(child_element, values)
+
+    def writeISignalGroup(self, element: ET.Element, group: ISignalGroup):
+        self.logger.debug("ISignalGroup %s" % group.short_name)
+        child_element = ET.SubElement(element, "I-SIGNAL-GROUP")
+        self.setIdentifiable(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.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-GROUP-REF", group.getSystemSignalGroupRef())
+
+    def writeISignalIPduGroup(self, element: ET.Element, group: ISignalIPduGroup):
+        self.logger.debug("ISignalIPduGroup %s" % group.short_name)
+        child_element = ET.SubElement(element, "I-SIGNAL-I-PDU-GROUP")
+        self.setIdentifiable(child_element, group)
+        self.setChildElementOptionalLiteral(child_element, "COMMUNICATION-DIRECTION", group.getCommunicationDirection())
+        self.setChildElementOptionalLiteral(child_element, "COMMUNICATION-MODE", group.getCommunicationMode())
+        group_refs = group.getContainedISignalIPduGroupRefs()
+        if len(group_refs) > 0:
+            pdu_refs_tag = ET.SubElement(child_element, "CONTAINED-I-SIGNAL-I-PDU-GROUP-REFS")
+            for pdu_ref in group_refs:
+                self.setChildElementOptionalRefType(pdu_refs_tag, "CONTAINED-I-SIGNAL-I-PDU-GROUP-REF", pdu_ref)
+        pdu_refs = group.getISignalIPduRefs()
+        if len(pdu_refs) > 0:
+            pdu_refs_tag = ET.SubElement(child_element, "I-SIGNAL-I-PDUS")
+            for pdu_ref in pdu_refs:
+                ref_conditional_tag = ET.SubElement(pdu_refs_tag, "I-SIGNAL-I-PDU-REF-CONDITIONAL")
+                self.setChildElementOptionalRefType(ref_conditional_tag, "I-SIGNAL-I-PDU-REF", pdu_ref)
+
+    def writeSystemSignal(self, element: ET.Element, signal: SystemSignal):
+        self.logger.debug("SystemSignal %s" % signal.short_name)
+        child_element = ET.SubElement(element, "SYSTEM-SIGNAL")
+        self.setIdentifiable(child_element, signal)
+        self.setChildElementOptionalBooleanValue(child_element, "DYNAMIC-LENGTH", signal.getDynamicLength())
+
+    def writeISignalToPduMappings(self, element: ET.Element, parent: ISignalIPdu):
+        mappings = parent.getISignalToPduMappings()
+        if len(mappings) > 0:
+            mappings_tag = ET.SubElement(element, "I-SIGNAL-TO-PDU-MAPPINGS")
+            for mapping in mappings:
+                child_element = ET.SubElement(mappings_tag, "I-SIGNAL-TO-I-PDU-MAPPING")
+                self.setIdentifiable(child_element, mapping)
+                self.setChildElementOptionalRefType(child_element, "I-SIGNAL-REF", mapping.getISignalRef())
+                self.setChildElementOptionalRefType(child_element, "I-SIGNAL-GROUP-REF", mapping.getISignalGroupRef())
+                self.setChildElementOptionalLiteral(child_element, "PACKING-BYTE-ORDER", mapping.getPackingByteOrder())
+                self.setChildElementOptionalNumericalValue(child_element, "START-POSITION", mapping.getStartPosition())
+                self.setChildElementOptionalLiteral(child_element, "TRANSFER-PROPERTY", mapping.getTransferProperty())
+                self.setChildElementOptionalNumericalValue(child_element, "UPDATE-INDICATION-BIT-POSITION", mapping.getUpdateIndicationBitPosition())
+
+    def writeISignalIPdu(self, element: ET.Element, i_pdu: ISignalIPdu):
+        self.logger.debug("ISignalIPdu %s" % i_pdu.short_name)
+        child_element = ET.SubElement(element, "I-SIGNAL-I-PDU")
+        self.setIdentifiable(child_element, i_pdu)
+        self.setChildElementOptionalNumericalValue(child_element, "LENGTH", i_pdu.getLength())
+        self.writeISignalToPduMappings(child_element, i_pdu)
+        self.setChildElementOptionalLiteral(child_element, "UNUSED-BIT-PATTERN", i_pdu.getUnusedBitPattern())
+
     def writeARPackageElement(self, element: ET.Element, ar_element: ARElement):
         if isinstance(ar_element, ComplexDeviceDriverSwComponentType):
             self.writeComplexDeviceDriverSwComponentType(element, ar_element)
@@ -1720,6 +2539,52 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeModeDeclarationGroup(element, ar_element)
         elif isinstance(ar_element, ModeSwitchInterface):
             self.writeModeSwitchInterface(element, ar_element)
+        elif isinstance(ar_element, SwcTiming):
+            self.writeSwcTiming(element, ar_element)
+        elif isinstance(ar_element, LinUnconditionalFrame):
+            self.writeLinUnconditionalFrame(element, ar_element)
+        elif isinstance(ar_element, NmConfig):
+            self.writeNmConfig(element, ar_element)
+        elif isinstance(ar_element, NmPdu):
+            self.writeNmPdu(element, ar_element)
+        elif isinstance(ar_element, NPdu):
+            self.writeNPdu(element, ar_element)
+        elif isinstance(ar_element, DcmIPdu):
+            self.writeDcmIPdu(element, ar_element)
+        elif isinstance(ar_element, SecuredIPdu):
+            self.writeSecuredIPdu(element, ar_element)
+        elif isinstance(ar_element, CanTpConfig):
+            self.writeCanTpConfig(element, ar_element)
+        elif isinstance(ar_element, LinCluster):
+            self.writeLinCluster(element, ar_element)
+        elif isinstance(ar_element, CanCluster):
+            self.writeCanCluster(element, ar_element)
+        elif isinstance(ar_element, CanFrame):
+            self.writeCanFrame(element, ar_element)
+        elif isinstance(ar_element, Gateway):
+            self.writeGateway(element, ar_element)
+        elif isinstance(ar_element, ISignal):
+            self.writeISignal(element, ar_element)
+        elif isinstance(ar_element, EcucValueCollection):
+            self.writeEcucValueCollection(element, ar_element)
+        elif isinstance(ar_element, EcucModuleConfigurationValues):
+            self.writeEcucModuleConfigurationValues(element, ar_element)
+        elif isinstance(ar_element, ISignalGroup):
+            self.writeISignalGroup(element, ar_element)
+        elif isinstance(ar_element, ISignalIPduGroup):
+            self.writeISignalIPduGroup(element, ar_element)
+        elif isinstance(ar_element, SystemSignal):
+            self.writeSystemSignal(element, ar_element)
+        elif isinstance(ar_element, ISignalIPdu):
+            self.writeISignalIPdu(element, ar_element)
+        elif isinstance(ar_element, EcuInstance):
+            self.writeEcuInstance(element, ar_element)
+        elif isinstance(ar_element, SystemSignalGroup):
+            self.writeSystemSignalGroup(element, ar_element)
+        elif isinstance(ar_element, System):
+            self.writeSystem(element, ar_element)
+        elif isinstance(ar_element, PhysicalDimension):
+            self.writePhysicalDimension(element, ar_element)
         else:
             raise NotImplementedError("Unsupported Elements of ARPackage <%s>" % type(ar_element))
         
@@ -1730,7 +2595,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             for pkg in pkgs:
                 pkg_tag  = ET.SubElement(pkgs_tag, "AR-PACKAGE")
             
-                self.writeIdentifiable(pkg_tag, pkg)
+                self.setIdentifiable(pkg_tag, pkg)
                 self.logger.debug("writeARPackage %s" % pkg.full_name)
 
                 if pkg.getTotalElement() > 0: