armodel 1.5.0__py3-none-any.whl → 1.6.1__py3-none-any.whl

armodel/writer/arxml_writer.py

@@ -2,42 +2,67 @@ import xml.etree.cElementTree as ET
 
 from typing import List
 
+from armodel.models.m2.autosar_templates.common_structure.implementation_data_types import ImplementationDataType
+
+
+
+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.ecuc_description_template import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue, EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue, EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
+from ..models.m2.autosar_templates.generic_structure.abstract_structure import AnyInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.components import PortGroup, SwComponentType, PPortPrototype, PortPrototype, RPortPrototype
+from ..models.m2.autosar_templates.sw_component_template.components.instance_refs import InnerPortGroupInCompositionInstanceRef, 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.sw_component_template.composition import AssemblySwConnector, CompositionSwComponentType, DelegationSwConnector, SwComponentPrototype, SwConnector
+from ..models.m2.autosar_templates.sw_component_template.composition.instance_refs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.port_interface.instance_refs import ApplicationCompositeElementInPortInterfaceInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.instance_refs_usage import AutosarParameterRef, AutosarVariableRef, VariableInAtomicSWCTypeInstanceRef
+from ..models.m2.autosar_templates.system_template.instance_refs import VariableDataPrototypeInSystemInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.components.instance_refs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
+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, ParameterRequireComSpec,  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.fibex.can_communication import CanFrame
-from ..models.fibex.fibex_core import DcmIPdu, Frame, ISignal, NPdu, NmPdu
-from ..models.fibex.lin_communication import LinUnconditionalFrame
-from ..models.fibex.lin_topology import LinCluster
-from ..models.system_template.network_management import NmConfig
-from ..models.system_template.transport_protocols import CanTpConfig
 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.m2.autosar_templates.sw_component_template.data_type.data_prototypes 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, InitEvent, 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, RTEEvent, ServiceDependency, ServiceSwComponentType, SwcModeSwitchEvent, SwcServiceDependency
 from ..models.ar_package import ARPackage
-from ..models.ar_ref import ApplicationCompositeElementInPortInterfaceInstanceRef, AutosarParameterRef, AutosarVariableRef, InnerPortGroupInCompositionInstanceRef, POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, RModeGroupInAtomicSWCInstanceRef, RModeInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef, RVariableInAtomicSwcInstanceRef, RefType, VariableDataPrototypeInSystemInstanceRef
+from ..models.ar_ref import RefType
 from ..models.calibration import SwAxisGrouped, SwAxisIndividual, SwCalprmAxis, SwCalprmAxisSet, SwValueCont, SwValues
-from ..models.common_structure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, IncludedModeDeclarationGroupSet, 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.datatype import ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType, AutosarDataType, BaseTypeDirectDefinition, DataTypeMappingSet, 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, ModeSwitchReceiverComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, PPortComSpec, PPortPrototype, PortPrototype, QueuedReceiverComSpec, RPortComSpec, RPortPrototype, ReceiverComSpec, SenderComSpec, ServerComSpec
-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, 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
@@ -53,6 +78,12 @@ class ARXMLWriter(AbstractARXMLWriter):
 
         return sub_element
     
+    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")
@@ -63,8 +94,9 @@ class ARXMLWriter(AbstractARXMLWriter):
         if sdg is not None:
             sdg_tag = ET.SubElement(parent, "SDG")
             sdg_tag.attrib['GID'] = sdg.gid
-            self.setSdg(sdg_tag, sdg.sdg_contents_type)
             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()
@@ -81,7 +113,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)
 
@@ -107,61 +139,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.writeSdgs(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 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 writeARElement(self, parent: ET.Element, ar_element: ARElement):
-        self.writeIdentifiable(parent, ar_element)
+    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))
         
