armodel 1.7.8__py3-none-any.whl → 1.8.0__py3-none-any.whl

armodel/writer/arxml_writer.py

@@ -17,21 +17,25 @@ from ..models.M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps, SwP
 from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayout, SwRecordLayoutGroup, SwRecordLayoutV
 from ..models.M2.MSR.DataDictionary.ServiceProcessTask import SwServiceArg
 from ..models.M2.MSR.Documentation.Annotation import Annotation
+from ..models.M2.MSR.Documentation.BlockElements.Figure import Graphic, MlFigure
+from ..models.M2.MSR.Documentation.TextModel.BlockElements.PaginationAndView import DocumentViewSelectable, Paginateable
 from ..models.M2.MSR.Documentation.TextModel.BlockElements import DocumentationBlock
-from ..models.M2.MSR.Documentation.TextModel.BlockElements.ListElements import ListElement
+from ..models.M2.MSR.Documentation.TextModel.BlockElements.ListElements import ARList
 from ..models.M2.MSR.Documentation.TextModel.LanguageDataModel import LLongName, LPlainText, LanguageSpecific
 from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultiLanguagePlainText
 from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultilanguageLongName
 
 from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswApiOptions, BswBackgroundEvent, BswCalledEntity, BswDataReceivedEvent, BswInternalTriggerOccurredEvent, BswOperationInvokedEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswApiOptions, BswAsynchronousServerCallPoint, BswBackgroundEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswDataReceivedEvent, BswModuleCallPoint
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalTriggerOccurredEvent, BswOperationInvokedEvent
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswDataReceptionPolicy, BswEvent, BswExternalTriggerOccurredEvent
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalBehavior, BswInterruptEntity, BswModeSenderPolicy, BswModuleEntity
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswQueuedDataReceptionPolicy, BswSchedulableEntity, BswScheduleEvent
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswTimingEvent, BswVariableAccess
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswTimingEvent, BswVariableAccess, BswInternalTriggeringPoint
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswImplementation import BswImplementation
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleClientServerEntry, BswModuleEntry
 from ..models.M2.AUTOSARTemplates.CommonStructure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference
 from ..models.M2.AUTOSARTemplates.CommonStructure import ConstantSpecification, NumericalValueSpecification, RecordValueSpecification
 from ..models.M2.AUTOSARTemplates.CommonStructure import TextValueSpecification, ValueSpecification
@@ -45,11 +49,14 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDec
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import ResourceConsumption
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import RoughEstimateStackUsage, StackUsage
 from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
-from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal, DltUserNeeds, ServiceNeeds
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticCapabilityElement, DtcStatusChangeNotificationNeeds
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import EcuStateMgrUserNeeds, NvBlockNeeds, RoleBasedDataAssignment
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import RoleBasedDataTypeAssignment, ServiceDependency
+from ..models.M2.AUTOSARTemplates.CommonStructure.StandardizationTemplate.Keyword import KeywordSet, Keyword
+from ..models.M2.AUTOSARTemplates.CommonStructure.StandardizationTemplate.BlueprintDedicated.PortPrototypeBlueprint import PortPrototypeBlueprint
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingExtensions import SwcTiming, TimingExtension
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import EOCExecutableEntityRef
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import ExecutionOrderConstraint
@@ -61,12 +68,13 @@ from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucReferenceVa
 from ..models.M2.AUTOSARTemplates.EcuResourceTemplate import HwDescriptionEntity, HwElement, HwPinGroup
 from ..models.M2.AUTOSARTemplates.EcuResourceTemplate.HwElementCategory import HwAttributeDef, HwCategory, HwType
 from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ElementCollection import Collection
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage, ReferenceBase
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Describable, Identifiable
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Referrable, MultilanguageReferrable
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType, ARLiteral, Limit
-from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfoSet
+from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfo, LifeCycleInfoSet, LifeCyclePeriod
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, ModeSwitchedAckRequest
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import TransmissionAcknowledgementRequest
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import ClientComSpec, ModeSwitchReceiverComSpec, ModeSwitchSenderComSpec
@@ -99,6 +107,7 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionVariablePrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ApplicationError, ArgumentDataPrototype, ClientServerInterface
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ClientServerInterfaceMapping, ClientServerOperationMapping
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ClientServerOperation, DataInterface
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import DataPrototypeMapping, ModeSwitchInterface, ParameterInterface
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import PortInterface, PortInterfaceMappingSet, SenderReceiverInterface
@@ -312,7 +321,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setAnnotations(element, identifiable.getAnnotations())
         self.setMultiLanguageOverviewParagraph(element, "DESC", identifiable.getDesc())
         self.setChildElementOptionalLiteral(element, "CATEGORY", identifiable.getCategory())
-        self.setDocumentationBlock(element, "INTRODUCTION", identifiable.getIntroduction())
+        self.writeDocumentationBlock(element, "INTRODUCTION", identifiable.getIntroduction())
         self.setAdminData(element, identifiable.getAdminData())
 
     def writeARElement(self, parent: ET.Element, ar_element: ARElement):
@@ -735,27 +744,57 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeLParagraphs(child_element, paragraph)
         return paragraphs
     
-    def setListElement(self, element: ET.Element, key: str, list: ListElement):
+    def setListElement(self, element: ET.Element, key: str, list: ARList):
         if list is not None:
             child_element = ET.SubElement(element, key)
             type = list.getType()
             if type is not None:
                 child_element.attrib['TYPE'] = type
             for item in list.getItems():
-                self.setDocumentationBlock(child_element, "ITEM", item)
+                self.writeDocumentationBlock(child_element, "ITEM", item)
 
-    def setDocumentationBlock(self, element: ET.Element, key: str, block: DocumentationBlock):
+    def setGraphic(self, element: ET.Element, key: str, graphic: Graphic):
+        if graphic is not None:
+            child_element = ET.SubElement(element, key)
+            if graphic.getFilename() is not None:
+                child_element.attrib["FILENAME"] = graphic.getFilename()
+    
+    def writeMlFigureLGraphics(self, element: ET.Element, figure: MlFigure):
+        graphics = figure.getLGraphics()
+        for graphic in graphics:
+            child_element = ET.SubElement(element, "L-GRAPHIC")
+            if graphic.getL() is not None:
+                child_element.attrib["L"] = graphic.getL()
+            self.setGraphic(child_element, "GRAPHIC", graphic.getGraphic())
+
+    def writeDocumentViewSelectable(self, element: ET.Element, selectable: DocumentViewSelectable):
+        self.writeARObjectAttributes(element, selectable)
+
+    def writePaginateable(self, element: ET.Element, paginateable: Paginateable):
+        self.writeDocumentViewSelectable(element, paginateable)
+    
+    def writeMlFigure(self, element: ET.Element, figure: MlFigure):
+        self.writePaginateable(element, figure)
+        self.writeMlFigureLGraphics(element, figure)
+
+    def setMlFigures(self, element: ET.Element, key: str, figures: List[MlFigure]):
+        for figure in figures:
+            child_element = ET.SubElement(element, key)
+            self.writeMlFigure(child_element, figure)
+
+    def writeDocumentationBlock(self, element: ET.Element, key: str, block: DocumentationBlock):
         if block is not None:
             child_element = ET.SubElement(element, key)
             self.writeARObjectAttributes(child_element, block)
             self.setMultiLanguageParagraphs(child_element, "P", block.getPs())
             for list in block.getLists():
                 self.setListElement(child_element, "LIST", list)
+            self.setMlFigures(child_element, "FIGURE", block.getFigures())
 
     def writeGeneralAnnotation(self, element: ET.Element, annotation: Annotation):
         self.setMultiLongName(element, "LABEL", annotation.getLabel())
         self.setChildElementOptionalLiteral(element, "ANNOTATION-ORIGIN", annotation.getAnnotationOrigin())
-        self.setDocumentationBlock(element, "ANNOTATION-TEXT", annotation.getAnnotationText())
+        self.writeDocumentationBlock(element, "ANNOTATION-TEXT", annotation.getAnnotationText())
 
     def setAnnotations(self, element: ET.Element, annotations: List[Annotation]):
         if len(annotations) > 0:
@@ -813,11 +852,11 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeARObjectAttributes(conditional_tag, props.conditional)
             self.setAnnotations(conditional_tag, props.getAnnotations())
             self.setChildElementOptionalRefType(conditional_tag, "BASE-TYPE-REF", props.getBaseTypeRef())
+            self.setChildElementOptionalRefType(conditional_tag, "SW-ADDR-METHOD-REF", props.getSwAddrMethodRef())
             self.setChildElementOptionalLiteral(conditional_tag, "SW-CALIBRATION-ACCESS", props.getSwCalibrationAccess())
             self.setChildElementOptionalRefType(conditional_tag, "COMPU-METHOD-REF", props.getCompuMethodRef())
             self.setValueSpecification(conditional_tag, "INVALID-VALUE", props.getInvalidValue())
             self.setChildElementOptionalFloatValue(conditional_tag, "STEP-SIZE", props.getStepSize())
-            self.setChildElementOptionalRefType(conditional_tag, "SW-ADDR-METHOD-REF", props.getSwAddrMethodRef())
             self.setChildElementOptionalRefType(conditional_tag, "DATA-CONSTR-REF", props.getDataConstrRef())
             self.setChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF", props.getImplementationDataTypeRef())
             self.setSwCalprmAxisSet(conditional_tag, "SW-CALPRM-AXIS-SET", props.getSwCalprmAxisSet())
@@ -1538,10 +1577,13 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Assigned Data <%s>" % type(data))
 
