armodel 1.7.6__py3-none-any.whl → 1.7.8__py3-none-any.whl

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

@@ -1,9 +1,11 @@
+from ....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import VariableDataPrototype
 from ....M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalBehavior
 from ....M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroupPrototype
+from ....M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARPositiveInteger, RefType
-from typing import Dict, List
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger, RefType
+from typing import List
 
 class BswModuleDescription(ARElement):
     '''
@@ -18,56 +20,153 @@ class BswModuleDescription(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        # MODULE-ID
-        self.moduleId = None                           # type: ARPositiveInteger
+        self.bswModuleDependencies = []                         # type: List[BswModuleDependency]
+        self.bswModuleDocumentation = None                      # type: SwComponentDocumentation
+        self.expectedEntryRefs = []                             # type: List[RefType]
+        self.implementedEntryRefs = []                          # type: List[RefType]
+        self.internalBehaviors = []                             # type: List[BswInternalBehavior]
+        self.moduleId = None                                    # type: PositiveInteger
+        self.providedClientServerEntries = []                   # type: List[BswModuleClientServerEntry]
+        self.providedDatas = []                                 # type: List[VariableDataPrototype]
+        self.providedModeGroups   = []                          # type: List[ModeDeclarationGroupPrototype]
+        self.releasedTriggers = []                              # type: List[Trigger]
+        self.requiredClientServerEntries = []                   # type: List[BswModuleClientServerEntry]
+        self.requiredDatas = []                                 # type: List[VariableDataPrototype]
+        self.requiredModeGroups = []                            # type: List[ModeDeclarationGroupPrototype]
+        self.requiredTriggers = []                              # typeL List[Trigger]
 
-        # PROVIDED-ENTRYS
-        self.implementedEntryRefs = []                 # type: List[RefType]
+    def getBswModuleDependencies(self):
+        return self.bswModuleDependencies
 
-        self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
-        self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
+    def setBswModuleDependencies(self, value):
+        if value is not None:
+            self.bswModuleDependencies = value
+        return self
+
+    def getBswModuleDocumentation(self):
+        return self.bswModuleDocumentation
+
+    def setBswModuleDocumentation(self, value):
+        if value is not None:
+            self.bswModuleDocumentation = value
+        return self
+
+    def getExpectedEntryRefs(self):
+        return self.expectedEntryRefs
+
+    def setExpectedEntryRefs(self, value):
+        if value is not None:
+            self.expectedEntryRefs = value
+        return self
+
+    def getImplementedEntryRefs(self):
+        return self.implementedEntryRefs
+
+    def addImplementedEntryRef(self, value):
+        if value is not None:
+            self.implementedEntryRefs.append(value)
+        return self
+
+    def getInternalBehaviors(self):
+        return self.internalBehaviors
+
+    def setInternalBehaviors(self, value):
+        if value is not None:
+            self.internalBehaviors = value
+        return self
     
+    def createBswInternalBehavior(self, short_name: str) -> BswInternalBehavior:
+        '''
+            Create the INTERNAL-BEHAVIORS tag
+        '''
+        if (not self.IsElementExists(short_name)):
+            behavior = BswInternalBehavior(self, short_name)
+            self.addElement(behavior)
+            self.internalBehaviors.append(behavior)
+        return self.getElement(short_name)
+
     def getModuleId(self):
         return self.moduleId
 
     def setModuleId(self, value):
-        self.moduleId = value
+        if value is not None:
+            self.moduleId = value
         return self
 
-    def addImplementedEntry(self, entry_ref: RefType):
-        self.implementedEntryRefs.append(entry_ref)
+    def getProvidedClientServerEntries(self):
+        return self.providedClientServerEntries
 
-    def getImplementedEntries(self) -> List[RefType]:
-        return self.implementedEntryRefs
+    def setProvidedClientServerEntries(self, value):
+        if value is not None:
+            self.providedClientServerEntries = value
+        return self
+
+    def getProvidedDatas(self):
+        return self.providedDatas
+
+    def createProvidedData(self, short_name: str) -> VariableDataPrototype:
+        if (not self.IsElementExists(short_name)):
+            prototype = VariableDataPrototype(self, short_name)
+            self.addElement(prototype)
+            self.providedDatas.append(prototype)
+        return self.getElement(short_name)
 
+    def getProvidedModeGroups(self):
+        return self.providedModeGroups
+    
     def createProvidedModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             prototype = ModeDeclarationGroupPrototype(self, short_name)
-            self.elements[short_name] = prototype
-            self.providedModeGroups[short_name] = prototype
-        return self.elements[short_name]
+            self.addElement(prototype)
+            self.providedModeGroups.append(prototype)
+        return self.getElement(short_name)
+
+    def getReleasedTriggers(self):
+        return self.releasedTriggers
 
-    def getProvidedModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
-        return sorted(self.providedModeGroups.values(), key=lambda v: v.short_name)
+    def createReleasedTrigger(self, short_name: str) -> Trigger:
+        if (not self.IsElementExists(short_name)):
+            trigger = Trigger(self, short_name)
+            self.addElement(trigger)
+            self.releasedTriggers.append(trigger)
+        return self.getElement(short_name)
+
+    def getRequiredClientServerEntries(self):
+        return self.requiredClientServerEntries
+
+    def setRequiredClientServerEntries(self, value):
+        if value is not None:
+            self.requiredClientServerEntries = value
+        return self
+
+    def getRequiredDatas(self):
+        return self.requiredDatas
+
+    def createRequiredData(self, short_name: str) -> VariableDataPrototype:
+        if (not self.IsElementExists(short_name)):
+            prototype = VariableDataPrototype(self, short_name)
+            self.addElement(prototype)
+            self.requiredDatas.append(prototype)
+        return self.getElement(short_name)
+
+    def getRequiredModeGroups(self):
+        return self.requiredModeGroups
 
     def createRequiredModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             prototype = ModeDeclarationGroupPrototype(self, short_name)
-            self.elements[short_name] = prototype
-            self.requiredModeGroups[short_name] = property
-        return self.elements[short_name]
+            self.addElement(prototype)
+            self.requiredModeGroups.append(prototype)
+        return self.getElement(short_name)
 
-    def getRequiredModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
-        return sorted(self.requiredModeGroups.values(), key=lambda v: v.short_name)
+    def getRequiredTriggers(self):
+        return self.requiredTriggers
 
-    def createBswInternalBehavior(self, short_name: str) -> BswInternalBehavior:
-        '''
-            Create the INTERNAL-BEHAVIORS tag
-        '''
-        if (short_name not in self.elements):
-            prototype = BswInternalBehavior(self, short_name)
-            self.elements[short_name] = prototype
-        return self.elements[short_name]
+    def createRequiredTrigger(self, short_name: str) -> Trigger:
+        if (not self.IsElementExists(short_name)):
+            trigger = Trigger(self, short_name)
+            self.addElement(trigger)
+            self.requiredTriggers.append(trigger)
+        return self.getElement(short_name)
 
-    def getBswInternalBehaviors(self) -> List[BswInternalBehavior]:
-        return list(filter(lambda a: isinstance(a, BswInternalBehavior), self.elements.values()))
+    

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

@@ -40,47 +40,57 @@ class DataFilter(ARObject):
         return self.dataFilterType
 
     def setDataFilterType(self, value):
-        self.dataFilterType = value
+        if value is not None:
+            self.dataFilterType = value
         return self
 
     def getMask(self):
         return self.mask
 
     def setMask(self, value):
-        self.mask = value
+        if value is not None:
+            self.mask = value
         return self
 
     def getMax(self):
         return self.max
 
     def setMax(self, value):
-        self.max = value
+        if value is not None:
+            self.max = value
         return self
 
     def getMin(self):
         return self.min
 
     def setMin(self, value):
-        self.min = value
+        if value is not None:
+            self.min = value
         return self
 
     def getOffset(self):
         return self.offset
 
     def setOffset(self, value):
-        self.offset = value
+        if value is not None:
+            self.offset = value
         return self
 
     def getPeriod(self):
         return self.period
 
     def setPeriod(self, value):
-        self.period = value
+        if value is not None:
+            self.period = value
         return self
 
     def getX(self):
         return self.x
 
     def setX(self, value):
-        self.x = value
+        if value is not None:
+            self.x = value
         return self
+
+
+    

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

@@ -4,7 +4,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 ARFloat, RefType
-from ....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype
+from ....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype, VariableDataPrototype
 
 class ReentrancyLevelEnum(Enum):
     ENUM_MULTICORE_REENTRANT = "multicoreReentrant"
@@ -109,7 +109,16 @@ class InternalBehavior(Identifiable, metaclass=ABCMeta):
 
     def getExclusiveAreas(self) -> List[ExclusiveArea]:
         return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
+    
+    def getStaticMemories(self):
+        return self.staticMemories
 
+    def createStaticMemory(self, short_name: str) -> VariableDataPrototype:
+        if (short_name not in self.elements):
+            prototype = VariableDataPrototype(self, short_name)
+            self.addElement(prototype)
+            self.staticMemories.append(prototype)
+        return self.getElement(short_name)
 
 class AbstractEvent(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):

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

@@ -5,5 +5,21 @@ class Trigger(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.swImplPolicy = None    # type: str
-        self.triggerPeriod = None   # type: float
+        self.swImplPolicy = None                                # type: SwImplPolicyEnum
+        self.triggerPeriod = None                               # type: MultidimensionalTime
+
+    def getSwImplPolicy(self):
+        return self.swImplPolicy
+
+    def setSwImplPolicy(self, value):
+        if value is not None:
+            self.swImplPolicy = value
+        return self
+
+    def getTriggerPeriod(self):
+        return self.triggerPeriod
+
+    def setTriggerPeriod(self, value):
+        if value is not None:
+            self.triggerPeriod = value
+        return self

armodel/models/M2/AUTOSARTemplates/ECUCDescriptionTemplate.py

@@ -7,6 +7,7 @@ from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject imp
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, RefType, ARBoolean
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
 
+
 class EcucValueCollection(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -27,26 +28,21 @@ class EcucValueCollection(ARElement):
     def setEcuExtractRef(self, value):
         self.ecuExtractRef = value
         return self
-    
-class EcucIndexableValue(ARObject, metaclass = ABCMeta):
+
+
+class EcucIndexableValue(ARObject, metaclass=ABCMeta):
     def __init__(self):
-        if type(self) == EcucIndexableValue:
+        if type(self) is EcucIndexableValue:
             raise NotImplementedError("EcucIndexableValue is an abstract class.")
-        
-        super().__init__()
 
-class EcucAbstractReferenceValue(EcucIndexableValue, metaclass=ABCMeta):
-    def __init__(self):
-        if type(self) == EcucAbstractReferenceValue:
-            raise NotImplementedError("EcucAbstractReferenceValue is an abstract class.")
-        
         super().__init__()
-    
+
+
 class EcucParameterValue(EcucIndexableValue, metaclass=ABCMeta):
     def __init__(self):
-        if type(self) == EcucParameterValue:
+        if type(self) is EcucParameterValue:
             raise NotImplementedError("EcucParameterValue is an abstract class.")
-        
+
         super().__init__()
 
         self.annotations = []                       # type: List[Annotation]
@@ -74,6 +70,7 @@ class EcucParameterValue(EcucIndexableValue, metaclass=ABCMeta):
         self.isAutoValue = value
         return self
 
+
 class EcucAddInfoParamValue(EcucParameterValue):
     def __init__(self):
         super().__init__()
@@ -86,6 +83,7 @@ class EcucAddInfoParamValue(EcucParameterValue):
     def setValue(self, value: DocumentationBlock):
         self.value = value
 
+
 class EcucTextualParamValue(EcucParameterValue):
     def __init__(self):
         super().__init__()
@@ -95,7 +93,7 @@ class EcucTextualParamValue(EcucParameterValue):
     def getValue(self) -> ARLiteral:
         return self.value
 
-    def setValue(self, value:ARLiteral):
+    def setValue(self, value: ARLiteral):
         self.value = value
 
 
@@ -111,11 +109,12 @@ class EcucNumericalParamValue(EcucParameterValue):
     def setValue(self, value: ARNumerical):
         self.value = value
 
+
 class EcucAbstractReferenceValue(EcucIndexableValue, metaclass=ABCMeta):
     def __init__(self):
-        if type(self) == EcucAbstractReferenceValue:
+        if type(self) is EcucAbstractReferenceValue:
             raise NotImplementedError("EcucAbstractReferenceValue is an abstract class.")
-        
+
         super().__init__()
 
         self.annotations = []                       # type: List[Annotation]
@@ -143,6 +142,7 @@ class EcucAbstractReferenceValue(EcucIndexableValue, metaclass=ABCMeta):
         self.isAutoValue = value
         return self
 
+
 class EcucInstanceReferenceValue(EcucAbstractReferenceValue):
     def __init__(self):
         super().__init__()
@@ -156,6 +156,7 @@ class EcucInstanceReferenceValue(EcucAbstractReferenceValue):
         self.valueRef = value
         return self
 
+
 class EcucReferenceValue(EcucAbstractReferenceValue):
     def __init__(self):
         super().__init__()
@@ -169,6 +170,7 @@ class EcucReferenceValue(EcucAbstractReferenceValue):
         self.valueRef = value
         return self
 
+
 class EcucContainerValue(ARElement, EcucIndexableValue):
     def __init__(self, parent: ARObject, short_name: str):
         ARElement.__init__(self, parent, short_name)
@@ -185,7 +187,7 @@ class EcucContainerValue(ARElement, EcucIndexableValue):
         self.definitionRef = value
         return self
 
-    def getParameterValues(self)-> List[EcucParameterValue]:
+    def getParameterValues(self) -> List[EcucParameterValue]:
         return self.parameterValues
 
     def addParameterValue(self, value: EcucParameterValue):
@@ -229,7 +231,7 @@ class EcucModuleConfigurationValues(ARElement):
         return self.elements[short_name]
 
     def getContainers(self) -> List[EcucContainerValue]:
-        return list(sorted(filter(lambda a: isinstance(a, EcucContainerValue), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, EcucContainerValue), self.elements.values()), key=lambda o: o.short_name))
 
     def getDefinitionRef(self) -> RefType:
         return self.definitionRef
@@ -265,4 +267,3 @@ class EcucModuleConfigurationValues(ARElement):
     def setPostBuildVariantUsed(self, value: ARBoolean):
         self.postBuildVariantUsed = value
         return self
-

armodel/models/M2/AUTOSARTemplates/EcuResourceTemplate/HwElementCategory.py

@@ -0,0 +1,59 @@
+from typing import List
+
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Boolean, RefType
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable
+
+
+class HwType(ARElement):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+
+class HwAttributeDef(Identifiable):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.hwAttributeLiterals = []                       # type: List[HwAttributeLiteralDef]
+        self.isRequired = None                              # type: Boolean
+        self.unitRef = None                                 # type: RefType
+
+    def getHwAttributeLiterals(self):
+        return self.hwAttributeLiterals
+
+    def setHwAttributeLiterals(self, value):
+        if value is not None:
+            self.hwAttributeLiterals = value
+        return self
+
+    def getIsRequired(self):
+        return self.isRequired
+
+    def setIsRequired(self, value):
+        if value is not None:
+            self.isRequired = value
+        return self
+
+    def getUnitRef(self):
+        return self.unitRef
+
+    def setUnitRef(self, value):
+        if value is not None:
+            self.unitRef = value
+        return self
+
+
+class HwCategory(ARElement):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.hwAttributeDefs = []                           # type: List[HwAttributeDef]
+
+    def getHwAttributeDefs(self):
+        return self.hwAttributeDefs
+
+    def createHwAttributeDef(self, short_name: str) -> HwAttributeDef:
+        if (not self.IsElementExists(short_name)):
+            pin_group = HwAttributeDef(self, short_name)
+            self.addElement(pin_group)
+            self.hwAttributeDefs.append(pin_group)
+        return self.getElement(short_name)

armodel/models/M2/AUTOSARTemplates/EcuResourceTemplate/__init__.py

@@ -0,0 +1,145 @@
+from typing import List
+
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Integer, RefType, String
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
+
+
+class HwDescriptionEntity(ARElement):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+        
+        self.hwAttributeValues = []                                 # type: List[HwAttributeValue]
+        self.hwCategoryRefs = []                                    # type: List[RefType]
+        self.hwTypeRef = None                                       # type: RefType
+
+    def getHwAttributeValues(self):
+        return self.hwAttributeValues
+
+    def setHwAttributeValues(self, value):
+        if value is not None:
+            self.hwAttributeValues = value
+        return self
+
+    def getHwCategoryRefs(self):
+        return self.hwCategoryRefs
+
+    def addHwCategoryRef(self, value):
+        if value is not None:
+            self.hwCategoryRefs.append(value)
+        return self
+
+    def getHwTypeRef(self):
+        return self.hwTypeRef
+
+    def setHwTypeRef(self, value):
+        if value is not None:
+            self.hwTypeRef = value
+        return self
+    
+
+class HwPin(HwDescriptionEntity):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.functionName = None                                    # type: String
+        self.packagingPinName = None                                # type: String
+        self.pinNumber = None                                       # type: Integer
+
+    def getFunctionName(self):
+        return self.functionName
+
+    def setFunctionName(self, value):
+        if value is not None:
+            self.functionName = value
+        return self
+
+    def getPackagingPinName(self):
+        return self.packagingPinName
+
+    def setPackagingPinName(self, value):
+        if value is not None:
+            self.packagingPinName = value
+        return self
+
+    def getPinNumber(self):
+        return self.pinNumber
+
+    def setPinNumber(self, value):
+        if value is not None:
+            self.pinNumber = value
+        return self
+
+
+class HwPinGroupContent(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.hwPin = None                                           # type: HwPin
+        self.hwPinGroup = None                                      # type: HwPinGroup
+
+    def getHwPin(self):
+        return self.hwPin
+
+    def createHwPin(self, short_name: str) -> HwPin:
+        pin = HwPin(self, short_name)
+        self.hwPin = pin
+        return pin
+
+    def getHwPinGroup(self):
+        return self.hwPinGroup
+
+    def setHwPinGroup(self, value):
+        if value is not None:
+            self.hwPinGroup = value
+        return self
+
+
+class HwPinGroup(HwDescriptionEntity):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.hwPinGroupContent = None                               # type: HwPinGroupContent
+
+    def getHwPinGroupContent(self):
+        return self.hwPinGroupContent
+
+    def setHwPinGroupContent(self, value):
+        if value is not None:
+            self.hwPinGroupContent = value
+        return self
+
+
+class HwElement(HwDescriptionEntity):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.hwElementConnections = []                              # type: List[HwElementConnector]
+        self.hwPinGroups = []                                       # type: List[HwPinGroup]
+        self.nestedElementRefs = []                                 # type: List[RefType]
+
+    def getHwElementConnections(self):
+        return self.hwElementConnections
+
+    def setHwElementConnections(self, value):
+        if value is not None:
+            self.hwElementConnections = value
+        return self
+
+    def getHwPinGroups(self):
+        return self.hwPinGroups
+
+    def createHwPinGroup(self, short_name: str) -> HwPinGroup:
+        if (not self.IsElementExists(short_name)):
+            pin_group = HwPinGroup(self, short_name)
+            self.addElement(pin_group)
+            self.hwPinGroups.append(pin_group)
+        return self.getElement(short_name)
+
+    def getNestedElementRefs(self):
+        return self.nestedElementRefs
+
+    def setNestedElementRefs(self, value):
+        if value is not None:
+            self.nestedElementRefs = value
+        return self