@@ -185,10 +233,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:
@@ -249,7 +297,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:
@@ -277,23 +325,30 @@ 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.getOperationRef())
+
+    def writeParameterRequireComSpec(self, element: ET.Element, com_spec: ParameterRequireComSpec):
+        self.logger.debug("writeParameterRequireComSpec")
+        child_element = ET.SubElement(element, "PARAMETER-REQUIRE-COM-SPEC")
+        self.setARObjectAttributes(child_element, com_spec)
+        self.setChildElementOptionalRefType(child_element, "PARAMETER-REF", com_spec.parameter_ref)
+        self.setInitValue(child_element, com_spec.init_value)
 
     def writeModeSwitchReceiverComSpec(self, element: ET.Element, com_spec: ModeSwitchReceiverComSpec):
         self.logger.debug("writeModeSwitchReceiverComSpec")
@@ -310,13 +365,15 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeClientComSpec(element, com_spec)
         elif isinstance(com_spec, ModeSwitchReceiverComSpec):
             self.writeModeSwitchReceiverComSpec(element, com_spec)
+        elif isinstance(com_spec, ParameterRequireComSpec):
+            self.writeParameterRequireComSpec(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()
@@ -325,18 +382,18 @@ class ARXMLWriter(AbstractARXMLWriter):
             for com_spec in com_specs:
                 self.writePPortComSpec(com_specs_tag, com_spec)
 
-        self.setChildElementOptionalRefType(prototype_tag, "PROVIDED-INTERFACE-TREF", prototype.provided_interface_tref)
+        self.setChildElementOptionalRefType(prototype_tag, "PROVIDED-INTERFACE-TREF", prototype.getProvidedInterfaceTRef())
 
     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")
             for com_spec in com_specs:
                 self.writeRPortComSpec(com_specs_tag, com_spec)
-        self.setChildElementOptionalRefType(prototype_tag, "REQUIRED-INTERFACE-TREF", prototype.required_interface_tref)
+        self.setChildElementOptionalRefType(prototype_tag, "REQUIRED-INTERFACE-TREF", prototype.getRequiredInterfaceTRef())
     
     def writePortPrototypes(self, ports_tag: ET.Element, port_prototypes: List[PortPrototype]):
         for port_prototype in port_prototypes:
@@ -349,8 +406,8 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeInnerGroupIRef(self, element: ET.Element, inner_group_iref: InnerPortGroupInCompositionInstanceRef):
         child_element = ET.SubElement(element, "INNER-GROUP-IREF")
-        self.setChildElementOptionalRefType(child_element, "CONTEXT-REF", inner_group_iref.contextRef)
-        self.setChildElementOptionalRefType(child_element, "TARGET-REF", inner_group_iref.targetRef)
+        #self.setChildElementOptionalRefType(child_element, "CONTEXT-REF", inner_group_iref.contextRef)
+        self.setChildElementOptionalRefType(child_element, "TARGET-REF", inner_group_iref.getTargetRef())
 
     def writePortGroupInnerGroupIRefs(self, element: ET.Element, parent: PortGroup):
         irefs = parent.getInnerGroupIRefs()
@@ -370,7 +427,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)
 
@@ -382,7 +439,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")
@@ -391,49 +448,54 @@ 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.setChildElementOptionalRefType(prototype_tag, "TYPE-TREF", prototype.type_tref)
+        self.setIdentifiable(prototype_tag, prototype)
+        self.setChildElementOptionalRefType(prototype_tag, "TYPE-TREF", prototype.getTypeTRef())
 
     def writeSwComponentPrototypes(self, element: ET.Element, sw_component: CompositionSwComponentType):
-        components_tag = ET.SubElement(element, "COMPONENTS")
-        for prototype in sw_component.getSwComponentPrototypes():
+        prototypes = sw_component.getSwComponentPrototypes()
+        if len(prototypes) > 0:
+            components_tag = ET.SubElement(element, "COMPONENTS")
+        for prototype in prototypes:
             self.writeSwComponentPrototype(components_tag, prototype)
 
     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:
+        if sw_connector.getProviderIRef() is not None:
             provider_iref_tag = ET.SubElement(connector_tag, "PROVIDER-IREF")
