armodel 1.7.2__py3-none-any.whl → 1.7.4__py3-none-any.whl

armodel/writer/arxml_writer.py

@@ -1,11 +1,10 @@
 import xml.etree.cElementTree as ET
-
 from typing import List
 
 from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfoSet
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition, SwBaseType
-from ..models.M2.MSR.AsamHdo.ComputationMethod import CompuConstTextContent, CompuMethod, CompuNominatorDenominator, CompuScale, CompuScaleConstantContents, CompuScaleRationalFormula, CompuScales
+from ..models.M2.MSR.AsamHdo.ComputationMethod import Compu, CompuConst, CompuConstContent, CompuConstFormulaContent, CompuConstNumericContent, CompuConstTextContent, CompuMethod, CompuNominatorDenominator, CompuScale, CompuScaleConstantContents, CompuScaleRationalFormula, CompuScales
 from ..models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstr, InternalConstrs, PhysConstrs
 from ..models.M2.MSR.AsamHdo.SpecialData import Sdg
 from ..models.M2.MSR.AsamHdo.Units import PhysicalDimension, Unit
@@ -13,8 +12,9 @@ from ..models.M2.MSR.CalibrationData.CalibrationValue import SwValueCont, SwValu
 from ..models.M2.MSR.DataDictionary.Axis import SwAxisGrouped, SwAxisIndividual
 from ..models.M2.MSR.DataDictionary.AuxillaryObjects import SwAddrMethod
 from ..models.M2.MSR.DataDictionary.CalibrationParameter import SwCalprmAxis, SwCalprmAxisSet
-from ..models.M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps, ValueList
+from ..models.M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps, SwPointerTargetProps, ValueList
 from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayout, SwRecordLayoutGroup, SwRecordLayoutV
+from ..models.M2.MSR.DataDictionary.ServiceProcessTask import SwServiceArg
 from ..models.M2.MSR.Documentation.Annotation import Annotation
 from ..models.M2.MSR.Documentation.TextModel.BlockElements import DocumentationBlock
 from ..models.M2.MSR.Documentation.TextModel.BlockElements.ListElements import ListElement
@@ -25,20 +25,21 @@ from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswImplementation import BswImplementation
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswEvent, BswInternalBehavior, BswModeSenderPolicy, BswModuleEntity, BswSchedulableEntity, BswScheduleEvent, BswTimingEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswEvent, BswInternalBehavior, BswInterruptEntity, BswModeSenderPolicy, BswModuleEntity, BswSchedulableEntity, BswScheduleEvent, BswTimingEvent
 from ..models.M2.AUTOSARTemplates.CommonStructure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, ConstantSpecification, NumericalValueSpecification, RecordValueSpecification, TextValueSpecification, ValueSpecification
+from ..models.M2.AUTOSARTemplates.CommonStructure.FlatMap import FlatInstanceDescriptor, FlatMap
 from ..models.M2.AUTOSARTemplates.CommonStructure.Filter import DataFilter
 from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
 from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import Code, Implementation
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingExtensions import SwcTiming, TimingExtension
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import EOCExecutableEntityRef, ExecutionOrderConstraint
-from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal, DiagnosticCommunicationManagerNeeds, DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds, NvBlockNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal, DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds, DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds, EcuStateMgrUserNeeds, NvBlockNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
 from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
 from ..models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
 from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
 from ..models.M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclaration, ModeDeclarationGroup, ModeDeclarationGroupPrototype
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import ResourceConsumption
-
+from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import RoughEstimateStackUsage, StackUsage
 from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue, EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue, EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable, MultilanguageReferrable, Referrable
@@ -46,7 +47,7 @@ from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyI
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage, ReferenceBase
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType, ARLiteral, Limit
 
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption, PortDefinedArgumentValue
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType, AutosarDataType
@@ -56,12 +57,13 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import Compo
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, ApplicationSwComponentType, AtomicSwComponentType, ComplexDeviceDriverSwComponentType, CompositionSwComponentType, EcuAbstractionSwComponentType, PRPortPrototype, PortGroup, SwComponentType, PPortPrototype, PortPrototype, RPortPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import InnerPortGroupInCompositionInstanceRef, PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef, RModeInAtomicSwcInstanceRef, RVariableInAtomicSwcInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior import AsynchronousServerCallPoint, RunnableEntity, RunnableEntityArgument, SwcInternalBehavior, SynchronousServerCallPoint
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AutosarVariableRef import AutosarVariableRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import AssemblySwConnector, DelegationSwConnector, SwComponentPrototype, SwConnector
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface.InstanceRefs import ApplicationCompositeElementInPortInterfaceInstanceRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, AutosarVariableRef, VariableInAtomicSWCTypeInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, VariableInAtomicSWCTypeInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import ClientComSpec, ModeSwitchReceiverComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, PPortComSpec, ParameterRequireComSpec,  QueuedReceiverComSpec, QueuedSenderComSpec, RPortComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
@@ -69,20 +71,24 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes im
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import ServiceSwComponentType
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import DataTypeMappingSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionSet
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ApplicationError, ClientServerInterface, ClientServerOperation, ModeSwitchInterface, ParameterInterface, PortInterface, SenderReceiverInterface, TriggerInterface
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ApplicationError, ClientServerInterface, ClientServerOperation, DataPrototypeMapping, ModeSwitchInterface, ParameterInterface, PortInterface, PortInterfaceMappingSet, SenderReceiverInterface, TriggerInterface, VariableAndParameterInterfaceMapping
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcImplementation import SwcImplementation
 
 from ..models.M2.AUTOSARTemplates.SystemTemplate import SwcToEcuMapping, System, SystemMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderReceiverToSignalGroupMapping, SenderReceiverToSignalMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FrameTriggering, IPdu, IPduTiming, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalTriggering, PduTriggering, SecuredIPdu, SystemSignal, DcmIPdu, Frame, ISignal, NPdu, NmPdu, SystemSignalGroup
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import CyclicTiming, EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SocketConnection, SocketConnectionBundle, SocketConnectionIpduIdentifier
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetFrame import GenericEthernetFrame
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import EthernetCluster, EthernetCommunicationConnector, EthernetCommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import Ipv6Configuration, NetworkEndpoint, NetworkEndpointAddress
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import SoAdConfig
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Multiplatform import Gateway, ISignalMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanCommunication import CanFrame, CanFrameTriggering, RxIdentifierRange
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import CanCommunicationConnector, CanCommunicationController
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import LinFrameTriggering, LinUnconditionalFrame
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
 from ..models.M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
 from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode
 from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpConfig
@@ -127,7 +133,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             for sdg in sdgs:
                 self.setSdg(sdgs_tag, sdg)
     
-    def writeChildLimitElement(self, element: ET.Element, key: str, limit: Limit):
+    def setChildLimitElement(self, element: ET.Element, key: str, limit: Limit):
         if limit is not None:
             limit_tag = ET.SubElement(element, key)
             self.setARObjectAttributes(limit_tag, limit)
@@ -222,7 +228,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         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)
+        self.setValueSpecification(child_element, "INIT-VALUE", com_spec.getInitValue())
             
     def setServerComSpec(self, element: ET.Element, com_spec: ServerComSpec):
         child_element = ET.SubElement(element, "SERVER-COM-SPEC")
@@ -297,9 +303,9 @@ class ARXMLWriter(AbstractARXMLWriter):
         if cont is not None:
             child_element = ET.SubElement(element, "SW-VALUE-CONT")
             self.setARObjectAttributes(child_element, cont)
-            self.setChildElementOptionalRefType(child_element, "UNIT-REF", cont.unit_ref)
-            self.setValueList(child_element, "SW-ARRAYSIZE", cont.sw_arraysize)
-            self.setSwValues(child_element, "SW-VALUES-PHYS", cont.sw_values_phys)
+            self.setChildElementOptionalRefType(child_element, "UNIT-REF", cont.unitRef)
+            self.setValueList(child_element, "SW-ARRAYSIZE", cont.swArraysize)
+            self.setSwValues(child_element, "SW-VALUES-PHYS", cont.swValuesPhys)
 
     def writeValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
         if value_spec is not None:
@@ -350,37 +356,34 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeValueSpecification(value_spec_tag, value_spec)
         self.setChildElementOptionalRefType(value_spec_tag, "CONSTANT-REF", value_spec.getConstantRef())
 
-    def setValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
+    def setValueSpecification(self, element: ET.Element, key: str, value_spec: ValueSpecification):
         if value_spec is not None:
+            child_element = ET.SubElement(element, key)
             if isinstance(value_spec, ApplicationValueSpecification):
-                self.setApplicationValueSpecification(element, value_spec)
+                self.setApplicationValueSpecification(child_element, value_spec)
             elif isinstance(value_spec, TextValueSpecification):
-                self.setTextValueSpecification(element, value_spec)
+                self.setTextValueSpecification(child_element, value_spec)
             elif isinstance(value_spec, ConstantReference):
-                self.setConstantReference(element, value_spec)
+                self.setConstantReference(child_element, value_spec)
             elif isinstance(value_spec, NumericalValueSpecification):
-                self.setNumericalValueSpecification(element, value_spec)
+                self.setNumericalValueSpecification(child_element, value_spec)
             elif isinstance(value_spec, ArrayValueSpecification):
-                self.setArrayValueSpecification(element, value_spec)
+                self.setArrayValueSpecification(child_element, value_spec)
             elif isinstance(value_spec, RecordValueSpecification):
-                self.setRecordValueSpecification(element, value_spec)
+                self.setRecordValueSpecification(child_element, value_spec)
             else:
                 self.notImplemented("Unsupported ValueSpecification %s" % type(value_spec))
 
-    def setInitValue(self, element: ET.Element, init_value: ValueSpecification):
-        if init_value is not None:
-            child_element = ET.SubElement(element, "INIT-VALUE")
-            self.setValueSpecification(child_element, init_value)
-
     def writeNonqueuedReceiverComSpec(self, element: ET.Element, com_spec: NonqueuedReceiverComSpec):
         child_element = ET.SubElement(element, "NONQUEUED-RECEIVER-COM-SPEC")
         self.setARObjectAttributes(child_element, com_spec)
         self.writeReceiverComSpec(child_element, com_spec)
-        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)
+        self.setChildElementOptionalFloatValue(child_element, "ALIVE-TIMEOUT", com_spec.getAliveTimeout())
+        self.setChildElementOptionalBooleanValue(child_element, "ENABLE-UPDATE", com_spec.getEnableUpdated())
+        self.setDataFilter(child_element, "FILTER", com_spec.getFilter())
+        self.setChildElementOptionalBooleanValue(child_element, "HANDLE-NEVER-RECEIVED", com_spec.getHandleNeverReceived())
+        self.setChildElementOptionalLiteral(child_element, "HANDLE-TIMEOUT-TYPE", com_spec.getHandleTimeoutType())
+        self.setValueSpecification(child_element, "INIT-VALUE", com_spec.getInitValue())
 
     def writeQueuedReceiverComSpec(self, element: ET.Element, com_spec: QueuedReceiverComSpec):
         child_element = ET.SubElement(element, "QUEUED-RECEIVER-COM-SPEC")
@@ -398,14 +401,16 @@ class ARXMLWriter(AbstractARXMLWriter):
         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)
+        self.setChildElementOptionalRefType(child_element, "PARAMETER-REF", com_spec.getParameterRef())
+        self.setValueSpecification(child_element, "INIT-VALUE", com_spec.getInitValue())
 
-    def writeModeSwitchReceiverComSpec(self, element: ET.Element, com_spec: ModeSwitchReceiverComSpec):
+    def setModeSwitchReceiverComSpec(self, element: ET.Element, com_spec: ModeSwitchReceiverComSpec):
         self.logger.debug("writeModeSwitchReceiverComSpec")
         child_element = ET.SubElement(element, "MODE-SWITCH-RECEIVER-COM-SPEC")
         self.setARObjectAttributes(child_element, com_spec)
-        self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.modeGroupRef)
+        self.setChildElementOptionalBooleanValue(child_element, "ENHANCED-MODE-API", com_spec.getEnhancedModeApi())
+        self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.getModeGroupRef())
+        self.setChildElementOptionalBooleanValue(child_element, "SUPPORTS-ASYNCHRONOUS-MODE-SWITCH", com_spec.getSupportsAsynchronousModeSwitch())
 
     def writeRPortComSpec(self, element: ET.Element, com_spec: RPortComSpec):
         if isinstance(com_spec, NonqueuedReceiverComSpec):
@@ -415,7 +420,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         elif isinstance(com_spec, ClientComSpec):
             self.writeClientComSpec(element, com_spec)
         elif isinstance(com_spec, ModeSwitchReceiverComSpec):
-            self.writeModeSwitchReceiverComSpec(element, com_spec)
+            self.setModeSwitchReceiverComSpec(element, com_spec)
         elif isinstance(com_spec, ParameterRequireComSpec):
             self.writeParameterRequireComSpec(element, com_spec)
         else:
@@ -432,7 +437,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         prototype_tag = ET.SubElement(ports_tag, "P-PORT-PROTOTYPE")
 
         self.setIdentifiable(prototype_tag, prototype)
-        self.logger.debug("write PPortPrototype %s" % prototype.short_name)
+        self.logger.debug("write PPortPrototype %s" % prototype.getShortName())
         self.setAbstractProvidedPortPrototype(prototype_tag, prototype)
         self.setChildElementOptionalRefType(prototype_tag, "PROVIDED-INTERFACE-TREF", prototype.getProvidedInterfaceTRef())
 
@@ -444,14 +449,14 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.writeRPortComSpec(com_specs_tag, com_spec)  
 
     def writeRPortPrototype(self, ports_tag: ET.Element, prototype: RPortPrototype):