-    def setNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
+    def writeServiceNeeds(self, element: ET.Element, needs: ServiceNeeds):
+        self.writeIdentifiable(element, needs)
+
+    def writeNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
         child_element = ET.SubElement(element, "NV-BLOCK-NEEDS")
         self.logger.debug("write NvBlockNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeServiceNeeds(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())
@@ -1562,23 +1604,26 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalPositiveInteger(child_element, "WRITING-FREQUENCY", needs.getWritingFrequency())
         self.setChildElementOptionalLiteral(child_element, "WRITING-PRIORITY", needs.getWritingPriority())
 
-    def setDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
+    def writeDiagnosticCapabilityElement(self, element: ET.Element, needs: DiagnosticCapabilityElement):
+        self.writeServiceNeeds(element, needs)
+
+    def writeDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS")
         self.logger.debug("write DiagnosticCommunicationManagerNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeDiagnosticCapabilityElement(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "SERVICE-REQUEST-CALLBACK-TYPE", needs.getServiceRequestCallbackType())
 
-    def setDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
+    def writeDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-ROUTINE-NEEDS")
         self.logger.debug("write DiagnosticRoutineNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeDiagnosticCapabilityElement(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DIAG-ROUTINE-TYPE", needs.getDiagRoutineType())
         self.setChildElementOptionalIntegerValue(child_element, "RID-NUMBER", needs.getRidNumber())
 
-    def setDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
+    def writeDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-VALUE-NEEDS")
         self.logger.debug("write DiagnosticValueNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeDiagnosticCapabilityElement(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "DATA-LENGTH", needs.getDataLength())
         self.setChildElementOptionalLiteral(child_element, "DIAGNOSTIC-VALUE-ACCESS", needs.getDiagnosticValueAccess())
         self.setChildElementOptionalIntegerValue(child_element, "DID-NUMBER", needs.getDidNumber())
@@ -1587,7 +1632,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setDiagEventDebounceMonitorInternal(self, element: ET.Element, algorithm: DiagEventDebounceMonitorInternal):
         child_element = ET.SubElement(element, "DIAG-EVENT-DEBOUNCE-MONITOR-INTERNAL")
-        self.writeIdentifiable(child_element, algorithm)
+        self.writeDiagnosticCapabilityElement(child_element, algorithm)
 
     def writeDiagEventDebounceAlgorithm(self, element: ET.Element, needs: DiagnosticEventNeeds):
         algorithm = needs.getDiagEventDebounceAlgorithm()
@@ -1598,54 +1643,70 @@ class ARXMLWriter(AbstractARXMLWriter):
             else:
                 self.notImplemented("Unsupported DiagEventDebounceAlgorithm <%s>" % type(algorithm))
 
-    def setDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
+    def writeDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
+        # self.logger.debug("Write DiagnosticEventNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "DIAGNOSTIC-EVENT-NEEDS")
-        self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeDiagnosticCapabilityElement(child_element, needs)
         self.writeDiagEventDebounceAlgorithm(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DTC-KIND", needs.getDtcKind())
         self.setChildElementOptionalIntegerValue(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
 
-    def setDiagnosticEventInfoNeeds(self, element: ET.Element, needs: DiagnosticEventInfoNeeds):
+    def writeDiagnosticEventInfoNeeds(self, element: ET.Element, needs: DiagnosticEventInfoNeeds):
+        # self.logger.debug("Write DiagnosticEventNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "DIAGNOSTIC-EVENT-INFO-NEEDS")
-        self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeDiagnosticCapabilityElement(child_element, needs)
+        self.setChildElementOptionalLiteral(child_element, "DTC-KIND", needs.getDtcKind())
         self.setChildElementOptionalPositiveInteger(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
 
-    def setCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
+    def writeCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
+        # self.logger.debug("Write CryptoServiceNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "CRYPTO-SERVICE-NEEDS")
-        self.logger.debug("write CryptoServiceNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeServiceNeeds(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "MAXIMUM-KEY-LENGTH", needs.getMaximumKeyLength())
 
-    def setEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
+    def writeEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
+        # self.logger.debug("write EcuStateMgrUserNeeds %s" % needs.getShortName())
         child_element = ET.SubElement(element, "ECU-STATE-MGR-USER-NEEDS")
-        self.logger.debug("write EcuStateMgrUserNeeds %s" % needs.getShortName())
-        self.writeIdentifiable(child_element, needs)
+        self.writeServiceNeeds(child_element, needs)
+
+    def writeDtcStatusChangeNotificationNeeds(self, element: ET.Element, needs: DtcStatusChangeNotificationNeeds):
+        # self.logger.debug("Write DtcStatusChangeNotificationNeeds %s" % needs.getShortName())
+        child_element = ET.SubElement(element, "DTC-STATUS-CHANGE-NOTIFICATION-NEEDS")
+        self.writeDiagnosticCapabilityElement(child_element, needs)
+        self.setChildElementOptionalLiteral(child_element, "DTC-FORMAT-TYPE", needs.getDtcFormatType())
+
+    def writeDltUserNeeds(self, element: ET.Element, needs: DtcStatusChangeNotificationNeeds):
+        # self.logger.debug("Write DtcStatusChangeNotificationNeeds %s" % needs.getShortName())
+        child_element = ET.SubElement(element, "DLT-USER-NEEDS")
+        self.writeServiceNeeds(child_element, needs)
 
     def writeSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
-        needs = parent.getServiceNeeds()
-        if len(needs) > 0:
+        needs_list = parent.getServiceNeeds()
+        if len(needs_list) > 0:
             child_element = ET.SubElement(element, "SERVICE-NEEDS")
-            for need in needs:
-                if isinstance(need, NvBlockNeeds):
-                    self.setNvBlockNeeds(child_element, need)
-                elif isinstance(need, DiagnosticCommunicationManagerNeeds):
-                    self.setDiagnosticCommunicationManagerNeeds(child_element, need)
-                elif isinstance(need, DiagnosticRoutineNeeds):
-                    self.setDiagnosticRoutineNeeds(child_element, need)
-                elif isinstance(need, DiagnosticValueNeeds):
-                    self.setDiagnosticValueNeeds(child_element, need)
-                elif isinstance(need, DiagnosticEventNeeds):
-                    self.setDiagnosticEventNeeds(child_element, need)
-                elif isinstance(need, DiagnosticEventInfoNeeds):
-                    self.setDiagnosticEventInfoNeeds(child_element, need)
-                elif isinstance(need, CryptoServiceNeeds):
-                    self.setCryptoServiceNeeds(child_element, need)
-                elif isinstance(need, EcuStateMgrUserNeeds):
-                    self.setEcuStateMgrUserNeeds(child_element, need)
+            for needs in needs_list:
+                if isinstance(needs, NvBlockNeeds):
+                    self.writeNvBlockNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticCommunicationManagerNeeds):
+                    self.writeDiagnosticCommunicationManagerNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticRoutineNeeds):
+                    self.writeDiagnosticRoutineNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticValueNeeds):
+                    self.writeDiagnosticValueNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticEventNeeds):
+                    self.writeDiagnosticEventNeeds(child_element, needs)
+                elif isinstance(needs, DiagnosticEventInfoNeeds):
+                    self.writeDiagnosticEventInfoNeeds(child_element, needs)
+                elif isinstance(needs, CryptoServiceNeeds):
+                    self.writeCryptoServiceNeeds(child_element, needs)
+                elif isinstance(needs, EcuStateMgrUserNeeds):
+                    self.writeEcuStateMgrUserNeeds(child_element, needs)
+                elif isinstance(needs, DtcStatusChangeNotificationNeeds):
+                    self.writeDtcStatusChangeNotificationNeeds(child_element, needs)
+                elif isinstance(needs, DltUserNeeds):
+                    self.writeDltUserNeeds(child_element, needs)
                 else:
-                    self.notImplemented("Unsupported service needs <%s>" % type(need))
+                    self.notImplemented("Unsupported service needs <%s>" % type(needs))
 
     def writeSwcServiceDependency(self, element: ET.Element, dependency: SwcServiceDependency):
         child_element = ET.SubElement(element, "SWC-SERVICE-DEPENDENCY")
@@ -1743,8 +1804,8 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalLiteral(artifact_desc_tag, "SHORT-LABEL", artifact_desc.short_label)
                 self.setChildElementOptionalLiteral(artifact_desc_tag, "CATEGORY", artifact_desc.category)
 
-    def setCode(self, element: ET.SubElement, code_desc: Code):
-        self.logger.debug("setCode %s" % code_desc.getShortName())
+    def writeCode(self, element: ET.SubElement, code_desc: Code):
+        # self.logger.debug("Write Code %s" % code_desc.getShortName())
         child_element = ET.SubElement(element, "CODE")
         self.writeIdentifiable(child_element, code_desc)
         self.writeArtifactDescriptor(child_element, code_desc)
@@ -1755,7 +1816,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "CODE-DESCRIPTORS")
             for desc in descs:
                 if isinstance(desc, Code):
-                    self.setCode(child_element, desc)
+                    self.writeCode(child_element, desc)
                 else:
                     self.notImplemented("Unsupported Code Descriptor <%s>" % type(desc))
 
@@ -2035,8 +2096,36 @@ class ARXMLWriter(AbstractARXMLWriter):
                 cond_tag = ET.SubElement(child_element, "TRIGGER-REF-CONDITIONAL")
                 self.setChildElementOptionalRefType(cond_tag, "TRIGGER-REF", ref)
 
+    def writeBswModuleEntityActivationPointRefs(self, element: ET.Element, entity: BswModuleEntity):
+        refs = entity.getActivationPointRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "ACTIVATION-POINTS")
+            for ref in refs:
+                cond_tag = ET.SubElement(child_element, "BSW-INTERNAL-TRIGGERING-POINT-REF-CONDITIONAL")
+                self.setChildElementOptionalRefType(cond_tag, "BSW-INTERNAL-TRIGGERING-POINT-REF", ref)
+
+    def writeBswModuleCallPoint(self, element: ET.Element, point: BswModuleCallPoint):
+        self.writeReferrable(element, point)
+
+    def writeBswAsynchronousServerCallPoint(self, element: ET.Element, point: BswAsynchronousServerCallPoint):
+        child_element = ET.SubElement(element, "BSW-ASYNCHRONOUS-SERVER-CALL-POINT")
+        self.writeBswModuleCallPoint(child_element, point)
+        self.setChildElementOptionalRefType(child_element, "CALLED-ENTRY-REF", point.getCalledEntryRef())
+
+    def writeBswModuleEntityCallPoints(self, element: ET.Element, entity: BswModuleEntity):
+        points = entity.getCallPoints()
+        if len(points) > 0:
+            child_element = ET.SubElement(element, "CALL-POINTS")
+            for point in points:
+                if isinstance(point, BswAsynchronousServerCallPoint):
+                    self.writeBswAsynchronousServerCallPoint(child_element, point)
+                else:
+                    self.notImplemented("Unsupported Call Point <%s>" % type(point))
+
     def writeBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
         self.writeExecutableEntity(element, entity)
+        self.writeBswModuleEntityActivationPointRefs(element, entity)
+        self.writeBswModuleEntityCallPoints(element, entity)
         self.writeBswModuleEntityDataSendPoints(element, entity)
         self.writeBswModuleEntityDataReceivePoints(element, entity)
         self.setChildElementOptionalRefType(element, "IMPLEMENTED-ENTRY-REF", entity.implementedEntryRef)
@@ -2060,7 +2149,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(child_element, "INTERRUPT-CATEGORY", entity.getInterruptCategory())
         self.setChildElementOptionalLiteral(child_element, "INTERRUPT-SOURCE", entity.getInterruptSource())
 
-    def writeBswInternalBehaviorBswModuleEntities(self, element: ET.Element, parent: BswInternalBehavior):
+    def writeBswInternalBehaviorEntities(self, element: ET.Element, parent: BswInternalBehavior):
         entities = parent.getBswModuleEntities()
         if len(entities) > 0:
             child_element = ET.SubElement(element, "ENTITYS")
@@ -2118,7 +2207,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeBswEvent(child_element, event)
         self.setChildElementOptionalRefType(child_element, "ENTRY-REF", event.getEntryRef())
 
-    def writeBswInternalBehaviorBswEvents(self, element: ET.Element, parent: BswInternalBehavior):
+    def writeBswInternalBehaviorEvents(self, element: ET.Element, parent: BswInternalBehavior):
         events = parent.getBswEvents()
         if len(events) > 0:
             child_element = ET.SubElement(element, "EVENTS")
@@ -2183,11 +2272,26 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Reception Policies <%s>" % type(policy))
 
+    def writeBswInternalTriggeringPoint(self, element: ET.Element, point: BswInternalTriggeringPoint):
+        child_element = ET.SubElement(element, "BSW-INTERNAL-TRIGGERING-POINT")
+        self.writeIdentifiable(child_element, point)
+
+    def writeBswInternalBehaviorInternalTriggeringPoints(self, element: ET.Element, behavior: BswInternalBehavior):
+        points = behavior.getInternalTriggeringPoints()
+        if len(points) > 0:
+            child_element = ET.SubElement(element, "INTERNAL-TRIGGERING-POINTS")
+            for point in points:
+                if isinstance(point, BswInternalTriggeringPoint):
+                    self.writeBswInternalTriggeringPoint(child_element, point)
+                else:
+                    self.notImplemented("Unsupported Internal Triggering Points <%s>" % type(point))
+
     def writeBswInternalBehavior(self, element: ET.Element, behavior: BswInternalBehavior):
         child_element = ET.SubElement(element, "BSW-INTERNAL-BEHAVIOR")
         self.writeInternalBehavior(child_element, behavior)
-        self.writeBswInternalBehaviorBswModuleEntities(child_element, behavior)
-        self.writeBswInternalBehaviorBswEvents(child_element, behavior)
+        self.writeBswInternalBehaviorInternalTriggeringPoints(child_element, behavior)
+        self.writeBswInternalBehaviorEntities(child_element, behavior)
+        self.writeBswInternalBehaviorEvents(child_element, behavior)
         self.writeBswInternalBehaviorModeSenderPolicy(child_element, behavior)
         self.writeBswInternalBehaviorIncludedModeDeclarationGroupSets(child_element, behavior)
         self.writeBswInternalBehaviorReceptionPolicies(child_element, behavior)
@@ -2245,7 +2349,35 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.writeVariableDataPrototype(child_element, data)
                 else:
                     self.notImplemented("Unsupported Required Data <%s>" % type(data))
-    
+
+    def writeBswModuleClientServerEntry(self, element: ET.Element, entry: BswModuleClientServerEntry):
+        if entry is not None:
+            child_element = ET.SubElement(element, "BSW-MODULE-CLIENT-SERVER-ENTRY")
+            self.writeReferrable(child_element, entry)
+            self.setChildElementOptionalRefType(child_element, "ENCAPSULATED-ENTRY-REF", entry.getEncapsulatedEntryRef())
+            self.setChildElementOptionalBooleanValue(child_element, "IS-REENTRANT", entry.getIsReentrant())
+            self.setChildElementOptionalBooleanValue(child_element, "IS-SYNCHRONOUS", entry.getIsSynchronous())
+
+    def writeBswModuleDescriptionProvidedClientServerEntries(self, element: ET.Element, desc: BswModuleDescription):
+        entries = desc.getProvidedClientServerEntries()
+        if len(entries) > 0:
+            child_element = ET.SubElement(element, "PROVIDED-CLIENT-SERVER-ENTRYS")
+            for entry in entries:
+                if isinstance(entry, BswModuleClientServerEntry):
+                    self.writeBswModuleClientServerEntry(child_element, entry)
+                else:
+                    self.notImplemented("Unsupported Provided Client Server Entry <%s>" % type(entry))
+
+    def writeBswModuleDescriptionRequiredClientServerEntries(self, element: ET.Element, desc: BswModuleDescription):
+        entries = desc.getRequiredClientServerEntries()
+        if len(entries) > 0:
+            child_element = ET.SubElement(element, "REQUIRED-CLIENT-SERVER-ENTRYS")
+            for entry in entries:
+                if isinstance(entry, BswModuleClientServerEntry):
+                    self.writeBswModuleClientServerEntry(child_element, entry)
+                else:
+                    self.notImplemented("Unsupported Provided Client Server Entry <%s>" % type(entry))
+
     def writeBswModuleDescription(self, element: ET.Element, desc: BswModuleDescription):
         self.logger.debug("writeBswModuleDescription %s" % desc.getShortName())
         child_element = ET.SubElement(element, "BSW-MODULE-DESCRIPTION")
@@ -2254,11 +2386,12 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeBswModuleDescriptionImplementedEntryRefs(child_element, desc)
         self.writeBswModuleDescriptionProvidedModeGroups(child_element, desc)
         self.writeBswModuleDescriptionRequiredModeGroups(child_element, desc)
-        self.writeBswModuleDescriptionReleasedTriggers(child_element, desc)
-        self.writeBswModuleDescriptionRequiredTriggers(child_element, desc)
+        self.writeBswModuleDescriptionProvidedClientServerEntries(child_element, desc)
+        self.writeBswModuleDescriptionRequiredClientServerEntries(child_element, desc)
         self.writeBswModuleDescriptionProvidedDatas(child_element, desc)
         self.writeBswModuleDescriptionRequiredDatas(child_element, desc)
         self.writeBswModuleDescriptionInternalBehaviors(child_element, desc)
+        self.writeBswModuleDescriptionReleasedTriggers(child_element, desc)
 
     def setSwServiceArg(self, element: ET.Element, arg: SwServiceArg):
         self.logger.debug("Set SwServiceArg <%s>" % arg.getShortName())
@@ -2315,8 +2448,8 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(element, "SHORT-LABEL", engineering_obj.short_label)
         self.setChildElementOptionalLiteral(element, "CATEGORY", engineering_obj.category)
         
-    def setAutosarEngineeringObject(self, element: ET.Element, obj: AutosarEngineeringObject):
-        self.logger.debug("readArtifactDescriptor %s", obj.short_label)
+    def writeAutosarEngineeringObject(self, element: ET.Element, obj: AutosarEngineeringObject):
+        # self.logger.debug("write ArtifactDescriptor %s", obj.short_label)
         child_element = ET.SubElement(element, "AUTOSAR-ENGINEERING-OBJECT")
         self.writeEngineeringObject(child_element, obj)
 
@@ -2326,7 +2459,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "ARTIFACT-DESCRIPTORS")
             for artifact_desc in artifact_descs:
                 if isinstance(artifact_desc, AutosarEngineeringObject):