-            self.setARObjectAttributes(provider_iref_tag, sw_connector.provider_iref)
-            self.setChildElementOptionalRefType(provider_iref_tag, "CONTEXT-COMPONENT-REF", sw_connector.provider_iref.context_component_ref)
-            self.setChildElementOptionalRefType(provider_iref_tag, "TARGET-P-PORT-REF", sw_connector.provider_iref.target_p_port_ref)
+            provider_iref = sw_connector.getProviderIRef()
+            self.setARObjectAttributes(provider_iref_tag, provider_iref)
+            self.setChildElementOptionalRefType(provider_iref_tag, "CONTEXT-COMPONENT-REF", provider_iref.getContextComponentRef())
+            self.setChildElementOptionalRefType(provider_iref_tag, "TARGET-P-PORT-REF", provider_iref.getTargetPPortRef())
 
-        if sw_connector.requester_iref is not None:
+        if sw_connector.getRequesterIRef() is not None:
             requester_iref_tag = ET.SubElement(connector_tag, "REQUESTER-IREF")
-            self.setARObjectAttributes(requester_iref_tag, sw_connector.requester_iref)
-            self.setChildElementOptionalRefType(requester_iref_tag, "CONTEXT-COMPONENT-REF", sw_connector.requester_iref.context_component_ref)
-            self.setChildElementOptionalRefType(requester_iref_tag, "TARGET-R-PORT-REF", sw_connector.requester_iref.target_r_port_ref)
+            requester_iref = sw_connector.getRequesterIRef()
+            self.setARObjectAttributes(requester_iref_tag, requester_iref)
+            self.setChildElementOptionalRefType(requester_iref_tag, "CONTEXT-COMPONENT-REF", requester_iref.getContextComponentRef())
+            self.setChildElementOptionalRefType(requester_iref_tag, "TARGET-R-PORT-REF", requester_iref.getTargetRPortRef())
 
     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:
+        if sw_connector.getInnerPortIRref() is not None:
             inner_port_iref_tag = ET.SubElement(connector_tag, "INNER-PORT-IREF")
-            if isinstance(sw_connector.inner_port_iref, PPortInCompositionInstanceRef):
+            inner_port_iref = sw_connector.getInnerPortIRref()
+            if isinstance(inner_port_iref, PPortInCompositionInstanceRef):
                 instance_ref_tag = ET.SubElement(inner_port_iref_tag, "P-PORT-IN-COMPOSITION-INSTANCE-REF")
-                self.setChildElementOptionalRefType(instance_ref_tag, "CONTEXT-COMPONENT-REF", sw_connector.inner_port_iref.context_component_ref)
-                self.setChildElementOptionalRefType(instance_ref_tag, "TARGET-P-PORT-REF", sw_connector.inner_port_iref.target_p_port_ref)
-            elif isinstance(sw_connector.inner_port_iref, RPortInCompositionInstanceRef):
+                self.setChildElementOptionalRefType(instance_ref_tag, "CONTEXT-COMPONENT-REF", inner_port_iref.getContextComponentRef())
+                self.setChildElementOptionalRefType(instance_ref_tag, "TARGET-P-PORT-REF", inner_port_iref.getTargetPPortRef())
+            elif isinstance(inner_port_iref, RPortInCompositionInstanceRef):
                 instance_ref_tag = ET.SubElement(inner_port_iref_tag, "R-PORT-IN-COMPOSITION-INSTANCE-REF")
-                self.setChildElementOptionalRefType(instance_ref_tag, "CONTEXT-COMPONENT-REF", sw_connector.inner_port_iref.context_component_ref)
-                self.setChildElementOptionalRefType(instance_ref_tag, "TARGET-R-PORT-REF", sw_connector.inner_port_iref.target_r_port_ref)
+                self.setChildElementOptionalRefType(instance_ref_tag, "CONTEXT-COMPONENT-REF", inner_port_iref.getContextComponentRef())
+                self.setChildElementOptionalRefType(instance_ref_tag, "TARGET-R-PORT-REF", inner_port_iref.getTargetRPortRef())
             else:
-                self._raiseError("Invalid inner port of DelegationSwConnector <%s>" % sw_connector.short_name)
+                self._raiseError("Invalid inner port of DelegationSwConnector <%s>" % sw_connector.getShortName())
 