-        self.logger.debug("write RPortPrototype %s" % prototype.short_name)
+        self.logger.debug("write RPortPrototype %s" % prototype.getShortName())
         prototype_tag = ET.SubElement(ports_tag, "R-PORT-PROTOTYPE")
         self.setIdentifiable(prototype_tag, prototype)
         self.setAbstractRequiredPortPrototype(prototype_tag, prototype)
         self.setChildElementOptionalRefType(prototype_tag, "REQUIRED-INTERFACE-TREF", prototype.getRequiredInterfaceTRef())
 
     def writePRPortPrototype(self, ports_tag: ET.Element, prototype: PRPortPrototype):
-        self.logger.debug("write PRPortPrototype %s" % prototype.short_name)
+        self.logger.debug("write PRPortPrototype %s" % prototype.getShortName())
         prototype_tag = ET.SubElement(ports_tag, "PR-PORT-PROTOTYPE")
         self.setIdentifiable(prototype_tag, prototype)
         self.setAbstractProvidedPortPrototype(prototype_tag, prototype)
@@ -490,7 +495,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(child_element, "PORT-PROTOTYPE-REF", ref)
 
     def writePortGroup(self, element: ET.Element, port_group: PortGroup):
-        self.logger.debug("writePortGroup %s" % port_group.short_name)
+        self.logger.debug("writePortGroup %s" % port_group.getShortName())
         child_element = ET.SubElement(element, "PORT-GROUP")
         self.setIdentifiable(child_element, port_group)
         self.writePortGroupInnerGroupIRefs(child_element, port_group)
@@ -524,18 +529,19 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeSwComponentPrototype(components_tag, prototype)
 
     def writeAssemblySwConnector(self, element: ET.Element, sw_connector: AssemblySwConnector):
-        connector_tag = ET.SubElement(element, "ASSEMBLY-SW-CONNECTOR")
-        self.setIdentifiable(connector_tag, sw_connector)
+        child_element = ET.SubElement(element, "ASSEMBLY-SW-CONNECTOR")
+        self.setIdentifiable(child_element, sw_connector)
+        self.setChildElementOptionalRefType(child_element, "MAPPING-REF", sw_connector.getMappingRef())
 
         if sw_connector.getProviderIRef() is not None:
-            provider_iref_tag = ET.SubElement(connector_tag, "PROVIDER-IREF")
+            provider_iref_tag = ET.SubElement(child_element, "PROVIDER-IREF")
             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.getRequesterIRef() is not None:
-            requester_iref_tag = ET.SubElement(connector_tag, "REQUESTER-IREF")
+            requester_iref_tag = ET.SubElement(child_element, "REQUESTER-IREF")
             requester_iref = sw_connector.getRequesterIRef()
             self.setARObjectAttributes(requester_iref_tag, requester_iref)
             self.setChildElementOptionalRefType(requester_iref_tag, "CONTEXT-COMPONENT-REF", requester_iref.getContextComponentRef())
@@ -650,11 +656,11 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setSwAxisIndividual(self, element: ET.Element, props: SwAxisIndividual):
         child_element = ET.SubElement(element, "SW-AXIS-INDIVIDUAL")
         self.setARObjectAttributes(child_element, props)
-        self.setChildElementOptionalRefType(child_element, "INPUT-VARIABLE-TYPE-REF", props.inputVariableTypeRef)
-        self.setChildElementOptionalRefType(child_element, "COMPU-METHOD-REF", props.compuMethodRef)
-        self.setChildElementOptionalNumericalValue(child_element, "SW-MAX-AXIS-POINTS", props.swMaxAxisPoints) 
-        self.setChildElementOptionalNumericalValue(child_element, "SW-MIN-AXIS-POINTS", props.swMinAxisPoints)
-        self.setChildElementOptionalRefType(child_element, "DATA-CONSTR-REF", props.dataConstrRef)
+        self.setChildElementOptionalRefType(child_element, "INPUT-VARIABLE-TYPE-REF", props.getInputVariableTypeRef())
+        self.setChildElementOptionalRefType(child_element, "COMPU-METHOD-REF", props.getCompuMethodRef())
+        self.setChildElementOptionalNumericalValue(child_element, "SW-MAX-AXIS-POINTS", props.getSwMaxAxisPoints()) 
+        self.setChildElementOptionalNumericalValue(child_element, "SW-MIN-AXIS-POINTS", props.getSwMinAxisPoints())
+        self.setChildElementOptionalRefType(child_element, "DATA-CONSTR-REF", props.getDataConstrRef())
 
     def setSwAxisGrouped(self, element: ET.Element, props: SwAxisGrouped):
         child_element = ET.SubElement(element, "SW-AXIS-GROUPED")
@@ -681,32 +687,36 @@ 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 setSwPointerTargetProps(self, element: ET.Element, key: str, props: SwPointerTargetProps):
+        if props is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalLiteral(child_element, "TARGET-CATEGORY", props.getTargetCategory())
+            self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", props.getSwDataDefProps())
 
-    def setSwDataDefProps(self, element: ET.Element, key: str, sw_data_def_props: SwDataDefProps):
-        if sw_data_def_props is not None:
+    def setSwDataDefProps(self, element: ET.Element, key: str, props: SwDataDefProps):
+        if props is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, sw_data_def_props)
+            self.setARObjectAttributes(child_element, props)
             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.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.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "DATA-CONSTR-REF", sw_data_def_props.getDataConstrRef())
-            self.setChildElementOptionalRefType(sw_data_def_props_conditional_tag, "SW-ADDR-METHOD-REF", sw_data_def_props.getSwAddrMethodRef())
-            self.setChildElementOptionalLiteral(sw_data_def_props_conditional_tag, "SW-IMPL-POLICY", sw_data_def_props.getSwImplPolicy())
-            self.setChildElementOptionalNumericalValue(sw_data_def_props_conditional_tag, "SW-INTENDED-RESOLUTION", sw_data_def_props.getSwIntendedResolution())
-            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, "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())
+            conditional_tag = ET.SubElement(sw_data_def_props_variants_tag, "SW-DATA-DEF-PROPS-CONDITIONAL")
+            self.setARObjectAttributes(conditional_tag, props.conditional)
+            self.setAnnotations(conditional_tag, props.getAnnotations())
+            self.setChildElementOptionalRefType(conditional_tag, "BASE-TYPE-REF", props.getBaseTypeRef())
+            self.setChildElementOptionalRefType(conditional_tag, "COMPU-METHOD-REF", props.getCompuMethodRef())
+            
+            self.setValueSpecification(conditional_tag, "INVALID-VALUE", props.getInvalidValue())
+            self.setChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF", props.getImplementationDataTypeRef())
+            self.setChildElementOptionalFloatValue(conditional_tag, "STEP-SIZE", props.getStepSize())
+            self.setChildElementOptionalRefType(conditional_tag, "SW-ADDR-METHOD-REF", props.getSwAddrMethodRef())
+            self.setChildElementOptionalLiteral(conditional_tag, "SW-CALIBRATION-ACCESS", props.getSwCalibrationAccess())
+            self.setChildElementOptionalRefType(conditional_tag, "DATA-CONSTR-REF", props.getDataConstrRef())
+            self.setSwCalprmAxisSet(conditional_tag, "SW-CALPRM-AXIS-SET", props.getSwCalprmAxisSet())
+            self.setChildElementOptionalLiteral(conditional_tag, "SW-IMPL-POLICY", props.getSwImplPolicy())
+            self.setChildElementOptionalNumericalValue(conditional_tag, "SW-INTENDED-RESOLUTION", props.getSwIntendedResolution())
+            self.setSwPointerTargetProps(conditional_tag, "SW-POINTER-TARGET-PROPS", props.getSwPointerTargetProps())
+            self.setChildElementOptionalRefType(conditional_tag, "SW-RECORD-LAYOUT-REF", props.getSwRecordLayoutRef())
+            self.setChildElementOptionalRefType(conditional_tag, "VALUE-AXIS-DATA-TYPE-REF", props.getValueAxisDataTypeRef())
+            self.setChildElementOptionalRefType(conditional_tag, "UNIT-REF", props.getUnitRef())
 
     def setApplicationDataType(self, element: ET.Element, data_type: ApplicationDataType):
         self.setAutosarDataType(element, data_type)
@@ -727,6 +737,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setSwDataDefProps(element, "SW-DATA-DEF-PROPS", prototype.getSwDataDefProps())
 
     def setApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
+        self.setIdentifiable(element, prototype)
         self.setDataPrototype(element, prototype)
         self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.typeTRef)
 
@@ -755,16 +766,17 @@ class ARXMLWriter(AbstractARXMLWriter):
             else:
                 self.notImplemented("Unsupported ApplicationDataType <%s>" % type(data_type))
 
-    def writeBaseTypeDirectDefinition(self, element: ET.Element, base_type_definition: BaseTypeDirectDefinition):
-        self.setChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE", base_type_definition.baseTypeSize)
-        self.setChildElementOptionalLiteral(element, "BASE-TYPE-ENCODING", base_type_definition.baseTypeEncoding)
-        self.setChildElementOptionalNumericalValue(element, "MEM-ALIGNMENT", base_type_definition.memAlignment)
-        self.setChildElementOptionalLiteral(element, "NATIVE-DECLARATION", base_type_definition.nativeDeclaration)
+    def setBaseTypeDirectDefinition(self, element: ET.Element, base_type_definition: BaseTypeDirectDefinition):
+        self.setChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE", base_type_definition.getBaseTypeSize())
+        self.setChildElementOptionalLiteral(element, "BASE-TYPE-ENCODING", base_type_definition.getBaseTypeEncoding())
+        self.setChildElementOptionalLiteral(element, "BYTE-ORDER", base_type_definition.getByteOrder())
+        self.setChildElementOptionalNumericalValue(element, "MEM-ALIGNMENT", base_type_definition.getMemAlignment())
+        self.setChildElementOptionalLiteral(element, "NATIVE-DECLARATION", base_type_definition.getNativeDeclaration())
 
     def writeSwBaseType(self, element: ET.Element, base_type: SwBaseType):
         data_type_tag = ET.SubElement(element, "SW-BASE-TYPE")
         self.setIdentifiable(data_type_tag, base_type)
-        self.writeBaseTypeDirectDefinition(data_type_tag, base_type.baseTypeDefinition)
+        self.setBaseTypeDirectDefinition(data_type_tag, base_type.getBaseTypeDefinition())
 
     def writeCompuScaleConstantContents(self, element: ET.Element, contents: CompuScaleConstantContents):
         compu_const_tag = ET.SubElement(element, "COMPU-CONST")
@@ -793,48 +805,49 @@ class ARXMLWriter(AbstractARXMLWriter):
         else:
             self.notImplemented("Unsupported CompuScaleContents %s" % type(compu_scale.compuScaleContents))
 
-    def writeCompuScales(self, element: ET.Element, compu_scales: CompuScales):
-        compu_scales_tag = ET.SubElement(element, "COMPU-SCALES")
-        for compu_scale in compu_scales.getCompuScales():
-            child_element = ET.SubElement(compu_scales_tag, "COMPU-SCALE")
-            self.setARObjectAttributes(child_element, compu_scale)
-            self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", compu_scale.getShortLabel())
-            self.setChildElementOptionalLiteral(child_element, "SYMBOL", compu_scale.getSymbol())
-            self.writeChildLimitElement(child_element, "LOWER-LIMIT", compu_scale.getLowerLimit())
-            self.writeChildLimitElement(child_element, "UPPER-LIMIT", compu_scale.getUpperLimit())
-            self.writeCompuScaleContents(child_element, compu_scale)
-
-    def writeCompuInternalToPhys(self, element: ET.Element, compu_method: CompuMethod):
-        compu = compu_method.getCompuInternalToPhys()
-        if  compu is not None:
-            child_element = ET.SubElement(element, "COMPU-INTERNAL-TO-PHYS")
-            self.setARObjectAttributes(child_element, compu)
-            compu_content = compu.getCompuContent()
-            if compu_content is not None:
-                if isinstance(compu_content, CompuScales):
-                    self.writeCompuScales(child_element, compu_content)
-                else:
-                    self.notImplemented("Unsupported CompuContent <%s>" % type(compu_content))
+    def setCompuConstContent(self, element: ET.Element, content: CompuConstContent):
+        if content is not None:
+            if isinstance(content, CompuConstFormulaContent):
+                self.setChildElementOptionalLiteral(element, "VF", content.getVf())
+            elif isinstance(content, CompuConstNumericContent):
+                self.setChildElementOptionalNumericalValue(element, "V", content.getV())
+            elif isinstance(content, CompuConstTextContent):
+                self.setChildElementOptionalLiteral(element, "VT", content.getVt())
+            else:
+                self.notImplemented("Unsupported CompuConstContent <%s>" % type(content))
+
+    def setCompuScales(self, element: ET.Element, compu_scales: CompuScales):
+        if compu_scales is not None:
+            compu_scales_tag = ET.SubElement(element, "COMPU-SCALES")
+            for compu_scale in compu_scales.getCompuScales():
+                child_element = ET.SubElement(compu_scales_tag, "COMPU-SCALE")
+                self.setARObjectAttributes(child_element, compu_scale)
+                self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", compu_scale.getShortLabel())
+                self.setChildElementOptionalLiteral(child_element, "SYMBOL", compu_scale.getSymbol())
+                self.setChildLimitElement(child_element, "LOWER-LIMIT", compu_scale.getLowerLimit())
+                self.setChildLimitElement(child_element, "UPPER-LIMIT", compu_scale.getUpperLimit())
+                self.writeCompuScaleContents(child_element, compu_scale)
+
+    def setCompuConst(self, element: ET.Element, key: str, compu_const: CompuConst):
+        if compu_const is not None:
+            child_element = ET.SubElement(element, key)
+            self.setARObjectAttributes(child_element, compu_const)
+            self.setCompuConstContent(child_element, compu_const.getCompuConstContentType())
 
-    def writeCompuPhysToInternal(self, element: ET.Element, compu_method: CompuMethod):
-        compu = compu_method.getCompuPhysToInternal()
+    def setCompu(self, element: ET.Element, key: str, compu: Compu):
         if  compu is not None:
-            child_element = ET.SubElement(element, "COMPU-PHYS-TO-INTERNAL")
+            child_element = ET.SubElement(element, key)
             self.setARObjectAttributes(child_element, compu)
-            compu_content = compu.getCompuContent()
-            if compu_content is not None:
-                if isinstance(compu_content, CompuScales):
-                    self.writeCompuScales(child_element, compu_content)
-                else:
-                    self.notImplemented("Unsupported CompuContent <%s>" % type(compu_content))
+            self.setCompuScales(child_element, compu.getCompuContent())
+            self.setCompuConst(child_element, "COMPU-DEFAULT-VALUE", compu.getCompuDefaultValue())
 
     def writeCompuMethod(self, element: ET.Element, compu_method: CompuMethod):
         child_element = ET.SubElement(element, "COMPU-METHOD")
-        self.logger.debug("writeCompuMethods %s" % compu_method.getShortName())
+        self.logger.debug("write CompuMethods %s" % compu_method.getShortName())
         self.setIdentifiable(child_element, compu_method)
         self.setChildElementOptionalRefType(child_element, "UNIT-REF", compu_method.getUnitRef())
-        self.writeCompuInternalToPhys(child_element, compu_method)
-        self.writeCompuPhysToInternal(child_element, compu_method)
+        self.setCompu(child_element, "COMPU-INTERNAL-TO-PHYS", compu_method.getCompuInternalToPhys())
+        self.setCompu(child_element, "COMPU-PHYS-TO-INTERNAL", compu_method.getCompuPhysToInternal())
 
     def setApplicationValueSpecification(self, element: ET.Element, spec: ApplicationValueSpecification):
         spec_tag = ET.SubElement(element, "APPLICATION-VALUE-SPECIFICATION")
@@ -868,26 +881,25 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setIdentifiable(spec_tag, spec)
 
         if spec.getValueSpec() is not None:
-            value_spec_tag = ET.SubElement(spec_tag, "VALUE-SPEC")
-            self.setValueSpecification(value_spec_tag, spec.getValueSpec())
+            self.setValueSpecification(spec_tag, "VALUE-SPEC", spec.getValueSpec())
                 
     def setInternalConstrs(self, element: ET.Element, constrs: InternalConstrs):
         if constrs is not None:
             constrs_tag = ET.SubElement(element, "INTERNAL-CONSTRS")
             self.setARObjectAttributes(constrs_tag, constrs)
             if constrs.lower_limit is not None:
-                self.writeChildLimitElement(constrs_tag, "LOWER-LIMIT", constrs.lower_limit)
+                self.setChildLimitElement(constrs_tag, "LOWER-LIMIT", constrs.lower_limit)
             if constrs.upper_limit is not None:
-                self.writeChildLimitElement(constrs_tag, "UPPER-LIMIT", constrs.upper_limit)
+                self.setChildLimitElement(constrs_tag, "UPPER-LIMIT", constrs.upper_limit)
 
     def setPhysConstrs(self, element: ET.Element, constrs: PhysConstrs):
         if constrs is not None:
             child_element = ET.SubElement(element, "PHYS-CONSTRS")
             self.setARObjectAttributes(child_element, constrs)
             if constrs.lower_limit is not None:
-                self.writeChildLimitElement(child_element, "LOWER-LIMIT", constrs.lower_limit)
+                self.setChildLimitElement(child_element, "LOWER-LIMIT", constrs.lower_limit)
             if constrs.upper_limit is not None:
-                self.writeChildLimitElement(child_element, "UPPER-LIMIT", constrs.upper_limit)
+                self.setChildLimitElement(child_element, "UPPER-LIMIT", constrs.upper_limit)
             self.setChildElementOptionalRefType(child_element, "UNIT-REF", constrs.unit_ref)
                 
     def writeDataConstrRules(self, element: ET.Element, parent: DataConstr):
@@ -907,7 +919,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeDataConstrRules(child_element, constr) 
 
     def writeUnit(self, element: ET.Element, unit: Unit):
-        self.logger.debug("writeUnit %s" % unit.short_name)
+        self.logger.debug("writeUnit %s" % unit.getShortName())
         child_element = ET.SubElement(element, "UNIT")
         self.setIdentifiable(child_element, unit)
         self.setChildElementOptionalLiteral(child_element, "DISPLAY-NAME", unit.getDisplayName())
@@ -1027,22 +1039,15 @@ class ARXMLWriter(AbstractARXMLWriter):
             for ref in refs:
                 self.setChildElementOptionalRefType(refs_tag, "DATA-TYPE-MAPPING-REF", ref)
 
-    def writeInternalBehaviorConstantMemories(self, element: ET.Element, behavior: InternalBehavior):
-        memories = behavior.getConstantMemorys()
-        if len(memories) > 0:
-            child_element = ET.SubElement(element, "CONSTANT-MEMORYS")
-            for memory in memories:
-                self.writeParameterDataPrototype(child_element, memory)
-           
     def writeInternalBehavior(self, element: ET.Element, behavior: InternalBehavior):
         self.setIdentifiable(element, behavior)
-        self.writeInternalBehaviorConstantMemories(element, behavior)
+        self.setParameterDataPrototypes(element, "CONSTANT-MEMORYS", behavior.getConstantMemories())
         self.writeDataTypeMappingRefs(element, behavior)
         self.writeExclusiveAreas(element, behavior)
 
-    def setAutosarVariableRef(self, element: ET.Element, ref: AutosarVariableRef):
+    def setAutosarVariableRef(self, element: ET.Element, key: str, ref: AutosarVariableRef):
         if ref is not None:
-            child_element = ET.SubElement(element, "ACCESSED-VARIABLE")
+            child_element = ET.SubElement(element, key)
             self.setARObjectAttributes(child_element, ref)
             if ref.getAutosarVariableIRef() is not None:
                 child_element = ET.SubElement(child_element, "AUTOSAR-VARIABLE-IREF")
@@ -1062,21 +1067,17 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setVariableAccess(self, element: ET.Element, access: VariableAccess):
         child_element = ET.SubElement(element, "VARIABLE-ACCESS")
         self.setIdentifiable(child_element, access)
-        self.setAutosarVariableRef(child_element, access.getAccessedVariableRef())
-
-    def writeDataReadAccesses(self, element: ET.Element, entity: RunnableEntity):
-        #accesses = entity.getDataReadAccesses():
-        pass
+        self.setAutosarVariableRef(child_element, "ACCESSED-VARIABLE", access.getAccessedVariableRef())
 
     def setAutosarParameterRef(self, element: ET.Element, key: str, parameter_ref: AutosarParameterRef):
         if parameter_ref is not None:
             child_element = ET.SubElement(element, key)
-            self.setChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF", parameter_ref.local_parameter_ref)
+            self.setChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF", parameter_ref.getLocalParameterRef())
 
     def writeParameterAccess(self, element: ET.Element, parameter_access: ParameterAccess):
         child_element = ET.SubElement(element, "PARAMETER-ACCESS")
         self.setIdentifiable(child_element, parameter_access)
-        self.setAutosarParameterRef(child_element, "ACCESSED-PARAMETER", parameter_access.accessed_parameter)
+        self.setAutosarParameterRef(child_element, "ACCESSED-PARAMETER", parameter_access.getAccessedParameter())
 
     def writeParameterAccesses(self, element: ET.Element, entity: RunnableEntity):
         parameter_accesses = entity.getParameterAccesses()
@@ -1099,12 +1100,19 @@ class ARXMLWriter(AbstractARXMLWriter):
             for point in points:
                 self.setVariableAccess(child_element, point)
 
+    def writeDataReadAccesses(self, element: ET.Element, entity: RunnableEntity):
+        accesses = entity.getDataReadAccesses()
+        if len(accesses) > 0:
+            child_element = ET.SubElement(element, "DATA-READ-ACCESSS")
+            for access in accesses:
+                self.setVariableAccess(child_element, access)
+
     def writeDataWriteAccesses(self, element: ET.Element, entity: RunnableEntity):
-        points = entity.getDataWriteAccesses()
-        if len(points) > 0:
+        accesses = entity.getDataWriteAccesses()
+        if len(accesses) > 0:
             child_element = ET.SubElement(element, "DATA-WRITE-ACCESSS")
-            for point in points:
-                self.setVariableAccess(child_element, point)
+            for access in accesses:
+                self.setVariableAccess(child_element, access)
 
     def writeReadLocalVariables(self, element: ET.Element, entity: RunnableEntity):
         variables = entity.getReadLocalVariables()
@@ -1213,12 +1221,13 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeRunnableEntityArguments(child_element, entity)
             self.writeAsynchronousServerCallResultPoint(child_element, entity)
             self.setChildElementOptionalBooleanValue(child_element, "CAN-BE-INVOKED-CONCURRENTLY", entity.getCanBeInvokedConcurrently())
-            self.writeParameterAccesses(child_element, entity)
+            self.writeDataReadAccesses(child_element, entity)
             self.writeDataReceivePointByArguments(child_element, entity)
             self.writeDataSendPoints(child_element, entity)
             self.writeDataWriteAccesses(child_element, entity)
             self.writeModeAccessPoints(child_element, entity)
             self.writeModeSwitchPoints(child_element, entity)
+            self.writeParameterAccesses(child_element, entity)
             self.writeReadLocalVariables(child_element, entity)
             self.writeServerCallPoints(child_element, entity)
             self.setChildElementOptionalLiteral(child_element, "SYMBOL", entity.symbol)
@@ -1233,6 +1242,16 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.writeRunnableEntity(runnables_tag, entity)
                 else:
                     self.notImplemented("Unsupported RunnableEntity <%s>" % type(entity))
+
+    def writeSwcInternalBehaviorArTypedPerInstanceMemories(self, element: ET.Element, behavior: SwcInternalBehavior):
+        prototypes = behavior.getArTypedPerInstanceMemories()
+        if len(prototypes) > 0:
+            child_element = ET.SubElement(element, "AR-TYPED-PER-INSTANCE-MEMORYS")
+            for prototype in prototypes:
+                if isinstance(prototype, VariableDataPrototype):
+                    self.writeVariableDataPrototype(child_element, prototype)
+                else:
+                    self._raiseError("Unsupported ArTypedPerInstanceMemories <%s>" % type(prototype))
                 
     def writeExplicitInterRunnableVariables(self, element: ET.Element, behavior: SwcInternalBehavior):
         prototypes = behavior.getExplicitInterRunnableVariables()
@@ -1256,29 +1275,26 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalLiteral(child_element, "TYPE", memory.getType())
                 self.setChildElementOptionalLiteral (child_element, "TYPE-DEFINITION", memory.getTypeDefinition())
 
-    def writeParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
+    def setParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
         child_element = ET.SubElement(element, "PARAMETER-DATA-PROTOTYPE")
         self.setIdentifiable(child_element, prototype)
         self.setAutosarDataPrototype(child_element, prototype)
-        self.setInitValue(child_element, prototype.getInitValue())
+        self.setValueSpecification(child_element, "INIT-VALUE", prototype.getInitValue())
 
-    def writePerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
-        prototypes = behavior.getPerInstanceParameters()
-        if len(prototypes) > 0:
-            child_element = ET.SubElement(element, "PER-INSTANCE-PARAMETERS")
-            for prototype in prototypes:
-                self.writeParameterDataPrototype(child_element, prototype)
+    def setParameterDataPrototypes(self, element: ET.Element, key: str, parameters: List[ParameterDataPrototype]):
+        if len(parameters) > 0:
+            child_element = ET.SubElement(element, key)
+            for parameter in parameters:
+                self.setParameterDataPrototype(child_element, parameter)
 
-    def writePortDefinedArgumentValues(self, element: ET.Element, option: PortAPIOption) :
-        argument_values = option.getPortArgValues()
+    def writePortDefinedArgumentValues(self, element: ET.Element, argument_values: List[PortDefinedArgumentValue]) :
         if len(argument_values) > 0:
             child_element = ET.SubElement(element, "PORT-ARG-VALUES")
             for argument_value in argument_values:
                 child_element = ET.SubElement(child_element, "PORT-DEFINED-ARGUMENT-VALUE")
-                if argument_value.value is not None:
-                    value_tag = ET.SubElement(child_element, "VALUE")
-                    self.setValueSpecification(value_tag, argument_value.value)
-                self.setChildElementOptionalRefType(child_element, "VALUE-TYPE-TREF", argument_value.valueTypeTRef)
+                if argument_value.getValue() is not None:
+                    self.setValueSpecification(child_element, "VALUE", argument_value.getValue())
+                self.setChildElementOptionalRefType(child_element, "VALUE-TYPE-TREF", argument_value.getValueTypeTRef())
 
     def writePortAPIOptions(self, element: ET.Element, behavior: SwcInternalBehavior):
         options = behavior.getPortAPIOptions()
@@ -1286,10 +1302,11 @@ class ARXMLWriter(AbstractARXMLWriter):
             port_api_options_tag = ET.SubElement(element, "PORT-API-OPTIONS")
             for option in options:
                 child_element = ET.SubElement(port_api_options_tag, "PORT-API-OPTION")
-                self.setChildElementOptionalBooleanValue(child_element, "ENABLE-TAKE-ADDRESS", option.enableTakeAddress)
-                self.setChildElementOptionalBooleanValue(child_element, "INDIRECT-API", option.indirectAPI)
-                self.writePortDefinedArgumentValues(child_element, option)
-                self.setChildElementOptionalRefType(child_element, "PORT-REF", option.portRef)
+                self.setChildElementOptionalBooleanValue(child_element, "ENABLE-TAKE-ADDRESS", option.getEnableTakeAddress())
+                self.setChildElementOptionalLiteral(child_element, "ERROR-HANDLING", option.getErrorHandling())
+                self.setChildElementOptionalBooleanValue(child_element, "INDIRECT-API", option.getIndirectAPI())
+                self.writePortDefinedArgumentValues(child_element, option.getPortArgValues())
+                self.setChildElementOptionalRefType(child_element, "PORT-REF", option.getPortRef())
 
     def writeRoleBasedDataTypeAssignment(self, element: ET.Element, assignment: RoleBasedDataTypeAssignment):
         child_element = ET.SubElement(element, "ROLE-BASED-DATA-TYPE-ASSIGNMENT")
@@ -1313,6 +1330,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeRoleBasedDataAssignment(self, element: ET.Element, assignment: RoleBasedDataAssignment):
         child_element = ET.SubElement(element, "ROLE-BASED-DATA-ASSIGNMENT")
         self.setChildElementOptionalLiteral(child_element, "ROLE", assignment.role)
+        self.setAutosarVariableRef(child_element, "USED-DATA-ELEMENT", assignment.getUsedDataElement())
         self.setAutosarParameterRef(child_element, "USED-PARAMETER-ELEMENT", assignment.getUsedParameterElement())
         self.setChildElementOptionalRefType(child_element, "USED-PIM-REF", assignment.getUsedPimRef())
 
@@ -1341,9 +1359,9 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported Assigned Data <%s>" % type(data)) 
 
-    def writeNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
+    def setNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
         child_element = ET.SubElement(element, "NV-BLOCK-NEEDS")
-        self.logger.debug("write NvBlockNeeds %s" % needs.short_name)
+        self.logger.debug("write NvBlockNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.setChildElementOptionalBooleanValue(child_element, "CALC-RAM-BLOCK-CRC", needs.getCalcRamBlockCrc())
         self.setChildElementOptionalBooleanValue(child_element, "CHECK-STATIC-BLOCK-ID", needs.getCheckStaticBlockId())
@@ -1362,24 +1380,25 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalBooleanValue(child_element, "USE-CRC-COMP-MECHANISM", needs.getUseCRCCompMechanism())
         self.setChildElementOptionalBooleanValue(child_element, "WRITE-ONLY-ONCE", needs.getWriteOnlyOnce())
         self.setChildElementOptionalBooleanValue(child_element, "WRITE-VERIFICATION", needs.getWriteVerification())
+        self.setChildElementOptionalPositiveInteger(child_element, "WRITING-FREQUENCY", needs.getWritingFrequency())
         self.setChildElementOptionalLiteral(child_element, "WRITING-PRIORITY", needs.getWritingPriority())
 
-    def writeDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
+    def setDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS")
-        self.logger.debug("write DiagnosticCommunicationManagerNeeds %s" % needs.short_name)
+        self.logger.debug("write DiagnosticCommunicationManagerNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "SERVICE-REQUEST-CALLBACK-TYPE", needs.getServiceRequestCallbackType()) 
     
-    def writeDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
+    def setDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-ROUTINE-NEEDS")
-        self.logger.debug("write DiagnosticRoutineNeeds %s" % needs.short_name)
+        self.logger.debug("write DiagnosticRoutineNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DIAG-ROUTINE-TYPE", needs.getDiagRoutineType())
         self.setChildElementOptionalIntegerValue(child_element, "RID-NUMBER", needs.getRidNumber())
 
-    def writeDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
+    def setDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-VALUE-NEEDS")
-        self.logger.debug("write DiagnosticValueNeeds %s" % needs.short_name)
+        self.logger.debug("write DiagnosticValueNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "DATA-LENGTH", needs.getDataLength())
         self.setChildElementOptionalLiteral(child_element, "DIAGNOSTIC-VALUE-ACCESS", needs.getDiagnosticValueAccess())
@@ -1400,39 +1419,54 @@ class ARXMLWriter(AbstractARXMLWriter):
             else:
                 self.notImplemented("Unsupported DiagEventDebounceAlgorithm <%s>" % type(algorithm))
 
-    def writeDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
+    def setDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-EVENT-NEEDS")
-        self.logger.debug("write DiagnosticEventNeeds %s" % needs.short_name)
+        self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.writeDiagEventDebounceAlgorithm(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DTC-KIND", needs.getDtcKind())
         self.setChildElementOptionalIntegerValue(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
+
+    def setDiagnosticEventInfoNeeds(self, element: ET.Element, needs: DiagnosticEventInfoNeeds):
+        child_element = ET.SubElement(element, "DIAGNOSTIC-EVENT-INFO-NEEDS")
+        self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
+        self.setIdentifiable(child_element, needs)
+        self.setChildElementOptionalPositiveInteger(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
     
-    def writeCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
+    def setCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
         child_element = ET.SubElement(element, "CRYPTO-SERVICE-NEEDS")
-        self.logger.debug("write CryptoServiceNeeds %s" % needs.short_name)
+        self.logger.debug("write CryptoServiceNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "MAXIMUM-KEY-LENGTH", needs.getMaximumKeyLength())
 
+    def setEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
+        child_element = ET.SubElement(element, "ECU-STATE-MGR-USER-NEEDS")
+        self.logger.debug("write EcuStateMgrUserNeeds %s" % needs.getShortName())
+        self.setIdentifiable(child_element, needs)
+
     def writeSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         needs = parent.getServiceNeeds()
         if len(needs) > 0:
             child_element = ET.SubElement(element, "SERVICE-NEEDS")
             for need in needs:
                 if isinstance(need, NvBlockNeeds):
-                    self.writeNvBlockNeeds(child_element, need)
+                    self.setNvBlockNeeds(child_element, need)
                 elif isinstance(need, DiagnosticCommunicationManagerNeeds):
-                    self.writeDiagnosticCommunicationManagerNeeds(child_element, need)
+                    self.setDiagnosticCommunicationManagerNeeds(child_element, need)
                 elif isinstance(need, DiagnosticRoutineNeeds):
-                    self.writeDiagnosticRoutineNeeds(child_element, need)
+                    self.setDiagnosticRoutineNeeds(child_element, need)
                 elif isinstance(need, DiagnosticValueNeeds):
-                    self.writeDiagnosticValueNeeds(child_element, need)
+                    self.setDiagnosticValueNeeds(child_element, need)
                 elif isinstance(need, DiagnosticEventNeeds):
-                    self.writeDiagnosticEventNeeds(child_element, need)
+                    self.setDiagnosticEventNeeds(child_element, need)
+                elif isinstance(need, DiagnosticEventInfoNeeds):
+                    self.setDiagnosticEventInfoNeeds(child_element, need)
                 elif isinstance(need, CryptoServiceNeeds):
-                    self.writeCryptoServiceNeeds(child_element, need)
+                    self.setCryptoServiceNeeds(child_element, need)
+                elif isinstance(need, EcuStateMgrUserNeeds):
+                    self.setEcuStateMgrUserNeeds(child_element, need)
                 else:
-                    self._raiseError("Unsupported service needs <%s>" % type(need))                  
+                    self.notImplemented("Unsupported service needs <%s>" % type(need))                  
 
     def writeSwcServiceDependency(self, element: ET.Element, dependency: SwcServiceDependency):
         child_element = ET.SubElement(element, "SWC-SERVICE-DEPENDENCY")
@@ -1463,21 +1497,24 @@ class ARXMLWriter(AbstractARXMLWriter):
                     for type_ref in type_refs:
                         self.setChildElementOptionalRefType(data_type_refs_tag, "DATA-TYPE-REF", type_ref)
 
+
     def writeSwcInternalBehavior(self, element: ET.Element, behavior: SwcInternalBehavior):
-        self.logger.debug("writeSwInternalBehavior %s" % behavior.short_name)
+        self.logger.debug("writeSwInternalBehavior %s" % behavior.getShortName())
 
         child_element = ET.SubElement(element, "SWC-INTERNAL-BEHAVIOR")
         self.writeInternalBehavior(child_element, behavior)
+        self.writeSwcInternalBehaviorArTypedPerInstanceMemories(child_element, behavior)
         self.writeRTEEvents(child_element, behavior)
         self.writeExplicitInterRunnableVariables(child_element, behavior)
-        self.setChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART", behavior.handle_termination_and_restart)
+        self.setChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART", behavior.getHandleTerminationAndRestart())
         self.setIncludedDataTypeSets(child_element, behavior.getIncludedDataTypeSets())
         self.writePerInstanceMemories(child_element, behavior)
-        self.writePerInstanceParameters(child_element, behavior)
+        self.setParameterDataPrototypes(child_element, "PER-INSTANCE-PARAMETERS", behavior.getPerInstanceParameters())
         self.writePortAPIOptions(child_element, behavior)
         self.writeSwcInternalBehaviorRunnableEntities(child_element, behavior)
         self.writeSwcInternalBehaviorServiceDependencies(child_element, behavior)
-        self.setChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION", behavior.supports_multiple_instantiation)
+        self.setParameterDataPrototypes(child_element, "SHARED-PARAMETERS", behavior.getSharedParameters())
+        self.setChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION", behavior.getSupportsMultipleInstantiation())
 
     def writeAtomicSwComponentTypeInternalBehaviors(self, element: ET.Element, behavior: InternalBehavior):
         if behavior is not None:
@@ -1492,7 +1529,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeAtomicSwComponentTypeInternalBehaviors(element, sw_component.internal_behavior)
 
     def writeComplexDeviceDriverSwComponentType(self, element: ET.Element, sw_component: ComplexDeviceDriverSwComponentType):
-        self.logger.debug("writeComplexDeviceDriverSwComponentType %s" % sw_component.short_name)
+        self.logger.debug("writeComplexDeviceDriverSwComponentType %s" % sw_component.getShortName())
         child_element = ET.SubElement(element, "COMPLEX-DEVICE-DRIVER-SW-COMPONENT-TYPE")
         self.writeAtomicSwComponentType(child_element, sw_component)
 
@@ -1508,7 +1545,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalLiteral(artifact_desc_tag, "CATEGORY", artifact_desc.category)
 
     def setCode(self, element: ET.SubElement, code_desc: Code):
-        self.logger.debug("setCode %s" % code_desc.short_name)
+        self.logger.debug("setCode %s" % code_desc.getShortName())
         child_element = ET.SubElement(element, "CODE")
         self.setIdentifiable(child_element, code_desc)
         self.writeArtifactDescriptor(child_element, code_desc)
@@ -1542,13 +1579,33 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalNumericalValue(child_element, "SIZE", memory_section.getSize())
                 self.setChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF", memory_section.getSwAddrMethodRef())
                 self.setChildElementOptionalLiteral(child_element, "SYMBOL", memory_section.getSymbol())
-                self.logger.debug("write MemorySection %s" % memory_section.getShortName())
+                self.logger.debug("Write MemorySection %s" % memory_section.getShortName())
+
+    def setStackUsage(self, element: ET.Element, usage: StackUsage):
+        self.logger.debug("Write StackUsage %s" % usage.getShortName())
+        self.setIdentifiable(element, usage)
+
+    def setRoughEstimateStackUsage(self, element: ET.Element, usage: RoughEstimateStackUsage):
+        if usage is not None:
+            child_element = ET.SubElement(element, "ROUGH-ESTIMATE-STACK-USAGE")
+            self.setStackUsage(child_element, usage)
+            self.setChildElementOptionalPositiveInteger(child_element, "MEMORY-CONSUMPTION", usage.getMemoryConsumption())
+
+    def writeStackUsages(self, element: ET.Element, usages: List[StackUsage]):
+        if len(usages) > 0:
+            child_element = ET.SubElement(element, "STACK-USAGES")
+            for usage in usages:
+                if isinstance(usage, RoughEstimateStackUsage):
+                    self.setRoughEstimateStackUsage(child_element, usage)
+                else:
+                    self.notImplemented("Unsupported Stack Usages: <%s>" % type(usage))
 
     def setResourceConsumption(self, element: ET.Element, consumption: ResourceConsumption):
         if consumption is not None:
             child_element = ET.SubElement(element, "RESOURCE-CONSUMPTION")
             self.setIdentifiable(child_element, consumption)
             self.writeMemorySections(child_element, consumption)
+            self.writeStackUsages(child_element, consumption.getStackUsages())
 
     def writeImplementation(self, element: ET.Element, impl: Implementation):
         self.setIdentifiable(element, impl)
@@ -1561,7 +1618,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalNumericalValue(element, "VENDOR-ID", impl.getVendorId())
 
     def writeSwcImplementation(self, element: ET.Element, impl: SwcImplementation):
-        self.logger.debug("writeSwcImplementation %s" % impl.short_name)
+        self.logger.debug("writeSwcImplementation %s" % impl.getShortName())
         child_element = ET.SubElement(element, "SWC-IMPLEMENTATION")
         self.writeImplementation(child_element, impl)
         self.setChildElementOptionalRefType(child_element, "BEHAVIOR-REF", impl.getBehaviorRef())
@@ -1627,7 +1684,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.setEndToEndProtection(child_element, protection)
 
     def writeEndToEndProtectionSet(self, element: ET.Element, protection_set: EndToEndProtectionSet):
-        self.logger.debug("writeEndToEndProtectionSet %s" % protection_set.short_name)
+        self.logger.debug("writeEndToEndProtectionSet %s" % protection_set.getShortName())
         child_element = ET.SubElement(element, "END-TO-END-PROTECTION-SET")
         self.setIdentifiable(child_element, protection_set)
         self.writeEndToEndProtections(child_element, protection_set)
@@ -1637,11 +1694,11 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.typeTRef)
 
     def writeVariableDataPrototype(self, element: ET.Element, prototype: VariableDataPrototype):
-        self.logger.debug("writeVariableDataPrototype %s" % prototype.short_name)
+        self.logger.debug("writeVariableDataPrototype %s" % prototype.getShortName())
         child_element = ET.SubElement(element, "VARIABLE-DATA-PROTOTYPE")
         self.setIdentifiable(child_element, prototype)
         self.setAutosarDataPrototype(child_element, prototype)
-        self.setInitValue(child_element, prototype.initValue)
+        self.setValueSpecification(child_element, "INIT-VALUE", prototype.getInitValue())
 
     def writeSenderReceiverInterfaceDataElements(self, element: ET.Element, sr_interface: SenderReceiverInterface):
         data_elements = sr_interface.getDataElements()
@@ -1663,7 +1720,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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)
+        self.logger.debug("writeSenderReceiverInterface %s" % sr_interface.getShortName())
         child_element = ET.SubElement(element, "SENDER-RECEIVER-INTERFACE")
         self.setIdentifiable(child_element, sr_interface)
         self.setChildElementOptionalBooleanValue(child_element, "IS-SERVICE", sr_interface.getIsService())
@@ -1717,15 +1774,22 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeBswModuleEntityManagedModeGroup(element, entity)
 
     def setBswCalledEntity(self, element: ET.Element, entity: BswCalledEntity):
-        self.logger.debug("setBswCalledEntity %s" % entity.short_name)
+        self.logger.debug("setBswCalledEntity %s" % entity.getShortName())
         child_element = ET.SubElement(element, "BSW-CALLED-ENTITY")
         self.setBswModuleEntity(child_element, entity)
 
     def setBswSchedulableEntity(self, element: ET.Element, entity: BswSchedulableEntity):
-        self.logger.debug("setBswCalledEntity %s" % entity.short_name)
+        self.logger.debug("set BswSchedulableEntity %s" % entity.getShortName())
         child_element = ET.SubElement(element, "BSW-SCHEDULABLE-ENTITY")
         self.setBswModuleEntity(child_element, entity)
 
+    def setBswInterruptEntity(self, element: ET.Element, entity: BswInterruptEntity):
+        self.logger.debug("read BswInterruptEntity %s" % entity.getShortName())
+        child_element = ET.SubElement(element, "BSW-INTERRUPT-ENTITY")
+        self.setBswModuleEntity(child_element, entity)
+        self.setChildElementOptionalLiteral(child_element, "INTERRUPT-CATEGORY", entity.getInterruptCategory())
+        self.setChildElementOptionalLiteral(child_element, "INTERRUPT-SOURCE", entity.getInterruptSource())
+
     def writeBswInternalBehaviorBswModuleEntities(self, element: ET.Element, parent: BswInternalBehavior):
         entities = parent.getBswModuleEntities()    
         if len(entities) > 0:
@@ -1735,8 +1799,10 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.setBswCalledEntity(child_element, entity)
                 elif isinstance(entity, BswSchedulableEntity):
                     self.setBswSchedulableEntity(child_element, entity)
+                elif isinstance(entity, BswInterruptEntity):
+                    self.setBswInterruptEntity(child_element, entity)
                 else:
-                    self._raiseError("Unsupported BswModuleEntity <%s>" % type(entity))
+                    self.notImplemented("Unsupported BswModuleEntity <%s>" % type(entity))
 
     def setBswEvent(self, element: ET.Element, event: BswEvent):
         self.setIdentifiable(element, event)
@@ -1746,7 +1812,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setBswEvent(element, event)
 
     def setBswTimingEvent(self, element: ET.Element, event: BswTimingEvent):
-        self.logger.debug("setBswTimingEvent %s" % event.short_name)
+        self.logger.debug("setBswTimingEvent %s" % event.getShortName())
         child_element = ET.SubElement(element, "BSW-TIMING-EVENT")
         self.setBswScheduleEvent(child_element, event)
         self.setChildElementOptionalTimeValue(child_element, "PERIOD", event.getPeriod())
@@ -1804,10 +1870,10 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self._raiseError("Unsupported BswInternalBehavior <%s>" % type(behavior))
 
     def writeBswModuleDescription(self, element: ET.Element, desc: BswModuleDescription):
-        self.logger.debug("writeBswModuleDescription %s" % desc.short_name)
+        self.logger.debug("writeBswModuleDescription %s" % desc.getShortName())
         child_element = ET.SubElement(element, "BSW-MODULE-DESCRIPTION")
         self.setIdentifiable(child_element, desc)
-        self.setChildElementOptionalNumericalValue(child_element, "MODULE-ID", desc.module_id)
+        self.setChildElementOptionalNumericalValue(child_element, "MODULE-ID", desc.getModuleId())
         self.writerBswModuleDescriptionImplementedEntry(child_element, desc)
         self.writeProvidedModeGroup(child_element, desc)
         #self.readRequiredModeGroup(element, bsw_module_description)
@@ -1821,22 +1887,37 @@ class ARXMLWriter(AbstractARXMLWriter):
                 child_element = ET.SubElement(mode_groups_tag, "MODE-DECLARATION-GROUP-PROTOTYPE-REF-CONDITIONAL")
                 self.setChildElementOptionalRefType(child_element, "MODE-DECLARATION-GROUP-PROTOTYPE-REF", mode_group_ref)
 
+    def setSwServiceArg(self, element: ET.Element, arg: SwServiceArg):
+        self.logger.debug("Set SwServiceArg <%s>" % arg.getShortName())
+        if arg is not None:
+            child_element = ET.SubElement(element, "SW-SERVICE-ARG")
+            self.setIdentifiable(child_element, arg)
+            self.setChildElementOptionalLiteral(child_element, "DIRECTION", arg.getDirection())
+            self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", arg.getSwDataDefProps())
+
+    def writeBswModuleEntryArguments(self, element: ET.Element, entry: BswModuleEntry):
+        arguments = entry.getArguments()
+        if len(arguments) > 0:
+            child_element = ET.SubElement(element, "ARGUMENTS")
+            for argument in arguments:
+                self.setSwServiceArg(child_element, argument)
+
     def writeBswModuleEntry(self, element: ET.Element, entry: BswModuleEntry):
-        self.logger.debug("writeBswModuleDescription %s" % entry.short_name)
+        self.logger.debug("writeBswModuleDescription %s" % entry.getShortName())
         child_element = ET.SubElement(element, "BSW-MODULE-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)
-        self.setChildElementOptionalLiteral(child_element, "CALL-TYPE", entry.call_type)
-        self.setChildElementOptionalLiteral(child_element, "EXECUTION-CONTEXT", entry.execution_context)
-        self.setChildElementOptionalLiteral(child_element, "SW-SERVICE-IMPL-POLICY", entry.sw_service_impl_policy)
-        
+        self.setChildElementOptionalNumericalValue(child_element, "SERVICE-ID", entry.getServiceId())
+        self.setChildElementOptionalBooleanValue(child_element, "IS-REENTRANT", entry.getIsReentrant())
+        self.setChildElementOptionalBooleanValue(child_element, "IS-SYNCHRONOUS", entry.getIsSynchronous())
+        self.setChildElementOptionalLiteral(child_element, "CALL-TYPE", entry.getCallType())
+        self.setChildElementOptionalLiteral(child_element, "EXECUTION-CONTEXT", entry.getExecutionContext())
+        self.setChildElementOptionalLiteral(child_element, "SW-SERVICE-IMPL-POLICY", entry.getSwServiceImplPolicy())
+        self.writeBswModuleEntryArguments(child_element, entry)
 
     def setSwcBswRunnableMapping(self, element: ET.SubElement, mapping: SwcBswRunnableMapping):
         child_element = ET.SubElement(element, "SWC-BSW-RUNNABLE-MAPPING")
-        self.setChildElementOptionalRefType(child_element, "BSW-ENTITY-REF", mapping.bswEntityRef)
-        self.setChildElementOptionalRefType(child_element, "SWC-RUNNABLE-REF", mapping.swcRunnableRef)
+        self.setChildElementOptionalRefType(child_element, "BSW-ENTITY-REF", mapping.getBswEntityRef())
+        self.setChildElementOptionalRefType(child_element, "SWC-RUNNABLE-REF", mapping.getSwcRunnableRef())
 
     def writeSwcBswRunnableMappings(self, element: ET.Element, parent: SwcBswMapping):
         runnable_mappings = parent.getRunnableMappings()
@@ -1848,13 +1929,13 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported Runnable Mapping <%s>" % type(mapping))
 
-    def setSwcBswMapping(self, element: ET.Element, mapping: SwcBswMapping):
-        self.logger.debug("writeBswModuleDescription %s" % mapping.short_name)
+    def writeSwcBswMapping(self, element: ET.Element, mapping: SwcBswMapping):
+        self.logger.debug("writeBswModuleDescription %s" % mapping.getShortName())
         child_element = ET.SubElement(element, "SWC-BSW-MAPPING")
         self.setIdentifiable(child_element, mapping)
-        self.setChildElementOptionalRefType(child_element, "BSW-BEHAVIOR-REF", mapping.bswBehaviorRef)
+        self.setChildElementOptionalRefType(child_element, "BSW-BEHAVIOR-REF", mapping.getBswBehaviorRef())
         self.writeSwcBswRunnableMappings(child_element, mapping)
-        self.setChildElementOptionalRefType(child_element, "SWC-BEHAVIOR-REF", mapping.swcBehaviorRef)
+        self.setChildElementOptionalRefType(child_element, "SWC-BEHAVIOR-REF", mapping.getSwcBehaviorRef())
 
     def writeEngineeringObject(self, element: ET.Element, engineering_obj: EngineeringObject):
         self.setARObjectAttributes(element, engineering_obj)
@@ -1885,7 +1966,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.setChildElementOptionalRefType(child_element, "VENDOR-SPECIFIC-MODULE-DEF-REF", ref)
 
     def writeBswImplementation(self, element: ET.Element, impl: BswImplementation):
-        self.logger.debug("writeBswModuleDescription %s" % impl.short_name)
+        self.logger.debug("writeBswModuleDescription %s" % impl.getShortName())
         child_element = ET.SubElement(element, "BSW-IMPLEMENTATION")
         self.writeImplementation(child_element, impl)
         self.setChildElementOptionalLiteral(child_element, "AR-RELEASE-VERSION", impl.getArReleaseVersion())
@@ -1906,7 +1987,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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)
+        self.logger.debug("writeImplementationDataType %s" % data_type.getShortName())
         child_element = ET.SubElement(element, "IMPLEMENTATION-DATA-TYPE")
         self.setAutosarDataType(child_element, data_type)
         self.setChildElementOptionalLiteral(child_element, "DYNAMIC-ARRAY-SIZE-PROFILE", data_type.getDynamicArraySizeProfile())
@@ -1923,7 +2004,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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)
+                self.setChildElementOptionalLiteral(child_element, "SERVER-ARGUMENT-IMPL-POLICY", prototype.serverArgumentImplPolicy)
 
     def writePossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
         error_refs = parent.getPossbileErrorRefs()
@@ -1933,7 +2014,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(error_refs_tag, "POSSIBLE-ERROR-REF", error_ref)
 
     def writeClientServerOperation(self, element: ET.Element, operation: ClientServerOperation):
-        self.logger.debug("writeClientServerOperation %s" % operation.short_name)
+        self.logger.debug("writeClientServerOperation %s" % operation.getShortName())
         child_element = ET.SubElement(element, "CLIENT-SERVER-OPERATION")
         self.setIdentifiable(child_element, operation)
         self.writeArgumentDataPrototypes(child_element, operation)
@@ -1950,7 +2031,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self._raiseError("Unsupported Operation <%s>" % type(operation))
 
     def writeApplicationError(self, element: ET.Element, error: ApplicationError):
-        self.logger.debug("writeApplicationError %s" % error.short_name)
+        self.logger.debug("writeApplicationError %s" % error.getShortName())
         child_element = ET.SubElement(element, "APPLICATION-ERROR")
         self.setIdentifiable(child_element, error)
         self.setChildElementOptionalNumericalValue(child_element, "ERROR-CODE", error.error_code)
@@ -1970,33 +2051,26 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalBooleanValue(element, "IS-SERVICE", port_interface.isService)
         self.setChildElementOptionalLiteral(element, "SERVICE-KIND", port_interface.serviceKind)
 
-    def writeParameterInterfaceParameters(self, element: ET.Element, param_interface: ParameterInterface):
-        parameters = param_interface.getParameters()
-        if len(parameters) > 0:
-            child_element = ET.SubElement(element, "PARAMETERS")
-            for prototype in parameters:
-                self.writeParameterDataPrototype(child_element, prototype)
-
     def writeParameterInterface(self, element: ET.Element, param_interface: ParameterInterface):
-        self.logger.debug("Write ParameterInterface %s" % param_interface.short_name)
+        self.logger.debug("Write ParameterInterface %s" % param_interface.getShortName())
         child_element = ET.SubElement(element, "PARAMETER-INTERFACE")
         self.setPortInterface(child_element, param_interface)
-        self.writeParameterInterfaceParameters(child_element, param_interface)
+        self.setParameterDataPrototypes(child_element, "PARAMETERS", param_interface.getParameters())
 
     def writeClientServerInterface(self, element: ET.Element, cs_interface: ClientServerInterface):
-        self.logger.debug("writeClientServerInterface %s" % cs_interface.short_name)
+        self.logger.debug("writeClientServerInterface %s" % cs_interface.getShortName())
         child_element = ET.SubElement(element, "CLIENT-SERVER-INTERFACE")
         self.setPortInterface(child_element, cs_interface)
         self.writeOperations(child_element, cs_interface)
         self.writePossibleErrors(child_element, cs_interface)
 
     def writeApplicationSwComponentType(self, element: ET.Element, sw_component: ApplicationSwComponentType):
-        self.logger.debug("writeApplicationSwComponentType %s" % sw_component.short_name)
+        self.logger.debug("writeApplicationSwComponentType %s" % sw_component.getShortName())
         child_element = ET.SubElement(element, "APPLICATION-SW-COMPONENT-TYPE")
         self.writeAtomicSwComponentType(child_element, sw_component)
 
     def writeEcuAbstractionSwComponentType(self, element: ET.Element, sw_component: EcuAbstractionSwComponentType):
-        self.logger.debug("writeEcuAbstractionSwComponentType %s" % sw_component.short_name)
+        self.logger.debug("writeEcuAbstractionSwComponentType %s" % sw_component.getShortName())
         child_element = ET.SubElement(element, "ECU-ABSTRACTION-SW-COMPONENT-TYPE")
         self.writeAtomicSwComponentType(child_element, sw_component)
 
@@ -2008,7 +2082,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalNumericalValue(child_element, "MAX-NUMBER-OF-ELEMENTS", prototype.maxNumberOfElements)
 
     def writeApplicationArrayDataType(self, element: ET.Element, data_type: ApplicationArrayDataType):
-        self.logger.debug("writeApplicationArrayDataType %s" % data_type.short_name)
+        self.logger.debug("writeApplicationArrayDataType %s" % data_type.getShortName())
         child_element = ET.SubElement(element, "APPLICATION-ARRAY-DATA-TYPE")
         self.setApplicationCompositeDataType(child_element, data_type)
         self.setApplicationArrayElement(child_element, data_type.element)
@@ -2037,13 +2111,13 @@ class ARXMLWriter(AbstractARXMLWriter):
         return group
 
     def writeSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
-        self.logger.debug("writeSwRecordLayout %s" % layout.short_name)
+        self.logger.debug("writeSwRecordLayout %s" % layout.getShortName())
         child_element = ET.SubElement(element, "SW-RECORD-LAYOUT")
         self.setIdentifiable(child_element, layout)
         self.setSwRecordLayoutGroup(child_element, "SW-RECORD-LAYOUT-GROUP", layout.getSwRecordLayoutGroup())
 
     def writeSwAddrMethod(self, element: ET.Element, method: SwAddrMethod):
-        self.logger.debug("writeSwAddrMethod %s" % method.short_name)
+        self.logger.debug("writeSwAddrMethod %s" % method.getShortName())
         child_element = ET.SubElement(element, "SW-ADDR-METHOD")
         self.setIdentifiable(child_element, method)
         self.setChildElementOptionalLiteral(child_element, "MEMORY-ALLOCATION-KEYWORD-POLICY", method.getMemoryAllocationKeywordPolicy())
@@ -2056,11 +2130,11 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(child_element, "SECTION-TYPE", method.getSectionType())
 
     def writeTriggerInterface(self, element: ET.Element, trigger_if: TriggerInterface):
-        self.logger.debug("writeTriggerInterface %s" % trigger_if.short_name)
+        self.logger.debug("writeTriggerInterface %s" % trigger_if.getShortName())
         child_element = ET.SubElement(element, "TRIGGER-INTERFACE")
 
     def writeServiceSwComponentType(self, element: ET.Element, sw_component: ServiceSwComponentType):
-        self.logger.debug("writeServiceSwComponentType %s" % sw_component.short_name)
+        self.logger.debug("writeServiceSwComponentType %s" % sw_component.getShortName())
         child_element = ET.SubElement(element, "SERVICE-SW-COMPONENT-TYPE")
         self.writeAtomicSwComponentType(child_element, sw_component)
 
@@ -2085,7 +2159,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", map.getModeGroupRef())
 
     def writeDataTypeMappingSet(self, element: ET.Element, mapping_set: DataTypeMappingSet):
-        self.logger.debug("writeDataTypeMappingSet %s" % mapping_set.short_name)
+        self.logger.debug("writeDataTypeMappingSet %s" % mapping_set.getShortName())
         child_element = ET.SubElement(element, "DATA-TYPE-MAPPING-SET")
         self.setIdentifiable(child_element, mapping_set)
         self.writeDataTypeMaps(child_element, mapping_set)
@@ -2104,7 +2178,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setModeDeclaration(child_element, mode_declaration)
 
     def writeModeDeclarationGroup(self, element: ET.Element, group: ModeDeclarationGroup):
-        self.logger.debug("writeModeDeclarationGroup %s" % group.short_name)
+        self.logger.debug("writeModeDeclarationGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "MODE-DECLARATION-GROUP")
         self.setIdentifiable(child_element, group)
         self.setChildElementOptionalRefType(child_element, "INITIAL-MODE-REF", group.initialModeRef)
@@ -2120,7 +2194,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalRefType(child_element, "TYPE-TREF", mode_group.type_tref)
 
     def writeModeSwitchInterface(self, element: ET.Element, mode_interface: ModeSwitchInterface):
-        self.logger.debug("writeModeSwitchInterface %s" % mode_interface.short_name)
+        self.logger.debug("writeModeSwitchInterface %s" % mode_interface.getShortName())
         child_element = ET.SubElement(element, "MODE-SWITCH-INTERFACE")
         self.setPortInterface(child_element, mode_interface)
         self.writeModeSwitchInterfaceModeGroup(child_element, mode_interface)
@@ -2147,7 +2221,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self._raiseError("Unsupported order element <%s>" % type(order_element))
 
     def writeExecutionOrderConstraint(self, element: ET.Element, constraint: ExecutionOrderConstraint):
-        self.logger.debug("writeExecutionOrderConstraint %s" % constraint.short_name)
+        self.logger.debug("writeExecutionOrderConstraint %s" % constraint.getShortName())
         child_element = ET.SubElement(element, "EXECUTION-ORDER-CONSTRAINT")
         self.setIdentifiable(child_element, constraint)
         self.writeExecutionOrderConstraintOrderedElement(child_element, constraint)
@@ -2166,7 +2240,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeTimingRequirements(element, extension)
 
     def writeSwcTiming(self, element: ET.Element, timing: SwcTiming):
-        self.logger.debug("writeSWcTiming %s" % timing.short_name)
+        self.logger.debug("writeSWcTiming %s" % timing.getShortName())
         child_element = ET.SubElement(element, "SWC-TIMING")
         self.setIdentifiable(child_element, timing)
         self.writeTimingExtension(child_element, timing)
@@ -2188,7 +2262,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writePduToFrameMappings(element, frame)
 
     def writeLinUnconditionalFrame(self, element: ET.Element, frame: LinUnconditionalFrame):
-        self.logger.debug("LinUnconditionalFrame %s" % frame.short_name)
+        self.logger.debug("LinUnconditionalFrame %s" % frame.getShortName())
         child_element = ET.SubElement(element, "LIN-UNCONDITIONAL-FRAME")
         self.writeFrame(child_element, frame)
 
@@ -2210,7 +2284,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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)
+        self.logger.debug("writeCanNmNode %s" % nm_node.getShortName())
         child_element = ET.SubElement(element, "CAN-NM-NODE")
         self.setIdentifiable(child_element, nm_node)
         self.writeNmNode(child_element, nm_node)
@@ -2259,7 +2333,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalBooleanValue(element, "NM-SYNCHRONIZING-NETWORK", cluster.getNmSynchronizingNetwork())
 
     def writeCanNmCluster(self, element: ET.Element, cluster: CanNmCluster):
-        self.logger.debug("WriteCanNmCluster %s" % cluster.short_name)
+        self.logger.debug("WriteCanNmCluster %s" % cluster.getShortName())
         child_element = ET.SubElement(element, "CAN-NM-CLUSTER")
         self.setIdentifiable(child_element, cluster)
         self.writeNmCluster(child_element, cluster)
@@ -2290,20 +2364,20 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self._raiseError("Unsupported Nm Cluster <%s>" % type(cluster))
 
     def writeNmConfig(self, element: ET.Element, config: NmConfig):
-        self.logger.debug("WriteNmConfig %s" % config.short_name)
+        self.logger.debug("WriteNmConfig %s" % config.getShortName())
         child_element = ET.SubElement(element, "NM-CONFIG")
         self.setIdentifiable(child_element, config)
         self.writeNmConfigNmClusters(child_element, config)
         self.writeNmConfigNmClusterCouplings(child_element, config)
 
     def writeNmPdu(self, element: ET.Element, pdu: NmPdu):
-        self.logger.debug("NmPdu %s" % pdu.short_name)
+        self.logger.debug("NmPdu %s" % pdu.getShortName())
         child_element = ET.SubElement(element, "NM-PDU")
         self.setIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
 
     def writeNPdu(self, element: ET.Element, pdu: NPdu):
-        self.logger.debug("NPdu %s" % pdu.short_name)
+        self.logger.debug("NPdu %s" % pdu.getShortName())
         child_element = ET.SubElement(element, "N-PDU")
         self.setIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
@@ -2312,20 +2386,20 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(element, "LENGTH", pdu.getLength())
 
     def writeDcmIPdu(self, element: ET.Element, pdu: DcmIPdu):
-        self.logger.debug("DcmIPdu %s" % pdu.short_name)
+        self.logger.debug("DcmIPdu %s" % pdu.getShortName())
         child_element = ET.SubElement(element, "DCM-I-PDU")
         self.setIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
         self.setChildElementOptionalLiteral(child_element, "DIAG-PDU-TYPE", pdu.getDiagPduType())
 
     def writeSecuredIPdu(self, element: ET.Element, pdu: DcmIPdu):
-        self.logger.debug("SecuredIPdu %s" % pdu.short_name)
+        self.logger.debug("SecuredIPdu %s" % pdu.getShortName())
         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)
+        self.logger.debug("CanTpConfig %s" % config.getShortName())
         child_element = ET.SubElement(element, "CAN-TP-CONFIG")
         self.setIdentifiable(child_element, config)
 
@@ -2431,27 +2505,129 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported PduTriggering <%s>" % type(triggering))
 
-    def writeCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
-        self.logger.debug("CanPhysicalChannel %s" % channel.short_name)
+    def setCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
+        self.logger.debug("Set CanPhysicalChannel %s" % channel.getShortName())
         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)
+        self.logger.debug("Set LinPhysicalChannel %s" % channel.getShortName())
         child_element = ET.SubElement(element, "LIN-PHYSICAL-CHANNEL")
         self.setIdentifiable(child_element, channel)
         self.writePhysicalChannel(child_element, channel)
 
+    def setIpv6Configuration(self, element: ET.Element, configuration: Ipv6Configuration):
+        if configuration is not None:
+            child_element = ET.SubElement(element, "IPV-6-CONFIGURATION")
+            self.setChildElementOptionalPositiveInteger(child_element, "ASSIGNMENT-PRIORITY", configuration.getAssignmentPriority())
+            self.setChildElementOptionalLiteral(child_element, "DEFAULT-ROUTER", configuration.getDefaultRouter())
+            self.setChildElementOptionalBooleanValue(child_element, "ENABLE-ANYCAST", configuration.getEnableAnycast())
+            self.setChildElementOptionalPositiveInteger(child_element, "HOP-COUNT", configuration.getHopCount())
+            self.setChildElementOptionalPositiveInteger(child_element, "IP-ADDRESS-PREFIX-LENGTH", configuration.getIpAddressPrefixLength())
+            self.setChildElementOptionalLiteral(child_element, "IPV-6-ADDRESS", configuration.getIpv6Address())
+            self.setChildElementOptionalLiteral(child_element, "IPV-6-ADDRESS-SOURCE", configuration.getIpv6AddressSource())
+
+    def writeNetworkEndPointNetworkEndPointAddresses(self, element: ET.Element, addresses: List[NetworkEndpointAddress]):
+        if len(addresses) > 0:
+            child_element = ET.SubElement(element, "NETWORK-ENDPOINT-ADDRESSES")
+            for address in addresses:
+                if isinstance(address, Ipv6Configuration):
+                    self.setIpv6Configuration(child_element, address)
+                else:
+                    self.notImplemented("Unsupported Network EndPoint Address <%s>" % type(address))
+
+    def writeNetworkEndPoint(self, element: ET.Element, end_point: NetworkEndpoint):
+        self.logger.debug("Set NetworkEndpoint %s" % end_point.getShortName())
+        child_element = ET.SubElement(element, "NETWORK-ENDPOINT")
+        self.setIdentifiable(child_element, end_point)
+        self.writeNetworkEndPointNetworkEndPointAddresses(child_element, end_point.getNetworkEndpointAddresses())
+        self.setChildElementOptionalPositiveInteger(child_element, "PRIORITY", end_point.getPriority())
+
+    def writeEthernetPhysicalChannelNetworkEndPoints(self, element: ET.Element, end_points: List[NetworkEndpoint]):
+        if len(end_points) > 0:
+            child_element = ET.SubElement(element, "NETWORK-ENDPOINTS")
+            for end_point in end_points:
+                self.writeNetworkEndPoint(child_element, end_point)
+
+    def setSocketConnectionIpduIdentifier(self, element: ET.Element,identifier: SocketConnectionIpduIdentifier):
+        if identifier is not None:
+            child_element = ET.SubElement(element, "SOCKET-CONNECTION-IPDU-IDENTIFIER")
+            self.setChildElementOptionalPositiveInteger(child_element, "HEADER-ID", identifier.getHeaderId())
+            self.setChildElementOptionalLiteral(child_element, "PDU-COLLECTION-SEMANTICS", identifier.getPduCollectionSemantics())
+            self.setChildElementOptionalLiteral(child_element, "PDU-COLLECTION-TRIGGER", identifier.getPduCollectionTrigger())
+            self.setChildElementOptionalRefType(child_element, "PDU-REF", identifier.getPduRef())
+            self.setChildElementOptionalRefType(child_element, "PDU-TRIGGERING-REF", identifier.getPduTriggeringRef())
+
+    def setSocketConnectionPdus(self, element: ET.Element, key: str, pdus: List[SocketConnectionIpduIdentifier]):
+        if len(pdus) > 0:
+            child_element = ET.SubElement(element, key)
+            for pdu in pdus:
+                if isinstance(pdu, SocketConnectionIpduIdentifier):
+                    self.setSocketConnectionIpduIdentifier(child_element, pdu)
+                else:
+                    self.notImplemented("Unsupported Pdu <%s>" % type(pdu))
+
+    def setSocketConnection(self, element: ET.Element, connection: SocketConnection):
+        if connection is not None:
+            child_element = ET.SubElement(element, "SOCKET-CONNECTION")
+            self.setChildElementOptionalRefType(child_element, "CLIENT-PORT-REF", connection.getClientPortRef())
+            self.setSocketConnectionPdus(child_element, "PDUS", connection.getPdus())
+            self.setChildElementOptionalPositiveInteger(child_element, "PDU-COLLECTION-MAX-BUFFER-SIZE", connection.getPduCollectionMaxBufferSize())
+            self.setChildElementOptionalTimeValue(child_element, "PDU-COLLECTION-TIMEOUT", connection.getPduCollectionTimeout())
+            self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", connection.getShortLabel())
+
+    def writeSocketConnectionBundleConnections(self, element: ET.Element, bundle: SocketConnectionBundle):
+        connections = bundle.getBundledConnections()
+        if len(connections) > 0:
+            child_element = ET.SubElement(element, "BUNDLED-CONNECTIONS")
+            for connection in connections:
+                if isinstance(connection, SocketConnection):
+                    self.setSocketConnection(child_element, connection)
+                else:
+                    self.notImplemented("Unsupported Bundled Connection <%s>" % type(connection))
+
+    def writeSocketConnectionBundle(self, element: ET.Element, bundle: SocketConnectionBundle):
+        if bundle is not None:
+            child_element = ET.SubElement(element, "SOCKET-CONNECTION-BUNDLE")
+            self.setReferable(child_element, bundle)
+            self.writeSocketConnectionBundleConnections(child_element, bundle)
+            self.setChildElementOptionalRefType(child_element, "SERVER-PORT-REF", bundle.getServerPortRef())
+
+    def writeSoAdConfigConnectionBundles(self, element: ET.Element, config: SoAdConfig):
+        bundles = config.getConnectionBundles()
+        if len(bundles) > 0:
+            child_element = ET.SubElement(element, "CONNECTION-BUNDLES")
+            for bundle in bundles:
+                if isinstance(bundle, SocketConnectionBundle):
+                    self.writeSocketConnectionBundle(child_element, bundle)
+                else:
+                    self.notImplemented("Unsupported Connection Bundle <%s>" % type(bundle))
+
+    def setSoAdConfig(self, element: ET.Element, key: str, config: SoAdConfig):
+        if config is not None:
+            child_element = ET.SubElement(element, key)
+            self.writeSoAdConfigConnectionBundles(child_element, config)
+
+    def setEthernetPhysicalChannel(self, element: ET.Element, channel: EthernetPhysicalChannel):
+        self.logger.debug("Set EthernetPhysicalChannel %s" % channel.getShortName())
+        child_element = ET.SubElement(element, "ETHERNET-PHYSICAL-CHANNEL")
+        self.setIdentifiable(child_element, channel)
+        self.writePhysicalChannel(child_element, channel)
+        self.writeEthernetPhysicalChannelNetworkEndPoints(child_element, channel.getNetworkEndpoints())
+        self.setSoAdConfig(child_element, "SO-AD-CONFIG", channel.getSoAdConfig())
+
     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)
+                    self.setCanPhysicalChannel(child_element, channel)
                 elif isinstance(channel, LinPhysicalChannel):
                     self.writeLinPhysicalChannel(child_element, channel)
+                elif isinstance(channel, EthernetPhysicalChannel):
+                    self.setEthernetPhysicalChannel(child_element, channel)
                 else:
                     self.notImplemented("Unsupported Physical Channel <%s>" % type(channel))
 
@@ -2466,7 +2642,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalNumericalValue(element, "SPEED", cluster.getSpeed())
 
     def writeLinCluster(self, element: ET.Element, cluster: LinCluster):
-        self.logger.debug("LinCluster %s" % cluster.short_name)
+        self.logger.debug("LinCluster %s" % cluster.getShortName())
         child_element = ET.SubElement(element, "LIN-CLUSTER")
         self.setIdentifiable(child_element, cluster)
         child_element = ET.SubElement(child_element, "LIN-CLUSTER-VARIANTS")
@@ -2474,7 +2650,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeCommunicationCluster(child_element, cluster)
 
     def writeCanCluster(self, element: ET.Element, cluster: CanCluster):
-        self.logger.debug("CanCluster %s" % cluster.short_name)
+        self.logger.debug("CanCluster %s" % cluster.getShortName())
         child_element = ET.SubElement(element, "CAN-CLUSTER")
         self.setIdentifiable(child_element, cluster)
 
@@ -2483,8 +2659,17 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeCommunicationCluster(child_element, cluster)
         self.readAbstractCanCluster(child_element, cluster)
 
+    def writeEthernetCluster(self, element: ET.Element, cluster: EthernetCluster):
+        self.logger.debug("Set EthernetCluster %s" % cluster.getShortName())
+        child_element = ET.SubElement(element, "ETHERNET-CLUSTER")
+        self.setARElement(child_element, cluster)
+
+        child_element = ET.SubElement(child_element, "ETHERNET-CLUSTER-VARIANTS")
+        child_element = ET.SubElement(child_element, "ETHERNET-CLUSTER-CONDITIONAL")
+        self.writeCommunicationCluster(child_element, cluster)
+
     def writeCanFrame(self, element: ET.Element, frame: CanFrame):
-        self.logger.debug("Write CanFrame %s" % frame.short_name)
+        self.logger.debug("Write CanFrame %s" % frame.getShortName())
         child_element = ET.SubElement(element, "CAN-FRAME")
         self.writeFrame(child_element, frame)
 
@@ -2519,10 +2704,14 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported CommConnectorPort <%s>" % type(port))      
 
-    def writeCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
+    def setCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
         self.logger.debug("Write CanCommunicationController %s" % controller.getShortName())
         self.setIdentifiable(element, controller)
 
+    def setEthernetCommunicationController(self, element: ET.Element, controller: EthernetCommunicationController):
+        self.logger.debug("Write EthernetCommunicationController %s" % controller.getShortName())
+        self.setIdentifiable(element, controller)
+
     def writeEcuInstanceCommControllers(self, element: ET.Element, instance: EcuInstance):
         controllers = instance.getCommControllers()
         if len(controllers) > 0:
@@ -2530,19 +2719,25 @@ class ARXMLWriter(AbstractARXMLWriter):
             for controller in controllers:
                 if isinstance(controller, CanCommunicationController):
                     child_element = ET.SubElement(controllers_tag, "CAN-COMMUNICATION-CONTROLLER")
-                    self.writeCanCommunicationController(child_element, controller)
+                    self.setCanCommunicationController(child_element, controller)
+                elif isinstance(controller, EthernetCommunicationController):
+                    child_element = ET.SubElement(controllers_tag, "ETHERNET-COMMUNICATION-CONTROLLER")
+                    self.setEthernetCommunicationController(child_element, controller)
                 else:
-                    self._raiseError("Unsupported Communication Controller <%s>" % type(controller))
+                    self.notImplemented("Unsupported Communication Controller <%s>" % type(controller))
 
     def writeCommunicationConnector(self, element: ET.Element, connector: CommunicationConnector):
         self.setIdentifiable(element, connector)
         self.setChildElementOptionalRefType(element, "COMM-CONTROLLER-REF", connector.getCommControllerRef())
         self.writeCommunicationConnectorEcuCommPortInstances(element, connector)
 
-
     def writeCanCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
         self.logger.debug("Write CanCommunicationConnector %s" % connector.getShortName())
-        self.writeCommunicationConnector(element, connector)                
+        self.writeCommunicationConnector(element, connector)
+
+    def writeEthernetCommunicationConnector(self, element: ET.Element, connector: EthernetCommunicationConnector):
+        self.logger.debug("Write EthernetCommunicationConnector %s" % connector.getShortName())
+        self.writeCommunicationConnector(element, connector)
 
     def writeEcuInstanceConnectors(self, element: ET.Element, instance: EcuInstance):
         connectors = instance.getConnectors()
@@ -2552,11 +2747,14 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(connector, CanCommunicationConnector):
                     child_element = ET.SubElement(connectors_tag, "CAN-COMMUNICATION-CONNECTOR")
                     self.writeCanCommunicationConnector(child_element, connector)
+                elif isinstance(connector, EthernetCommunicationConnector):
+                    child_element = ET.SubElement(connectors_tag, "ETHERNET-COMMUNICATION-CONNECTOR")
+                    self.writeEthernetCommunicationConnector(child_element, connector)
                 else:
                     self._raiseError("Unsupported Communication connector <%s>" % type(connector))
 
     def writeEcuInstance(self, element: ET.Element, instance: EcuInstance):
-        self.logger.debug("EcuInstance %s" % instance.short_name)
+        self.logger.debug("EcuInstance %s" % instance.getShortName())
         child_element = ET.SubElement(element, "ECU-INSTANCE")
         self.setIdentifiable(child_element, instance)
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-GW-TIME-BASE", instance.getComConfigurationGwTimeBase())
@@ -2569,7 +2767,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalBooleanValue(child_element, "WAKE-UP-OVER-BUS-SUPPORTED", instance.getWakeUpOverBusSupported())
 
     def writeSystemSignalGroup(self, element: ET.Element, group: SystemSignalGroup):
-        self.logger.debug("Write SystemSignalGroup %s" % group.short_name)
+        self.logger.debug("Write SystemSignalGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "SYSTEM-SIGNAL-GROUP")
         self.setIdentifiable(child_element, group)
         signal_refs = group.getSystemSignalRefs()
@@ -2580,6 +2778,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setSenderReceiverToSignalMapping(self, element: ET.Element, mapping: SenderReceiverToSignalMapping):
         child_element = ET.SubElement(element, "SENDER-RECEIVER-TO-SIGNAL-MAPPING")
+        self.setChildElementOptionalLiteral(child_element, "COMMUNICATION-DIRECTION", mapping.getCommunicationDirection())
         self.setVariableDataPrototypeInSystemInstanceRef(child_element, "DATA-ELEMENT-IREF", mapping.getDataElementIRef())
         self.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-REF", mapping.getSystemSignalRef())
 
@@ -2621,7 +2820,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.notImplemented("Unsupported Sw Mapping %s" % type(sw_mapping))
 
     def writeSystemMapping(self, element: ET.Element, mapping: SystemMapping):
-        self.logger.debug("Write SystemMapping %s" % mapping.short_name)
+        self.logger.debug("Write SystemMapping %s" % mapping.getShortName())
         child_element = ET.SubElement(element, "SYSTEM-MAPPING")
         self.setIdentifiable(child_element, mapping)
         self.writeSystemMappingDataMappings(child_element, mapping)
@@ -2644,10 +2843,11 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "ROOT-SOFTWARE-COMPOSITIONS")
             child_element = ET.SubElement(child_element, "ROOT-SW-COMPOSITION-PROTOTYPE")
             self.setIdentifiable(child_element, prototype)
+            self.setChildElementOptionalRefType(child_element, "FLAT-MAP-REF", prototype.getFlatMapRef())
             self.setChildElementOptionalRefType(child_element, "SOFTWARE-COMPOSITION-TREF", prototype.getSoftwareCompositionTRef())
                 
     def writeSystem(self, element: ET.Element, system: System):
-        self.logger.debug("Write System %s" % system.short_name)
+        self.logger.debug("Write System %s" % system.getShortName())
         child_element = ET.SubElement(element, "SYSTEM")
         self.setARElement(child_element, system)
 
@@ -2664,13 +2864,69 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRevisionLabelString(child_element, "SYSTEM-VERSION", system.getSystemVersion())
 
     def writePhysicalDimension(self, element: ET.Element, dimension: PhysicalDimension):
-        self.logger.debug("Write PhysicalDimension %s" % dimension.short_name)
+        self.logger.debug("Set PhysicalDimension %s" % dimension.getShortName())
         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())
         self.setChildElementOptionalNumericalValue(child_element, "TIME-EXP", dimension.getTimeExp())
 
+    def setFlatInstanceDescriptor(self, element: ET.Element, desc: FlatInstanceDescriptor):
+        self.logger.debug("Set FlatInstanceDescriptor %s" % desc.getShortName())
+        child_element = ET.SubElement(element, "FLAT-INSTANCE-DESCRIPTOR")
+        self.setIdentifiable(child_element, desc)
+        self.setAnyInstanceRef(child_element, "UPSTREAM-REFERENCE-IREF", desc.getUpstreamReferenceIRef())
+        self.setAnyInstanceRef(child_element, "ECU-EXTRACT-REFERENCE-IREF", desc.getEcuExtractReferenceIRef())
+
+    def writeFlatMapInstances(self, element: ET.Element, map: FlatMap):
+        instances = map.getInstances()
+        if len(instances) > 0:
+            child_element = ET.SubElement(element, "INSTANCES")
+            for instance in instances:
+                if isinstance(instance, FlatInstanceDescriptor):
+                    self.setFlatInstanceDescriptor(child_element, instance)
+                else:
+                    self.notImplemented("Unsupported Flat Map Instances <%s>" % type(instance))
+
+    def writeFlatMap(self, element: ET.Element, map: FlatMap):
+        self.logger.debug("Set FlatMap %s" % map.getShortName())
+        child_element = ET.SubElement(element, "FLAT-MAP")
+        self.setARElement(child_element, map)
+        self.writeFlatMapInstances(child_element, map)
+
+    def setDataPrototypeMapping(self, element: ET.Element, mapping: DataPrototypeMapping):
+        child_element = ET.SubElement(element, "DATA-PROTOTYPE-MAPPING")
+        self.setChildElementOptionalRefType(child_element, "FIRST-DATA-PROTOTYPE-REF", mapping.getFirstDataPrototypeRef())
+        self.setChildElementOptionalRefType(child_element, "SECOND-DATA-PROTOTYPE-REF", mapping.getSecondDataPrototypeRef())
+
+    def setDataPrototypeMappings(self, element: ET.Element, key: str, mappings: List[DataPrototypeMapping]):
+        if len(mappings) > 0:
+            child_element = ET.SubElement(element, key)
+            for mapping in mappings:
+                self.setDataPrototypeMapping(child_element, mapping)
+
+    def setVariableAndParameterInterfaceMapping(self, element: ET.Element, mapping: VariableAndParameterInterfaceMapping):
+        self.logger.debug("set VariableAndParameterInterfaceMapping %s" % mapping.getShortName())
+        child_element = ET.SubElement(element, "VARIABLE-AND-PARAMETER-INTERFACE-MAPPING")
+        self.setIdentifiable(child_element, mapping)
+        self.setDataPrototypeMappings(child_element, "DATA-MAPPINGS", mapping.getDataMappings())
+
+    def writePortInterfaceMappings(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
+        mappings = mapping_set.getPortInterfaceMappings()
+        if len(mappings) > 0:
+            child_element = ET.SubElement(element, "PORT-INTERFACE-MAPPINGS")
+            for mapping in mappings:
+                if isinstance(mapping, VariableAndParameterInterfaceMapping):
+                    self.setVariableAndParameterInterfaceMapping(child_element, mapping)
+                else:
+                    self.notImplemented("Unsupported PortInterfaceMapping <%s>" % type(mapping))
+
+    def writePortInterfaceMappingSet(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
+        self.logger.debug("Set PortInterfaceMappingSet %s" % mapping_set.getShortName())
+        child_element = ET.SubElement(element, "PORT-INTERFACE-MAPPING-SET")
+        self.setARElement(child_element, mapping_set)
+        self.writePortInterfaceMappings(child_element, mapping_set)
+
     def setISignalMappings(self, element: ET.Element, mappings: List[ISignalMapping]):
         if len(mappings) > 0:
             mappings_tag = ET.SubElement(element, "SIGNAL-MAPPINGS")
@@ -2680,21 +2936,22 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(child_element, "TARGET-SIGNAL-REF", mapping.targetSignalRef)
 
     def writeGateway(self, element: ET.Element, gateway: Gateway):
-        self.logger.debug("Gateway %s" % gateway.short_name)
+        self.logger.debug("Gateway %s" % gateway.getShortName())
         child_element = ET.SubElement(element, "GATEWAY")
         self.setIdentifiable(child_element, gateway)
         self.setChildElementOptionalRefType(child_element, "ECU-REF", gateway.ecuRef)
         self.setISignalMappings(child_element, gateway.getSignalMappings())
 
     def writeISignal(self, element: ET.Element, signal: ISignal):
-        self.logger.debug("ISignal %s" % signal.short_name)
+        self.logger.debug("ISignal %s" % signal.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL")
         self.setIdentifiable(child_element, signal)
-        self.setChildElementOptionalLiteral(child_element, "DATA-TYPE-POLICY", signal.dataTypePolicy)
-        self.setInitValue(child_element, signal.initValue)
-        self.setChildElementOptionalNumericalValue(child_element, "LENGTH", signal.length)
-        self.setSwDataDefProps(child_element, "NETWORK-REPRESENTATION-PROPS", signal.networkRepresentationProps)
-        self.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-REF", signal.systemSignalRef)
+        self.setChildElementOptionalLiteral(child_element, "DATA-TYPE-POLICY", signal.getDataTypePolicy())
+        self.setChildElementOptionalLiteral(child_element, "I-SIGNAL-TYPE", signal.getISignalType())
+        self.setValueSpecification(child_element, "INIT-VALUE", signal.getInitValue())
+        self.setChildElementOptionalNumericalValue(child_element, "LENGTH", signal.getLength())
+        self.setSwDataDefProps(child_element, "NETWORK-REPRESENTATION-PROPS", signal.getNetworkRepresentationProps())
+        self.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-REF", signal.getSystemSignalRef())
 
     def writeEcucValueCollectionEcucValues(self, element: ET.Element, collection: EcucValueCollection):
         value_refs = collection.getEcucValueRefs()
@@ -2705,7 +2962,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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)
+        self.logger.debug("EcucValueCollection %s" % collection.getShortName())
         child_element = ET.SubElement(element, "ECUC-VALUE-COLLECTION")
         self.setIdentifiable(child_element, collection)
         self.setChildElementOptionalRefType(child_element, "ECU-EXTRACT-REF", collection.getEcuExtractRef())
@@ -2761,7 +3018,8 @@ class ARXMLWriter(AbstractARXMLWriter):
         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())
+            for ref in instance_ref.getContextElementRefs():
+                self.setChildElementOptionalRefType(child_element, "CONTEXT-ELEMENT-REF", ref)
             self.setChildElementOptionalRefType(child_element, "TARGET-REF", instance_ref.getTargetRef())
         return instance_ref
     
@@ -2784,7 +3042,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.notImplemented("Unsupported EcucParameterValue <%s>" % type(reference_value))
 
     def writeEcucContainValue(self, element: ET.Element, container_value: EcucContainerValue):
-        self.logger.debug("EcucContainerValue %s" % container_value.short_name)
+        self.logger.debug("EcucContainerValue %s" % container_value.getShortName())
         child_element = ET.SubElement(element, "ECUC-CONTAINER-VALUE")
         self.setIdentifiable(child_element, container_value)
         self.setChildElementOptionalRefType(child_element, "DEFINITION-REF", container_value.getDefinitionRef())
@@ -2803,7 +3061,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.notImplemented("Unsupported Container %s" % type(container)) 
 
     def writeEcucModuleConfigurationValues(self, element: ET.Element, values: EcucModuleConfigurationValues):
-        self.logger.debug("EcucModuleConfigurationValues %s" % values.short_name)
+        self.logger.debug("EcucModuleConfigurationValues %s" % values.getShortName())
         child_element = ET.SubElement(element, "ECUC-MODULE-CONFIGURATION-VALUES")
         self.setIdentifiable(child_element, values)
         self.setChildElementOptionalRefType(child_element, "DEFINITION-REF", values.getDefinitionRef())
@@ -2812,7 +3070,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeEcucModuleConfigurationValuesContainers(child_element, values)
 
     def writeISignalGroup(self, element: ET.Element, group: ISignalGroup):
-        self.logger.debug("ISignalGroup %s" % group.short_name)
+        self.logger.debug("ISignalGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-GROUP")
         self.setIdentifiable(child_element, group)
         signal_refs = group.getISignalRefs()
@@ -2823,7 +3081,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         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)
+        self.logger.debug("Set ISignalIPduGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-I-PDU-GROUP")
         self.setIdentifiable(child_element, group)
         self.setChildElementOptionalLiteral(child_element, "COMMUNICATION-DIRECTION", group.getCommunicationDirection())
