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

armodel/writer/arxml_writer.py

@@ -40,6 +40,7 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import Intern
 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.DiagnosticExtract.DiagnosticContribution import DiagnosticServiceTable
 from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue, EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue, EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable, MultilanguageReferrable, Referrable
@@ -76,22 +77,24 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcImplementation import S
 
 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.DiagnosticConnection import DiagnosticConnection
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalTriggering, MultiplexedIPdu, PduTriggering, SecureCommunicationPropsSet, SecuredIPdu, SystemSignal, DcmIPdu, Frame, ISignal, NPdu, NmPdu, SystemSignalGroup, UserDefinedIPdu, UserDefinedPdu
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import CyclicTiming, EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SocketConnection, SocketConnectionBundle, SocketConnectionIpduIdentifier
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SoAdRoutingGroup, SocketConnection, SocketConnectionBundle, SocketConnectionIpduIdentifier
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetFrame import GenericEthernetFrame
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import 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.Fibex4Ethernet.EthernetTopology import EthernetCluster, EthernetCommunicationConnector, EthernetCommunicationController, InitialSdDelayConfig, RequestResponseDelay, SdClientConfig
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import DoIpEntity, InfrastructureServices, Ipv6Configuration, NetworkEndpoint, NetworkEndpointAddress
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import ApplicationEndpoint, ConsumedEventGroup, ConsumedServiceInstance, GenericTp, SoAdConfig, SocketAddress, TcpTp, TpPort, TransportProtocolConfiguration, UdpTp
 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, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import ApplicationEntry, LinFrameTriggering, LinScheduleTable, LinUnconditionalFrame, ScheduleTableEntry
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanClusterBusOffRecovery, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinMaster
 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
+from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmNode
+from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpConfig, DoIpTpConfig
 
 from .abstract_arxml_writer import AbstractARXMLWriter
 class ARXMLWriter(AbstractARXMLWriter):
@@ -194,7 +197,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setMultiLanguagePlainText(child_element, "USED-LANGUAGES", admin_data.getUsedLanguages())
             self.writeSdgs(child_element, admin_data)
 
-    def setIdentifiable(self, element: ET.Element, identifiable: Identifiable):
+    def writeIdentifiable(self, element: ET.Element, identifiable: Identifiable):
         self.setMultilanguageReferrable(element, identifiable)
         self.setAnnotations(element, identifiable.getAnnotations())
         self.setMultiLanguageOverviewParagraph(element, "DESC", identifiable.getDesc())
@@ -203,7 +206,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setAdminData(element, identifiable.getAdminData())
 
     def setARElement(self, parent: ET.Element, ar_element: ARElement):
-        self.setIdentifiable(parent, ar_element)
+        self.writeIdentifiable(parent, ar_element)
     
     def setTransmissionAcknowledgementRequest(self, element: ET.Element, acknowledge: TransmissionAcknowledgementRequest):
         if (acknowledge != None):
@@ -436,7 +439,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writePPortPrototype(self, ports_tag: ET.Element, prototype: PPortPrototype):
         prototype_tag = ET.SubElement(ports_tag, "P-PORT-PROTOTYPE")
 
-        self.setIdentifiable(prototype_tag, prototype)
+        self.writeIdentifiable(prototype_tag, prototype)
         self.logger.debug("write PPortPrototype %s" % prototype.getShortName())
         self.setAbstractProvidedPortPrototype(prototype_tag, prototype)
         self.setChildElementOptionalRefType(prototype_tag, "PROVIDED-INTERFACE-TREF", prototype.getProvidedInterfaceTRef())
@@ -451,14 +454,14 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeRPortPrototype(self, ports_tag: ET.Element, prototype: RPortPrototype):
         self.logger.debug("write RPortPrototype %s" % prototype.getShortName())
         prototype_tag = ET.SubElement(ports_tag, "R-PORT-PROTOTYPE")
-        self.setIdentifiable(prototype_tag, prototype)
+        self.writeIdentifiable(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.getShortName())
         prototype_tag = ET.SubElement(ports_tag, "PR-PORT-PROTOTYPE")
-        self.setIdentifiable(prototype_tag, prototype)
+        self.writeIdentifiable(prototype_tag, prototype)
         self.setAbstractProvidedPortPrototype(prototype_tag, prototype)
         self.setAbstractRequiredPortPrototype(prototype_tag, prototype)
         self.setChildElementOptionalRefType(prototype_tag, "PROVIDED-REQUIRED-INTERFACE-TREF", prototype.getProvidedRequiredInterface())
@@ -497,7 +500,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writePortGroup(self, element: ET.Element, port_group: PortGroup):
         self.logger.debug("writePortGroup %s" % port_group.getShortName())
         child_element = ET.SubElement(element, "PORT-GROUP")
-        self.setIdentifiable(child_element, port_group)
+        self.writeIdentifiable(child_element, port_group)
         self.writePortGroupInnerGroupIRefs(child_element, port_group)
         self.writePortGroupOuterPortRefs(child_element, port_group)
 
@@ -509,7 +512,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.writePortGroup(child_element, port_group)
     
     def writeSwComponentType(self, element: ET.Element, sw_component: SwComponentType):
-        self.setIdentifiable(element, sw_component)
+        self.writeIdentifiable(element, sw_component)
         port_prototypes = sw_component.getPortPrototypes()
         if len(port_prototypes) > 0:
             ports_tag = ET.SubElement(element, "PORTS")
@@ -518,7 +521,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeSwComponentPrototype(self, element: ET.Element, prototype: SwComponentPrototype):
         prototype_tag = ET.SubElement(element, "SW-COMPONENT-PROTOTYPE")
-        self.setIdentifiable(prototype_tag, prototype)
+        self.writeIdentifiable(prototype_tag, prototype)
         self.setChildElementOptionalRefType(prototype_tag, "TYPE-TREF", prototype.getTypeTRef())
 
     def writeSwComponentPrototypes(self, element: ET.Element, sw_component: CompositionSwComponentType):
@@ -530,7 +533,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeAssemblySwConnector(self, element: ET.Element, sw_connector: AssemblySwConnector):
         child_element = ET.SubElement(element, "ASSEMBLY-SW-CONNECTOR")
-        self.setIdentifiable(child_element, sw_connector)
+        self.writeIdentifiable(child_element, sw_connector)
         self.setChildElementOptionalRefType(child_element, "MAPPING-REF", sw_connector.getMappingRef())
 
         if sw_connector.getProviderIRef() is not None:
@@ -549,7 +552,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeDelegationSwConnector(self, element: ET.Element, sw_connector: DelegationSwConnector):
         connector_tag = ET.SubElement(element, "DELEGATION-SW-CONNECTOR")
-        self.setIdentifiable(connector_tag, sw_connector)
+        self.writeIdentifiable(connector_tag, sw_connector)
 
         if sw_connector.getInnerPortIRref() is not None:
             inner_port_iref_tag = ET.SubElement(connector_tag, "INNER-PORT-IREF")
@@ -737,7 +740,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.writeIdentifiable(element, prototype)
         self.setDataPrototype(element, prototype)
         self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.typeTRef)
 
@@ -775,7 +778,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     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.writeIdentifiable(data_type_tag, base_type)
         self.setBaseTypeDirectDefinition(data_type_tag, base_type.getBaseTypeDefinition())
 
     def writeCompuScaleConstantContents(self, element: ET.Element, contents: CompuScaleConstantContents):
@@ -844,7 +847,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeCompuMethod(self, element: ET.Element, compu_method: CompuMethod):
         child_element = ET.SubElement(element, "COMPU-METHOD")
         self.logger.debug("write CompuMethods %s" % compu_method.getShortName())
-        self.setIdentifiable(child_element, compu_method)
+        self.writeIdentifiable(child_element, compu_method)
         self.setChildElementOptionalRefType(child_element, "UNIT-REF", compu_method.getUnitRef())
         self.setCompu(child_element, "COMPU-INTERNAL-TO-PHYS", compu_method.getCompuInternalToPhys())
         self.setCompu(child_element, "COMPU-PHYS-TO-INTERNAL", compu_method.getCompuPhysToInternal())
@@ -878,7 +881,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeConstantSpecification(self, element: ET.Element, spec: ConstantSpecification):
         spec_tag = ET.SubElement(element, "CONSTANT-SPECIFICATION")
-        self.setIdentifiable(spec_tag, spec)
+        self.writeIdentifiable(spec_tag, spec)
 
         if spec.getValueSpec() is not None:
             self.setValueSpecification(spec_tag, "VALUE-SPEC", spec.getValueSpec())
@@ -915,13 +918,13 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeDataConstr(self, element: ET.Element, constr: DataConstr):
         child_element = ET.SubElement(element, "DATA-CONSTR")
-        self.setIdentifiable(child_element, constr)
+        self.writeIdentifiable(child_element, constr)
         self.writeDataConstrRules(child_element, constr) 
 
     def writeUnit(self, element: ET.Element, unit: Unit):
         self.logger.debug("writeUnit %s" % unit.getShortName())
         child_element = ET.SubElement(element, "UNIT")
-        self.setIdentifiable(child_element, unit)
+        self.writeIdentifiable(child_element, unit)
         self.setChildElementOptionalLiteral(child_element, "DISPLAY-NAME", unit.getDisplayName())
         self.setChildElementOptionalFloatValue(child_element, "FACTOR-SI-TO-UNIT", unit.getFactorSiToUnit())
         self.setChildElementOptionalFloatValue(child_element, "OFFSET-SI-TO-UNIT", unit.getOffsetSiToUnit())
@@ -943,7 +946,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalRefType(child_element, "TARGET-PROVIDED-OPERATION-REF", iref.getTargetProvidedOperationRef())
 
     def setRTEEvent(self, element: ET.Element, event: RTEEvent):
-        self.setIdentifiable(element, event)
+        self.writeIdentifiable(element, event)
         irefs = event.getDisabledModeIRefs()
         if len(irefs) > 0:
             child_element = ET.SubElement(element, "DISABLED-MODE-IREFS")
@@ -1030,7 +1033,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             areas_tag = ET.SubElement(element, "EXCLUSIVE-AREAS")
             for area in areas:
                 child_element = ET.SubElement(areas_tag, "EXCLUSIVE-AREA")
-                self.setIdentifiable(child_element, area)
+                self.writeIdentifiable(child_element, area)
 
     def writeDataTypeMappingRefs(self, element: ET.Element, behavior: InternalBehavior):
         refs = behavior.getDataTypeMappingRefs()
@@ -1040,7 +1043,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(refs_tag, "DATA-TYPE-MAPPING-REF", ref)
 
     def writeInternalBehavior(self, element: ET.Element, behavior: InternalBehavior):