-        if sw_connector.outer_port_ref is not None:
-            self.setChildElementOptionalRefType(connector_tag, "OUTER-PORT-REF", sw_connector.outer_port_ref)
+        if sw_connector.getOuterPortRef() is not None:
+            self.setChildElementOptionalRefType(connector_tag, "OUTER-PORT-REF", sw_connector.getOuterPortRef())
             #self.writeChildOptionalRefElement(requester_iref_tag, "TARGET-R-PORT-REF", sw_connector.requester_iref.target_r_port_ref)
         
     def writeSwConnector(self, element: ET.Element, sw_connector: SwConnector):
@@ -448,8 +510,13 @@ class ARXMLWriter(AbstractARXMLWriter):
         sw_connectors = sw_component.getSwConnectors()
         if len(sw_connectors) > 0:
             connectors_tag = ET.SubElement(element, "CONNECTORS")
+            # Change the implementation to compatible with AUTOSAR builder
             for sw_connector in sw_connectors:
                 self.writeSwConnector(connectors_tag, sw_connector)
+            #for sw_connector in sw_component.getAssemblySwConnectors():
+            #    self.writeSwConnector(connectors_tag, sw_connector)
+            #for sw_connector in sw_component.getDelegationSwConnectors():
+            #    self.writeSwConnector(connectors_tag, sw_connector)
 
     def writeCompositionSwComponentTypeDataTypeMappingSet(self, element: ET.Element, parent: CompositionSwComponentType):
         data_type_mappings = parent.getDataTypeMappings()
@@ -471,11 +538,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:
@@ -516,6 +605,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)
@@ -523,18 +617,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)
@@ -543,8 +637,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)
@@ -552,7 +646,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)
@@ -591,7 +685,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):
@@ -626,6 +720,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         for compu_scale in compu_scales.getCompuScales():
             child_element = ET.SubElement(compu_scales_tag, "COMPU-SCALE")
             self.setARObjectAttributes(child_element, compu_scale)
+            self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", compu_scale.short_label)
             self.setChildElementOptionalLiteral(child_element, "SYMBOL", compu_scale.symbol)
             self.writeChildLimitElement(child_element, "LOWER-LIMIT", compu_scale.lowerLimit)
             self.writeChildLimitElement(child_element, "UPPER-LIMIT", compu_scale.upperLimit)
@@ -641,7 +736,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)
 
@@ -672,11 +767,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:
@@ -710,21 +805,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)
@@ -732,7 +830,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")
@@ -766,14 +864,14 @@ 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
@@ -810,7 +908,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()
@@ -827,31 +925,25 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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.minimumStartInterval)
-            self.setChildElementOptionalRefType(element, "SW-ADDR-METHOD-REF", entity.swAddrMethodRef)
-
     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.setARObjectAttributes(child_element, ref.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():
@@ -864,7 +956,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):
@@ -902,20 +994,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()
@@ -923,7 +1015,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))
 
@@ -934,10 +1026,18 @@ class ARXMLWriter(AbstractARXMLWriter):
             for access in variables:
                 self.setVariableAccess(child_element, access)
 
-    def setRModeGroupInAtomicSWCInstanceRef(self, element: ET.Element, iref: RModeGroupInAtomicSWCInstanceRef):
-        child_element = ET.SubElement(element, "R-MODE-GROUP-IN-ATOMIC-SWC-INSTANCE-REF")
-        self.setChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF", iref.contextRPort)
-        self.setChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF", iref.targetModeGroup)
+    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()
@@ -945,21 +1045,43 @@ class ARXMLWriter(AbstractARXMLWriter):
             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")
-                if point.modeGroupIRef is not None:
-                    child_element = ET.SubElement(child_element, "MODE-GROUP-IREF")
-                    self.setRModeGroupInAtomicSWCInstanceRef(child_element, point.modeGroupIRef)
+                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)
@@ -991,17 +1113,17 @@ 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.getPerInstanceParameters()
@@ -1033,7 +1155,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")
@@ -1069,7 +1191,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)
@@ -1169,7 +1291,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):
@@ -1194,7 +1316,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)
@@ -1205,11 +1327,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())
@@ -1272,7 +1394,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)
 
@@ -1287,21 +1409,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")
@@ -1311,12 +1433,21 @@ 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.getIsService())
+        self.writeSenderReceiverInterfaceDataElements(child_element, sr_interface)
 
     def writerBswModuleDescriptionImplementedEntry(self, element: ET.Element, desc: BswModuleDescription):
         entries = desc.getImplementedEntries()