@@ -2841,20 +3099,19 @@ class ARXMLWriter(AbstractARXMLWriter):
                 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)
+        self.logger.debug("SystemSignal %s" % signal.getShortName())
         child_element = ET.SubElement(element, "SYSTEM-SIGNAL")
         self.setIdentifiable(child_element, signal)
         self.setChildElementOptionalBooleanValue(child_element, "DYNAMIC-LENGTH", signal.getDynamicLength())
-
-    
+        self.setSwDataDefProps(child_element, "PHYSICAL-PROPS", signal.getPhysicalProps())
 
     def writeGenericEthernetFrame(self, element: ET.Element, signal: GenericEthernetFrame):
-        self.logger.debug("Write GenericEthernetFrame %s" % signal.short_name)
+        self.logger.debug("Write GenericEthernetFrame %s" % signal.getShortName())
         child_element = ET.SubElement(element, "ETHERNET-FRAME")
         self.writeFrame(child_element, signal)
 
     def writeLifeCycleInfoSet(self, element: ET.Element, set: LifeCycleInfoSet):
-        self.logger.debug("Write LifeCycleInfoSet %s" % set.short_name)
+        self.logger.debug("Write LifeCycleInfoSet %s" % set.getShortName())
         child_element = ET.SubElement(element, "LIFE-CYCLE-INFO-SET")
         self.setIdentifiable(child_element, set)
 
@@ -2873,8 +3130,9 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalNumericalValue(child_element, "UPDATE-INDICATION-BIT-POSITION", mapping.getUpdateIndicationBitPosition())
     
     def setDataFilter(self, element: ET.Element, key: str, filter: DataFilter):
-        child_element = ET.SubElement(element, key)
-        self.setChildElementOptionalLiteral(child_element, "DATA-FILTER-TYPE", filter.getDataFilterType())
+        if filter is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalLiteral(child_element, "DATA-FILTER-TYPE", filter.getDataFilterType())
 
     def setTransmissionModeConditions(self, element: ET.Element, conditions: List[TransmissionModeCondition]):
         if len(conditions) > 0:
@@ -2895,11 +3153,22 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalIntegerValue(child_element, "NUMBER-OF-REPETITIONS", timing.getNumberOfRepetitions())
             self.setTimeRangeType(child_element, "REPETITION-PERIOD", timing.getRepetitionPeriod())
 
+    def setTimeRangeType(self, element: ET.Element, key: str, time_range: TimeRangeType):
+        if time_range is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalTimeValue(child_element, "VALUE", time_range.getValue())
+    
+    def setCyclicTiming(self, element: ET.Element, key: str, timing: CyclicTiming):
+        if timing is not None:
+            child_element = ET.SubElement(element, key)
+            self.setTimeRangeType(child_element, "TIME-OFFSET", timing.getTimeOffset())
+            self.setTimeRangeType(child_element, "TIME-PERIOD", timing.getTimePeriod())
+
     def setTransmissionModeTiming(self, element: ET.Element, key: str, timing: TransmissionModeTiming):
         if timing is not None:
             self.logger.debug("Set TransmissionModeTiming of <%s>" % key)
             child_element = ET.SubElement(element, key)
-            #timing.getCyclicTiming(child_element, "")
+            self.setCyclicTiming(child_element, "CYCLIC-TIMING", timing.getCyclicTiming())
             self.setEventControlledTiming(child_element, "EVENT-CONTROLLED-TIMING", timing.getEventControlledTiming())
 
     def setTransmissionModeDeclaration(self, element: ET.Element, key: str, decl : TransmissionModeDeclaration):
@@ -2912,10 +3181,11 @@ class ARXMLWriter(AbstractARXMLWriter):
         if timing is not None:
             spec_tag = ET.SubElement(element, "I-PDU-TIMING-SPECIFICATIONS")
             child_element = ET.SubElement(spec_tag, "I-PDU-TIMING")
+            self.setChildElementOptionalTimeValue(child_element, "MINIMUM-DELAY", timing.getMinimumDelay())
             self.setTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION", timing.getTransmissionModeDeclaration())
 
     def writeISignalIPdu(self, element: ET.Element, i_pdu: ISignalIPdu):
-        self.logger.debug("ISignalIPdu %s" % i_pdu.short_name)
+        self.logger.debug("ISignalIPdu %s" % i_pdu.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-I-PDU")
         self.setIdentifiable(child_element, i_pdu)
         self.setChildElementOptionalNumericalValue(child_element, "LENGTH", i_pdu.getLength())
@@ -2953,7 +3223,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         elif isinstance(ar_element, BswModuleEntry):
             self.writeBswModuleEntry(element, ar_element)
         elif isinstance(ar_element, SwcBswMapping):
-            self.setSwcBswMapping(element, ar_element)
+            self.writeSwcBswMapping(element, ar_element)
         elif isinstance(ar_element, BswImplementation):
             self.writeBswImplementation(element, ar_element)
         elif isinstance(ar_element, ImplementationDataType):
@@ -3022,6 +3292,14 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeLifeCycleInfoSet(element, ar_element)
         elif isinstance(ar_element, PhysicalDimension):
             self.writePhysicalDimension(element, ar_element)
+        elif isinstance(ar_element, FlatMap):
+            self.writeFlatMap(element, ar_element)
+        elif isinstance(ar_element, PortInterfaceMappingSet):
+            self.writePortInterfaceMappingSet(element, ar_element)
+        elif isinstance(ar_element, EthernetCluster):
+            self.writeEthernetCluster(element, ar_element)
+        elif isinstance(ar_element, ISignalIPduGroup):
+            self.writeISignalIPduGroup(element, ar_element)
         else:
             self.notImplemented("Unsupported Elements of ARPackage <%s>" % type(ar_element))