-        self.setIdentifiable(element, behavior)
+        self.writeIdentifiable(element, behavior)
         self.setParameterDataPrototypes(element, "CONSTANT-MEMORYS", behavior.getConstantMemories())
         self.writeDataTypeMappingRefs(element, behavior)
         self.writeExclusiveAreas(element, behavior)
@@ -1066,7 +1069,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setVariableAccess(self, element: ET.Element, access: VariableAccess):
         child_element = ET.SubElement(element, "VARIABLE-ACCESS")
-        self.setIdentifiable(child_element, access)
+        self.writeIdentifiable(child_element, access)
         self.setAutosarVariableRef(child_element, "ACCESSED-VARIABLE", access.getAccessedVariableRef())
 
     def setAutosarParameterRef(self, element: ET.Element, key: str, parameter_ref: AutosarParameterRef):
@@ -1076,7 +1079,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeParameterAccess(self, element: ET.Element, parameter_access: ParameterAccess):
         child_element = ET.SubElement(element, "PARAMETER-ACCESS")
-        self.setIdentifiable(child_element, parameter_access)
+        self.writeIdentifiable(child_element, parameter_access)
         self.setAutosarParameterRef(child_element, "ACCESSED-PARAMETER", parameter_access.getAccessedParameter())
 
     def writeParameterAccesses(self, element: ET.Element, entity: RunnableEntity):
@@ -1134,12 +1137,12 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setSynchronousServerCallPoint(self, element: ET.Element, call_point: SynchronousServerCallPoint):
         child_element = ET.SubElement(element, "SYNCHRONOUS-SERVER-CALL-POINT")
-        self.setIdentifiable(child_element, call_point)
+        self.writeIdentifiable(child_element, call_point)
         self.setServerCallPoint(child_element, call_point)
 
     def setAsynchronousServerCallPoint(self, element: ET.Element, call_point: SynchronousServerCallPoint):
         child_element = ET.SubElement(element, "ASYNCHRONOUS-SERVER-CALL-POINT")
-        self.setIdentifiable(child_element, call_point)
+        self.writeIdentifiable(child_element, call_point)
         self.setServerCallPoint(child_element, call_point)
 
     def writeServerCallPoints(self, element: ET.Element, entity: RunnableEntity):
@@ -1188,7 +1191,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             mode_access_points_tag = ET.SubElement(element, "MODE-SWITCH-POINTS")
             for point in points:
                 child_element = ET.SubElement(mode_access_points_tag, "MODE-SWITCH-POINT")
-                self.setIdentifiable(child_element, point)
+                self.writeIdentifiable(child_element, point)
                 self.setPModeGroupInAtomicSWCInstanceRef(child_element, "MODE-GROUP-IREF", point.getModeGroupIRef())
 
     def setRunnableEntityArgument(self, element: ET.Element, argument: RunnableEntityArgument):
@@ -1211,7 +1214,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             points_tag = ET.SubElement(element, "ASYNCHRONOUS-SERVER-CALL-RESULT-POINTS")
             for point in points:
                 child_element = ET.SubElement(points_tag, "ASYNCHRONOUS-SERVER-CALL-RESULT-POINT")
-                self.setIdentifiable(child_element, point)
+                self.writeIdentifiable(child_element, point)
                 self.setChildElementOptionalRefType(child_element, "ASYNCHRONOUS-SERVER-CALL-POINT-REF", point.getAsynchronousServerCallPointRef())
 
     def writeRunnableEntity(self, element: ET.Element, entity: RunnableEntity):
@@ -1269,7 +1272,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             memories_tag = ET.SubElement(element, "PER-INSTANCE-MEMORYS")
             for memory in memories:
                 child_element = ET.SubElement(memories_tag, "PER-INSTANCE-MEMORY")
-                self.setIdentifiable(child_element, memory)
+                self.writeIdentifiable(child_element, memory)
                 self.setChildElementOptionalLiteral(child_element, "INIT-VALUE", memory.getInitValue())
                 self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", memory.getSwDataDefProps())
                 self.setChildElementOptionalLiteral(child_element, "TYPE", memory.getType())
@@ -1277,7 +1280,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
         child_element = ET.SubElement(element, "PARAMETER-DATA-PROTOTYPE")
-        self.setIdentifiable(child_element, prototype)
+        self.writeIdentifiable(child_element, prototype)
         self.setAutosarDataPrototype(child_element, prototype)
         self.setValueSpecification(child_element, "INIT-VALUE", prototype.getInitValue())
 
@@ -1324,7 +1327,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self._raiseError("Unsupported Assigned Data <%s>" % type(data))
 
     def writeServiceDependency(self, element: ET.Element, dependency: ServiceDependency):
-        self.setIdentifiable(element, dependency)
+        self.writeIdentifiable(element, dependency)
         self.writeServiceDependencyAssignedDataType(element, dependency)
 
     def writeRoleBasedDataAssignment(self, element: ET.Element, assignment: RoleBasedDataAssignment):
@@ -1362,7 +1365,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
         child_element = ET.SubElement(element, "NV-BLOCK-NEEDS")
         self.logger.debug("write NvBlockNeeds %s" % needs.getShortName())
-        self.setIdentifiable(child_element, needs)
+        self.writeIdentifiable(child_element, needs)
         self.setChildElementOptionalBooleanValue(child_element, "CALC-RAM-BLOCK-CRC", needs.getCalcRamBlockCrc())
         self.setChildElementOptionalBooleanValue(child_element, "CHECK-STATIC-BLOCK-ID", needs.getCheckStaticBlockId())
         self.setChildElementOptionalNumericalValue(child_element, "N-DATA-SETS", needs.getNDataSets())
@@ -1386,20 +1389,20 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS")
         self.logger.debug("write DiagnosticCommunicationManagerNeeds %s" % needs.getShortName())
-        self.setIdentifiable(child_element, needs)
+        self.writeIdentifiable(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "SERVICE-REQUEST-CALLBACK-TYPE", needs.getServiceRequestCallbackType()) 
     
     def setDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-ROUTINE-NEEDS")
         self.logger.debug("write DiagnosticRoutineNeeds %s" % needs.getShortName())