@@ -1327,7 +1458,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):
@@ -1346,9 +1477,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()
@@ -1360,7 +1492,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):
@@ -1386,7 +1518,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):
@@ -1453,7 +1585,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)
@@ -1471,7 +1603,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)
@@ -1498,7 +1630,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)
@@ -1545,15 +1677,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.getSwDataDefProps())
 
     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()
@@ -1561,10 +1695,11 @@ 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.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", prototype.sw_data_def_props)
-                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)
+                self.setChildElementOptionalLiteral(child_element, "SERVER-ARGUMENT-IMPL-POLICY", prototype.server_argument_impl_policy)
 
     def writePossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
         error_refs = parent.getPossbileErrorRefs()
@@ -1576,7 +1711,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)
 
@@ -1593,7 +1728,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):
@@ -1607,8 +1742,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):
@@ -1666,7 +1801,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):
@@ -1705,13 +1840,13 @@ class ARXMLWriter(AbstractARXMLWriter):
     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):
@@ -1724,7 +1859,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())
@@ -1734,7 +1869,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):
@@ -1751,7 +1886,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeEOCExecutableEntityRef(self, element: ET.Element, entity_ref: EOCExecutableEntityRef):
         child_element = ET.SubElement(element, "EOC-EXECUTABLE-ENTITY-REF")
-        self.writeIdentifiable(child_element, entity_ref)
+        self.setIdentifiable(child_element, entity_ref)
         self.setEOCExecutableEntityRefSuccessorRefs(child_element, entity_ref.getSuccessorRefs())
 
     def writeExecutionOrderConstraintOrderedElement(self, element: ET.Element, constraint: ExecutionOrderConstraint):
@@ -1767,7 +1902,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     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.writeIdentifiable(child_element, constraint)
+        self.setIdentifiable(child_element, constraint)
         self.writeExecutionOrderConstraintOrderedElement(child_element, constraint)
 
     def writeTimingRequirements(self, element: ET.Element, extension: TimingExtension):
@@ -1786,7 +1921,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeSwcTiming(self, element: ET.Element, timing: SwcTiming):
         self.logger.debug("writeSWcTiming %s" % timing.short_name)
         child_element = ET.SubElement(element, "SWC-TIMING")
-        self.writeIdentifiable(child_element, timing)
+        self.setIdentifiable(child_element, timing)
         self.writeTimingExtension(child_element, timing)
 
     def writePduToFrameMappings(self, element: ET.Element, parent: Frame):
@@ -1795,13 +1930,13 @@ class ARXMLWriter(AbstractARXMLWriter):
             mappings_tags = ET.SubElement(element, "PDU-TO-FRAME-MAPPINGS")
             for mapping in mappings:
                 child_element = ET.SubElement(mappings_tags, "PDU-TO-FRAME-MAPPING")
-                self.writeIdentifiable(child_element, 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.writeIdentifiable(element, frame)
+        self.setIdentifiable(element, frame)
         self.setChildElementOptionalNumericalValue(element, "FRAME-LENGTH",  frame.frameLength)
         self.writePduToFrameMappings(element, frame)
 
@@ -1810,41 +1945,376 @@ class ARXMLWriter(AbstractARXMLWriter):
         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("NmConfig %s" % config.short_name)
+        self.logger.debug("WriteNmConfig %s" % config.short_name)
         child_element = ET.SubElement(element, "NM-CONFIG")
-        self.writeIdentifiable(child_element, 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.writeIdentifiable(child_element, 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.writeIdentifiable(child_element, 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.writeIdentifiable(child_element, 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.writeIdentifiable(child_element, 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.writeIdentifiable(child_element, 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")
@@ -1856,20 +2326,192 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeGateway(self, element: ET.Element, gateway: Gateway):
         self.logger.debug("Gateway %s" % gateway.short_name)
         child_element = ET.SubElement(element, "GATEWAY")
-        self.writeIdentifiable(child_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.writeIdentifiable(child_element, 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)
@@ -1939,10 +2581,14 @@ class ARXMLWriter(AbstractARXMLWriter):
             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):
@@ -1959,7 +2605,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: