armodel 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/__init__.py

@@ -7,6 +7,7 @@ from .....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PerInstanceMemory import PerInstanceMemory
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, BackgroundEvent
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import DataSendCompletedEvent
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import ModeSwitchedAckEvent, OperationInvokedEvent, RTEEvent
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import SwcModeSwitchEvent, TimingEvent
@@ -16,7 +17,7 @@ from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElemen
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet, ModeAccessPoint
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import ModeSwitchPoint
-from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.Trigger import InternalTriggeringPoint
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.Trigger import ExternalTriggeringPoint, InternalTriggeringPoint
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
 
@@ -72,44 +73,32 @@ class RunnableEntity(ExecutableEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        # type: List[RunnableEntityArgument]
-        self.arguments = []
-        # type: List[AsynchronousServerCallResultPoint]
-        self.asynchronousServerCallResultPoints = []
-        self.canBeInvokedConcurrently = None            # type: ARBoolean
-        # type: Dict[str, VariableAccess]
-        self.dataReadAccesses = {}
-        # type: Dict[str, VariableAccess]
-        self.dataReceivePointByArguments = {}
-        # type: Dict[str, VariableAccess]
-        self.dataReceivePointByValues = {}
-        # type: Dict[str, VariableAccess]
-        self.dataSendPoints = {}
-        # type: Dict[str, VariableAccess]
-        self.dataWriteAccesses = {}
-        # type: Dict[str, ExternalTriggeringPoint]
-        self.externalTriggeringPoints = {}
-        # type: Dict[str, InternalTriggeringPoint]
-        self.internalTriggeringPoints = {}
-        self.modeAccessPoints = []                      # type: List[ModeAccessPoint]
-        self.modeSwitchPoints = []                      # type: List[ModeSwitchPoint]
-        # type: Dict[str, ParameterAccess]
-        self.parameterAccesses = {}
-        # type: Dict[str, VariableAccess]
-        self.readLocalVariables = {}
-        # type: Dict[str, ServerCallPoint]
-        self.serverCallPoints = {}
-        self.symbol = None                              # type: ARLiteral
+        self.arguments: List[RunnableEntityArgument] = []
+        self.asynchronousServerCallResultPoints: List[AsynchronousServerCallResultPoint] = []
+        self.canBeInvokedConcurrently: ARBoolean = None
+        self.dataReadAccesses: List[VariableAccess] = []
+        self.dataReceivePointByArguments: List[VariableAccess] = []
+        self.dataReceivePointByValues: List[VariableAccess] = []
+        self.dataSendPoints: List[VariableAccess] = []
+        self.dataWriteAccesses: List[VariableAccess] = []
+        self.externalTriggeringPoints: List[ExternalTriggeringPoint] = []
+        self.internalTriggeringPoints: List[InternalTriggeringPoint] = []
+        self.modeAccessPoints: List[ModeAccessPoint] = []
+        self.modeSwitchPoints: List[ModeSwitchPoint] = []
+        self.parameterAccesses: List[ParameterAccess] = []
+        self.readLocalVariables: List[VariableAccess] = []
+        self.serverCallPoints: List[ServerCallPoint] = []
+        self.symbol: ARLiteral = None
         # type: Dict[str, WaitPoint]
         self.waitPoints = {}
-        # type: Dict[str, VariableAccess]
-        self.writtenLocalVariables = {}
+        self.writtenLocalVariables: List[VariableAccess] = []
 
-    def _createVariableAccess(self, short_name, variable_accesses: Dict[str, VariableAccess]):
+    def _createVariableAccess(self, short_name, variable_accesses: List[VariableAccess]):
         if not self.IsElementExists(short_name):
             variable_access = VariableAccess(self, short_name)
-            variable_accesses[short_name] = variable_access
-        return variable_accesses[short_name]
+            self.addElement(variable_access)
+            variable_accesses.append(variable_access)
+        return self.getElement(short_name, VariableAccess)
 
     def getArguments(self):
         return self.arguments
@@ -129,46 +118,45 @@ class RunnableEntity(ExecutableEntity):
         return self._createVariableAccess(short_name, self.dataReadAccesses)
 
     def getDataReadAccesses(self) -> List[VariableAccess]:
-        return sorted(self.dataReadAccesses.values(), key=lambda v: v.short_name)
+        return sorted(self.dataReadAccesses, key=lambda v: v.short_name)
 
     def createDataWriteAccess(self, short_name: str) -> VariableAccess:
         return self._createVariableAccess(short_name, self.dataWriteAccesses)
 
     def getDataWriteAccesses(self) -> List[VariableAccess]:
-        return sorted(self.dataWriteAccesses.values(), key=lambda v: v.short_name)
+        return sorted(self.dataWriteAccesses, key=lambda v: v.short_name)
 
     def createDataReceivePointByArgument(self, short_name: str) -> VariableAccess:
         return self._createVariableAccess(short_name, self.dataReceivePointByArguments)
 
     def getDataReceivePointByArguments(self) -> List[VariableAccess]:
-        return sorted(self.dataReceivePointByArguments.values(), key=lambda v: v.short_name)
+        return sorted(self.dataReceivePointByArguments, key=lambda v: v.short_name)
 
     def createDataReceivePointByValue(self, short_name: str) -> VariableAccess:
         return self._createVariableAccess(short_name, self.dataReceivePointByValues)
 
     def getDataReceivePointByValues(self) -> List[VariableAccess]:
-        return sorted(self.dataReceivePointByValues.values(), key=lambda v: v.short_name)
+        return sorted(self.dataReceivePointByValues, key=lambda v: v.short_name)
 
     def createDataSendPoint(self, short_name: str) -> VariableAccess:
         return self._createVariableAccess(short_name, self.dataSendPoints)
 
     def getDataSendPoints(self) -> List[VariableAccess]:
         # return sorted(self.dataSendPoints.values(), key=lambda v: v.short_name)
-        return self.dataSendPoints.values()
+        return self.dataSendPoints
 
     def createReadLocalVariable(self, short_name: str) -> VariableAccess:
         return self._createVariableAccess(short_name, self.readLocalVariables)
 
     def getReadLocalVariables(self) -> List[VariableAccess]:
         # return sorted(self.readLocalVariables.values(), key=lambda v: v.short_name)
-        return self.readLocalVariables.values()
+        return self.readLocalVariables
 
     def createWrittenLocalVariable(self, short_name: str) -> VariableAccess:
         return self._createVariableAccess(short_name, self.writtenLocalVariables)
 
     def getWrittenLocalVariables(self) -> List[VariableAccess]:
-        # return sorted(self.writtenLocalVariables.values(), key=lambda v: v.short_name)
-        return self.writtenLocalVariables.values()
+        return self.writtenLocalVariables
 
     def getParameterAccesses(self) -> List[ParameterAccess]:
         return list(sorted(filter(lambda a: isinstance(a, ParameterAccess), self.elements), key=lambda o: o.short_name))
@@ -191,7 +179,7 @@ class RunnableEntity(ExecutableEntity):
         if (short_name not in self.serverCallPoints):
             point = AsynchronousServerCallPoint(self, short_name)
             self.addElement(point)
-        return self.getElement(short_name)
+        return self.getElement(short_name, AsynchronousServerCallPoint)
         # self.serverCallPoints[short_name] = server_call_point
         # return self.serverCallPoints[short_name]
 
@@ -398,6 +386,12 @@ class SwcInternalBehavior(InternalBehavior):
             event = BackgroundEvent(self, short_name)
             self.addElement(event)
         return self.getElement(short_name, BackgroundEvent)
+    
+    def createDataSendCompletedEvent(self, short_name: str) -> DataSendCompletedEvent:
+        if not self.IsElementExists(short_name):
+            event = DataSendCompletedEvent(self, short_name)
+            self.addElement(event)
+        return self.getElement(short_name, DataSendCompletedEvent)
 
     def getRteEvents(self) -> List[RTEEvent]:
         return sorted(filter(lambda c: isinstance(c, RTEEvent), self.elements), key=lambda e: e.short_name)
@@ -425,6 +419,9 @@ class SwcInternalBehavior(InternalBehavior):
 
     def getBackgroundEvents(self) -> List[BackgroundEvent]:
         return sorted(filter(lambda c: isinstance(c, BackgroundEvent), self.elements), key=lambda e: e.short_name)
+    
+    def getDataSendCompletedEvents(self) -> List[DataSendCompletedEvent]:
+        return sorted(filter(lambda c: isinstance(c, DataSendCompletedEvent), self.elements), key=lambda e: e.short_name)
 
     def getSwcServiceDependencies(self) -> List[SwcServiceDependency]:
         return sorted(filter(lambda c: isinstance(c, SwcServiceDependency), self.elements), key=lambda e: e.short_name)

armodel/models/M2/MSR/AsamHdo/ComputationMethod.py

@@ -202,15 +202,15 @@ class CompuScale(Compu):
     def __init__(self):
         super().__init__()
 
-        self.a2lDisplayText = None                              # type: String
-        self.compuInverseValue = None                           # type: CompuConst
-        self.compuScaleContents = None                          # type: CompuScaleContents
-        self.desc = None                                        # type: MultiLanguageOverviewParagraph
-        self.lowerLimit = None                                  # type: Limit
-        self.mask = None                                        # type: PositiveUnlimitedInteger
-        self.shortLabel = None                                  # type: Identifier
-        self.symbol = None                                      # type: CIdentifier
-        self.upperLimit = None                                  # type: Limit
+        self.a2lDisplayText: String = None
+        self.compuInverseValue: CompuConst = None
+        self.compuScaleContents: CompuScaleContents = None
+        self.desc: MultiLanguageOverviewParagraph = None
+        self.lowerLimit: Limit = None
+        self.mask: PositiveUnlimitedInteger = None
+        self.shortLabel: Identifier = None
+        self.symbol: CIdentifier = None
+        self.upperLimit: Limit = None
 
     def getA2lDisplayText(self):
         return self.a2lDisplayText
@@ -247,11 +247,12 @@ class CompuScale(Compu):
         self.lowerLimit = value
         return self
 
-    def getMask(self):
+    def getMask(self) -> PositiveUnlimitedInteger:
         return self.mask
 
-    def setMask(self, value):
-        self.mask = value
+    def setMask(self, value: PositiveUnlimitedInteger):
+        if value is not None:
+            self.mask = value
         return self
 
     def getShortLabel(self):

armodel/models/M2/MSR/DataDictionary/DataDefProperties.py

@@ -6,6 +6,44 @@ from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTy
 from ....M2.AUTOSARTemplates.CommonStructure import ValueSpecification
 
 
+class SwImplPolicyEnum(AREnum):
+    """
+    Enumeration for software implementation policy.
+    * const
+        forced implementation such that the running software within the ECU shall not modify it. For example
+        implemented with the "const" modifier in C. This can be applied for parameters (not for those in
+        NVRAM) as well as argument data prototypes.
+    * fixed
+        This data element is fixed. In particular this indicates, that it might also be implemented e.g. as in
+        place data, (#DEFINE).
+    * measurementPoint
+        The data element is created for measurement purposes only. The data element is never read directly
+        within the ECU software. In contrast to a "standard" data element in an unconnected provide port is,
+        this unconnection is guaranteed for measurementPoint data elements.
+    * queued
+        The content of the data element is queued and the data element has 'event' semantics, i.e. data
+        elements are stored in a queue and all data elements are processed in 'first in first out' order. The
+        queuing is intended to be implemented by RTE Generator. This value is not applicable for parameters.
+    * standard
+        This is applicable for all kinds of data elements. For variable data prototypes the 'last is best'
+        semantics applies. For parameter there is no specific implementation directive.
+    """
+    CONST = "const"
+    FIXED = "fixed"
+    MEASUREMENT_POINT = "measurementPoint"
+    QUEUED = "queued"
+    STANDARD = "standard"
+
+    def __init__(self):
+        super().__init__([
+            SwImplPolicyEnum.CONST,
+            SwImplPolicyEnum.FIXED,
+            SwImplPolicyEnum.MEASUREMENT_POINT,
+            SwImplPolicyEnum.QUEUED,
+            SwImplPolicyEnum.STANDARD
+        ])
+
+
 class SwDataDefPropsConditional(ARObject):
     '''
     Patch for the time-stamp
@@ -14,18 +52,11 @@ class SwDataDefPropsConditional(ARObject):
         super().__init__()
 
 
-class SwImplPolicyEnum(AREnum):
-    def __init__(self, enum_values):
-        super().__init__([
-
-        ])
-
-
 class SwDataDefProps(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.additionalNativeTypeQualifier = None           
+        self.additionalNativeTypeQualifier = None
         self.annotations = []                               # type: List[Annotation]
         self.baseTypeRef = None                             # type: RefType
         self.compuMethodRef = None                          # type: RefType
@@ -268,6 +299,7 @@ class SwDataDefProps(ARObject):
         self.valueAxisDataTypeRef = value
         return self
 
+
 class SwPointerTargetProps(ARObject):
     def __init__(self):
         super().__init__()
@@ -317,4 +349,3 @@ class ValueList(ARObject):
 
     def getVfs(self) -> List[ARLiteral]:
         return sorted(self._vf)
-

armodel/models/utils/uuid_mgr.py

@@ -21,3 +21,9 @@ class UUIDMgr:
         if uuid in self.uuid_object_mappings:
             result = self.uuid_object_mappings[uuid]
         return result
+    
+    def getDuplicateUUIDs(self):
+        if len(self.uuid_object_mappings) > 0:
+            return self.uuid_object_mappings.keys()
+        else:
+            return []

armodel/parser/abstract_arxml_parser.py

@@ -175,7 +175,7 @@ class AbstractARXMLParser:
             return None
         bool_value = Boolean()
         bool_value.timestamp = literal.timestamp
-        bool_value.setValue(literal.getValue())
+        bool_value.setValue(literal.getText())
         return bool_value
 
     def _convertStringToNumberValue(self, value) -> int:
@@ -190,6 +190,8 @@ class AbstractARXMLParser:
             return None
         numerical = ARNumerical()
         self.readARObjectAttributes(child_element, numerical)
+        if "SHORT-LABEL" in child_element.attrib:
+            numerical.setShortLabel(child_element.attrib["SHORT-LABEL"])
         numerical.setValue(child_element.text)
         return numerical
     
@@ -206,6 +208,8 @@ class AbstractARXMLParser:
         child_element = self.find(element, key)
         if child_element is None:
             return None
+        if child_element.text is None:
+            return None
         numerical = PositiveInteger()
         self.readARObjectAttributes(child_element, numerical)
         numerical.setValue(child_element.text)