-        self.setIdentifiable(child_element, needs)
+        self.writeIdentifiable(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DIAG-ROUTINE-TYPE", needs.getDiagRoutineType())
         self.setChildElementOptionalIntegerValue(child_element, "RID-NUMBER", needs.getRidNumber())
 
     def setDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-VALUE-NEEDS")
         self.logger.debug("write DiagnosticValueNeeds %s" % needs.getShortName())
-        self.setIdentifiable(child_element, needs)
+        self.writeIdentifiable(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "DATA-LENGTH", needs.getDataLength())
         self.setChildElementOptionalLiteral(child_element, "DIAGNOSTIC-VALUE-ACCESS", needs.getDiagnosticValueAccess())
         self.setChildElementOptionalIntegerValue(child_element, "DID-NUMBER", needs.getDidNumber())
@@ -1408,7 +1411,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setDiagEventDebounceMonitorInternal(self, element: ET.Element, algorithm: DiagEventDebounceMonitorInternal):
         child_element = ET.SubElement(element, "DIAG-EVENT-DEBOUNCE-MONITOR-INTERNAL")
-        self.setIdentifiable(child_element, algorithm)
+        self.writeIdentifiable(child_element, algorithm)
         
     def writeDiagEventDebounceAlgorithm(self, element: ET.Element, needs: DiagnosticEventNeeds):
         algorithm = needs.getDiagEventDebounceAlgorithm()
@@ -1422,7 +1425,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-EVENT-NEEDS")
         self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
-        self.setIdentifiable(child_element, needs)
+        self.writeIdentifiable(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())
@@ -1430,19 +1433,19 @@ class ARXMLWriter(AbstractARXMLWriter):
     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.writeIdentifiable(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
     
     def setCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
         child_element = ET.SubElement(element, "CRYPTO-SERVICE-NEEDS")
         self.logger.debug("write CryptoServiceNeeds %s" % needs.getShortName())
-        self.setIdentifiable(child_element, needs)
+        self.writeIdentifiable(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)
+        self.writeIdentifiable(child_element, needs)
 
     def writeSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         needs = parent.getServiceNeeds()
@@ -1547,7 +1550,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setCode(self, element: ET.SubElement, code_desc: Code):
         self.logger.debug("setCode %s" % code_desc.getShortName())
         child_element = ET.SubElement(element, "CODE")
-        self.setIdentifiable(child_element, code_desc)
+        self.writeIdentifiable(child_element, code_desc)
         self.writeArtifactDescriptor(child_element, code_desc)
 
     def writeCodeDescriptors(self, element: ET.Element, impl: Implementation):
@@ -1572,7 +1575,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             sections_tag = ET.SubElement(element, "MEMORY-SECTIONS")
             for memory_section in memory_sections:
                 child_element = ET.SubElement(sections_tag, "MEMORY-SECTION")
-                self.setIdentifiable(child_element, memory_section)
+                self.writeIdentifiable(child_element, memory_section)
                 self.setChildElementOptionalLiteral(child_element, "ALIGNMENT", memory_section.getAlignment())
                 self.setChildElementOptionalLiteral(child_element, "MEM-CLASS-SYMBOL", memory_section.getMemClassSymbol())
                 self.setMemorySectionOptions(child_element, memory_section.getOptions())
@@ -1583,7 +1586,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setStackUsage(self, element: ET.Element, usage: StackUsage):
         self.logger.debug("Write StackUsage %s" % usage.getShortName())
-        self.setIdentifiable(element, usage)
+        self.writeIdentifiable(element, usage)
 
     def setRoughEstimateStackUsage(self, element: ET.Element, usage: RoughEstimateStackUsage):
         if usage is not None:
@@ -1603,12 +1606,12 @@ class ARXMLWriter(AbstractARXMLWriter):
     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.writeIdentifiable(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)
+        self.writeIdentifiable(element, impl)
         self.writeCodeDescriptors(element, impl)
         self.setChildElementOptionalLiteral(element, "PROGRAMMING-LANGUAGE", impl.getProgrammingLanguage())
         self.setResourceConsumption(element, impl.getResourceConsumption())
@@ -1671,7 +1674,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setEndToEndProtection(self, element: ET.Element, protection: EndToEndProtection):
         if protection is not None:
             child_element = ET.SubElement(element, "END-TO-END-PROTECTION")
-            self.setIdentifiable(child_element, protection)
+            self.writeIdentifiable(child_element, protection)
             self.setEndToEndDescription(child_element, "END-TO-END-PROFILE", protection.endToEndProfile)
             self.writeEndToEndProtectionVariablePrototypes(child_element, protection)
 
@@ -1686,7 +1689,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeEndToEndProtectionSet(self, element: ET.Element, protection_set: EndToEndProtectionSet):
         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.writeIdentifiable(child_element, protection_set)
         self.writeEndToEndProtections(child_element, protection_set)
 
     def setAutosarDataPrototype(self, element: ET.Element, prototype: AutosarDataPrototype):
@@ -1696,7 +1699,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeVariableDataPrototype(self, element: ET.Element, prototype: VariableDataPrototype):
         self.logger.debug("writeVariableDataPrototype %s" % prototype.getShortName())
         child_element = ET.SubElement(element, "VARIABLE-DATA-PROTOTYPE")
-        self.setIdentifiable(child_element, prototype)
+        self.writeIdentifiable(child_element, prototype)
         self.setAutosarDataPrototype(child_element, prototype)
         self.setValueSpecification(child_element, "INIT-VALUE", prototype.getInitValue())
 
@@ -1722,7 +1725,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeSenderReceiverInterface(self, element: ET.Element, sr_interface: SenderReceiverInterface):
         self.logger.debug("writeSenderReceiverInterface %s" % sr_interface.getShortName())
         child_element = ET.SubElement(element, "SENDER-RECEIVER-INTERFACE")
-        self.setIdentifiable(child_element, sr_interface)
+        self.writeIdentifiable(child_element, sr_interface)
         self.setChildElementOptionalBooleanValue(child_element, "IS-SERVICE", sr_interface.getIsService())
         self.writeSenderReceiverInterfaceDataElements(child_element, sr_interface)
         self.writeSenderReceiverInterfaceInvalidationPolicies(child_element, sr_interface)
@@ -1736,7 +1739,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(entry_tag, "BSW-MODULE-ENTRY-REF", entry)
 
     def setModeDeclarationGroupPrototype(self, element: ET.Element, prototype: ModeDeclarationGroupPrototype):
-        self.setIdentifiable(element, prototype)
+        self.writeIdentifiable(element, prototype)
         self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.type_tref)
 
     def writeProvidedModeGroup(self, element: ET.Element, parent: BswModuleDescription):
@@ -1755,7 +1758,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalRefType(child_element, "CAN-ENTER-EXCLUSIVE-AREA-REF", ref)
 
     def setExecutableEntity(self, element: ET.Element, entity: ExecutableEntity):
-        self.setIdentifiable(element, entity)
+        self.writeIdentifiable(element, entity)
         self.writeCanEnterExclusiveAreaRefs(element, entity)
         self.setChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL", entity.getMinimumStartInterval())
         self.setChildElementOptionalRefType(element, "SW-ADDR-METHOD-REF", entity.getSwAddrMethodRef())
@@ -1805,7 +1808,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.notImplemented("Unsupported BswModuleEntity <%s>" % type(entity))
 
     def setBswEvent(self, element: ET.Element, event: BswEvent):
-        self.setIdentifiable(element, event)
+        self.writeIdentifiable(element, event)
         self.setChildElementOptionalRefType(element, "STARTS-ON-EVENT-REF", event.startsOnEventRef)
 
     def setBswScheduleEvent(self, element: ET.Element, event: BswScheduleEvent):
@@ -1872,7 +1875,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeBswModuleDescription(self, element: ET.Element, desc: BswModuleDescription):
         self.logger.debug("writeBswModuleDescription %s" % desc.getShortName())
         child_element = ET.SubElement(element, "BSW-MODULE-DESCRIPTION")
-        self.setIdentifiable(child_element, desc)
+        self.writeIdentifiable(child_element, desc)
         self.setChildElementOptionalNumericalValue(child_element, "MODULE-ID", desc.getModuleId())
         self.writerBswModuleDescriptionImplementedEntry(child_element, desc)
         self.writeProvidedModeGroup(child_element, desc)
@@ -1891,7 +1894,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         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.writeIdentifiable(child_element, arg)
             self.setChildElementOptionalLiteral(child_element, "DIRECTION", arg.getDirection())
             self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", arg.getSwDataDefProps())
 
@@ -1905,7 +1908,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeBswModuleEntry(self, element: ET.Element, entry: BswModuleEntry):
         self.logger.debug("writeBswModuleDescription %s" % entry.getShortName())
         child_element = ET.SubElement(element, "BSW-MODULE-ENTRY")
-        self.setIdentifiable(child_element, entry)
+        self.writeIdentifiable(child_element, entry)
         self.setChildElementOptionalNumericalValue(child_element, "SERVICE-ID", entry.getServiceId())
         self.setChildElementOptionalBooleanValue(child_element, "IS-REENTRANT", entry.getIsReentrant())
         self.setChildElementOptionalBooleanValue(child_element, "IS-SYNCHRONOUS", entry.getIsSynchronous())
@@ -1932,7 +1935,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     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.writeIdentifiable(child_element, mapping)
         self.setChildElementOptionalRefType(child_element, "BSW-BEHAVIOR-REF", mapping.getBswBehaviorRef())
         self.writeSwcBswRunnableMappings(child_element, mapping)
         self.setChildElementOptionalRefType(child_element, "SWC-BEHAVIOR-REF", mapping.getSwcBehaviorRef())
@@ -1979,7 +1982,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             sub_elements_tag = ET.SubElement(element, "SUB-ELEMENTS")
             for type_element in sub_elements:
                 child_element = ET.SubElement(sub_elements_tag, "IMPLEMENTATION-DATA-TYPE-ELEMENT")
-                self.setIdentifiable(child_element, type_element)
+                self.writeIdentifiable(child_element, type_element)
                 self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE", type_element.getArraySize())
                 self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE-HANDLING", type_element.getArraySizeHandling())
                 self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS", type_element.getArraySizeSemantics())
@@ -2000,7 +2003,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             arguments_tag = ET.SubElement(element, "ARGUMENTS")
             for prototype in arguments:
                 child_element = ET.SubElement(arguments_tag, "ARGUMENT-DATA-PROTOTYPE")
-                self.setIdentifiable(child_element, prototype)
+                self.writeIdentifiable(child_element, prototype)
                 self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", prototype.swDataDefProps)
                 self.setChildElementOptionalRefType(child_element, "TYPE-TREF", prototype.typeTRef)
                 self.setChildElementOptionalLiteral(child_element, "DIRECTION", prototype.direction)
@@ -2016,7 +2019,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeClientServerOperation(self, element: ET.Element, operation: ClientServerOperation):
         self.logger.debug("writeClientServerOperation %s" % operation.getShortName())
         child_element = ET.SubElement(element, "CLIENT-SERVER-OPERATION")
-        self.setIdentifiable(child_element, operation)
+        self.writeIdentifiable(child_element, operation)
         self.writeArgumentDataPrototypes(child_element, operation)
         self.writePossibleErrorRefs(child_element, operation)
 
@@ -2033,7 +2036,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeApplicationError(self, element: ET.Element, error: ApplicationError):
         self.logger.debug("writeApplicationError %s" % error.getShortName())
         child_element = ET.SubElement(element, "APPLICATION-ERROR")
-        self.setIdentifiable(child_element, error)
+        self.writeIdentifiable(child_element, error)
         self.setChildElementOptionalNumericalValue(child_element, "ERROR-CODE", error.error_code)
 
     def writePossibleErrors(self, element: ET.Element, parent: ClientServerInterface):
@@ -2047,7 +2050,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self._raiseError("Unsupported PossibleError %s" % type(error))
 
     def setPortInterface(self, element: ET.Element, port_interface: PortInterface):
-        self.setIdentifiable(element, port_interface)
+        self.writeIdentifiable(element, port_interface)
         self.setChildElementOptionalBooleanValue(element, "IS-SERVICE", port_interface.isService)
         self.setChildElementOptionalLiteral(element, "SERVICE-KIND", port_interface.serviceKind)
 
@@ -2092,7 +2095,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", layout_v.getShortLabel())
             self.setChildElementOptionalRefType(child_element, "BASE-TYPE-REF", layout_v.getBaseTypeRef())
-            self.setChildElementOptionalNumericalValue(child_element, "SW-RECORD-LAYOUT-V-AXIS", layout_v.getSwRecordLayoutVAxis())
+            self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-AXIS", layout_v.getSwRecordLayoutVAxis())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-PROP", layout_v.getSwRecordLayoutVProp())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-INDEX", layout_v.getSwRecordLayoutVIndex())
 
@@ -2101,7 +2104,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", group.getShortLabel())
             self.setChildElementOptionalLiteral(child_element, "CATEGORY", group.getCategory())
-            self.setChildElementOptionalNumericalValue(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS", group.getSwRecordLayoutGroupAxis())
+            self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS", group.getSwRecordLayoutGroupAxis())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-INDEX", group.getSwRecordLayoutGroupIndex())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-FROM", group.getSwRecordLayoutGroupFrom())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO", group.getSwRecordLayoutGroupTo())
@@ -2113,13 +2116,13 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
         self.logger.debug("writeSwRecordLayout %s" % layout.getShortName())
         child_element = ET.SubElement(element, "SW-RECORD-LAYOUT")
-        self.setIdentifiable(child_element, layout)
+        self.writeIdentifiable(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.getShortName())
         child_element = ET.SubElement(element, "SW-ADDR-METHOD")
-        self.setIdentifiable(child_element, method)
+        self.writeIdentifiable(child_element, method)
         self.setChildElementOptionalLiteral(child_element, "MEMORY-ALLOCATION-KEYWORD-POLICY", method.getMemoryAllocationKeywordPolicy())
         options = method.getOptions()
         if len(options) > 0:
@@ -2161,13 +2164,13 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeDataTypeMappingSet(self, element: ET.Element, mapping_set: DataTypeMappingSet):
         self.logger.debug("writeDataTypeMappingSet %s" % mapping_set.getShortName())
         child_element = ET.SubElement(element, "DATA-TYPE-MAPPING-SET")
-        self.setIdentifiable(child_element, mapping_set)
+        self.writeIdentifiable(child_element, mapping_set)
         self.writeDataTypeMaps(child_element, mapping_set)
         self.writeModeRequestTypeMaps(child_element, mapping_set)
 
     def setModeDeclaration(self, element: ET.Element, mode_declaration: ModeDeclaration):
         child_element = ET.SubElement(element, "MODE-DECLARATION")
-        self.setIdentifiable(child_element, mode_declaration)
+        self.writeIdentifiable(child_element, mode_declaration)
         self.setChildElementOptionalNumericalValue(child_element, "VALUE", mode_declaration.getValue())
 
     def writeModeDeclarationGroupModeDeclaration(self, element: ET.Element, parent: ModeDeclarationGroup):
