armodel 1.7.1__py3-none-any.whl → 1.7.3__py3-none-any.whl

armodel/models/M2/AUTOSARTemplates/CommonStructure/InternalBehavior.py

@@ -23,17 +23,18 @@ class ExecutableEntity(Identifiable, metaclass=ABCMeta):
 
         super().__init__(parent, short_name)
 
-        self.activationReason = None                # *
+        self.activationReasons = []                 # type: List[ExecutableEntityActivationReason]
+        self.canEnterExclusiveAreaRefs = []         # type: List[RefType]  
         self.minimumStartInterval = None            # type: ARFloat
         self.reentrancyLevel = None                 # 
-        self.canEnterExclusiveAreaRefs = []         # type: List[RefType]  
+        
         self.swAddrMethodRef = None                 # type: RefType
 
-    def getActivationReason(self):
-        return self.activationReason
+    def getActivationReasons(self):
+        return self.activationReasons
 
-    def setActivationReason(self, value):
-        self.activationReason = value
+    def addActivationReason(self, value):
+        self.activationReasons.append(value)
         return self
 
     def getMinimumStartInterval(self):
@@ -76,33 +77,39 @@ class InternalBehavior(Identifiable, metaclass=ABCMeta):
             raise NotImplementedError("InternalBehavior is an abstract class.")
         super().__init__(parent, short_name)
 
-        self.data_type_mapping_refs = []        # type: List[RefType]                       
-        self.constant_memories = []             # type: List[ParameterDataPrototype]
+        self.constantMemories = []                          # type: List[ParameterDataPrototype]
+        self.constantValueMappingRefs = []                  # type: List[RefType]
+        self.dataTypeMappingRefs = []                       # type: List[RefType]
+        self.exclusiveAreas = []                            # type: List[ExclusiveArea]
+        self.exclusiveAreaNestingOrders = []                # type: List[ExclusiveAreaNestingOrder]
+        self.staticMemories = []                            # type: List[VariableDataPrototype]
+
+    def createConstantMemory(self, short_name: str) -> ParameterDataPrototype:
+        if (short_name not in self.elements):
+            prototype = ParameterDataPrototype(self, short_name)
+            self.addElement(prototype)
+            self.constantMemories.append(prototype)
+        return self.getElement(short_name)
+
+    def getConstantMemorys(self) -> List[ParameterDataPrototype]:
+        return self.constantMemories
 
     def addDataTypeMappingRef(self, ref: RefType):
-        self.data_type_mapping_refs.append(ref)
+        self.dataTypeMappingRefs.append(ref)
 
     def getDataTypeMappingRefs(self) -> List[RefType]:
-        return self.data_type_mapping_refs
+        return self.dataTypeMappingRefs
 
     def createExclusiveArea(self, short_name: str) -> ExclusiveArea:
         if (short_name not in self.elements):
-            event = ExclusiveArea(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            area = ExclusiveArea(self, short_name)
+            self.addElement(area)
+            self.exclusiveAreas.append(area)
+        return self.getElement(short_name)
 
     def getExclusiveAreas(self) -> List[ExclusiveArea]:
         return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
 
-    def createConstantMemory(self, short_name: str) -> ParameterDataPrototype:
-        if (short_name not in self.elements):
-            prototype = ParameterDataPrototype(self, short_name)
-            self.elements[short_name] = prototype
-            self.constant_memories.append(prototype)
-        return self.elements[short_name]
-
-    def getConstantMemorys(self) -> List[ParameterDataPrototype]:
-        return self.constant_memories
 
 class AbstractEvent(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):

armodel/models/M2/AUTOSARTemplates/CommonStructure/ModeDeclaration.py

@@ -1,7 +1,7 @@
 from typing import List
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, RefType, TRefType
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, PositiveInteger, RefType, TRefType
 
 class ModeDeclaration(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
@@ -21,16 +21,33 @@ class ModeRequestTypeMap(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.implementation_data_type_ref = None           # type: RefType
-        self.mode_group_ref = None                        # type: RefType
+        self.implementationDataTypeRef = None               # type: RefType
+        self.modeGroupRef = None                            # type: RefType
 
+    def getImplementationDataTypeRef(self):
+        return self.implementationDataTypeRef
+
+    def setImplementationDataTypeRef(self, value):
+        self.implementationDataTypeRef = value
+        return self
+
+    def getModeGroupRef(self):
+        return self.modeGroupRef
+
+    def setModeGroupRef(self, value):
+        self.modeGroupRef = value
+        return self
 
 class ModeDeclarationGroup(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._initial_mode_ref = None                      # type: RefType
-        self._on_transition_value = None                   # type: ARNumerical
+        self.initialModeRef = None                          # type: RefType
+        self.modeDeclarations = []                          # type: ModeDeclaration
+        self.modeManagerErrorBehavior = None                # type: ModeErrorBehavior
+        self.modeTransition = None                          # type: ModeTransition
+        self.modeUserErrorBehavior = None                   # type: ModeErrorBehavior
+        self.onTransitionValue = None                       # type: PositiveInteger
 
     def createModeDeclaration(self, short_name: str) -> ModeDeclaration:
         if (short_name not in self.elements):
@@ -42,21 +59,21 @@ class ModeDeclarationGroup(Identifiable):
         return list(sorted(filter(lambda a: isinstance(a, ModeDeclaration), self.elements.values()), key= lambda o:o.short_name))
 
     def setInitialModeRef(self, ref: RefType):
-        self._initial_mode_ref = ref
+        self.initialModeRef = ref
         return self
 
     def getInitialModeRef(self) -> RefType:
-        return self._initial_mode_ref
+        return self.initialModeRef
 
     def setOnTransitionValue(self, value):
         if isinstance(value, int):
             value = ARNumerical()
             value.setValue(value)
-        self._on_transition_value = value
+        self.onTransitionValue = value
         return self
 
     def getOnTransitionValue(self) -> ARNumerical:
-        return self._on_transition_value
+        return self.onTransitionValue
 
 
 class ModeDeclarationGroupPrototype(Identifiable):

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/HardwareConfiguration.py

@@ -0,0 +1,33 @@
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import String
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+class HardwareConfiguration(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.additionalInformation = None                       # type: String
+        self.processorMode = None                               # type: String
+        self.processorSpeed = None                              # type: String
+
+    def getAdditionalInformation(self):
+        return self.additionalInformation
+
+    def setAdditionalInformation(self, value):
+        self.additionalInformation = value
+        return self
+
+    def getProcessorMode(self):
+        return self.processorMode
+
+    def setProcessorMode(self, value):
+        self.processorMode = value
+        return self
+
+    def getProcessorSpeed(self):
+        return self.processorSpeed
+
+    def setProcessorSpeed(self, value):
+        self.processorSpeed = value
+        return self
+
+        

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/HeapUsage.py

@@ -0,0 +1,10 @@
+from abc import ABCMeta
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+
+class HeapUsage(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == HeapUsage:
+            raise NotImplementedError("HeapUsage is an abstract class.")
+        
+        super().__init__(parent, short_name)

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/MemorySectionUsage.py

@@ -9,6 +9,7 @@ class MemorySection(Identifiable):
         super().__init__(parent, short_name)
 
         self._alignment = None              # type: ARLiteral
+        self.memClassSymbol = None          # type: ARLiteral
         self.size = None
         self.options = []                   # type: List[ARLiteral]
         self.swAddrMethodRef = None         # type: RefType
@@ -20,6 +21,13 @@ class MemorySection(Identifiable):
     def setAlignment(self, value):
         self.alignment = value
         return self
+    
+    def getMemClassSymbol(self):
+        return self.memClassSymbol
+
+    def setMemClassSymbol(self, value):
+        self.memClassSymbol = value
+        return self
 
     def getSize(self):
         return self.size

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/SoftwareContext.py

@@ -0,0 +1,23 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import String
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+class SoftwareContext(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.input = None                       # type: String
+        self.state = None                       # type: String
+
+    def getInput(self):
+        return self.input
+
+    def setInput(self, value):
+        self.input = value
+        return self
+
+    def getState(self):
+        return self.state
+
+    def setState(self, value):
+        self.state = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/StackUsage.py

@@ -0,0 +1,93 @@
+from abc import ABCMeta
+from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import SoftwareContext
+from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.HardwareConfiguration import HardwareConfiguration
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger, RefType
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+
+class StackUsage(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == StackUsage:
+            raise NotImplementedError("StackUsage is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self.executableEntityRef = None                 # type: RefType
+        self.hardwareConfiguration = None               # type: HardwareConfiguration
+        self.hwElementRef = None                        # type: RefType
+        self.softwareContext = None                     # type: SoftwareContext
+
+    def getExecutableEntityRef(self):
+        return self.executableEntityRef
+
+    def setExecutableEntityRef(self, value):
+        self.executableEntityRef = value
+        return self
+
+    def getHardwareConfiguration(self):
+        return self.hardwareConfiguration
+
+    def setHardwareConfiguration(self, value):
+        self.hardwareConfiguration = value
+        return self
+
+    def getHwElementRef(self):
+        return self.hwElementRef
+
+    def setHwElementRef(self, value):
+        self.hwElementRef = value
+        return self
+
+    def getSoftwareContext(self):
+        return self.softwareContext
+
+    def setSoftwareContext(self, value):
+        self.softwareContext = value
+        return self
+
+class MeasuredStackUsage(StackUsage):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.averageMemoryConsumption = None            # type: PositiveInteger
+        self.maximumMemoryConsumption = None            # type: PositiveInteger
+
+    def getAverageMemoryConsumption(self):
+        return self.averageMemoryConsumption
+
+    def setAverageMemoryConsumption(self, value):
+        self.averageMemoryConsumption = value
+        return self
+
+    def getMaximumMemoryConsumption(self):
+        return self.maximumMemoryConsumption
+
+    def setMaximumMemoryConsumption(self, value):
+        self.maximumMemoryConsumption = value
+        return self
+
+class RoughEstimateStackUsage(StackUsage):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.memoryConsumption = None                   # type: PositiveInteger
+
+    def getMemoryConsumption(self):
+        return self.memoryConsumption
+
+    def setMemoryConsumption(self, value):
+        self.memoryConsumption = value
+        return self
+
+class WorstCaseStackUsage(StackUsage):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.memoryConsumption = None                   # type: PositiveInteger
+
+    def getMemoryConsumption(self):
+        return self.memoryConsumption
+
+    def setMemoryConsumption(self, value):
+        self.memoryConsumption = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/__init__.py

@@ -1,3 +1,5 @@
+from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import MeasuredStackUsage, RoughEstimateStackUsage, StackUsage, WorstCaseStackUsage
+from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.HeapUsage import HeapUsage
 from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.MemorySectionUsage import MemorySection
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
@@ -7,14 +9,46 @@ class ResourceConsumption(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.accessCountSets = []                               # type: List[AccessCountSet]
+        self.executionTimes = []                                # type: List[ExecutionTime]
+        self.heapUsages = []                                    # type: List[HeapUsage]
+        self.memorySections = []
+        self.sectionNamePrefixs = []                            # type: List[SectionNamePrefix]
+        self.stackUsages = []                                   # type: List[StackUsage]
+
     def createMemorySection(self, short_name: str) -> MemorySection:
         if (short_name not in self.elements):
-            entry = MemorySection(self, short_name)
-            self.elements[short_name] = entry
-        return self.elements[short_name]
+            section = MemorySection(self, short_name)
+            self.addElement(section)
+            self.memorySections.append(section)
+        return self.getElement(short_name)
 
     def getMemorySections(self) -> List[MemorySection]:
-        return list(filter(lambda a : isinstance(a, MemorySection), self.elements.values()))
+        return list(sorted(filter(lambda a: isinstance(a, MemorySection), self.elements.values()), key= lambda o:o.short_name))
 
     def getMemorySection(self, short_name: str) -> MemorySection:
-        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements.values()), None)
+        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements.values()), None)
+    
+    def createMeasuredStackUsage(self, short_name: str) -> MeasuredStackUsage:
+        if (short_name not in self.elements):
+            section = MeasuredStackUsage(self, short_name)
+            self.addElement(section)
+            self.stackUsages.append(section)
+        return self.getElement(short_name)
+    
+    def createRoughEstimateStackUsage(self, short_name: str) -> RoughEstimateStackUsage:
+        if (short_name not in self.elements):
+            section = RoughEstimateStackUsage(self, short_name)
+            self.addElement(section)
+            self.stackUsages.append(section)
+        return self.getElement(short_name)
+    
+    def createWorstCaseStackUsage(self, short_name: str) -> WorstCaseStackUsage:
+        if (short_name not in self.elements):
+            section = WorstCaseStackUsage(self, short_name)
+            self.addElement(section)
+            self.stackUsages.append(section)
+        return self.getElement(short_name)
+    
+    def getStackUsages(self) -> List[StackUsage]:
+        return list(sorted(filter(lambda a: isinstance(a, StackUsage), self.elements.values()), key= lambda o:o.short_name))