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

armodel/cli/arxml_dump_cli.py

@@ -116,7 +116,7 @@ def show_bsw_internal_behavior(indent: int, behavior: BswInternalBehavior):
         print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntryRef", starts_on_event.implementedEntryRef.value))
         implemented_entry = document.find(starts_on_event.implementedEntryRef.value) # type: BswModuleEntry
         print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntry", implemented_entry.short_name))
-        print("%s-%s: %d" % (" " * (indent + 6), "Service Id", implemented_entry.service_id))
+        print("%s-%s: %d" % (" " * (indent + 6), "Service Id", implemented_entry.serviceId))
 
 def show_bsw_module_description(indent: int, description: BswModuleDescription):
     print("%s-%s" % (" " * indent, description.short_name))

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswBehavior.py

@@ -1,7 +1,7 @@
 from ....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from ....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARFloat, ARNumerical, TimeValue
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, AREnum, ARFloat, ARNumerical, String, TimeValue
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 from ....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
@@ -132,23 +132,36 @@ class BswSchedulableEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+class BswInterruptCategory(AREnum):
+    CAT1 = "cat1"
+    CAT2 = "cat2"
+
+    def __init__(self):
+        super().__init__((
+            BswInterruptCategory.CAT1,
+            BswInterruptCategory.CAT2,
+        ))    
+
 class BswInterruptEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._interrupt_category = ""
-        self.interrupt_source = ""
+        self.interruptCategory = None               # type: BswInterruptCategory
+        self.interruptSource = None                 # type: String
 
-    @property
-    def interrupt_category(self) -> str:
-        return self._interrupt_category
+    def getInterruptCategory(self):
+        return self.interruptCategory
 
-    @interrupt_category.setter
-    def interrupt_category(self, value):
-        if (value.upper() not in ("CAT1", "CAT2")):
-            raise ValueError("Invalid interrupt category <%s> of %s" % (value, self.short_name))
-        self._interrupt_category = value
+    def setInterruptCategory(self, value):
+        self.interruptCategory = value
+        return self
+
+    def getInterruptSource(self):
+        return self.interruptSource
 
+    def setInterruptSource(self, value):
+        self.interruptSource = value
+        return self
 
 class BswEvent(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -293,23 +306,33 @@ class BswInternalBehavior(InternalBehavior):
 
     def createBswCalledEntity(self, short_name: str) -> BswCalledEntity:
         if (short_name not in self.elements):
-            event = BswCalledEntity(self, short_name)
-            self.elements[short_name] = event
-            self.entities.append(event)
-        return self.elements[short_name]
+            entity = BswCalledEntity(self, short_name)
+            self.addElement(entity)
+            self.entities.append(entity)
+        return self.getElement(short_name)
 
     def getBswCalledEntities(self) -> List[BswCalledEntity]:
         return list(filter(lambda a: isinstance(a, BswCalledEntity), self.elements.values()))
 
     def createBswSchedulableEntity(self, short_name: str) -> BswSchedulableEntity:
         if (short_name not in self.elements):
-            event = BswSchedulableEntity(self, short_name)
-            self.elements[short_name] = event
-            self.entities.append(event)
-        return self.elements[short_name]
+            entity = BswSchedulableEntity(self, short_name)
+            self.addElement(entity)
+            self.entities.append(entity)
+        return self.getElement(short_name)
 
     def getBswSchedulableEntities(self) -> List[BswSchedulableEntity]:
         return list(filter(lambda a: isinstance(a, BswSchedulableEntity), self.elements.values()))
+    
+    def createBswInterruptEntity(self, short_name: str) -> BswInterruptEntity:
+        if (short_name not in self.elements):
+            entity = BswInterruptEntity(self, short_name)
+            self.addElement(entity)
+            self.entities.append(entity)
+        return self.getElement(short_name)
+
+    def getBswInterruptEntities(self) -> List[BswInterruptEntity]:
+        return list(filter(lambda a: isinstance(a, BswInterruptEntity), self.elements.values()))
 
     def getBswModuleEntities(self) -> List[BswModuleEntity]:
         return list(filter(lambda a: isinstance(a, BswModuleEntity), self.elements.values()))

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswInterfaces.py

@@ -1,52 +1,126 @@
+from typing import List
+
+from ....M2.MSR.DataDictionary.ServiceProcessTask import SwServiceArg
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARLiteral, ARNumerical
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, Boolean, Identifier, NameToken
 
 class BswModuleEntry(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.service_id = None                      # type: ARNumerical
-        self.is_reentrant = None                    # type: ARBoolean
-        self.is_synchronous = None                  # type: ARBoolean
-        self.call_type = None                       # type: ARLiteral
-        self._execution_context = None              # type: ARLiteral
-        self._sw_service_impl_policy = None         # type: ARLiteral
+        self.arguments = []                         # type: List[SwServiceArg]
+        self.bswEntryKind = None                    # type: BswEntryKindEnum
+        self.callType = None                        # type: BswCallType
+        self.executionContext = None                # type: BswExecutionContext
+        self.functionPrototypeEmitter = None        # type: NameToken
+        self.isReentrant = None                     # type: Boolean
+        self.isSynchronous = None                   # type: Boolean
+        self.returnType = None                      # type: SwServiceArg
+        self.role = None                            # type: Identifier
+        self.serviceId = None                       # type: ARNumerical
+        self.swServiceImplPolicy = None             # type: SwServiceImplPolicyEnum
+
+    def getArguments(self):
+        return self.arguments
+
+    def createArgument(self, short_name: str) -> SwServiceArg:
+        if (short_name not in self.elements):
+            arg = SwServiceArg(self, short_name)
+            self.addElement(arg)
+            self.arguments.append(arg)
+        return self.getElement(short_name)
+
+    def getBswEntryKind(self):
+        return self.bswEntryKind
+
+    def setBswEntryKind(self, value):
+        self.bswEntryKind = value
+        return self
 
-    @property
-    def execution_context(self):
-        return self._execution_context
+    def getCallType(self):
+        return self.callType
 
-    @execution_context.setter
-    def execution_context(self, value):
+    def setCallType(self, value):
+        self.callType = value
+        return self
+
+    def getExecutionContext(self):
+        return self.executionContext
+
+    def setExecutionContext(self, value):
         if value.upper() not in ("HOOK", "INTERRUPT-CAT-1", "INTERRUPT-CAT-2", "TASK", "UNSPECIFIED"):
             raise ValueError("Invalid execution context <%s> of BswModuleEntry <%s>" % (value, self.short_name))
-        self._execution_context = value
+        self.executionContext = value
+        return self
+
+    def getFunctionPrototypeEmitter(self):
+        return self.functionPrototypeEmitter
+
+    def setFunctionPrototypeEmitter(self, value):
+        self.functionPrototypeEmitter = value
+        return self
+
+    def getIsReentrant(self):
+        return self.isReentrant
 
-    @property
-    def sw_service_impl_policy(self):
-        return self._sw_service_impl_policy
+    def setIsReentrant(self, value):
+        self.isReentrant = value
+        return self
 
-    @sw_service_impl_policy.setter
-    def sw_service_impl_policy(self, value):
+    def getIsSynchronous(self):
+        return self.isSynchronous
+
+    def setIsSynchronous(self, value):
+        self.isSynchronous = value
+        return self
+
+    def getReturnType(self):
+        return self.returnType
+
+    def setReturnType(self, value):
+        self.returnType = value
+        return self
+
+    def getRole(self):
+        return self.role
+
+    def setRole(self, value):
+        self.role = value
+        return self
+
+    def getServiceId(self):
+        return self.serviceId
+
+    def setServiceId(self, value):
+        self.serviceId = value
+        return self
+
+    def getSwServiceImplPolicy(self):
+        return self.swServiceImplPolicy
+
+    def setSwServiceImplPolicy(self, value):
         if value.upper() not in ("INLINE", "INLINE-CONDITIONAL", "MACRO", "STANDARD"):
             raise ValueError("Invalid SwServiceImplPolicy <%s> of BswModuleEntry <%s>" % (value, self.short_name))
-        self._sw_service_impl_policy = value
+        self.swServiceImplPolicy = value
+        return self
 
     def __str__(self) -> str:
         result = []
+
         result.append("short_name             : %s" % self.short_name)
-        if self.service_id != None:
-            result.append("service_id             : %d" % self.service_id)
-        if self.is_reentrant != None:
-            result.append("is_reentrant           : %s" % self.is_reentrant)
-        if self.is_synchronous != None:
-            result.append("is_synchronous         : %s" % self.is_synchronous)
-        if self.call_type != None:
-            result.append("call_type              : %s" % self.call_type)
+        if self.serviceId != None:
+            result.append("service_id             : %d" % self.serviceId)
+        if self.isReentrant != None:
+            result.append("is_reentrant           : %s" % self.isReentrant)
+        if self.isSynchronous != None:
+            result.append("is_synchronous         : %s" % self.isSynchronous)
+        if self.callType != None:
+            result.append("call_type              : %s" % self.callType)
         if self.execution_context != None:
-            result.append("execution_context      : %s" % self.execution_context)
+            result.append("execution_context      : %s" % self.executionContext)
         if self.sw_service_impl_policy != None:
-            result.append("sw_service_impl_policy : %s" % self.sw_service_impl_policy)
+            result.append("sw_service_impl_policy : %s" % self.swServiceImplPolicy)
 
-        return "\n".join(result)
+        return "\n".join(result)
+    

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswOverview.py

@@ -19,30 +19,26 @@ class BswModuleDescription(ARElement):
         super().__init__(parent, short_name)
 
         # MODULE-ID
-        self.module_id = None                           # type: ARPositiveInteger           
+        self.moduleId = None                           # type: ARPositiveInteger
+
         # PROVIDED-ENTRYS
-        self._implementedEntryRefs = []                 # type: List[RefType]
+        self.implementedEntryRefs = []                 # type: List[RefType]
 
         self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
         self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
+    
+    def getModuleId(self):
+        return self.moduleId
+
+    def setModuleId(self, value):
+        self.moduleId = value
+        return self
 
     def addImplementedEntry(self, entry_ref: RefType):
-        self._implementedEntryRefs.append(entry_ref)
+        self.implementedEntryRefs.append(entry_ref)
 
     def getImplementedEntries(self) -> List[RefType]:
-        return self._implementedEntryRefs
-
-    #@property
-    #def category(self) -> str:
-    #    return ARElement.getCategory(self)
-
-    #@category.setter
-    #def category(self, value:str):
-    #    if value is None:
-    #        return
-    #    if value not in ("BSW_MODULE", "BSW_CLUSTER", "LIBRARY"):
-    #        raise ValueError("Invalid category <%s> of BswModuleDescription <%s>" % (value, self.short_name))
-    #    ARElement.setCategory(self, value)
+        return self.implementedEntryRefs
 
     def createProvidedModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
         if (short_name not in self.elements):

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

@@ -0,0 +1,70 @@
+from typing import List
+from ....M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Identifier
+from ....M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable
+
+class FlatInstanceDescriptor(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        
+        self.ecuExtractReferenceIRef = None                     # type: AnyInstanceRef
+        self.role = None                                        # type: Identifier
+        self.rtePluginProps = None                              # type: RtePluginProps
+        self.swDataDefProps = None                              # type: SwDataDefProps
+        self.upstreamReferenceIRef = None                       # type: AnyInstanceRef
+
+    def getEcuExtractReferenceIRef(self):
+        return self.ecuExtractReferenceIRef
+
+    def setEcuExtractReferenceIRef(self, value):
+        self.ecuExtractReferenceIRef = value
+        return self
+
+    def getRole(self):
+        return self.role
+
+    def setRole(self, value):
+        self.role = value
+        return self
+
+    def getRtePluginProps(self):
+        return self.rtePluginProps
+
+    def setRtePluginProps(self, value):
+        self.rtePluginProps = value
+        return self
+
+    def getSwDataDefProps(self):
+        return self.swDataDefProps
+
+    def setSwDataDefProps(self, value):
+        self.swDataDefProps = value
+        return self
+
+    def getUpstreamReferenceIRef(self):
+        return self.upstreamReferenceIRef
+
+    def setUpstreamReferenceIRef(self, value):
+        self.upstreamReferenceIRef = value
+        return self
+
+
+class FlatMap(ARElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.instances = []                                 # type: List[FlatInstanceDescriptor]
+
+    def getInstances(self):
+        return list(sorted(filter(lambda a: isinstance(a, FlatInstanceDescriptor), self.elements.values()), key= lambda o:o.short_name))
+
+    def createFlatInstanceDescriptor(self, short_name: str):
+        if (short_name not in self.elements):
+            element = FlatInstanceDescriptor(self, short_name)
+            self.addElement(element)
+            self.instances.append(element)
+        return self.getElement(short_name)
+
+

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

@@ -1,6 +1,6 @@
 from abc import ABCMeta
 from typing import List
-from ....M2.AUTOSARTemplates.CommonStructure import ResourceConsumption
+from ....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import ResourceConsumption
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, PackageableElement, Referrable
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger, RefType, ARLiteral, String
@@ -28,17 +28,18 @@ class Code(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._artifactDescriptors = []          # type: List[AutosarEngineeringObject]
+        self.artifactDescriptors = []          # type: List[AutosarEngineeringObject]
         self.callbackHeaderRefs = []            # type: List[RefType]
 
     def addArtifactDescriptor(self, desc: AutosarEngineeringObject):
-        self._artifactDescriptors.append(desc)
+        self.artifactDescriptors.append(desc)
+        return self
 
     def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
         if (category == ""):
-            return self._artifactDescriptors
+            return self.artifactDescriptors
         else:
-            return list(filter(lambda a: a.getCategory().getText() == category, self._artifactDescriptors))
+            return list(filter(lambda a: a.getCategory().getText() == category, self.artifactDescriptors))
 
 class Compiler(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
@@ -199,10 +200,12 @@ class Implementation(PackageableElement, metaclass = ABCMeta):
     def getResourceConsumption(self):
         return self.resourceConsumption
 
-    def setResourceConsumption(self, consumption: ResourceConsumption):
-        self.elements[consumption.short_name] = consumption
-        self.resourceConsumption = consumption
-        return self
+    def createResourceConsumption(self, short_name: str) -> ResourceConsumption:
+        if (short_name not in self.elements):
+            consumption = ResourceConsumption(self, short_name)
+            self.addElement(consumption)
+            self.resourceConsumption = consumption
+        return self.getElement(short_name)
 
     def getSwcBswMappingRef(self):
         return self.swcBswMappingRef

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/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/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