@@ -2180,7 +2183,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeModeDeclarationGroup(self, element: ET.Element, group: ModeDeclarationGroup):
         self.logger.debug("writeModeDeclarationGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "MODE-DECLARATION-GROUP")
-        self.setIdentifiable(child_element, group)
+        self.writeIdentifiable(child_element, group)
         self.setChildElementOptionalRefType(child_element, "INITIAL-MODE-REF", group.initialModeRef)
         self.writeModeDeclarationGroupModeDeclaration(child_element, group)
         self.setChildElementOptionalNumericalValue(child_element, "ON-TRANSITION-VALUE", group.getOnTransitionValue())
@@ -2190,7 +2193,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         if len(mode_groups) > 0:
             mode_group = mode_groups[0]
             child_element = ET.SubElement(element, "MODE-GROUP")
-            self.setIdentifiable(child_element, mode_group)
+            self.writeIdentifiable(child_element, mode_group)
             self.setChildElementOptionalRefType(child_element, "TYPE-TREF", mode_group.type_tref)
 
     def writeModeSwitchInterface(self, element: ET.Element, mode_interface: ModeSwitchInterface):
@@ -2207,7 +2210,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeEOCExecutableEntityRef(self, element: ET.Element, entity_ref: EOCExecutableEntityRef):
         child_element = ET.SubElement(element, "EOC-EXECUTABLE-ENTITY-REF")
-        self.setIdentifiable(child_element, entity_ref)
+        self.writeIdentifiable(child_element, entity_ref)
         self.setEOCExecutableEntityRefSuccessorRefs(child_element, entity_ref.getSuccessorRefs())
 
     def writeExecutionOrderConstraintOrderedElement(self, element: ET.Element, constraint: ExecutionOrderConstraint):
@@ -2223,7 +2226,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeExecutionOrderConstraint(self, element: ET.Element, constraint: ExecutionOrderConstraint):
         self.logger.debug("writeExecutionOrderConstraint %s" % constraint.getShortName())
         child_element = ET.SubElement(element, "EXECUTION-ORDER-CONSTRAINT")
-        self.setIdentifiable(child_element, constraint)
+        self.writeIdentifiable(child_element, constraint)
         self.writeExecutionOrderConstraintOrderedElement(child_element, constraint)
 
     def writeTimingRequirements(self, element: ET.Element, extension: TimingExtension):
@@ -2242,7 +2245,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeSwcTiming(self, element: ET.Element, timing: SwcTiming):
         self.logger.debug("writeSWcTiming %s" % timing.getShortName())
         child_element = ET.SubElement(element, "SWC-TIMING")
-        self.setIdentifiable(child_element, timing)
+        self.writeIdentifiable(child_element, timing)
         self.writeTimingExtension(child_element, timing)
 
     def writePduToFrameMappings(self, element: ET.Element, parent: Frame):
@@ -2251,13 +2254,13 @@ class ARXMLWriter(AbstractARXMLWriter):
             mappings_tags = ET.SubElement(element, "PDU-TO-FRAME-MAPPINGS")
             for mapping in mappings:
                 child_element = ET.SubElement(mappings_tags, "PDU-TO-FRAME-MAPPING")
-                self.setIdentifiable(child_element, mapping)
+                self.writeIdentifiable(child_element, mapping)
                 self.setChildElementOptionalLiteral(child_element, "PACKING-BYTE-ORDER", mapping.packingByteOrder)
                 self.setChildElementOptionalRefType(child_element, "PDU-REF", mapping.pduRef)
                 self.setChildElementOptionalNumericalValue(child_element, "START-POSITION", mapping.startPosition)
 
     def writeFrame(self, element: ET.Element, frame: Frame):
-        self.setIdentifiable(element, frame)
+        self.writeIdentifiable(element, frame)
         self.setChildElementOptionalNumericalValue(element, "FRAME-LENGTH",  frame.frameLength)
         self.writePduToFrameMappings(element, frame)
 
@@ -2284,15 +2287,21 @@ 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.getShortName())
+        self.logger.debug("write CanNmNode %s" % nm_node.getShortName())
         child_element = ET.SubElement(element, "CAN-NM-NODE")
-        self.setIdentifiable(child_element, nm_node)
+        self.writeIdentifiable(child_element, nm_node)
         self.writeNmNode(child_element, nm_node)
 
         self.setChildElementOptionalFloatValue(child_element, "NM-MSG-CYCLE-OFFSET", nm_node.getNmMsgCycleOffset())
         self.setChildElementOptionalFloatValue(child_element, "NM-MSG-REDUCED-TIME", nm_node.getNmMsgReducedTime())
         self.setChildElementRxIdentifierRange(child_element, "NM-RANGE-CONFIG", nm_node.getNmRangeConfig())
 
+    def writeUdpNmNode(self, element: ET.Element, nm_node: UdpNmNode):
+        self.logger.debug("write UdpNmNode %s" % nm_node.getShortName())
+        child_element = ET.SubElement(element, "UDP-NM-NODE")
+        self.writeIdentifiable(child_element, nm_node)
+        self.writeNmNode(child_element, nm_node)
+
     def writeNmClusterNmNodes(self, element: ET.Element, parent: NmCluster):
         nodes = parent.getNmNodes()
         if len(nodes) > 0:
@@ -2300,10 +2309,12 @@ class ARXMLWriter(AbstractARXMLWriter):
             for node in nodes:
                 if isinstance(node, CanNmNode):
                     self.writeCanNmNode(child_element, node)
+                elif isinstance(node, UdpNmNode):
+                    self.writeUdpNmNode(child_element, node)
                 else:
-                    self._raiseError("Unsupported Nm Node <%s>" % type(node))
+                    self.notImplemented("Unsupported Nm Node <%s>" % type(node))
 
-    def setCanNmClusterCoupling(self, element: ET.Element, coupling: CanNmClusterCoupling):
+    def writeCanNmClusterCoupling(self, element: ET.Element, coupling: CanNmClusterCoupling):
         child_element = ET.SubElement(element, "CAN-NM-CLUSTER-COUPLING")
         refs = coupling.getCoupledClusterRefs()
         if len(refs) > 0:
@@ -2314,6 +2325,9 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalBooleanValue(child_element, "NM-BUSLOAD-REDUCTION-ENABLED", coupling.getNmBusloadReductionEnabled())
         self.setChildElementOptionalBooleanValue(child_element, "NM-IMMEDIATE-RESTART-ENABLED", coupling.getNmImmediateRestartEnabled())
 
+    def writeUdpNmClusterCoupling(self, element: ET.Element, coupling: UdpNmClusterCoupling):
+        child_element = ET.SubElement(element, "UDP-NM-CLUSTER-COUPLING")
+
     def writeNmConfigNmClusterCouplings(self, element: ET.Element, config: NmConfig):
         self.logger.debug("writeNmConfigNmClusterCouplings %s" % config.getShortName())
         couplings = config.getNmClusterCouplings()
@@ -2321,11 +2335,14 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element= ET.SubElement(element, "NM-CLUSTER-COUPLINGS")
             for coupling in couplings:
                 if isinstance(coupling, CanNmClusterCoupling):
-                    self.setCanNmClusterCoupling(child_element, coupling)
+                    self.writeCanNmClusterCoupling(child_element, coupling)
+                elif isinstance(coupling, UdpNmClusterCoupling):
+                    self.writeUdpNmClusterCoupling(child_element, coupling)
                 else:
-                    self._raiseError("Unsupported Nm Cluster Coupling <%s>" % type(coupling))
+                    self.notImplemented("Unsupported Nm Cluster Coupling <%s>" % type(coupling))
 
     def writeNmCluster(self, element: ET.Element, cluster: NmCluster):
+        self.writeIdentifiable(element, cluster)
         self.setChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF", cluster.communicationClusterRef)
         self.setChildElementOptionalNumericalValue(element, "NM-CHANNEL-ID", cluster.nmChannelId)
         self.setChildElementOptionalBooleanValue(element, "NM-CHANNEL-SLEEP-MASTER", cluster.nmChannelSleepMaster)
@@ -2335,7 +2352,6 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeCanNmCluster(self, element: ET.Element, cluster: CanNmCluster):
         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)
 
         self.setChildElementOptionalBooleanValue(child_element, "NM-BUSLOAD-REDUCTION-ACTIVE", cluster.getNmBusloadReductionActive())
@@ -2353,6 +2369,11 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalNumericalValue(child_element, "NM-USER-DATA-LENGTH", cluster.getNmUserDataLength())
         self.setChildElementOptionalFloatValue(child_element, "NM-WAIT-BUS-SLEEP-TIME", cluster.getNmWaitBusSleepTime())
 
+    def writeUdpNmCluster(self, element: ET.Element, cluster: CanNmCluster):
+        self.logger.debug("Write UdpNmCluster %s" % cluster.getShortName())
+        child_element = ET.SubElement(element, "UDP-NM-CLUSTER")
+        self.writeNmCluster(child_element, cluster)
+
     def writeNmConfigNmClusters(self, element: ET.Element, parent: NmConfig):
         clusters = parent.getNmClusters()
         if len(clusters) > 0:
@@ -2360,26 +2381,28 @@ class ARXMLWriter(AbstractARXMLWriter):
             for cluster in clusters:
                 if isinstance(cluster, CanNmCluster):
                     self.writeCanNmCluster(child_element, cluster)
+                elif isinstance(cluster, UdpNmCluster):
+                    self.writeUdpNmCluster(child_element, cluster)
                 else:
-                    self._raiseError("Unsupported Nm Cluster <%s>" % type(cluster))
+                    self.notImplemented("Unsupported Nm Cluster <%s>" % type(cluster))
 
     def writeNmConfig(self, element: ET.Element, config: NmConfig):
         self.logger.debug("WriteNmConfig %s" % config.getShortName())
         child_element = ET.SubElement(element, "NM-CONFIG")
-        self.setIdentifiable(child_element, config)
+        self.writeIdentifiable(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.getShortName())
         child_element = ET.SubElement(element, "NM-PDU")
-        self.setIdentifiable(child_element, pdu)
+        self.writeIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
 
     def writeNPdu(self, element: ET.Element, pdu: NPdu):
         self.logger.debug("NPdu %s" % pdu.getShortName())
         child_element = ET.SubElement(element, "N-PDU")
-        self.setIdentifiable(child_element, pdu)
+        self.writeIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
 
     def writeIPdu(self, element: ET.Element, pdu: IPdu):
@@ -2388,20 +2411,20 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeDcmIPdu(self, element: ET.Element, pdu: DcmIPdu):
         self.logger.debug("DcmIPdu %s" % pdu.getShortName())
         child_element = ET.SubElement(element, "DCM-I-PDU")
-        self.setIdentifiable(child_element, pdu)
+        self.writeIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
         self.setChildElementOptionalLiteral(child_element, "DIAG-PDU-TYPE", pdu.getDiagPduType())
 
     def writeSecuredIPdu(self, element: ET.Element, pdu: DcmIPdu):
         self.logger.debug("SecuredIPdu %s" % pdu.getShortName())
         child_element = ET.SubElement(element, "SECURED-I-PDU")