-                    self.setAutosarEngineeringObject(child_element, artifact_desc)
+                    self.writeAutosarEngineeringObject(child_element, artifact_desc)
                 else:
                     self.notImplemented("Unsupported Artifact descriptor <%s>" % type(artifact_desc))
 
@@ -2348,7 +2481,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeBswImplementationVendorSpecificModuleDefRefs(child_element, impl)
 
     def writeImplementationDataTypeElements(self, element: ET.Element, parent: ImplementationDataType):
-        sub_elements = parent.getImplementationDataTypeElements()
+        sub_elements = parent.getSubElements()
         if len(sub_elements) > 0:
             sub_elements_tag = ET.SubElement(element, "SUB-ELEMENTS")
             for type_element in sub_elements:
@@ -3743,6 +3876,68 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalIntegerValue(child_element, "WAKEUP-TX-ACTIVE", cluster.getWakeupTxActive())
             self.setChildElementOptionalIntegerValue(child_element, "WAKEUP-TX-IDLE", cluster.getWakeupTxIdle())
 
+    def writeCollectionElementRefs(self, element: ET.Element, collection: Collection):
+        refs = collection.getElementRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "ELEMENT-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "ELEMENT-REF", ref)
+
+    def writeCollectionSourceElementRefs(self, element: ET.Element, collection: Collection):
+        refs = collection.getSourceElementRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "SOURCE-ELEMENT-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "SOURCE-ELEMENT-REF", ref)
+
+    def writeCollection(self, element: ET.Element, collection: Collection):
+        if collection is not None:
+            child_element = ET.SubElement(element, "COLLECTION")
+            self.writeARElement(child_element, collection)
+            self.setChildElementOptionalLiteral(child_element, "AUTO-COLLECT", collection.getAutoCollect())
+            self.setChildElementOptionalLiteral(child_element, "ELEMENT-ROLE", collection.getElementRole())
+            self.writeCollectionElementRefs(child_element, collection)
+            self.writeCollectionSourceElementRefs(child_element, collection)
+
+    def writeKeywordClassifications(self, element: ET.Element, keyword: Keyword):
+        classifications = keyword.getClassifications()
+        if len(classifications) > 0:
+            child_element = ET.SubElement(element, "CLASSIFICATIONS")
+            for classification in classifications:
+                self.setChildElementOptionalLiteral(child_element, "CLASSIFICATION", classification)
+
+    def writeKeyword(self, element: ET.Element, keyword: Keyword):
+        if keyword is not None:
+            # self.logger.debug("Write Keyword <%s>" % keyword.getShortName())
+            child_element = ET.SubElement(element, "KEYWORD")
+            self.writeIdentifiable(child_element, keyword)
+            self.setChildElementOptionalLiteral(child_element, "ABBR-NAME", keyword.getAbbrName())
+            self.writeKeywordClassifications(child_element, keyword)
+
+    def writeKeywordSetKeywords(self, element: ET.Element, keyword_set: KeywordSet):
+        keywords = keyword_set.getKeywords()
+        if len(keywords) > 0:
+            child_element = ET.SubElement(element, "KEYWORDS")
+            for keyword in keywords:
+                if isinstance(keyword, Keyword):
+                    self.writeKeyword(child_element, keyword)
+                else:
+                    self.notImplemented("Unsupported Keyword <%s>" % type(keyword))
+
+    def writeKeywordSet(self, element: ET.Element, keyword_set: KeywordSet):
+        if keyword_set is not None:
+            self.logger.debug("Write KeywordSet <%s>" % keyword_set.getShortName())
+            child_element = ET.SubElement(element, "KEYWORD-SET")
+            self.writeARElement(child_element, keyword_set)
+            self.writeKeywordSetKeywords(child_element, keyword_set)
+
+    def writePortPrototypeBlueprint(self, element: ET.Element, blueprint: PortPrototypeBlueprint):
+        if blueprint is not None:
+            self.logger.debug("Write PortPrototypeBlueprint <%s>" % blueprint.getShortName())
+            child_element = ET.SubElement(element, "PORT-PROTOTYPE-BLUEPRINT")
+            self.writeARElement(child_element, blueprint)
+            self.setChildElementOptionalRefType(child_element, "INTERFACE-REF", blueprint.getInterfaceRef())
+
     def writeMacMulticastGroup(self, element: ET.Element, group: MacMulticastGroup):
         if group is not None:
             child_element = ET.SubElement(element, "MAC-MULTICAST-GROUP")
@@ -4231,6 +4426,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalNumericalValue(child_element, "LENGTH-EXP", dimension.getLengthExp())
         self.setChildElementOptionalNumericalValue(child_element, "LUMINOUS-INTENSITY-EXP", dimension.getLuminousIntensityExp())
         self.setChildElementOptionalNumericalValue(child_element, "MASS-EXP", dimension.getMassExp())
+        self.setChildElementOptionalNumericalValue(child_element, "MOLAR-AMOUNT-EXP", dimension.getMolarAmountExp())
         self.setChildElementOptionalNumericalValue(child_element, "TEMPERATURE-EXP", dimension.getTemperatureExp())
         self.setChildElementOptionalNumericalValue(child_element, "TIME-EXP", dimension.getTimeExp())
         self.setChildElementOptionalNumericalValue(child_element, "CURRENT-EXP", dimension.getCurrentExp())
@@ -4269,19 +4465,43 @@ class ARXMLWriter(AbstractARXMLWriter):
             for mapping in mappings:
                 self.setDataPrototypeMapping(child_element, mapping)
 
-    def setVariableAndParameterInterfaceMapping(self, element: ET.Element, mapping: VariableAndParameterInterfaceMapping):
-        self.logger.debug("set VariableAndParameterInterfaceMapping %s" % mapping.getShortName())
+    def writeVariableAndParameterInterfaceMapping(self, element: ET.Element, mapping: VariableAndParameterInterfaceMapping):
+        # self.logger.debug("Write VariableAndParameterInterfaceMapping %s" % mapping.getShortName())
         child_element = ET.SubElement(element, "VARIABLE-AND-PARAMETER-INTERFACE-MAPPING")
         self.writeIdentifiable(child_element, mapping)
         self.setDataPrototypeMappings(child_element, "DATA-MAPPINGS", mapping.getDataMappings())
 
+    def writeClientServerOperationMapping(self, element: ET.Element, mapping: ClientServerOperationMapping):
+        child_element = ET.SubElement(element, "CLIENT-SERVER-OPERATION-MAPPING")
+        self.setChildElementOptionalRefType(child_element, "FIRST-OPERATION-REF", mapping.getFirstOperationRef())
+        self.setChildElementOptionalRefType(child_element, "SECOND-OPERATION-REF", mapping.getSecondOperationRef())
+
+    def writeClientServerInterfaceMappingOperationMappings(self, element: ET.Element, mapping: ClientServerInterfaceMapping):
+        operation_mappings = mapping.getOperationMappings()
+        if len(operation_mappings) > 0:
+            child_element = ET.SubElement(element, "OPERATION-MAPPINGS")
+            for operation_mapping in operation_mappings:
+                if isinstance(operation_mapping, ClientServerOperationMapping):
+                    self.writeClientServerOperationMapping(child_element, operation_mapping)
+                else:
+                    self.notImplemented("Unsupported Operation Mapping <%s>" % type(operation_mapping))
+
+    def writeClientServerInterfaceMapping(self, element: ET.Element, mapping: ClientServerInterfaceMapping):
+        # self.logger.debug("Read ClientServerInterfaceMapping %s" % mapping.getShortName())
+        if mapping is not None:
+            child_element = ET.SubElement(element, "CLIENT-SERVER-INTERFACE-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.writeClientServerInterfaceMappingOperationMappings(child_element, mapping)
+
     def writePortInterfaceMappings(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
         mappings = mapping_set.getPortInterfaceMappings()
         if len(mappings) > 0:
             child_element = ET.SubElement(element, "PORT-INTERFACE-MAPPINGS")
             for mapping in mappings:
                 if isinstance(mapping, VariableAndParameterInterfaceMapping):
-                    self.setVariableAndParameterInterfaceMapping(child_element, mapping)
+                    self.writeVariableAndParameterInterfaceMapping(child_element, mapping)
+                elif isinstance(mapping, ClientServerInterfaceMapping):
+                    self.writeClientServerInterfaceMapping(child_element, mapping)
                 else:
                     self.notImplemented("Unsupported PortInterfaceMapping <%s>" % type(mapping))
 
@@ -4530,10 +4750,47 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "ETHERNET-FRAME")
         self.writeFrame(child_element, frame)
 
-    def writeLifeCycleInfoSet(self, element: ET.Element, set: LifeCycleInfoSet):
-        self.logger.debug("Write LifeCycleInfoSet %s" % set.getShortName())
-        child_element = ET.SubElement(element, "LIFE-CYCLE-INFO-SET")
-        self.writeIdentifiable(child_element, set)
+    def setLifeCyclePeriod(self, element: ET.Element, key: str, period: LifeCyclePeriod):
+        if period is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalRevisionLabelString(child_element, "AR-RELEASE-VERSION", period.getArReleaseVersion())
+
+    def writeLifeCycleInfoUseInsteadRefs(self, element: ET.Element, info: LifeCycleInfo):
+        refs = info.getUseInsteadRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "USE-INSTEAD-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "USE-INSTEAD-REF", ref)
+
+    def writeLifeCycleInfo(self, element: ET.Element, info: LifeCycleInfo):
+        if info is not None:
+            child_element = ET.SubElement(element, "LIFE-CYCLE-INFO")
+            self.writeARObjectAttributes(child_element, info)
+            self.setChildElementOptionalRefType(child_element, "LC-OBJECT-REF", info.getLcObjectRef())
+            self.setChildElementOptionalRefType(child_element, "LC-STATE-REF", info.getLcStateRef())
+            self.setLifeCyclePeriod(child_element, "PERIOD-BEGIN", info.getPeriodBegin())
+            self.writeDocumentationBlock(child_element, "REMARK", info.getRemark())
+            self.writeLifeCycleInfoUseInsteadRefs(child_element, info)
+
+    def writeLifeCycleInfoSetLifeCycleInfos(self, element: ET.Element, info_set: LifeCycleInfoSet):
+        infos = info_set.getLifeCycleInfos()
+        if len(infos) > 0:
+            child_element = ET.SubElement(element, "LIFE-CYCLE-INFOS")
+            for info in infos:
+                if isinstance(info, LifeCycleInfo):
+                    self.writeLifeCycleInfo(child_element, info)
+                else:
+                    self.notImplemented("Unsupported Life Cycle Info <%s>" % type(info))
+
+    def writeLifeCycleInfoSet(self, element: ET.Element, info_set: LifeCycleInfoSet):
+        if info_set is not None:
+            self.logger.debug("Write LifeCycleInfoSet %s" % info_set.getShortName())
+            child_element = ET.SubElement(element, "LIFE-CYCLE-INFO-SET")
+            self.writeIdentifiable(child_element, info_set)
+            self.setChildElementOptionalRefType(child_element, "DEFAULT-LC-STATE-REF", info_set.getDefaultLcStateRef())
+            self.writeLifeCycleInfoSetLifeCycleInfos(child_element, info_set)
+            self.setChildElementOptionalRefType(child_element, "USED-LIFE-CYCLE-STATE-DEFINITION-GROUP-REF",
+                                                info_set.getUsedLifeCycleStateDefinitionGroupRef())
 
     def writeDiagnosticConnectionFunctionalRequestRefs(self, element: ET.Element, connection: DiagnosticConnection):
         refs = connection.getFunctionalRequestRefs()
@@ -5191,6 +5448,12 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeSystemSignalGroup(element, ar_element)
         elif isinstance(ar_element, FlexrayCluster):
             self.writeFlexrayCluster(element, ar_element)
+        elif isinstance(ar_element, Collection):
+            self.writeCollection(element, ar_element)
+        elif isinstance(ar_element, KeywordSet):
+            self.writeKeywordSet(element, ar_element)
+        elif isinstance(ar_element, PortPrototypeBlueprint):
+            self.writePortPrototypeBlueprint(element, ar_element)
         else:
             self.notImplemented("Unsupported Elements of ARPackage <%s>" % type(ar_element))