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

armodel/writer/arxml_writer.py

@@ -1,7 +1,7 @@
 import xml.etree.cElementTree as ET
 from typing import List
 
-from ..models.M2.MSR.AsamHdo.AdminData import AdminData
+from ..models.M2.MSR.AsamHdo.AdminData import AdminData, DocRevision, Modification
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition, SwBaseType
 from ..models.M2.MSR.AsamHdo.ComputationMethod import Compu, CompuConst, CompuConstContent, CompuConstFormulaContent, CompuConstNumericContent
 from ..models.M2.MSR.AsamHdo.ComputationMethod import CompuConstTextContent, CompuMethod, CompuNominatorDenominator, CompuScale
@@ -62,9 +62,20 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.Execut
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import ExecutionOrderConstraint
 from ..models.M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger
 from ..models.M2.AUTOSARTemplates.DiagnosticExtract.DiagnosticContribution import DiagnosticServiceTable
-from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue
+from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucDefinitionElement
+from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucInstanceReferenceValue
 from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue
-from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
+from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucReferenceValue, EcucTextualParamValue, EcucValueCollection, EcucModuleDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucAbstractConfigurationClass, EcucAbstractExternalReferenceDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucFunctionNameDef, EcucReferenceDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucAbstractInternalReferenceDef, EcucAbstractReferenceDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucAbstractStringParamDef, EcucBooleanParamDef, EcucSymbolicNameReferenceDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucEnumerationLiteralDef, EcucValueConfigurationClass
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucCommonAttributes, EcucParameterDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucChoiceContainerDef, EcucEnumerationParamDef, EcucFloatParamDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucIntegerParamDef, EcucStringParamDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucContainerDef
+from ..models.M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucMultiplicityConfigurationClass, EcucParamConfContainerDef
 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
@@ -107,8 +118,9 @@ 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 ModeDeclarationMapping, ModeDeclarationMappingSet
 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 ClientServerOperation, DataInterface, ModeInterfaceMapping
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import DataPrototypeMapping, ModeSwitchInterface, ParameterInterface
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import PortInterface, PortInterfaceMappingSet, SenderReceiverInterface
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import TriggerInterface, VariableAndParameterInterfaceMapping
@@ -248,7 +260,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setSdg(child_element, sdg_item)
             self.writeSdgSdxRefs(child_element, sdg)
             
-    def writeSdgs(self, parent: ET.Element, admin_data: AdminData):
+    def writeAdminDataSdgs(self, parent: ET.Element, admin_data: AdminData):
         sdgs = admin_data.getSdgs()
         if len(sdgs) > 0:
             sdgs_tag = ET.SubElement(parent, "SDGS")
@@ -309,12 +321,51 @@ class ARXMLWriter(AbstractARXMLWriter):
             for l10 in paragraph.getL10s():
                 self.setLPlainText(child_element, l10)
 
+    def writeModification(self, element: ET.Element, modification: Modification):
+        if modification is not None:
+            child_element = ET.SubElement(element, "MODIFICATION")
+            self.setMultiLanguageOverviewParagraph(child_element, "CHANGE", modification.getChange())
+            self.setMultiLanguageOverviewParagraph(child_element, "REASON", modification.getReason())
+
+    def writeDocRevisionModifications(self, element: ET.Element, revision: DocRevision):
+        modifications = revision.getModifications()
+        if len(modifications) > 0:
+            child_element = ET.SubElement(element, "MODIFICATIONS")
+            for modification in modifications:
+                if isinstance(modification, Modification):
+                    self.writeModification(child_element, modification)
+                else:
+                    self.notImplemented("Unsupported Modification <%s>" % type(modification))
+
+    def writeDocRevision(self, element: ET.Element, revision: DocRevision):
+        if revision is not None:
+            child_element = ET.SubElement(element, "DOC-REVISION")
+            # self.setChildElementOptionalDataTime(child_element, "DATE", revision.getDate())
+            # self.setChildElementOptionalLiteral(child_element, "ISSUED-BY", revision.getIssuedBy())
+            self.setChildElementOptionalRevisionLabelString(child_element, "REVISION-LABEL", revision.getRevisionLabel())
+            self.setChildElementOptionalLiteral(child_element, "STATE", revision.getState())
+            self.setChildElementOptionalLiteral(child_element, "ISSUED-BY", revision.getIssuedBy())
+            self.setChildElementOptionalDataTime(child_element, "DATE", revision.getDate())
+            self.writeDocRevisionModifications(child_element, revision)
+
+    def writeAdminDataDocRevisions(self, element: ET.Element, admin_data: AdminData):
+        revisions = admin_data.getDocRevisions()
+        if len(revisions) > 0:
+            child_element = ET.SubElement(element, "DOC-REVISIONS")
+            for revision in revisions:
+                if isinstance(revision, DocRevision):
+                    self.writeDocRevision(child_element, revision)
+                else:
+                    self.notImplemented("Unsupported DocRevision <%s>" % type(revision))
+
     def setAdminData(self, element: ET.Element, admin_data: AdminData):
         if admin_data is not None:
+            self.logger.debug("Write AdminData")
             child_element = ET.SubElement(element, "ADMIN-DATA")
             self.setChildElementOptionalLiteral(child_element, "LANGUAGE", admin_data.getLanguage())
             self.setMultiLanguagePlainText(child_element, "USED-LANGUAGES", admin_data.getUsedLanguages())
-            self.writeSdgs(child_element, admin_data)
+            self.writeAdminDataSdgs(child_element, admin_data)
+            self.writeAdminDataDocRevisions(child_element, admin_data)
 
     def writeIdentifiable(self, element: ET.Element, identifiable: Identifiable):
         self.writeMultilanguageReferrable(element, identifiable)
@@ -327,41 +378,41 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeARElement(self, parent: ET.Element, ar_element: ARElement):
         self.writeIdentifiable(parent, ar_element)
 
-    def setTransmissionAcknowledgementRequest(self, element: ET.Element, acknowledge: TransmissionAcknowledgementRequest):
+    def writeTransmissionAcknowledgementRequest(self, element: ET.Element, acknowledge: TransmissionAcknowledgementRequest):
         if (acknowledge is not None):
             child_element = ET.SubElement(element, "TRANSMISSION-ACKNOWLEDGE")
             self.writeARObjectAttributes(child_element, acknowledge)
             if acknowledge.timeout is not None:
                 self.setChildElementOptionalFloatValue(child_element, "TIMEOUT", acknowledge.timeout)
 
-    def setSenderComSpec(self, element: ET.Element, com_spec: SenderComSpec):
+    def writeSenderComSpec(self, element: ET.Element, com_spec: SenderComSpec):
         representations = com_spec.getCompositeNetworkRepresentations()
         if len(representations) > 0:
             child_element = ET.SubElement(element, "COMPOSITE-NETWORK-REPRESENTATIONS")
             for representation in representations:
-                self.setCompositeNetworkRepresentation(child_element, representation)
+                self.writeCompositeNetworkRepresentation(child_element, representation)
         self.setChildElementOptionalRefType(element, "DATA-ELEMENT-REF", com_spec.getDataElementRef())
         self.setSwDataDefProps(element, "NETWORK-REPRESENTATION", com_spec.getNetworkRepresentation())
         self.setChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE", com_spec.getHandleOutOfRange())
-        self.setTransmissionAcknowledgementRequest(element, com_spec.getTransmissionAcknowledge())
+        self.writeTransmissionAcknowledgementRequest(element, com_spec.getTransmissionAcknowledge())
         self.setChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION", com_spec.getUsesEndToEndProtection())
 
-    def setNonqueuedSenderComSpec(self, element: ET.Element, com_spec: NonqueuedSenderComSpec):
+    def writeNonqueuedSenderComSpec(self, element: ET.Element, com_spec: NonqueuedSenderComSpec):
         child_element = ET.SubElement(element, "NONQUEUED-SENDER-COM-SPEC")
         self.writeARObjectAttributes(child_element, com_spec)
-        self.setSenderComSpec(child_element, com_spec)
+        self.writeSenderComSpec(child_element, com_spec)
         self.setValueSpecification(child_element, "INIT-VALUE", com_spec.getInitValue())
 
-    def setServerComSpec(self, element: ET.Element, com_spec: ServerComSpec):
+    def writeServerComSpec(self, element: ET.Element, com_spec: ServerComSpec):
         child_element = ET.SubElement(element, "SERVER-COM-SPEC")
         self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "OPERATION-REF", com_spec.getOperationRef())
         self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH", com_spec.getQueueLength())
 
-    def setQueuedSenderComSpec(self, element: ET.Element, com_spec: QueuedSenderComSpec):
+    def writeQueuedSenderComSpec(self, element: ET.Element, com_spec: QueuedSenderComSpec):
         child_element = ET.SubElement(element, "QUEUED-SENDER-COM-SPEC")
         self.writeARObjectAttributes(child_element, com_spec)
-        self.setSenderComSpec(child_element, com_spec)
+        self.writeSenderComSpec(child_element, com_spec)
 
     def setModeSwitchedAckRequest(self, element: ET.Element, key: str, request: ModeSwitchedAckRequest):
         if request is not None:
@@ -369,7 +420,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeARObjectAttributes(child_element, request)
             self.setChildElementOptionalTimeValue(child_element, "TIMEOUT", request.getTimeout())
 