-        self.setIdentifiable(child_element, pdu)
+        self.writeIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
 
     def writeCanTpConfig(self, element: ET.Element, config: CanTpConfig):
         self.logger.debug("CanTpConfig %s" % config.getShortName())
         child_element = ET.SubElement(element, "CAN-TP-CONFIG")
-        self.setIdentifiable(child_element, config)
+        self.writeIdentifiable(child_element, config)
 
     def writeFrameTriggering(self, element: ET.Element, triggering: FrameTriggering):
         ref_list = triggering.getFramePortRefs()
@@ -2421,7 +2444,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeCanFrameTriggering(self, element: ET.Element, triggering: CanFrameTriggering):
         self.logger.debug("WRite CanFrameTriggering %s" % triggering.getShortName())
         child_element = ET.SubElement(element, "CAN-FRAME-TRIGGERING")
-        self.setIdentifiable(child_element, triggering)
+        self.writeIdentifiable(child_element, triggering)
         self.writeFrameTriggering(child_element, triggering)
         self.setChildElementOptionalLiteral(child_element, "CAN-ADDRESSING-MODE", triggering.getCanAddressingMode())
         self.setChildElementOptionalBooleanValue(child_element, "CAN-FD-FRAME-SUPPORT", triggering.getCanFdFrameSupport())
@@ -2433,7 +2456,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeLinFrameTriggering(self, element: ET.Element, triggering: LinFrameTriggering):
         self.logger.debug("Write LinFrameTriggering %s" % triggering.getShortName())
         child_element = ET.SubElement(element, "LIN-FRAME-TRIGGERING")
-        self.setIdentifiable(child_element, triggering)
+        self.writeIdentifiable(child_element, triggering)
         self.writeFrameTriggering(child_element, triggering)
         self.setChildElementOptionalNumericalValue(child_element, "IDENTIFIER", triggering.getIdentifier())
         self.setChildElementOptionalLiteral(child_element, "LIN-CHECKSUM", triggering.getLinChecksum())
@@ -2441,7 +2464,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeISignalTriggering(self, element: ET.Element, triggering: ISignalTriggering):
         self.logger.debug("Write ISignalTriggering %s" % triggering.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-TRIGGERING")
-        self.setIdentifiable(child_element, triggering)
+        self.writeIdentifiable(child_element, triggering)
         self.setChildElementOptionalRefType(child_element, "I-SIGNAL-GROUP-REF", triggering.getISignalGroupRef())
         ref_list = triggering.getISignalPortRefs()
         if len(ref_list) > 0:
@@ -2453,7 +2476,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writePduTriggering(self, element: ET.Element, triggering: PduTriggering):
         self.logger.debug("Write PduTriggering %s" % triggering.getShortName())
         child_element = ET.SubElement(element, "PDU-TRIGGERING")
-        self.setIdentifiable(child_element, triggering)
+        self.writeIdentifiable(child_element, triggering)
         ref_list = triggering.getIPduPortRefs()
         if len(ref_list) > 0:
             i_signal_port_refs_tag = ET.SubElement(child_element, "I-PDU-PORT-REFS")
@@ -2505,17 +2528,55 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported PduTriggering <%s>" % type(triggering))
 
-    def setCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
+    def writeCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
         self.logger.debug("Set CanPhysicalChannel %s" % channel.getShortName())
         child_element = ET.SubElement(element, "CAN-PHYSICAL-CHANNEL")
-        self.setIdentifiable(child_element, channel)
+        self.writeIdentifiable(child_element, channel)
         self.writePhysicalChannel(child_element, channel)
 
+    def writeScheduleTableEntry(self, element: ET.Element, entry: ScheduleTableEntry):
+        self.setChildElementOptionalTimeValue(element, "DELAY", entry.getDelay())
+        self.setChildElementOptionalIntegerValue(element, "POSITION-IN-TABLE", entry.getPositionInTable())
+
+    def setApplicationEntry(self, element: ET.Element, key: str, entry: ApplicationEntry):
+        if entry is not None:
+            child_element = ET.SubElement(element, key)
+            self.writeScheduleTableEntry(child_element, entry)
+            self.setChildElementOptionalRefType(child_element, "FRAME-TRIGGERING-REF", entry.getFrameTriggeringRef())
+
+    def writeLinScheduleTableTableEntries(self, element: ET.Element, table: LinScheduleTable):
+        entries = table.getTableEntries()
+        if len(entries) > 0:
+            child_element = ET.SubElement(element, "TABLE-ENTRYS")
+            for entry in entries:
+                if isinstance(entry, ApplicationEntry):
+                    self.setApplicationEntry(child_element, "APPLICATION-ENTRY", entry)
+                else:
+                    self.notImplemented("Unsupported Schedule Table <%s>" % type(entry))
+
+    def writeLinScheduleTable(self, element: ET.Element, table: LinScheduleTable):
+        child_element = ET.SubElement(element, "LIN-SCHEDULE-TABLE")
+        self.writeIdentifiable(child_element, table)
+        self.setChildElementOptionalLiteral(child_element, "RESUME-POSITION", table.getResumePosition())
+        self.setChildElementOptionalLiteral(child_element, "RUN-MODE", table.getRunMode())
+        self.writeLinScheduleTableTableEntries(child_element, table)
+
+    def writeLinPhysicalChannelScheduleTables(self, element: ET.Element, channel: LinPhysicalChannel):
+        tables = channel.getScheduleTables()
+        if len(tables) > 0:
+            child_element = ET.SubElement(element, "SCHEDULE-TABLES")
+            for table in tables:
+                if isinstance(table, LinScheduleTable):
+                    self.writeLinScheduleTable(child_element, table)
+                else:
+                    self.notImplemented("Unsupported Schedule Table <%s>" % type(table))
+
     def writeLinPhysicalChannel(self, element: ET.Element, channel: LinPhysicalChannel):
         self.logger.debug("Set LinPhysicalChannel %s" % channel.getShortName())
         child_element = ET.SubElement(element, "LIN-PHYSICAL-CHANNEL")
-        self.setIdentifiable(child_element, channel)
+        self.writeIdentifiable(child_element, channel)
         self.writePhysicalChannel(child_element, channel)
+        self.writeLinPhysicalChannelScheduleTables(child_element, channel)
 
     def setIpv6Configuration(self, element: ET.Element, configuration: Ipv6Configuration):
         if configuration is not None:
@@ -2537,10 +2598,21 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Network EndPoint Address <%s>" % type(address))
 
+    def setDoIpEntity(self, element: ET.Element, key: str, entity: DoIpEntity):
+        if entity is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalLiteral(child_element, "DO-IP-ENTITY-ROLE", entity.getDoIpEntityRole())
+
+    def setInfrastructureServices(self, element: ET.Element, key: str, services: InfrastructureServices):
+        if services is not None:
+            child_element = ET.SubElement(element, key)
+            self.setDoIpEntity(child_element, "DO-IP-ENTITY", services.getDoIpEntity())
+
     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.writeIdentifiable(child_element, end_point)
+        self.setInfrastructureServices(child_element, "INFRASTRUCTURE-SERVICES", end_point.getInfrastructureServices())
         self.writeNetworkEndPointNetworkEndPointAddresses(child_element, end_point.getNetworkEndpointAddresses())
         self.setChildElementOptionalPositiveInteger(child_element, "PRIORITY", end_point.getPriority())
 
@@ -2571,10 +2643,14 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setSocketConnection(self, element: ET.Element, connection: SocketConnection):
         if connection is not None:
             child_element = ET.SubElement(element, "SOCKET-CONNECTION")
+            self.setChildElementOptionalBooleanValue(child_element, "CLIENT-IP-ADDR-FROM-CONNECTION-REQUEST", connection.getClientIpAddrFromConnectionRequest())
+            self.setChildElementOptionalBooleanValue(child_element, "CLIENT-PORT-FROM-CONNECTION-REQUEST", connection.getClientPortFromConnectionRequest())
             self.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, "RUNTIME-IP-ADDRESS-CONFIGURATION", connection.getRuntimeIpAddressConfiguration())
+            self.setChildElementOptionalLiteral(child_element, "RUNTIME-PORT-CONFIGURATION", connection.getRuntimePortConfiguration())
             self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", connection.getShortLabel())
 
     def writeSocketConnectionBundleConnections(self, element: ET.Element, bundle: SocketConnectionBundle):
@@ -2604,18 +2680,166 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Connection Bundle <%s>" % type(bundle))
 
-    def setSoAdConfig(self, element: ET.Element, key: str, config: SoAdConfig):
+    def setTpPort(self, element: ET.SubElement, key: str, port: TpPort):
+        if port is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalBooleanValue(child_element, "DYNAMICALLY-ASSIGNED", port.getDynamicallyAssigned())
+            self.setChildElementOptionalPositiveInteger(child_element, "PORT-NUMBER", port.getPortNumber())
+
+    def writeUdpTp(self, element: ET.Element, tp: UdpTp):
+        child_element = ET.SubElement(element, "UDP-TP")
+        self.setTpPort(child_element, "UDP-TP-PORT", tp.getUdpTpPort())
+
+    def writeTcpTp(self, element: ET.Element, tp: TcpTp):
+        child_element = ET.SubElement(element, "TCP-TP")
+        self.setChildElementOptionalTimeValue(child_element, "KEEP-ALIVE-INTERVAL", tp.getKeepAliveInterval())
+        self.setChildElementOptionalPositiveInteger(child_element, "KEEP-ALIVE-PROBES-MAX", tp.getKeepAliveProbesMax())
+        self.setChildElementOptionalTimeValue(child_element, "KEEP-ALIVE-TIME", tp.getKeepAliveTime())
+        self.setChildElementOptionalBooleanValue(child_element, "KEEP-ALIVES", tp.getKeepAlives())
+        self.setChildElementOptionalLiteral(child_element, "NAGLES-ALGORITHM", tp.getNaglesAlgorithm())
+        self.setTpPort(child_element, "TCP-TP-PORT", tp.getTcpTpPort())
+
+    def writeGenericTp(self, element: ET.Element, tp: GenericTp):
+        child_element = ET.SubElement(element, "GENERIC-TP")
+        self.setChildElementOptionalLiteral(child_element, "TP-ADDRESS", tp.getTpAddress())
+        self.setChildElementOptionalLiteral(child_element, "TP-TECHNOLOGY", tp.getTpTechnology())
+
+    def writeTransportProtocolConfiguration(self, element: ET.Element, configuration: TransportProtocolConfiguration):
+        if configuration is not None:
+            child_element = ET.SubElement(element, "TP-CONFIGURATION")
+            if isinstance(configuration, UdpTp):
+                self.writeUdpTp(child_element, configuration)
+            elif isinstance(configuration, TcpTp):
+                self.writeTcpTp(child_element, configuration)
+            elif isinstance(configuration, GenericTp):
+                self.writeGenericTp(child_element, configuration)
+            else:
+                self.notImplemented("Unsupported TransportProtocolConfiguration <%s>" % type(configuration))
+
+        return configuration
+    
+    def writeConsumedEventGroupRoutingGroupRefs(self, element: ET.Element, group: ConsumedEventGroup):
+        refs = group.getRoutingGroupRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "ROUTING-GROUP-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "ROUTING-GROUP-REF", ref)
+
+    def setRequestResponseDelay(self, element: ET.Element, key: str, delay: RequestResponseDelay):
+        if delay is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalTimeValue(child_element, "MAX-VALUE", delay.getMaxValue())
+            self.setChildElementOptionalTimeValue(child_element, "MIN-VALUE", delay.getMinValue())
+
+    def setInitialSdDelayConfig(self, element: ET.Element, key: str, config: InitialSdDelayConfig):
+        if config is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MAX-VALUE", config.getInitialDelayMaxValue())
+            self.setChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MIN-VALUE", config.getInitialDelayMinValue())
+            self.setChildElementOptionalTimeValue(child_element, "INITIAL-REPETITIONS-BASE-DELAY", config.getInitialRepetitionsBaseDelay())
+            self.setChildElementOptionalPositiveInteger(child_element, "INITIAL-REPETITIONS-MAX", config.getInitialRepetitionsMax())
+
+    def setSdClientConfig(self, element: ET.Element, key: str, config: SdClientConfig):
+        if config is not None:
+            child_element = ET.SubElement(element, key)
+
+            self.setChildElementOptionalPositiveInteger(child_element, "CLIENT-SERVICE-MAJOR-VERSION", config.getClientServiceMajorVersion())
+            self.setChildElementOptionalPositiveInteger(child_element, "CLIENT-SERVICE-MINOR-VERSION", config.getClientServiceMinorVersion())
+            self.setInitialSdDelayConfig(child_element, "INITIAL-FIND-BEHAVIOR", config.getInitialFindBehavior())
+            self.setRequestResponseDelay(child_element, "REQUEST-RESPONSE-DELAY", config.getRequestResponseDelay())
+            self.setChildElementOptionalPositiveInteger(child_element, "TTL", config.getTtl())
+    
+    def writeConsumedEventGroup(self, element: ET.Element, group: ConsumedEventGroup):
+        child_element = ET.SubElement(element, "CONSUMED-EVENT-GROUP")
+        self.writeIdentifiable(child_element, group)
+        self.setChildElementOptionalRefType(child_element, "APPLICATION-ENDPOINT-REF", group.getApplicationEndpointRef())
+        self.setChildElementOptionalPositiveInteger(child_element, "EVENT-GROUP-IDENTIFIER", group.getEventGroupIdentifier())
+        self.writeConsumedEventGroupRoutingGroupRefs(child_element, group)
+        self.setSdClientConfig(child_element, "SD-CLIENT-CONFIG", group.getSdClientConfig())
+    
+    def writeConsumedServiceInstanceConsumedEventGroups(self, element: ET.Element, instance: ConsumedServiceInstance):
+        groups = instance.getConsumedEventGroups()
+        if len(groups) > 0:
+            child_element = ET.SubElement(element, "CONSUMED-EVENT-GROUPS")
+            for group in groups:
+                if isinstance(group, ConsumedEventGroup):
+                    self.writeConsumedEventGroup(child_element, group)
+                else:
+                    self.notImplemented("Unsupported ConsumedEventGroups <%s>" % type(group)) 
+    
+    def writeConsumedServiceInstance(self, element: ET.Element, instance: ConsumedServiceInstance):
+        child_element = ET.SubElement(element, "CONSUMED-SERVICE-INSTANCE")
+        self.writeIdentifiable(child_element, instance)
+        self.writeConsumedServiceInstanceConsumedEventGroups(child_element, instance)
+        self.setChildElementOptionalRefType(child_element, "PROVIDED-SERVICE-INSTANCE-REF", instance.getProvidedServiceInstanceRef())
+        self.setSdClientConfig(child_element, "SD-CLIENT-CONFIG", instance.getSdClientConfig())
+    
+    def writeSocketAddressApplicationEndpointConsumedServiceInstances(self, element: ET.Element, end_point: ApplicationEndpoint):
+        instances = end_point.getConsumedServiceInstances()
+        if len(instances) > 0:
+            child_element = ET.SubElement(element, "CONSUMED-SERVICE-INSTANCES")
+            for instance in instances:
+                if isinstance(instance, ConsumedServiceInstance):
+                    self.writeConsumedServiceInstance(child_element, instance)
+                else:   
+                    self.notImplemented("Unsupported ConsumedServiceInstances <%s>" % type(instance))
+
+    def writeSocketAddressApplicationEndpoint(self, element: ET.Element, address: SocketAddress):
+        end_point = address.getApplicationEndpoint()
+        if end_point is not None:
+            child_element = ET.SubElement(element, "APPLICATION-ENDPOINT")
+            self.writeIdentifiable(child_element, end_point)
+            self.writeSocketAddressApplicationEndpointConsumedServiceInstances(child_element, end_point)
+            self.setChildElementOptionalRefType(child_element, "NETWORK-ENDPOINT-REF", end_point.getNetworkEndpointRef())
+            self.setChildElementOptionalPositiveInteger(child_element, "PRIORITY", end_point.getPriority())
+            self.writeTransportProtocolConfiguration(child_element, end_point.getTpConfiguration())
+
+    def writeSocketAddressMulticastConnectorRefs(self, element: ET.Element, address: SocketAddress):
+        refs = address.getMulticastConnectorRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "MULTICAST-CONNECTOR-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "MULTICAST-CONNECTOR-REF", ref)
+
+    def writeSocketAddress(self, element: ET.Element, address: SocketAddress):
+        child_element = ET.SubElement(element, "SOCKET-ADDRESS")
+        self.writeIdentifiable(child_element, address)
+        self.writeSocketAddressApplicationEndpoint(child_element, address)
+        self.writeSocketAddressMulticastConnectorRefs(child_element, address)
+        self.setChildElementOptionalRefType(child_element, "CONNECTOR-REF", address.getConnectorRef()) 
+        self.setChildElementOptionalPositiveInteger(child_element, "PORT-ADDRESS", address.getPortAddress())
+
+    def writeSoAdConfigSocketAddresses(self, element: ET.Element, config: SoAdConfig):
+        addresses = config.getSocketAddresses()
+        if len(addresses) > 0:
+            child_element = ET.SubElement(element, "SOCKET-ADDRESSS")
+            for address in addresses:
+                if isinstance(address, SocketAddress):
+                    self.writeSocketAddress(child_element, address)
+                else:
+                    self.notImplemented("Unsupported Socket Address <%s>" % type(address))
+
+    def writeSoAdConfig(self, element: ET.Element, key: str, config: SoAdConfig):
         if config is not None:
             child_element = ET.SubElement(element, key)
             self.writeSoAdConfigConnectionBundles(child_element, config)
+            self.writeSoAdConfigSocketAddresses(child_element, config)
+
+    def writeEthernetPhysicalChannelVlan(self, element: ET.Element, channel: EthernetPhysicalChannel):
+        vlan = channel.getVlan()
+        if vlan is not None:
+            child_element = ET.SubElement(element, "VLAN")
+            self.writeIdentifiable(child_element, vlan)
+            self.setChildElementOptionalPositiveInteger(child_element, "VLAN-IDENTIFIER", vlan.getVlanIdentifier())
 
-    def setEthernetPhysicalChannel(self, element: ET.Element, channel: EthernetPhysicalChannel):
+    def writeEthernetPhysicalChannel(self, element: ET.Element, channel: EthernetPhysicalChannel):
         self.logger.debug("Set EthernetPhysicalChannel %s" % channel.getShortName())
         child_element = ET.SubElement(element, "ETHERNET-PHYSICAL-CHANNEL")
-        self.setIdentifiable(child_element, channel)
+        self.writeIdentifiable(child_element, channel)
         self.writePhysicalChannel(child_element, channel)
         self.writeEthernetPhysicalChannelNetworkEndPoints(child_element, channel.getNetworkEndpoints())
-        self.setSoAdConfig(child_element, "SO-AD-CONFIG", channel.getSoAdConfig())
+        self.writeSoAdConfig(child_element, "SO-AD-CONFIG", channel.getSoAdConfig())
+        self.writeEthernetPhysicalChannelVlan(child_element, channel)
 
     def writeCommunicationClusterPhysicalChannels(self, element: ET.Element, cluster: CommunicationCluster):
         channels = cluster.getPhysicalChannels()
@@ -2623,11 +2847,11 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "PHYSICAL-CHANNELS")
             for channel in channels:
                 if isinstance(channel, CanPhysicalChannel):
-                    self.setCanPhysicalChannel(child_element, channel)
+                    self.writeCanPhysicalChannel(child_element, channel)
                 elif isinstance(channel, LinPhysicalChannel):
                     self.writeLinPhysicalChannel(child_element, channel)
                 elif isinstance(channel, EthernetPhysicalChannel):
-                    self.setEthernetPhysicalChannel(child_element, channel)
+                    self.writeEthernetPhysicalChannel(child_element, channel)
                 else:
                     self.notImplemented("Unsupported Physical Channel <%s>" % type(channel))
 
@@ -2637,14 +2861,22 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(element, "PROTOCOL-NAME", cluster.getProtocolName())
         self.setChildElementOptionalLiteral(element, "PROTOCOL-VERSION", cluster.getProtocolVersion())
 
-    def readAbstractCanCluster(self, element: ET.Element, cluster: AbstractCanCluster):
+    def setCanClusterBusOffRecovery(self, element: ET.Element, key: str, recovery: CanClusterBusOffRecovery):
+        if recovery is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalPositiveInteger(child_element, "BOR-COUNTER-L-1-TO-L-2", recovery.getBorCounterL1ToL2())
+            self.setChildElementOptionalTimeValue(child_element, "BOR-TIME-L-1", recovery.getBorTimeL1())
+            self.setChildElementOptionalTimeValue(child_element, "BOR-TIME-L-2", recovery.getBorTimeL2())
+
+    def writeAbstractCanCluster(self, element: ET.Element, cluster: AbstractCanCluster):
+        self.setCanClusterBusOffRecovery(element, "BUS-OFF-RECOVERY", cluster.getBusOffRecovery())
         self.setChildElementOptionalNumericalValue(element, "CAN-FD-BAUDRATE", cluster.getCanFdBaudrate())
         self.setChildElementOptionalNumericalValue(element, "SPEED", cluster.getSpeed())
 
     def writeLinCluster(self, element: ET.Element, cluster: LinCluster):
         self.logger.debug("LinCluster %s" % cluster.getShortName())
         child_element = ET.SubElement(element, "LIN-CLUSTER")
-        self.setIdentifiable(child_element, cluster)
+        self.writeIdentifiable(child_element, cluster)
         child_element = ET.SubElement(child_element, "LIN-CLUSTER-VARIANTS")
         child_element = ET.SubElement(child_element, "LIN-CLUSTER-CONDITIONAL")
         self.writeCommunicationCluster(child_element, cluster)
@@ -2652,12 +2884,12 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeCanCluster(self, element: ET.Element, cluster: CanCluster):
         self.logger.debug("CanCluster %s" % cluster.getShortName())
         child_element = ET.SubElement(element, "CAN-CLUSTER")
-        self.setIdentifiable(child_element, cluster)
+        self.writeIdentifiable(child_element, cluster)
 
         child_element = ET.SubElement(child_element, "CAN-CLUSTER-VARIANTS")
         child_element = ET.SubElement(child_element, "CAN-CLUSTER-CONDITIONAL")
         self.writeCommunicationCluster(child_element, cluster)
-        self.readAbstractCanCluster(child_element, cluster)
+        self.writeAbstractCanCluster(child_element, cluster)
 
     def writeEthernetCluster(self, element: ET.Element, cluster: EthernetCluster):
         self.logger.debug("Set EthernetCluster %s" % cluster.getShortName())
@@ -2674,7 +2906,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeFrame(child_element, frame)
 
     def writeCommConnectorPort(self, element: ET.Element, port: CommConnectorPort):
-        self.setIdentifiable(element, port)
+        self.writeIdentifiable(element, port)
         self.setChildElementOptionalLiteral(element, "COMMUNICATION-DIRECTION", port.getCommunicationDirection())
 
     def writeFramePort(self, element: ET.Element, port: FramePort):
@@ -2704,30 +2936,32 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported CommConnectorPort <%s>" % type(port))      
 
-    def setCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
+    def writeCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
+        child_element = ET.SubElement(element, "CAN-COMMUNICATION-CONTROLLER")
         self.logger.debug("Write CanCommunicationController %s" % controller.getShortName())
-        self.setIdentifiable(element, controller)
+        self.writeIdentifiable(child_element, controller)
 
-    def setEthernetCommunicationController(self, element: ET.Element, controller: EthernetCommunicationController):
+    def writeEthernetCommunicationController(self, element: ET.Element, controller: EthernetCommunicationController):
+        child_element = ET.SubElement(element, "ETHERNET-COMMUNICATION-CONTROLLER")
         self.logger.debug("Write EthernetCommunicationController %s" % controller.getShortName())
-        self.setIdentifiable(element, controller)
+        self.writeIdentifiable(child_element, controller)
 
     def writeEcuInstanceCommControllers(self, element: ET.Element, instance: EcuInstance):
         controllers = instance.getCommControllers()
         if len(controllers) > 0:
-            controllers_tag = ET.SubElement(element, "COMM-CONTROLLERS")
+            child_element = ET.SubElement(element, "COMM-CONTROLLERS")
             for controller in controllers:
                 if isinstance(controller, CanCommunicationController):
-                    child_element = ET.SubElement(controllers_tag, "CAN-COMMUNICATION-CONTROLLER")
-                    self.setCanCommunicationController(child_element, controller)
+                    self.writeCanCommunicationController(child_element, controller)
                 elif isinstance(controller, EthernetCommunicationController):
-                    child_element = ET.SubElement(controllers_tag, "ETHERNET-COMMUNICATION-CONTROLLER")
-                    self.setEthernetCommunicationController(child_element, controller)
+                    self.writeEthernetCommunicationController(child_element, controller)
+                elif isinstance(controller, LinMaster):
+                    self.writeLinMaster(child_element, controller)
                 else:
                     self.notImplemented("Unsupported Communication Controller <%s>" % type(controller))
 
     def writeCommunicationConnector(self, element: ET.Element, connector: CommunicationConnector):
-        self.setIdentifiable(element, connector)
+        self.writeIdentifiable(element, connector)
         self.setChildElementOptionalRefType(element, "COMM-CONTROLLER-REF", connector.getCommControllerRef())
         self.writeCommunicationConnectorEcuCommPortInstances(element, connector)
 
@@ -2739,6 +2973,10 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.logger.debug("Write EthernetCommunicationConnector %s" % connector.getShortName())
         self.writeCommunicationConnector(element, connector)
 
+    def writeLinCommunicationConnector(self, element: ET.Element, connector: LinCommunicationConnector):
+        self.logger.debug("Write LinCommunicationConnector %s" % connector.getShortName())
+        self.writeCommunicationConnector(element, connector)
+
     def writeEcuInstanceConnectors(self, element: ET.Element, instance: EcuInstance):
         connectors = instance.getConnectors()
         if len(connectors) > 0:
@@ -2750,13 +2988,16 @@ class ARXMLWriter(AbstractARXMLWriter):
                 elif isinstance(connector, EthernetCommunicationConnector):
                     child_element = ET.SubElement(connectors_tag, "ETHERNET-COMMUNICATION-CONNECTOR")
                     self.writeEthernetCommunicationConnector(child_element, connector)
+                elif isinstance(connector, LinCommunicationConnector):
+                    child_element = ET.SubElement(connectors_tag, "LIN-COMMUNICATION-CONNECTOR")
+                    self.writeLinCommunicationConnector(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.getShortName())
         child_element = ET.SubElement(element, "ECU-INSTANCE")
