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

armodel/parser/arxml_parser.py

@@ -2,15 +2,25 @@ from typing import List
 import xml.etree.ElementTree as ET
 import os
 
+from ..models.ar_ref import RefType
+from ..models.m2.autosar_templates.common_structure.implementation import ImplementationProps
 from ..models.m2.autosar_templates.common_structure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, NumericalValueSpecification, RecordValueSpecification, TextValueSpecification, ValueSpecification
-from ..models.m2.autosar_templates.sw_component_template.components.instance_refs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
+from ..models.m2.autosar_templates.generic_structure.abstract_structure import AnyInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.composition.instance_refs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.port_interface.instance_refs import ApplicationCompositeElementInPortInterfaceInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.instance_refs_usage import AutosarParameterRef, AutosarVariableRef, VariableInAtomicSWCTypeInstanceRef
+from ..models.m2.autosar_templates.system_template.instance_refs import VariableDataPrototypeInSystemInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.components.instance_refs import InnerPortGroupInCompositionInstanceRef, PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
 from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior import RunnableEntityArgument
-from ..models.m2.msr.data_dictionary.data_def_properties import SwDataDefProps
+from ..models.m2.autosar_templates.sw_component_template.components import PortGroup, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
+from ..models.m2.autosar_templates.sw_component_template.composition import AssemblySwConnector, CompositionSwComponentType, DelegationSwConnector
+
 from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.mode_declaration_group import ModeAccessPoint, ModeSwitchPoint
 from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.server_call import ServerCallPoint
-from ..models.m2.autosar_templates.sw_component_template.communication import ClientComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, QueuedSenderComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
+from ..models.m2.autosar_templates.sw_component_template.communication import ClientComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, ParameterRequireComSpec, QueuedSenderComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
 from ..models.fibex.lin_communication import LinFrameTriggering
 from ..models.fibex.fibex_core.core_topology import AbstractCanCluster, CanPhysicalChannel, CommunicationCluster, LinPhysicalChannel, PhysicalChannel
+from ..models.m2.msr.data_dictionary.data_def_properties import SwDataDefProps
 from ..models.m2.msr.documentation.block_elements import DocumentationBlock
 from ..models.m2.autosar_templates.system_template import System, SystemMapping
 from ..models.m2.autosar_templates.system_template.data_mapping import SenderReceiverToSignalGroupMapping, SenderReceiverToSignalMapping
@@ -22,7 +32,7 @@ from ..models.fibex.fibex_core.core_communication import Frame, FrameTriggering,
 from ..models.internal_behavior import IncludedDataTypeSet
 from ..models.timing import ExecutionOrderConstraint, TimingExtension
 from ..models.bsw_module_template import BswModeSenderPolicy
-from ..models.m2.autosar_templates.sw_component_template.port_interface import InvalidationPolicy, ModeSwitchInterface, PortInterface
+from ..models.m2.autosar_templates.sw_component_template.port_interface import InvalidationPolicy, ModeSwitchInterface, ParameterInterface, PortInterface
 from ..models.common_structure import IncludedModeDeclarationGroupSet, MemorySection, ModeDeclarationGroup, ModeDeclarationGroupPrototype, ModeRequestTypeMap
 from ..models.implementation import BswImplementation, EngineeringObject
 from ..models.general_structure import MultilanguageReferrable
@@ -37,22 +47,18 @@ from ..models.service_mapping import RoleBasedPortAssignment
 from ..models.ar_package import AUTOSAR, ARPackage
 from ..models.ar_object import ARLiteral
 from ..models.service_needs import RoleBasedDataAssignment
-from ..models.ar_ref import AnyInstanceRef, ApplicationCompositeElementInPortInterfaceInstanceRef, InnerPortGroupInCompositionInstanceRef, RefType, VariableDataPrototypeInSystemInstanceRef, VariableInAtomicSWCTypeInstanceRef, AutosarParameterRef
-from ..models.sw_component import AtomicSwComponentType, CompositionSwComponentType, PortAPIOption, PortDefinedArgumentValue, PortGroup, ServiceDependency, SwComponentType, SwcServiceDependency
-from ..models.data_prototype import ApplicationCompositeElementDataPrototype, AutosarDataPrototype, DataPrototype, ParameterDataPrototype, VariableDataPrototype
+from ..models.sw_component import AtomicSwComponentType, PortAPIOption, PortDefinedArgumentValue, ServiceDependency,  SwcServiceDependency
+from ..models.m2.autosar_templates.sw_component_template.data_type.data_prototypes import ApplicationCompositeElementDataPrototype, AutosarDataPrototype, DataPrototype, ParameterDataPrototype, VariableDataPrototype
 from ..models.port_prototype import ModeSwitchReceiverComSpec, QueuedReceiverComSpec
 from ..models.annotation import Annotation, GeneralAnnotation
 from ..models.global_constraints import InternalConstrs, DataConstr, DataConstrRule, PhysConstrs
 
 from ..models import SwcInternalBehavior, RunnableEntity, RTEEvent, OperationInvokedEvent, DataReceivedEvent, RVariableInAtomicSwcInstanceRef
 from ..models import SwcModeSwitchEvent, RModeInAtomicSwcInstanceRef
-from ..models import AutosarVariableRef, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef
-from ..models import ImplementationDataType,  SwPointerTargetProps, DataTypeMappingSet, DataTypeMap, ImplementationDataTypeElement
-from ..models import RPortPrototype, PPortPrototype
+
+from ..models import ImplementationDataType,  SwPointerTargetProps, DataTypeMappingSet, DataTypeMap
 from ..models import SenderReceiverInterface, ClientServerInterface, ClientServerOperation, ArgumentDataPrototype
 from ..models import Identifiable, AdminData, Sdg, Sd
-from ..models import AssemblySwConnector, PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
-from ..models import DelegationSwConnector
 from ..models import CompuMethod, CompuScale, CompuScales, Compu, CompuConst, CompuConstTextContent, CompuScaleConstantContents, CompuScaleRationalFormula, CompuRationalCoeffs, CompuNominatorDenominator
 from ..models import InternalBehavior, ExecutableEntity
 from ..models import Implementation, Code, AutosarEngineeringObject, ResourceConsumption
@@ -547,7 +553,7 @@ class ARXMLParser(AbstractARXMLParser):
             short_name = self.getShortName(child_element)
             memory_section = consumption.createMemorySection(short_name)
             self.readIdentifiable(child_element, memory_section)
-            memory_section.alignment = self.getChildElementOptionalLiteral(child_element, "ALIGNMENT")
+            memory_section.setAlignment(self.getChildElementOptionalLiteral(child_element, "ALIGNMENT"))
             self.readMemorySectionOptions(child_element, memory_section)
             memory_section.size = self.getChildElementOptionalNumericalValue(child_element, "SIZE")
             memory_section.swAddrMethodRef = self.getChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF")
@@ -1057,16 +1063,26 @@ class ARXMLParser(AbstractARXMLParser):
         self.readAutosarDataType(element, data_type)
         self.readImplementationDataTypeElements(element, data_type)
         data_type.setTypeEmitter(self.getChildElementOptionalLiteral(element, "TYPE-EMITTER"))
-        if (data_type.category == ImplementationDataType.CATEGORY_ARRAY):
+        if (data_type.getCategory().getValue() == ImplementationDataType.CATEGORY_ARRAY):
             if (len(data_type.getImplementationDataTypeElements()) < 1):
                 self._raiseError("Array Sub-Element of <%s> do not defined." % data_type.short_name)
+
             array_sub_element = data_type.getImplementationDataTypeElements()[0]