-    def setModeSwitchSenderComSpec(self, element: ET.Element, com_spec: ModeSwitchSenderComSpec):
+    def writeModeSwitchSenderComSpec(self, element: ET.Element, com_spec: ModeSwitchSenderComSpec):
         child_element = ET.SubElement(element, "MODE-SWITCH-SENDER-COM-SPEC")
         self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.getModeGroupRef())
@@ -378,13 +429,13 @@ class ARXMLWriter(AbstractARXMLWriter):
     
     def writePPortComSpec(self, com_specs_tag: ET.Element, com_spec: PPortComSpec):
         if isinstance(com_spec, NonqueuedSenderComSpec):
-            self.setNonqueuedSenderComSpec(com_specs_tag, com_spec)
+            self.writeNonqueuedSenderComSpec(com_specs_tag, com_spec)
         elif isinstance(com_spec, ServerComSpec):
-            self.setServerComSpec(com_specs_tag, com_spec)
+            self.writeServerComSpec(com_specs_tag, com_spec)
         elif isinstance(com_spec, QueuedSenderComSpec):
-            self.setQueuedSenderComSpec(com_specs_tag, com_spec)
+            self.writeQueuedSenderComSpec(com_specs_tag, com_spec)
         elif isinstance(com_spec, ModeSwitchSenderComSpec):
-            self.setModeSwitchSenderComSpec(com_specs_tag, com_spec)
+            self.writeModeSwitchSenderComSpec(com_specs_tag, com_spec)
         else:
             self.notImplemented("Unsupported PPortComSpec %s" % type(com_spec))
 
@@ -395,7 +446,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF", iref.target_data_prototype_ref)
         return iref
 
-    def setCompositeNetworkRepresentation(self, element: ET.Element, representation: CompositeNetworkRepresentation):
+    def writeCompositeNetworkRepresentation(self, element: ET.Element, representation: CompositeNetworkRepresentation):
         if representation is not None:
             self.logger.debug("setCompositeNetworkRepresentation")
             child_element = ET.SubElement(element, "COMPOSITE-NETWORK-REPRESENTATION")
@@ -407,7 +458,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         if len(representations) > 0:
             child_element = ET.SubElement(element, "COMPOSITE-NETWORK-REPRESENTATIONS")
             for representation in representations:
-                self.setCompositeNetworkRepresentation(child_element, representation)
+                self.writeCompositeNetworkRepresentation(child_element, representation)
         self.setChildElementOptionalRefType(element, "DATA-ELEMENT-REF", com_spec.getDataElementRef())
         self.setSwDataDefProps(element, "NETWORK-REPRESENTATION", com_spec.getNetworkRepresentation())
         self.setChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE", com_spec.getHandleOutOfRange())
@@ -1246,7 +1297,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPOSITION-REF", ref.getContextCompositionRef())
             self.setChildElementOptionalRefType(child_element, "TARGET-COMPONENT-REF", ref.getTargetComponentRef())
 
-    def setVariableAccess(self, element: ET.Element, access: VariableAccess):
+    def writeVariableAccess(self, element: ET.Element, access: VariableAccess):
         child_element = ET.SubElement(element, "VARIABLE-ACCESS")
         self.writeIdentifiable(child_element, access)
         self.setAutosarVariableRef(child_element, "ACCESSED-VARIABLE", access.getAccessedVariableRef())
@@ -1273,35 +1324,35 @@ class ARXMLWriter(AbstractARXMLWriter):
         if len(accesses) > 0:
             child_element = ET.SubElement(element, "DATA-RECEIVE-POINT-BY-ARGUMENTS")
             for access in accesses:
-                self.setVariableAccess(child_element, access)
+                self.writeVariableAccess(child_element, access)
 
     def writeRunnableEntityDataSendPoints(self, element: ET.Element, entity: RunnableEntity):
         points = entity.getDataSendPoints()
         if len(points) > 0:
             child_element = ET.SubElement(element, "DATA-SEND-POINTS")
             for point in points:
-                self.setVariableAccess(child_element, point)
+                self.writeVariableAccess(child_element, point)
 
     def writeRunnableEntityDataReadAccesses(self, element: ET.Element, entity: RunnableEntity):
         accesses = entity.getDataReadAccesses()
         if len(accesses) > 0:
             child_element = ET.SubElement(element, "DATA-READ-ACCESSS")
             for access in accesses:
-                self.setVariableAccess(child_element, access)
+                self.writeVariableAccess(child_element, access)
 
     def writeRunnableEntityDataWriteAccesses(self, element: ET.Element, entity: RunnableEntity):
         accesses = entity.getDataWriteAccesses()
         if len(accesses) > 0:
             child_element = ET.SubElement(element, "DATA-WRITE-ACCESSS")
             for access in accesses:
-                self.setVariableAccess(child_element, access)
+                self.writeVariableAccess(child_element, access)
 
     def writeRunnableEntityReadLocalVariables(self, element: ET.Element, entity: RunnableEntity):
         variables = entity.getReadLocalVariables()
         if len(variables) > 0:
             child_element = ET.SubElement(element, "READ-LOCAL-VARIABLES")
             for access in variables:
-                self.setVariableAccess(child_element, access)
+                self.writeVariableAccess(child_element, access)
 
     def setROperationInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: ROperationInAtomicSwcInstanceRef):
         if iref is not None:
@@ -1341,7 +1392,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         if len(variables) > 0:
             child_element = ET.SubElement(element, "WRITTEN-LOCAL-VARIABLES")
             for access in variables:
-                self.setVariableAccess(child_element, access)
+                self.writeVariableAccess(child_element, access)
 
     def writeModeGroupInAtomicSwcInstanceRef(self, element: ET.Element, instance_ref: ModeGroupInAtomicSwcInstanceRef):
         self.setChildElementOptionalRefType(element, "BASE-REF", instance_ref.getBaseRef())
@@ -3938,6 +3989,279 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeARElement(child_element, blueprint)
             self.setChildElementOptionalRefType(child_element, "INTERFACE-REF", blueprint.getInterfaceRef())
 
+    def writeModeDeclarationMappingFirstModeRefs(self, element: ET.Element, mapping: ModeDeclarationMapping):
+        ref_links = mapping.getFirstModeRefs()
+        if len(ref_links) > 0:
+            child_element = ET.SubElement(element, "FIRST-MODE-REFS")
+            for ref_link in ref_links:
+                self.setChildElementOptionalRefType(child_element, "FIRST-MODE-REF", ref_link)
+
+    def writeModeDeclarationMapping(self, element: ET.Element, mapping: ModeDeclarationMapping):
+        # self.logger.debug("Read ModeDeclarationMapping <%s>" % mapping.getShortName())
+        if mapping is not None:
+            child_element = ET.SubElement(element, "MODE-DECLARATION-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.writeModeDeclarationMappingFirstModeRefs(child_element, mapping)
+            self.setChildElementOptionalRefType(child_element, "SECOND-MODE-REF", mapping.getSecondModeRef())
+
+    def writeModeDeclarationMappingSetModeDeclarationMappings(self, element: ET.Element, mapping_set: ModeDeclarationMappingSet):
+        mappings = mapping_set.getModeDeclarationMappings()
+        if len(mappings) > 0:
+            child_element = ET.SubElement(element, "MODE-DECLARATION-MAPPINGS")
+            for mapping in mappings:
+                if isinstance(mapping, ModeDeclarationMapping):
+                    self.writeModeDeclarationMapping(child_element, mapping)
+                else:
+                    self.notImplemented("Unsupported ModeDeclarationMapping <%s>" % type(mapping))
+
+    def writeModeDeclarationMappingSet(self, element: ET.Element, mapping_set: ModeDeclarationMappingSet):
+        if mapping_set is not None:
+            self.logger.debug("Write ModeDeclarationMappingSet <%s>" % mapping_set.getShortName())
+            child_element = ET.SubElement(element, "MODE-DECLARATION-MAPPING-SET")
+            self.writeARElement(child_element, mapping_set)
+            self.writeModeDeclarationMappingSetModeDeclarationMappings(element, mapping_set)
+
+    def writeEcucDefinitionElement(self, element: ET.Element, def_element: EcucDefinitionElement):
+        self.writeARElement(element, def_element)
+        self.setChildElementOptionalPositiveInteger(element, "LOWER-MULTIPLICITY", def_element.getLowerMultiplicity())
+        self.setChildElementOptionalPositiveInteger(element, "UPPER-MULTIPLICITY", def_element.getUpperMultiplicity())
+        self.setChildElementOptionalLiteral(element, "SCOPE", def_element.getScope())
+
+    def writeEcucModuleDefSupportedConfigVariants(self, element: ET.Element, module_def: EcucModuleDef):
+        variants = module_def.getSupportedConfigVariants()
+        if len(variants) > 0:
+            child_element = ET.SubElement(element, "SUPPORTED-CONFIG-VARIANTS")
+            for variant in variants:
+                self.setChildElementOptionalLiteral(child_element, "SUPPORTED-CONFIG-VARIANT", variant)
+
+    def writeEcucAbstractConfigurationClass(self, element: ET.Element, cfg_class: EcucAbstractConfigurationClass):
+        self.writeARObjectAttributes(element, cfg_class)
+        self.setChildElementOptionalLiteral(element, "CONFIG-CLASS", cfg_class.getConfigClass())
+        self.setChildElementOptionalLiteral(element, "CONFIG-VARIANT", cfg_class.getConfigVariant())
+
+    def writeEcucMultiplicityConfigurationClass(self, element: ET.Element, cfg_class: EcucMultiplicityConfigurationClass):
+        if cfg_class is not None:
+            child_element = ET.SubElement(element, "ECUC-MULTIPLICITY-CONFIGURATION-CLASS")
+            self.writeEcucAbstractConfigurationClass(child_element, cfg_class)
+
+    def setEcucMultiplicityConfigClasses(self, element: ET.Element, cfg_classes: List[EcucMultiplicityConfigurationClass]):
+        if len(cfg_classes) > 0:
+            child_element = ET.SubElement(element, "MULTIPLICITY-CONFIG-CLASSES")
+            for cfg_class in cfg_classes:
+                if isinstance(cfg_class, EcucMultiplicityConfigurationClass):
+                    self.writeEcucMultiplicityConfigurationClass(child_element, cfg_class)
+                else:
+                    self.notImplemented("Unsupported MultiplicityConfigClass <%s>" % type(cfg_class))
+
+    def writeEcucValueConfigurationClass(self, element: ET.Element, cfg_class: EcucValueConfigurationClass):
+        if cfg_class is not None:
+            child_element = ET.SubElement(element, "ECUC-VALUE-CONFIGURATION-CLASS")
+            self.writeEcucAbstractConfigurationClass(child_element, cfg_class)
+
+    def setEcuValueConfigurationClasses(self, element: ET.Element, cfg_classes: List[EcucValueConfigurationClass]):
+        if len(cfg_classes) > 0:
+            child_element = ET.SubElement(element, "VALUE-CONFIG-CLASSES")
+            for cfg_class in cfg_classes:
+                if isinstance(cfg_class, EcucValueConfigurationClass):
+                    self.writeEcucValueConfigurationClass(child_element, cfg_class)
+                else:
+                    self.notImplemented("Unsupported ValueConfigClass <%s>" % type(cfg_class))
+
+    def writeEcucCommonAttributes(self, element: ET.Element, common_attrs: EcucCommonAttributes):
+        self.writeEcucDefinitionElement(element, common_attrs)
+        self.setEcucMultiplicityConfigClasses(element, common_attrs.getMultiplicityConfigClasses())
+        self.setChildElementOptionalLiteral(element, "ORIGIN", common_attrs.getOrigin())
+        self.setChildElementOptionalBooleanValue(element, "POST-BUILD-VARIANT-MULTIPLICITY", common_attrs.getPostBuildVariantMultiplicity())
+        self.setChildElementOptionalBooleanValue(element, "POST-BUILD-VARIANT-VALUE", common_attrs.getPostBuildVariantValue())
+        self.setChildElementOptionalBooleanValue(element, "REQUIRES-INDEX", common_attrs.getRequiresIndex())
+        self.setEcuValueConfigurationClasses(element, common_attrs.getValueConfigClasses())
+
+    def writeEcucParameterDef(self, element: ET.Element, param_def: EcucParameterDef):
+        self.writeEcucCommonAttributes(element, param_def)
+        self.setChildElementOptionalLiteral(element, "DERIVATION", param_def.getDerivation())
+        self.setChildElementOptionalBooleanValue(element, "SYMBOLIC-NAME-VALUE", param_def.getSymbolicNameValue())
+        self.setChildElementOptionalBooleanValue(element, "WITH-AUTO", param_def.getWithAuto())
+
+    def writeEcucBooleanParamDef(self, element: ET.Element, param_def: EcucBooleanParamDef):
+        if param_def is not None:
+            child_element = ET.SubElement(element, "ECUC-BOOLEAN-PARAM-DEF")
+            self.writeEcucParameterDef(child_element, param_def)
+            self.setChildElementOptionalBooleanValue(child_element, "DEFAULT-VALUE", param_def.getDefaultValue())
+
+    def writeEcucAbstractStringParamDef(self, element: ET.Element, param_def: EcucAbstractStringParamDef):
+        self.writeEcucParameterDef(element, param_def)
+        # self.setChildElementOptionalLiteral(element, "DEFAULT-VALUE", param_def.getDefaultValue())
+
+    def writeEcucStringParamDef(self, element: ET.Element, param_def: EcucStringParamDef):
+        if param_def is not None:
+            child_element = ET.SubElement(element, "ECUC-STRING-PARAM-DEF")
+            self.writeEcucAbstractStringParamDef(child_element, param_def)
+
+    def writeEcucIntegerParamDef(self, element: ET.Element, param_def: EcucIntegerParamDef):
+        if param_def is not None:
+            child_element = ET.SubElement(element, "ECUC-INTEGER-PARAM-DEF")
+            self.writeEcucParameterDef(child_element, param_def)
+            self.setChildElementOptionalIntegerValue(child_element, "DEFAULT-VALUE", param_def.getDefaultValue())
+            self.setChildElementOptionalIntegerValue(child_element, "MAX", param_def.getMax())
+            self.setChildElementOptionalIntegerValue(child_element, "MIN", param_def.getMin())
+
+    def writeEcucFloatParamDef(self, element: ET.Element, param_def: EcucFloatParamDef):
+        if param_def is not None:
+            child_element = ET.SubElement(element, "ECUC-FLOAT-PARAM-DEF")
+            self.writeEcucParameterDef(child_element, param_def)
+            self.setChildElementOptionalFloatValue(child_element, "DEFAULT-VALUE", param_def.getDefaultValue())
+            self.setChildLimitElement(child_element, "MAX", param_def.getMax())
+            self.setChildLimitElement(child_element, "MIN", param_def.getMin())
+
+    def writeEcucEnumerationLiteralDef(self, element: ET.Element, literal: EcucEnumerationLiteralDef):
+        if literal is not None:
+            child_element = ET.SubElement(element, "ECUC-ENUMERATION-LITERAL-DEF")
+            self.writeIdentifiable(child_element, literal)
+            self.setChildElementOptionalLiteral(child_element, "ORIGIN", literal.getOrigin())
+
+    def writeEcucEnumerationParamDefLiterals(self, element: ET.Element, param_def: EcucEnumerationParamDef):
+        literals = param_def.getLiterals()
+        if len(literals) > 0:
+            child_element = ET.SubElement(element, "LITERALS")
+            for literal in literals:
+                if isinstance(literal, EcucEnumerationLiteralDef):
+                    self.writeEcucEnumerationLiteralDef(child_element, literal)
+                else:
+                    self.notImplemented("Unsupported EnumerationLiteral <%s>" % type(literal))
+
+    def writeEcucEnumerationParamDef(self, element: ET.Element, param_def: EcucEnumerationParamDef):
+        if param_def is not None:
+            child_element = ET.SubElement(element, "ECUC-ENUMERATION-PARAM-DEF")
+            self.writeEcucParameterDef(child_element, param_def)
+            self.setChildElementOptionalLiteral(child_element, "DEFAULT-VALUE", param_def.getDefaultValue())
+            self.writeEcucEnumerationParamDefLiterals(child_element, param_def)
+
+    def writeEcucFunctionNameDef(self, element: ET.Element, param_def: EcucFunctionNameDef):
+        if param_def is not None:
+            child_element = ET.SubElement(element, "ECUC-FUNCTION-NAME-DEF")
+            self.writeEcucAbstractStringParamDef(child_element, param_def)
+
+            variants_tag = ET.SubElement(child_element, "ECUC-FUNCTION-NAME-DEF-VARIANTS")
+            cond_tag = ET.SubElement(variants_tag, "ECUC-FUNCTION-NAME-DEF-CONDITIONAL")
+            self.setChildElementOptionalLiteral(cond_tag, "DEFAULT-VALUE", param_def.getDefaultValue())
+            self.setChildElementOptionalIntegerValue(cond_tag, "MIN-LENGTH", param_def.getMinLength())
+            self.setChildElementOptionalIntegerValue(cond_tag, "MAX-LENGTH", param_def.getMaxLength())
+
+    def writeEcucContainerDefParameters(self, element: ET.Element, container_def: EcucParamConfContainerDef):
+        parameters = container_def.getParameters()
+        if len(parameters) > 0:
+            child_element = ET.SubElement(element, "PARAMETERS")
+            for parameter in parameters:
+                if isinstance(parameter, EcucBooleanParamDef):
+                    self.writeEcucBooleanParamDef(child_element, parameter)
+                elif isinstance(parameter, EcucStringParamDef):
+                    self.writeEcucStringParamDef(child_element, parameter)
+                elif isinstance(parameter, EcucIntegerParamDef):
+                    self.writeEcucIntegerParamDef(child_element, parameter)
+                elif isinstance(parameter, EcucFloatParamDef):
+                    self.writeEcucFloatParamDef(child_element, parameter)
+                elif isinstance(parameter, EcucEnumerationParamDef):
+                    self.writeEcucEnumerationParamDef(child_element, parameter)
+                elif isinstance(parameter, EcucFunctionNameDef):
+                    self.writeEcucFunctionNameDef(child_element, parameter)
+                else:
+                    self.notImplemented("Unsupported Parameter <%s>" % type(parameter))
+
+    def writeEcucContainerDef(self, element: ET.Element, container_def: EcucContainerDef):
+        self.writeEcucDefinitionElement(element, container_def)
+        self.setEcucMultiplicityConfigClasses(element, container_def.getMultiplicityConfigClasses())
+        self.setChildElementOptionalBooleanValue(element, "POST-BUILD-VARIANT-MULTIPLICITY", container_def.getPostBuildVariantMultiplicity())
+        self.setChildElementOptionalBooleanValue(element, "REQUIRES-INDEX", container_def.getRequiresIndex())
+        self.setChildElementOptionalBooleanValue(element, "MULTIPLE-CONFIGURATION-CONTAINER", container_def.getMultipleConfigurationContainer())
+
+    def writeEcucAbstractReferenceDef(self, element: ET.Element, reference: EcucAbstractReferenceDef):
+        self.writeEcucCommonAttributes(element, reference)
+        self.setChildElementOptionalBooleanValue(element, "WITH-AUTO", reference.getWithAuto())
+
+    def writeEcucAbstractInternalReferenceDef(self, element: ET.Element, reference: EcucAbstractInternalReferenceDef):
+        self.writeEcucAbstractReferenceDef(element, reference)
+        
+    def writeEcucSymbolicNameReferenceDef(self, element: ET.Element, reference: EcucSymbolicNameReferenceDef):
+        if reference is not None:
+            child_element = ET.SubElement(element, "ECUC-SYMBOLIC-NAME-REFERENCE-DEF")
+            self.writeEcucAbstractInternalReferenceDef(child_element, reference)
+            self.setChildElementOptionalRefType(child_element, "DESTINATION-REF", reference.getDestinationRef())
+
+    def writeEcucReferenceDef(self, element: ET.Element, reference: EcucReferenceDef):
+        if reference is not None:
+            child_element = ET.SubElement(element, "ECUC-REFERENCE-DEF")
+            self.writeEcucAbstractInternalReferenceDef(child_element, reference)
+            self.setChildElementOptionalRefType(child_element, "DESTINATION-REF", reference.getDestinationRef())
+
+    def writeEcucContainerDefReferences(self, element: ET.Element, container_def: EcucContainerDef):
+        references = container_def.getReferences()
+        if len(references) > 0:
+            child_element = ET.SubElement(element, "REFERENCES")
+            for reference in references:
+                if isinstance(reference, EcucSymbolicNameReferenceDef):
+                    self.writeEcucSymbolicNameReferenceDef(child_element, reference)
+                elif isinstance(reference, EcucReferenceDef):
+                    self.writeEcucReferenceDef(child_element, reference)
+                else:
+                    self.notImplemented("Unsupported Reference <%s>" % type(reference))
+
+    def writeEcucContainerDefSubContainers(self, element: ET.Element, container_def: EcucParamConfContainerDef):
+        sub_containers = container_def.getSubContainers()
+        if len(sub_containers) > 0:
+            child_element = ET.SubElement(element, "SUB-CONTAINERS")
+            for sub_container in sub_containers:
+                if isinstance(sub_container, EcucParamConfContainerDef):
+                    self.writeEcucParamConfContainerDef(child_element, sub_container)
+                elif isinstance(sub_container, EcucChoiceContainerDef):
+                    self.writeEcucChoiceContainerDef(child_element, sub_container)
+                else:
+                    self.notImplemented("Unsupported SubContainer <%s>" % type(sub_container))
+
+    def writeEcucParamConfContainerDef(self, element: ET.Element, container_def: EcucParamConfContainerDef):
+        if container_def is not None:
+            child_element = ET.SubElement(element, "ECUC-PARAM-CONF-CONTAINER-DEF")
+            self.writeEcucContainerDef(child_element, container_def)
+            self.writeEcucContainerDefParameters(child_element, container_def)
+            self.writeEcucContainerDefReferences(child_element, container_def)
+            self.writeEcucContainerDefSubContainers(child_element, container_def)
+
+    def writeEcucChoiceContainerDefChoices(self, element: ET.Element, container_def: EcucChoiceContainerDef):
+        choices = container_def.getChoices()
+        if len(choices) > 0:
+            child_element = ET.SubElement(element, "CHOICES")
+            for choice in choices:
+                if isinstance(choice, EcucParamConfContainerDef):
+                    self.writeEcucParamConfContainerDef(child_element, choice)
+                else:
+                    self.notImplemented("Unsupported Choice <%s>" % type(choice))
+
+    def writeEcucChoiceContainerDef(self, element: ET.Element, container_def: EcucChoiceContainerDef):
+        if container_def is not None:
+            child_element = ET.SubElement(element, "ECUC-CHOICE-CONTAINER-DEF")
+            self.writeEcucContainerDef(child_element, container_def)
+            self.writeEcucChoiceContainerDefChoices(child_element, container_def)
+
+    def writeEcucModuleDefContainers(self, element: ET.Element, module_def: EcucModuleDef):
+        container_defs = module_def.getContainers()
+        if len(container_defs) > 0:
+            child_element = ET.SubElement(element, "CONTAINERS")
+            for container_def in container_defs:
+                if isinstance(container_def, EcucParamConfContainerDef):
+                    self.writeEcucParamConfContainerDef(child_element, container_def)
+                elif isinstance(container_def, EcucChoiceContainerDef):
+                    self.writeEcucChoiceContainerDef(child_element, container_def)
+                else:
+                    self.notImplemented("Unsupported Container <%s>" % type(container_def))
+
+    def writeEcucModuleDef(self, element: ET.Element, module_def: EcucModuleDef):
+        if module_def is not None:
+            self.logger.debug("Write EcucModuleDef <%s>" % module_def.getShortName())
+            child_element = ET.SubElement(element, "ECUC-MODULE-DEF")
+            self.writeEcucDefinitionElement(child_element, module_def)
+            self.setChildElementOptionalBooleanValue(child_element, "POST-BUILD-VARIANT-SUPPORT", module_def.getPostBuildVariantSupport())
+            self.writeEcucModuleDefSupportedConfigVariants(child_element, module_def)
+            self.writeEcucModuleDefContainers(child_element, module_def)
+
     def writeMacMulticastGroup(self, element: ET.Element, group: MacMulticastGroup):
         if group is not None:
             child_element = ET.SubElement(element, "MAC-MULTICAST-GROUP")
@@ -4493,6 +4817,21 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeIdentifiable(child_element, mapping)
             self.writeClientServerInterfaceMappingOperationMappings(child_element, mapping)
 
+    def writeModeInterfaceMappingModeMapping(self, element: ET.Element, mapping: ModeInterfaceMapping):
+        mode_mapping = mapping.getModeMapping()
+        if mode_mapping is not None:
+            child_element = ET.SubElement(element, "MODE-MAPPING")
+            self.setChildElementOptionalRefType(child_element, "FIRST-MODE-GROUP-REF", mode_mapping.getFirstModeGroupRef())
+            self.setChildElementOptionalRefType(child_element, "MODE-DECLARATION-MAPPING-SET-REF", mode_mapping.getModeDeclarationMappingSetRef())
+            self.setChildElementOptionalRefType(child_element, "SECOND-MODE-GROUP-REF", mode_mapping.getSecondModeGroupRef())
+
+    def writeModeInterfaceMapping(self, element: ET.Element, mapping: ModeInterfaceMapping):
+        # self.logger.debug("Read ClientServerInterfaceMapping %s" % mapping.getShortName())
+        if mapping is not None:
+            child_element = ET.SubElement(element, "MODE-INTERFACE-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.writeModeInterfaceMappingModeMapping(child_element, mapping)
+
     def writePortInterfaceMappings(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
         mappings = mapping_set.getPortInterfaceMappings()
         if len(mappings) > 0:
@@ -4502,6 +4841,8 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.writeVariableAndParameterInterfaceMapping(child_element, mapping)
                 elif isinstance(mapping, ClientServerInterfaceMapping):
                     self.writeClientServerInterfaceMapping(child_element, mapping)
+                elif isinstance(mapping, ModeInterfaceMapping):
+                    self.writeModeInterfaceMapping(child_element, mapping)
                 else:
                     self.notImplemented("Unsupported PortInterfaceMapping <%s>" % type(mapping))
 
@@ -5454,6 +5795,12 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeKeywordSet(element, ar_element)
         elif isinstance(ar_element, PortPrototypeBlueprint):
             self.writePortPrototypeBlueprint(element, ar_element)
+        elif isinstance(ar_element, ModeDeclarationMappingSet):
+            self.writeModeDeclarationMappingSet(element, ar_element)
+        elif isinstance(ar_element, EcucModuleDef):
+            self.writeEcucModuleDef(element, ar_element)
+        elif isinstance(ar_element, EcucModuleConfigurationValues):
+            self.writeEcucModuleConfigurationValues(element, ar_element)
         else:
             self.notImplemented("Unsupported Elements of ARPackage <%s>" % type(ar_element))
 

{armodel-1.8.0.dist-info → armodel-1.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: armodel
-Version: 1.8.0
+Version: 1.8.1
 Summary: the python arxml parser
 Home-page: http://github.com/melodypapa/py-armodel
 Author: melodypapa
@@ -602,3 +602,19 @@ Fix the attribute intervalType of **Limit** is empty issue.
    * findVariableDataPrototype
    * findImplementationDataType
 
+**Version 1.8.1**
+
+1. To support the following AR Element:
+   * MODE-DECLARATION-MAPPING-SET
+   * MODE-INTERFACE-MAPPING
+   * ECUC-MODULE-DEF
+   * DOC-REVISION
+   * ECUC-PARAM-CONF-CONTAINER-DEF
+   * ECUC-BOOLEAN-PARAM-DEF
+   * ECUC-STRING-PARAM-DEF
+   * ECUC-INTEGER-PARAM-DEF
+   * ECUC-FLOAT-PARAM-DEF
+   * ECUC-ENUMERATION-PARAM-DEF
+2. Same short name with different type can be added and located.
+
+