-        self.setIdentifiable(child_element, instance)
+        self.writeIdentifiable(child_element, instance)
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-GW-TIME-BASE", instance.getComConfigurationGwTimeBase())
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-RX-TIME-BASE", instance.getComConfigurationRxTimeBase())
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-TX-TIME-BASE", instance.getComConfigurationTxTimeBase())
@@ -2769,7 +3010,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeSystemSignalGroup(self, element: ET.Element, group: SystemSignalGroup):
         self.logger.debug("Write SystemSignalGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "SYSTEM-SIGNAL-GROUP")
-        self.setIdentifiable(child_element, group)
+        self.writeIdentifiable(child_element, group)
         signal_refs = group.getSystemSignalRefs()
         if len(signal_refs) > 0:
             signal_refs_tag = ET.SubElement(child_element, "SYSTEM-SIGNAL-REFS")
@@ -2801,7 +3042,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 
     def setSwcToEcuMapping(self, element: ET.Element, mapping: SwcToEcuMapping):
         child_element = ET.SubElement(element, "SWC-TO-ECU-MAPPING")
-        self.setIdentifiable(child_element, mapping)
+        self.writeIdentifiable(child_element, mapping)
         irefs = mapping.getComponentIRefs()
         if len(irefs) > 0:
             irefs_tag = ET.SubElement(child_element, "COMPONENT-IREFS")
@@ -2822,7 +3063,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeSystemMapping(self, element: ET.Element, mapping: SystemMapping):
         self.logger.debug("Write SystemMapping %s" % mapping.getShortName())
         child_element = ET.SubElement(element, "SYSTEM-MAPPING")
-        self.setIdentifiable(child_element, mapping)
+        self.writeIdentifiable(child_element, mapping)
         self.writeSystemMappingDataMappings(child_element, mapping)
         self.writeSystemMappingSwMappings(child_element, mapping)
 
@@ -2842,7 +3083,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.logger.debug("Write RootSwCompositionPrototype <%s>" % prototype.getShortName())
             child_element = ET.SubElement(element, "ROOT-SOFTWARE-COMPOSITIONS")
             child_element = ET.SubElement(child_element, "ROOT-SW-COMPOSITION-PROTOTYPE")
-            self.setIdentifiable(child_element, prototype)
+            self.writeIdentifiable(child_element, prototype)
             self.setChildElementOptionalRefType(child_element, "FLAT-MAP-REF", prototype.getFlatMapRef())
             self.setChildElementOptionalRefType(child_element, "SOFTWARE-COMPOSITION-TREF", prototype.getSoftwareCompositionTRef())
                 
@@ -2874,7 +3115,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     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.writeIdentifiable(child_element, desc)
         self.setAnyInstanceRef(child_element, "UPSTREAM-REFERENCE-IREF", desc.getUpstreamReferenceIRef())
         self.setAnyInstanceRef(child_element, "ECU-EXTRACT-REFERENCE-IREF", desc.getEcuExtractReferenceIRef())
 
@@ -2908,7 +3149,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     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.writeIdentifiable(child_element, mapping)
         self.setDataPrototypeMappings(child_element, "DATA-MAPPINGS", mapping.getDataMappings())
 
     def writePortInterfaceMappings(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
@@ -2938,14 +3179,14 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeGateway(self, element: ET.Element, gateway: Gateway):
         self.logger.debug("Gateway %s" % gateway.getShortName())
         child_element = ET.SubElement(element, "GATEWAY")
-        self.setIdentifiable(child_element, gateway)
+        self.writeIdentifiable(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.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL")
-        self.setIdentifiable(child_element, signal)
+        self.writeIdentifiable(child_element, signal)
         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())
@@ -2964,7 +3205,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeEcucValueCollection(self, element: ET.Element, collection: EcucValueCollection):
         self.logger.debug("EcucValueCollection %s" % collection.getShortName())
         child_element = ET.SubElement(element, "ECUC-VALUE-COLLECTION")
-        self.setIdentifiable(child_element, collection)
+        self.writeIdentifiable(child_element, collection)
         self.setChildElementOptionalRefType(child_element, "ECU-EXTRACT-REF", collection.getEcuExtractRef())
         self.writeEcucValueCollectionEcucValues(child_element, collection)
 
@@ -3044,7 +3285,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeEcucContainValue(self, element: ET.Element, container_value: EcucContainerValue):
         self.logger.debug("EcucContainerValue %s" % container_value.getShortName())
         child_element = ET.SubElement(element, "ECUC-CONTAINER-VALUE")
-        self.setIdentifiable(child_element, container_value)
+        self.writeIdentifiable(child_element, container_value)
         self.setChildElementOptionalRefType(child_element, "DEFINITION-REF", container_value.getDefinitionRef())
         self.writeEcucContainerValueParameterValues(child_element, container_value)
         self.writeEcucContainerValueReferenceValues(child_element, container_value)
@@ -3063,7 +3304,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeEcucModuleConfigurationValues(self, element: ET.Element, values: EcucModuleConfigurationValues):
         self.logger.debug("EcucModuleConfigurationValues %s" % values.getShortName())
         child_element = ET.SubElement(element, "ECUC-MODULE-CONFIGURATION-VALUES")
-        self.setIdentifiable(child_element, values)
+        self.writeIdentifiable(child_element, values)
         self.setChildElementOptionalRefType(child_element, "DEFINITION-REF", values.getDefinitionRef())
         self.setChildElementOptionalLiteral(child_element, "IMPLEMENTATION-CONFIG-VARIANT", values.getImplementationConfigVariant())
         self.setChildElementOptionalRefType(child_element, "MODULE-DESCRIPTION-REF", values.getModuleDescriptionRef())
@@ -3072,7 +3313,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeISignalGroup(self, element: ET.Element, group: ISignalGroup):
         self.logger.debug("ISignalGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-GROUP")
-        self.setIdentifiable(child_element, group)
+        self.writeIdentifiable(child_element, group)
         signal_refs = group.getISignalRefs()
         if len(signal_refs) > 0:
             signal_refs_tag = ET.SubElement(child_element, "I-SIGNAL-REFS")
@@ -3083,7 +3324,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeISignalIPduGroup(self, element: ET.Element, group: ISignalIPduGroup):
         self.logger.debug("Set ISignalIPduGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-I-PDU-GROUP")
-        self.setIdentifiable(child_element, group)
+        self.writeIdentifiable(child_element, group)
         self.setChildElementOptionalLiteral(child_element, "COMMUNICATION-DIRECTION", group.getCommunicationDirection())
         self.setChildElementOptionalLiteral(child_element, "COMMUNICATION-MODE", group.getCommunicationMode())
         group_refs = group.getContainedISignalIPduGroupRefs()
@@ -3101,19 +3342,84 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeSystemSignal(self, element: ET.Element, signal: SystemSignal):
         self.logger.debug("SystemSignal %s" % signal.getShortName())
         child_element = ET.SubElement(element, "SYSTEM-SIGNAL")
-        self.setIdentifiable(child_element, signal)
+        self.writeIdentifiable(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.getShortName())
+    def writeGenericEthernetFrame(self, element: ET.Element, frame: GenericEthernetFrame):
+        self.logger.debug("Write GenericEthernetFrame %s" % frame.getShortName())
         child_element = ET.SubElement(element, "ETHERNET-FRAME")
-        self.writeFrame(child_element, signal)
+        self.writeFrame(child_element, frame)
 
     def writeLifeCycleInfoSet(self, element: ET.Element, set: LifeCycleInfoSet):
         self.logger.debug("Write LifeCycleInfoSet %s" % set.getShortName())
         child_element = ET.SubElement(element, "LIFE-CYCLE-INFO-SET")
-        self.setIdentifiable(child_element, set)
+        self.writeIdentifiable(child_element, set)
+
+    def writeDiagnosticConnectionFunctionalRequestRefs(self, element: ET.Element, connection: DiagnosticConnection):
+        refs = connection.getFunctionalRequestRefs()
+        if len(refs) > 0:
+            refs_tag = ET.SubElement(element, "FUNCTIONAL-REQUEST-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(refs_tag, "FUNCTIONAL-REQUEST-REF", ref)
+
+    def writeDiagnosticConnection(self, element: ET.Element, connection: DiagnosticConnection):
+        self.logger.debug("Write DiagnosticConnection %s" % connection.getShortName())
+        child_element = ET.SubElement(element, "DIAGNOSTIC-CONNECTION")
+        self.writeIdentifiable(child_element, connection)
+        self.writeDiagnosticConnectionFunctionalRequestRefs(child_element, connection)
+        self.setChildElementOptionalRefType(child_element, "PHYSICAL-REQUEST-REF", connection.getPhysicalRequestRef())
+        self.setChildElementOptionalRefType(child_element, "RESPONSE-REF", connection.getResponseOnEventRef())
+
+    def writeDiagnosticServiceTable(self, element: ET.Element, table: DiagnosticServiceTable):
+        self.logger.debug("Write DiagnosticServiceTable %s" % table.getShortName())
+        child_element = ET.SubElement(element, "DIAGNOSTIC-SERVICE-TABLE")
+        self.writeIdentifiable(child_element, table)
+
+    def writeMultiplexedIPdu(self, element: ET.Element, i_pdu: MultiplexedIPdu):
+        self.logger.debug("Write MultiplexedIPdu %s" % i_pdu.getShortName())
+        child_element = ET.SubElement(element, "MULTIPLEXED-I-PDU")
+        self.writeIdentifiable(child_element, i_pdu)
+
+    def writeUserDefinedIPdu(self, element: ET.Element, i_pdu: UserDefinedIPdu):
+        self.logger.debug("Write UserDefinedIPdu %s" % i_pdu.getShortName())
+        child_element = ET.SubElement(element, "USER-DEFINED-I-PDU")
+        self.writeIdentifiable(child_element, i_pdu)
+
+    def writeUserDefinedPdu(self, element: ET.Element, pdu: UserDefinedPdu):
+        self.logger.debug("Write UserDefinedPdu %s" % pdu.getShortName())
+        child_element = ET.SubElement(element, "USER-DEFINED-PDU")
+        self.writeIdentifiable(child_element, pdu)
+
+    def writeGeneralPurposePdu(self, element: ET.Element, pdu: GeneralPurposePdu):
+        self.logger.debug("Write GeneralPurposePdu %s" % pdu.getShortName())
+        child_element = ET.SubElement(element, "GENERAL-PURPOSE-PDU")
+        self.writeIdentifiable(child_element, pdu)
+
+    def writeGeneralPurposeIPdu(self, element: ET.Element, i_pdu: GeneralPurposeIPdu):
+        self.logger.debug("Write GeneralPurposeIPdu %s" % i_pdu.getShortName())
+        child_element = ET.SubElement(element, "GENERAL-PURPOSE-I-PDU")
+        self.writeIdentifiable(child_element, i_pdu)
+
+    def writeSecureCommunicationPropsSet(self, element: ET.Element, set: SecureCommunicationPropsSet):
+        self.logger.debug("Write SecureCommunicationPropsSet %s" % set.getShortName())
+        child_element = ET.SubElement(element, "SECURE-COMMUNICATION-PROPS-SET")
+        self.writeIdentifiable(child_element, set)
+
+    def writeSoAdRoutingGroup(self, element: ET.Element, group: SoAdRoutingGroup):
+        self.logger.debug("Write SoAdRoutingGroup %s" % group.getShortName())
+        child_element = ET.SubElement(element, "SO-AD-ROUTING-GROUP")
+        self.writeIdentifiable(child_element, group)
+
+    def writeDoIpTpConfig(self, element: ET.Element, config: DoIpTpConfig):
+        self.logger.debug("Write DoIpTpConfig %s" % config.getShortName())
+        child_element = ET.SubElement(element, "DO-IP-TP-CONFIG")
+        self.writeIdentifiable(child_element, config)
+
+    def writeLinMaster(self, element: ET.Element, master: LinMaster):
+        self.logger.debug("Write LinMaster %s" % master.getShortName())
+        child_element = ET.SubElement(element, "LIN-MASTER")
+        self.writeIdentifiable(child_element, master)
 
     def writeISignalToPduMappings(self, element: ET.Element, parent: ISignalIPdu):
         mappings = parent.getISignalToPduMappings()
@@ -3121,7 +3427,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             mappings_tag = ET.SubElement(element, "I-SIGNAL-TO-PDU-MAPPINGS")
             for mapping in mappings:
                 child_element = ET.SubElement(mappings_tag, "I-SIGNAL-TO-I-PDU-MAPPING")
-                self.setIdentifiable(child_element, mapping)
+                self.writeIdentifiable(child_element, mapping)
                 self.setChildElementOptionalRefType(child_element, "I-SIGNAL-REF", mapping.getISignalRef())
                 self.setChildElementOptionalRefType(child_element, "I-SIGNAL-GROUP-REF", mapping.getISignalGroupRef())
                 self.setChildElementOptionalLiteral(child_element, "PACKING-BYTE-ORDER", mapping.getPackingByteOrder())
@@ -3187,7 +3493,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeISignalIPdu(self, element: ET.Element, i_pdu: ISignalIPdu):
         self.logger.debug("ISignalIPdu %s" % i_pdu.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-I-PDU")
-        self.setIdentifiable(child_element, i_pdu)
+        self.writeIdentifiable(child_element, i_pdu)
         self.setChildElementOptionalNumericalValue(child_element, "LENGTH", i_pdu.getLength())
         self.setISignalIPduIPduTimingSpecification(child_element, i_pdu.getIPduTimingSpecification())
         self.writeISignalToPduMappings(child_element, i_pdu)
@@ -3300,6 +3606,26 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeEthernetCluster(element, ar_element)
         elif isinstance(ar_element, ISignalIPduGroup):
             self.writeISignalIPduGroup(element, ar_element)
+        elif isinstance(ar_element, DiagnosticConnection):
+            self.writeDiagnosticConnection(element, ar_element)
+        elif isinstance(ar_element, DiagnosticServiceTable):
+            self.writeDiagnosticServiceTable(element, ar_element)
+        elif isinstance(ar_element, MultiplexedIPdu):
+            self.writeMultiplexedIPdu(element, ar_element)
+        elif isinstance(ar_element, UserDefinedIPdu):
+            self.writeUserDefinedIPdu(element, ar_element)
+        elif isinstance(ar_element, UserDefinedPdu):
+            self.writeUserDefinedPdu(element, ar_element)
+        elif isinstance(ar_element, GeneralPurposePdu):
+            self.writeGeneralPurposePdu(element, ar_element)
+        elif isinstance(ar_element, GeneralPurposeIPdu):
+            self.writeGeneralPurposeIPdu(element, ar_element)
+        elif isinstance(ar_element, SecureCommunicationPropsSet):
+            self.writeSecureCommunicationPropsSet(element, ar_element)
+        elif isinstance(ar_element, SoAdRoutingGroup):
+            self.writeSoAdRoutingGroup(element, ar_element)
+        elif isinstance(ar_element, DoIpTpConfig):
+            self.writeDoIpTpConfig(element, ar_element)
         else:
             self.notImplemented("Unsupported Elements of ARPackage <%s>" % type(ar_element))
         
@@ -3322,7 +3648,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             for pkg in pkgs:
                 pkg_tag  = ET.SubElement(pkgs_tag, "AR-PACKAGE")
             
-                self.setIdentifiable(pkg_tag, pkg)
+                self.writeIdentifiable(pkg_tag, pkg)
                 self.logger.debug("writeARPackage %s" % pkg.full_name)
 
                 self.writeReferenceBases(pkg_tag, pkg.getReferenceBases())