-            if (array_sub_element.category == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
+            if (array_sub_element.category.getValue() == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
                 data_type.setArrayElementType(array_sub_element.swDataDefProps.implementationDataTypeRef.value)
-            elif (array_sub_element.category == ImplementationDataType.CATEGORY_TYPE_VALUE):  # TODO: fix 
+            elif (array_sub_element.category.getValue() == ImplementationDataType.CATEGORY_TYPE_VALUE):  # TODO: fix 
                 return
             else:
-                self._raiseError("The category <%s> of array sub-element <%s> does not support." % (array_sub_element.category, data_type.short_name))
+                self._raiseError("The category <%s> of array sub-element <%s> does not support." % (array_sub_element.category.value, data_type.short_name))
+        elif (data_type.getCategory().getValue() == ImplementationDataType.CATEGORY_TYPE_STRUCTURE):
+            if (len(data_type.getImplementationDataTypeElements()) < 1):
+                self._raiseError("Structure Sub-Element of <%s> do not defined." % data_type.short_name)
+            self.readImplementationDataTypeSymbolProps(element, data_type)
+            struct_sub_element = data_type.getImplementationDataTypeElements()[0]
+            if (struct_sub_element.getCategory().getValue() == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
+                data_type.setStructElementType(struct_sub_element.getSwDataDefProps().getImplementationDataTypeRef().getValue())
+            else:
+                self._raiseError("The category <%s> of structure sub-element <%s> does not support." % (struct_sub_element.category.value, data_type.short_name))
 
     def readBaseTypeDirectDefinition(self, element: ET.Element, definition: BaseTypeDirectDefinition):
         definition.base_type_size = self.getChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE")
@@ -1085,8 +1101,8 @@ class ARXMLParser(AbstractARXMLParser):
         iref = None
         if child_element is not None:
             iref = ApplicationCompositeElementInPortInterfaceInstanceRef()
-            iref.root_data_prototype_ref = self.getChildElementOptionalRefType(child_element, "ROOT-DATA-PROTOTYPE-REF")
-            iref.target_data_prototype_ref = self.getChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF")
+            iref.setRootDataPrototypeRef(self.getChildElementOptionalRefType(child_element, "ROOT-DATA-PROTOTYPE-REF"))\
+                .setTargetDataPrototypeRef(self.getChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF"))
         return iref
 
     def getCompositeNetworkRepresentation(self, element: ET.Element) -> CompositeNetworkRepresentation:
@@ -1096,9 +1112,9 @@ class ARXMLParser(AbstractARXMLParser):
         representation.network_representation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
         return representation
 
-    def readReceiverComSpec(self, element, com_spec: ReceiverComSpec):
+    def readReceiverComSpec(self, element: ET.Element, com_spec: ReceiverComSpec):
         self.readElementAttributes(element, com_spec)
-        for child_element in element.findall("./xmlns:COMPOSITE-NETWORK-REPRESENTATIONS/xmlns:COMPOSITE-NETWORK-REPRESENTATION", self.nsmap):
+        for child_element in self.findall(element, "COMPOSITE-NETWORK-REPRESENTATIONS/COMPOSITE-NETWORK-REPRESENTATION"):
             com_spec.addCompositeNetworkRepresentation(self.getCompositeNetworkRepresentation(child_element))
         com_spec.dataElementRef = self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")
         com_spec.networkRepresentation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
@@ -1159,6 +1175,13 @@ class ARXMLParser(AbstractARXMLParser):
         com_spec.operationRef = self.getChildElementOptionalRefType(element, "OPERATION-REF")
         return com_spec
     
+    def getParameterRequireComSpec(self, element: ET.Element) -> ParameterRequireComSpec:
+        com_spec = ParameterRequireComSpec()
+        self.readElementAttributes(element, com_spec)
+        com_spec.setInitValue(self.getInitValue(element)) \
+                .setParameterRef(self.getChildElementOptionalRefType(element, "PARAMETER-REF"))
+        return com_spec
+    
     def getQueuedReceiverComSpec(self, element: ET.Element) -> QueuedReceiverComSpec:
         com_spec = QueuedReceiverComSpec()
         self.readElementAttributes(element, com_spec)
@@ -1194,6 +1217,8 @@ class ARXMLParser(AbstractARXMLParser):
                 parent.addRequiredComSpec(self.getQueuedReceiverComSpec(child_element))
             elif tag_name == "MODE-SWITCH-RECEIVER-COM-SPEC":
                 parent.addRequiredComSpec(self.getModeSwitchReceiverComSpec(child_element))
+            elif tag_name == "PARAMETER-REQUIRE-COM-SPEC":
+                parent.addRequiredComSpec(self.getParameterRequireComSpec(child_element))
             else:
                 self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
@@ -1202,12 +1227,12 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("readRPortPrototype %s" % short_name)
         prototype = parent.createRPortPrototype(short_name)
         self.readIdentifiable(element, prototype)
-        prototype.required_interface_tref = self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF")
+        prototype.setRequiredInterfaceTRef(self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF"))
 
         self.readRequiredComSpec(element, prototype)
 
     def readAtomicSwComponentTypePorts(self, element: ET.Element, sw_component: AtomicSwComponentType):
-        for child_element in element.findall("./xmlns:PORTS/*", self.nsmap):
+        for child_element in self.findall(element, "PORTS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "P-PORT-PROTOTYPE":
                 self.readPPortPrototype(child_element, sw_component)
@@ -1277,19 +1302,19 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("readPPortPrototype %s" % short_name)
         prototype = parent.createPPortPrototype(short_name)
         self.readIdentifiable(element, prototype)
-        prototype.provided_interface_tref = self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF")
+        prototype.setProvidedInterfaceTRef(self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF"))
 
         self.readProvidedComSpec(element, prototype)
 
     def readPortGroupInnerGroupIRefs(self, element: ET.Element, parent: PortGroup):
-        for child_element in element.findall("./xmlns:INNER-GROUP-IREFS/xmlns:INNER-GROUP-IREF", self.nsmap):
+        for child_element in self.findall(element, "INNER-GROUP-IREFS/INNER-GROUP-IREF"):
             inner_group_iref = InnerPortGroupInCompositionInstanceRef()
-            inner_group_iref.contextRef = self.getChildElementOptionalRefType(child_element, "CONTEXT-REF")
-            inner_group_iref.targetRef = self.getChildElementOptionalRefType(child_element, "TARGET-REF")
+            #inner_group_iref.contextRef = self.getChildElementOptionalRefType(child_element, "CONTEXT-REF")
+            inner_group_iref.setTargetRef(self.getChildElementOptionalRefType(child_element, "TARGET-REF"))
             parent.addInnerGroupIRef(inner_group_iref)
 
     def readPortGroupOuterPortRefs(self, element: ET.Element, parent: PortGroup):
-        for child_element in element.findall("./xmlns:OUTER-PORTS/xmlns:PORT-PROTOTYPE-REF-CONDITIONAL", self.nsmap):
+        for child_element in self.findall(element, "OUTER-PORTS/PORT-PROTOTYPE-REF-CONDITIONAL"):
             parent.addOuterPortRef(self.getChildElementOptionalRefType(child_element, "PORT-PROTOTYPE-REF"))
 
     def readPortGroup(self, element: ET.Element, parent: SwComponentType):
@@ -1346,40 +1371,40 @@ class ARXMLParser(AbstractARXMLParser):
         self.readAtomicSwComponentType(element, sw_component)
 
     def readPPortInCompositionInstanceRef(self, element: ET.Element, p_port_in_composition_instance_ref: PPortInCompositionInstanceRef):
-        p_port_in_composition_instance_ref.context_component_ref = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
-        p_port_in_composition_instance_ref.target_p_port_ref = self.getChildElementOptionalRefType(element, "TARGET-P-PORT-REF")
+        p_port_in_composition_instance_ref.setContextComponentRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")) \
+                                          .setTargetPPortRef(self.getChildElementOptionalRefType(element, "TARGET-P-PORT-REF"))
         
         self.logger.debug("PPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
-                          % (p_port_in_composition_instance_ref.context_component_ref.dest, p_port_in_composition_instance_ref.context_component_ref.value))
+                          % (p_port_in_composition_instance_ref.getContextComponentRef().getDest(), p_port_in_composition_instance_ref.getContextComponentRef().getValue()))
         self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s" 
-                          % (p_port_in_composition_instance_ref.target_p_port_ref.dest, p_port_in_composition_instance_ref.target_p_port_ref.value))
+                          % (p_port_in_composition_instance_ref.getTargetPPortRef().getDest(), p_port_in_composition_instance_ref.getTargetPPortRef().getValue()))
 
     def readRPortInCompositionInstanceRef(self, element, r_port_in_composition_instance_ref: RPortInCompositionInstanceRef):
-        r_port_in_composition_instance_ref.context_component_ref = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
-        r_port_in_composition_instance_ref.target_r_port_ref = self.getChildElementOptionalRefType(element, "TARGET-R-PORT-REF")
+        r_port_in_composition_instance_ref.setContextComponentRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")) \
+                                          .setTargetRPortRef(self.getChildElementOptionalRefType(element, "TARGET-R-PORT-REF"))
 
         self.logger.debug("RPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
-                          % (r_port_in_composition_instance_ref.context_component_ref.dest, r_port_in_composition_instance_ref.context_component_ref.value))
+                          % (r_port_in_composition_instance_ref.getContextComponentRef().getDest(), r_port_in_composition_instance_ref.getContextComponentRef().getValue()))
         self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s" 
-                          % (r_port_in_composition_instance_ref.target_r_port_ref.dest, r_port_in_composition_instance_ref.target_r_port_ref.value))
+                          % (r_port_in_composition_instance_ref.getTargetRPortRef().getDest(), r_port_in_composition_instance_ref.getTargetRPortRef().getValue()))
 
     def readAssemblySwConnectorProviderIRef(self, element: ET.Element, parent: AssemblySwConnector):
-        child_element = element.find("./xmlns:PROVIDER-IREF", self.nsmap)
+        child_element = self.find(element, "PROVIDER-IREF")
         if (child_element is not None):
             provide_iref = PPortInCompositionInstanceRef()
             self.readElementAttributes(child_element, provide_iref)
             self.readPPortInCompositionInstanceRef(child_element, provide_iref)
-            parent.provider_iref = provide_iref
+            parent.setProviderIRef(provide_iref)
 
     def readAssemblySwConnectorRequesterIRef(self, element: ET.Element, parent: AssemblySwConnector):
-        child_element = element.find("./xmlns:REQUESTER-IREF", self.nsmap)
+        child_element = self.find(element, "REQUESTER-IREF")
         if (child_element is not None):
             requester_iref = RPortInCompositionInstanceRef()
             self.readElementAttributes(child_element, requester_iref)
             self.readRPortInCompositionInstanceRef(child_element, requester_iref)
-            parent.requester_iref = requester_iref
+            parent.setRequesterIRef(requester_iref)
 
     def readAssemblySwConnectors(self, element: ET.Element, parent: CompositionSwComponentType):
         for child_element in element.findall("./xmlns:CONNECTORS/xmlns:ASSEMBLY-SW-CONNECTOR", self.nsmap):
@@ -1392,26 +1417,26 @@ class ARXMLParser(AbstractARXMLParser):
             self.readAssemblySwConnectorRequesterIRef(child_element, connector)
 
     def readDelegationSwConnectorInnerPortIRef(self, element, parent: DelegationSwConnector):
-        inner_port_iref_element = element.find("./xmlns:INNER-PORT-IREF", self.nsmap)
+        inner_port_iref_element = self.find(element, "INNER-PORT-IREF")
         if (inner_port_iref_element is not None):
-            child_element = inner_port_iref_element.find("./xmlns:R-PORT-IN-COMPOSITION-INSTANCE-REF", self.nsmap)
+            child_element = self.find(inner_port_iref_element, "R-PORT-IN-COMPOSITION-INSTANCE-REF")
             if (child_element is not None):
                 r_port_in_composition_instance_ref = RPortInCompositionInstanceRef()
                 self.readRPortInCompositionInstanceRef(child_element, r_port_in_composition_instance_ref)
-                parent.inner_port_iref = r_port_in_composition_instance_ref
+                parent.setInnerPortIRref(r_port_in_composition_instance_ref)
                 return
             
-            child_element = inner_port_iref_element.find("./xmlns:P-PORT-IN-COMPOSITION-INSTANCE-REF", self.nsmap)
+            child_element = self.find(inner_port_iref_element, "P-PORT-IN-COMPOSITION-INSTANCE-REF")
             if (child_element is not None):
                 p_port_in_composition_instance_ref = PPortInCompositionInstanceRef()
                 self.readPPortInCompositionInstanceRef(child_element, p_port_in_composition_instance_ref)
-                parent.inner_port_iref = p_port_in_composition_instance_ref
+                parent.setInnerPortIRref(p_port_in_composition_instance_ref)
                 return
             
             self._raiseError("Unsupported child element of INNER-PORT-IREF")
 
     def readDelegationSwConnectors(self, element, parent: CompositionSwComponentType):
-        for child_element in element.findall("./xmlns:CONNECTORS/xmlns:DELEGATION-SW-CONNECTOR", self.nsmap):
+        for child_element in self.findall(element, "CONNECTORS/DELEGATION-SW-CONNECTOR"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readDelegationSwConnectors %s" % short_name)
 
@@ -1419,12 +1444,12 @@ class ARXMLParser(AbstractARXMLParser):
             self.readIdentifiable(child_element, connector)
             self.readDelegationSwConnectorInnerPortIRef(child_element, connector)
 
-            if connector.inner_port_iref == None and connector.outer_port_iref == None:
+            if connector.getInnerPortIRref() == None and connector.getOuterPortRef() == None:
                 self._raiseError("Invalid PortPrototype of DELEGATION-SW-CONNECTOR")
 
-            connector.outer_port_ref = self.getChildElementOptionalRefType(child_element, "OUTER-PORT-REF")
+            connector.setOuterPortRef(self.getChildElementOptionalRefType(child_element, "OUTER-PORT-REF"))
             self.logger.debug("OUTER-PORT-REF DEST: %s, %s"
-                          % (connector.outer_port_ref.dest, connector.outer_port_ref.value))
+                          % (connector.getOuterPortRef().getDest(), connector.getOuterPortRef().getValue()))
 
     def readSwComponentPrototypes(self, element: ET.Element, parent: CompositionSwComponentType):
         for child_element in element.findall("./xmlns:COMPONENTS/xmlns:SW-COMPONENT-PROTOTYPE", self.nsmap):
@@ -1432,7 +1457,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug("readSwComponentPrototypes %s" % short_name)
             prototype = parent.createSwComponentPrototype(short_name)
             self.readIdentifiable(child_element, prototype)
-            prototype.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
+            prototype.typeTRef = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
 
     def readCompositionSwComponentTypeDataTypeMappingSet(self, element: ET.Element, parent: CompositionSwComponentType):
         child_element = element.find("./xmlns:DATA-TYPE-MAPPING-REFS", self.nsmap)
@@ -1496,6 +1521,14 @@ class ARXMLParser(AbstractARXMLParser):
                   .setHandleInvalid(self.getChildElementOptionalLiteral(child_element, "HANDLE-INVALID"))
             sr_interface.addInvalidationPolicy(policy)
 
+    def readInvalidationPolicys(self, element: ET.Element, parent: SenderReceiverInterface):
+        for child_element in element.findall("./xmlns:INVALIDATION-POLICYS/xmlns:INVALIDATION-POLICY", self.nsmap):
+            # short_name = self.getShortName(child_element)
+            policy = parent.createInvalidationPolicy()
+            self.readIdentifiable(child_element, policy)
+            policy.data_element_ref = self.getChildElementOptionalRefType(child_element, "DATA-ELEMENT-REF")
+            policy.handle_invalid = self.getChildElementOptionalLiteral(child_element, "HANDLE-INVALID")
+
     def readSenderReceiverInterfaces(self, element, parent: ARPackage):
         short_name = self.getShortName(element)
         sr_interface = parent.createSenderReceiverInterface(short_name)
@@ -1512,6 +1545,7 @@ class ARXMLParser(AbstractARXMLParser):
             prototype.swDataDefProps = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
             prototype.typeTRef = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
             prototype.direction = self.getChildElementOptionalLiteral(child_element, "DIRECTION")
+            prototype.server_argument_impl_policy = self.getChildElementOptionalLiteral(child_element, "SERVER-ARGUMENT-IMPL-POLICY")
             parent.addArgumentDataPrototype(prototype)
 
     def readPossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
@@ -1532,6 +1566,7 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in element.findall("./xmlns:POSSIBLE-ERRORS/xmlns:APPLICATION-ERROR", self.nsmap):
             short_name = self.getShortName(child_element)
             error = parent.createApplicationError(short_name)
+            self.readIdentifiable(child_element, error) # some errors has its uuid
             error.error_code = self.getChildElementOptionalNumericalValue(child_element, "ERROR-CODE")
 
     def readPortInterface(self, element: ET.Element, port_interface: PortInterface):
@@ -1582,6 +1617,7 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in element.findall('./xmlns:COMPU-SCALES/xmlns:COMPU-SCALE', self.nsmap):
             compu_scale = CompuScale()
             self.readElementAttributes(child_element, compu_scale)
+            compu_scale.short_label = self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")
             compu_scale.symbol = self.getChildElementOptionalLiteral(child_element, "SYMBOL")
             compu_scale.lowerLimit = self.getChildLimitElement(child_element, "LOWER-LIMIT")
             compu_scale.upperLimit = self.getChildLimitElement(child_element, "UPPER-LIMIT")
@@ -1768,10 +1804,10 @@ class ARXMLParser(AbstractARXMLParser):
         iref = None
         if element is not None:
             iref = VariableDataPrototypeInSystemInstanceRef()
-            iref.context_component_refs = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
-            iref.context_composition_ref = self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF")
-            iref.context_port_ref = self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")
-            iref.target_data_prototype_ref = self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF")
+            #iref.addContextComponentRef() = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
+            iref.setContextCompositionRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF")) \
+                .setContextPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")) \
+                .setTargetDataPrototypeRef(self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF"))
         return iref
     
     def getEndToEndProtectionVariablePrototype(self, element: ET.Element) -> EndToEndProtectionVariablePrototype:
@@ -1815,6 +1851,20 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, data_type)
         data_type.swDataDefProps = self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS")
 
+    def readImplementationProps(self, element: ET.Element, props: ImplementationProps):
+        props.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
+
+    def readSymbolProps(self, element: ET.Element, props: SymbolProps):
+        self.readImplementationProps(element, props)
+
+    def readImplementationDataTypeSymbolProps(self, element: ET.Element, data_type: ImplementationDataType):
+        child_element = element.find("./xmlns:SYMBOL-PROPS", self.nsmap)
+        if child_element is not None:
+            short_name = self.getShortName(child_element)
+            self.logger.debug("readSymbolProps %s" % short_name)
+            props = data_type.createSymbolProps(short_name)
+            self.readSymbolProps(child_element, props)
+
     def readApplicationDataType(self, element: ET.Element, data_type: ApplicationDataType):
         self.readAutosarDataType(element, data_type)
 
@@ -2363,8 +2413,8 @@ class ARXMLParser(AbstractARXMLParser):
         if child_element is not None:
             instance_ref = AnyInstanceRef()
             instance_ref.setBaseRef(self.getChildElementOptionalRefType(child_element, "BASE-REF")) \
-                .setContextElementRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-ELEMENT-REF")) \
-                .setTargetRef(self.getChildElementOptionalRefType(child_element, "TARGET-REF"))
+                        .setContextElementRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-ELEMENT-REF")) \
+                        .setTargetRef(self.getChildElementOptionalRefType(child_element, "TARGET-REF"))
         return instance_ref
     
     def getEcucInstanceReferenceValue(self, element: ET.Element) -> EcucInstanceReferenceValue:
@@ -2556,9 +2606,22 @@ class ARXMLParser(AbstractARXMLParser):
         system.setEcuExtractVersion(self.getChildElementOptionalLiteral(element, "ECU-EXTRACT-VERSION"))
         for child_element in self.findall(element, "FIBEX-ELEMENTS/FIBEX-ELEMENT-REF-CONDITIONAL"):
             system.addFibexElementRef(self.getChildElementOptionalRefType(child_element, "FIBEX-ELEMENT-REF"))
-
         self.readSystemMappings(element, system)
 
+    def readParameterInterfaceParameters(self, element: ET.Element, parent: ParameterInterface):
+        for child_element in element.findall("./xmlns:PARAMETERS/xmlns:PARAMETER-DATA-PROTOTYPE", self.nsmap):
+            short_name = self.getShortName(child_element)
+            prototype = parent.createParameter(short_name)
+            self.readParameterDataPrototype(child_element, prototype)
+    
+    def readParameterInterface(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("ParameterInterface %s" % short_name)
+        pi_interface = parent.createParameterInterface(short_name)
+        self.readIdentifiable(element, pi_interface)
+        self.readParameterInterfaceParameters(element, pi_interface)
+
+
     def readARPackageElements(self, element: ET.Element, parent: ARPackage):
         for child_element in self.findall(element, "./ELEMENTS/*"):
             tag_name = self.getTagName(child_element.tag)
@@ -2668,9 +2731,10 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readEcucModuleConfigurationValues(child_element, parent)
             elif tag_name == "PHYSICAL-DIMENSION":
                 self.readPhysicalDimensions(child_element, parent)
+            elif tag_name == "PARAMETER-INTERFACE":
+                self.readParameterInterface(child_element, parent)
             else:
                 self._raiseError("Unsupported element type of ARPackage <%s>" % tag_name)
-                #pass
 
     def readARPackages(self, element: ET.Element, parent: ARPackage):
         for child_element in element.findall("./xmlns:AR-PACKAGES/xmlns:AR-PACKAGE", self.nsmap):
@@ -2694,3 +2758,5 @@ class ARXMLParser(AbstractARXMLParser):
 
         self.getAUTOSARInfo(root, document)
         self.readARPackages(root, document)
+
+        document.reload()

armodel/parser/file_parser.py

@@ -0,0 +1,43 @@
+import logging
+import os
+import re
+from typing import List
+
+
+class FileListParser:
+    '''
+        FileListParser supports to collect the arxml files from the following rules
+         
+    '''
+    def __init__(self) -> None:
+        self.file_list = []
+        self.logger = logging.getLogger()
+
+    def get_file_list(self) -> List[str]:
+        return self.file_list
+    
+    def parse_text_file(self, file):
+        try:
+            with open(file) as f_in:
+                for line in f_in:
+                    self.file_list.append(line.strip())
+        except:
+            self.logger.error("No such file or directory: %s" % os.path.realpath(file))
+
+    def parse_dir_files(self, dir_name):
+        for (root, _, files) in os.walk(dir_name, topdown=False):
+            for file in files:
+                m = re.match(r'.*\.arxml$', file, re.I)
+                if m:
+                    self.file_list.append(os.path.join(root, file))
+
+    def parse(self, args: List[str]):
+        for input_file in args:
+            if os.path.isdir(input_file):
+                self.parse_dir_files(input_file)
+            else:
+                if input_file[0] == "@":
+                    logging.debug("Parse ARXML list file %s " % input_file)
+                    self.parse_text_file(input_file[1:])
+                else:
+                    self.file_list.append(input_file)

armodel/tests/test_armodel/models/test_ar_package.py

@@ -1,12 +1,15 @@
 """ Test AR Package """
 import pytest
 
+from ....models.m2.autosar_templates.common_structure.implementation_data_types import ImplementationDataType
+from ....models.m2.autosar_templates.sw_component_template.components import SwComponentType
 from ....models.ar_package import AUTOSAR
-from ....models.datatype import ApplicationPrimitiveDataType, ApplicationRecordDataType, DataTypeMappingSet, ImplementationDataType, SwBaseType
+from ....models.datatype import ApplicationPrimitiveDataType, ApplicationRecordDataType, DataTypeMappingSet, SwBaseType
 from ....models.general_structure import ARElement, ARObject, CollectableElement, Identifiable, MultilanguageReferrable, PackageableElement, Referrable
 from ....models.m2_msr import CompuMethod
 from ....models.m2.autosar_templates.sw_component_template.port_interface import ClientServerInterface, DataInterface, PortInterface, SenderReceiverInterface
-from ....models.sw_component import ApplicationSwComponentType, AtomicSwComponentType, CompositionSwComponentType, EcuAbstractionSwComponentType, ServiceSwComponentType, SwComponentType
+from ....models.sw_component import ApplicationSwComponentType, AtomicSwComponentType, EcuAbstractionSwComponentType, ServiceSwComponentType
+from ....models.m2.autosar_templates.sw_component_template.composition import CompositionSwComponentType
 
 class TestAUTOSAR:
 

armodel/tests/test_armodel/models/test_ar_ref.py

@@ -2,8 +2,10 @@
 
 import pytest
 
-from ....models.ar_ref import ArVariableInImplementationDataInstanceRef, AutosarVariableRef, PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
-from ....models.ar_ref import OperationInAtomicSwcInstanceRef, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, RefType, TRefType, AtpInstanceRef
+from ....models.m2.autosar_templates.generic_structure.abstract_structure import AtpInstanceRef
+from ....models.m2.autosar_templates.sw_component_template.composition.instance_refs import OperationInAtomicSwcInstanceRef, POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
+from ....models.m2.autosar_templates.sw_component_template.swc_internal_behavior.instance_refs_usage import ArVariableInImplementationDataInstanceRef, AutosarVariableRef
+from ....models.ar_ref import RefType, TRefType
 from ....models.general_structure import ARObject
 
 
@@ -33,24 +35,24 @@ class TestARRef:
     def test_ProvidedPortPrototypeInstanceRef(self):
         ref_type = PPortInCompositionInstanceRef()
         assert(ref_type != None)
-        assert(ref_type.context_component_ref == None)
-        assert(ref_type.target_p_port_ref == None)
+        assert(ref_type.getContextComponentRef() == None)
+        assert(ref_type.getTargetPPortRef() == None)
 
     def test_RequiredPortPrototypeInstanceRef(self):
         ref_type = RPortInCompositionInstanceRef()
         assert(ref_type != None)
-        assert(ref_type.context_component_ref == None)
-        assert(ref_type.target_r_port_ref == None)
+        assert(ref_type.getContextComponentRef() == None)
+        assert(ref_type.getTargetRPortRef() == None)
 
     def test_ArVariableInImplementationDataInstanceRef(self):
         ref_type = ArVariableInImplementationDataInstanceRef()
         assert(ref_type != None)
-        assert(ref_type.port_prototype_ref == None)
-        assert(ref_type.target_data_prototype_ref == None)
+        assert(ref_type.getPortPrototypeRef() == None)
+        assert(ref_type.getTargetDataPrototypeRef() == None)
 
     def test_OperationInAtomicSwcInstanceRef(self):
         with pytest.raises(NotImplementedError) as err:
-            ref_type = OperationInAtomicSwcInstanceRef()
+            _ = OperationInAtomicSwcInstanceRef()
         assert(str(err.value) == "OperationInAtomicSwcInstanceRef is an abstract class.")
 
     def test_POperationInAtomicSwcInstanceRef(self):
@@ -60,8 +62,8 @@ class TestARRef:
         assert(isinstance(ref_type, OperationInAtomicSwcInstanceRef))
         assert(isinstance(ref_type, POperationInAtomicSwcInstanceRef))
         assert(ref_type != None)
-        assert(ref_type.context_p_port_ref == None)
-        assert(ref_type.target_provided_operation_ref == None)
+        assert(ref_type.getContextPPortRef() == None)
+        assert(ref_type.getTargetProvidedOperationRef() == None)
 
     def test_ROperationInAtomicSwcInstanceRef(self):
         ref_type = ROperationInAtomicSwcInstanceRef()
@@ -70,5 +72,5 @@ class TestARRef:
         assert(isinstance(ref_type, OperationInAtomicSwcInstanceRef))
         assert(isinstance(ref_type, ROperationInAtomicSwcInstanceRef))
         assert(ref_type != None)
-        assert(ref_type.context_r_port_ref == None)
-        assert(ref_type.target_required_operation_ref == None)
+        assert(ref_type.getContextRPortRef() == None)
+        assert(ref_type.getTargetRequiredOperationRef() == None)

armodel/tests/test_armodel/models/test_common_structure.py

@@ -1,8 +1,9 @@
 import pytest
 
+from ....models.m2.autosar_templates.common_structure.implementation_data_types import AbstractImplementationDataTypeElement, ImplementationDataTypeElement
 from .... import AUTOSAR
 from ....models.m2.autosar_templates.common_structure import ConstantReference, ConstantSpecification, ValueSpecification
-from ....models.common_structure import AbstractImplementationDataTypeElement, ImplementationDataTypeElement, ExecutableEntity
+from ....models.common_structure import ExecutableEntity
 from ....models.general_structure import ARElement, ARObject, CollectableElement, Identifiable
 from ....models.general_structure import MultilanguageReferrable, PackageableElement, Referrable
 
@@ -50,9 +51,9 @@ class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
         ar_root = document.createARPackage("AUTOSAR")
         data_type = ImplementationDataTypeElement(ar_root, "implementation_data_type")
 
-        assert(data_type.short_name == "implementation_data_type")
-        assert(data_type.arraySize == None)
-        assert(data_type.isOptional == None)
+        assert(data_type.getShortName() == "implementation_data_type")
+        assert(data_type.getArraySize() == None)
+        assert(data_type.getIsOptional() == None)
 
         assert(isinstance(data_type, ARObject))
         assert(isinstance(data_type, AbstractImplementationDataTypeElement))
@@ -65,7 +66,7 @@ class Test_M2_AUTOSARTemplates_CommonStructure_ImplementationDataTypes:
         assert(isinstance(data_type, ImplementationDataTypeElement))
 
         sub_type = data_type.createImplementationDataTypeElement("sub_type")
-        assert(sub_type.short_name == "sub_type")
+        assert(sub_type.getShortName() == "sub_type")
         assert(isinstance(sub_type, ImplementationDataTypeElement))
 
         assert(len(data_type.getImplementationDataTypeElements()) == 1)

armodel/tests/test_armodel/models/test_data_prototype.py

@@ -2,7 +2,7 @@ import pytest
 
 from .... import AUTOSAR
 from ....models.ar_ref import RefType
-from ....models.data_prototype import ApplicationArrayElement, ApplicationCompositeElementDataPrototype, ApplicationRecordElement, AtpPrototype, AutosarDataPrototype, DataPrototype, VariableDataPrototype
+from ....models.m2.autosar_templates.sw_component_template.data_type.data_prototypes import ApplicationArrayElement, ApplicationCompositeElementDataPrototype, ApplicationRecordElement, AtpPrototype, AutosarDataPrototype, DataPrototype, VariableDataPrototype
 from ....models.general_structure import ARObject, AtpFeature, Identifiable, MultilanguageReferrable, Referrable
 
 class Test_M2_AUTOSARTemplates_SWComponentTemplate_Datatype_DataPrototypes: