armodel 1.7.7__py3-none-any.whl → 1.7.9__py3-none-any.whl

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

@@ -1,9 +1,45 @@
 from typing import List
 
 from ....M2.MSR.DataDictionary.ServiceProcessTask import SwServiceArg
+from ....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import ServiceNeeds
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, Boolean, Identifier, NameToken
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable, Referrable
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, Boolean, Identifier, NameToken, RefType
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger
+
+
+class BswModuleDependency(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.serviceItems = []                      # type: List[ServiceNeeds]
+        self.targetModuleId = None                  # type: PositiveInteger
+        self.targetModuleRef = None                 # type: RefType
+
+    def getServiceItems(self):
+        return self.serviceItems
+
+    def setServiceItems(self, value):
+        if value is not None:
+            self.serviceItems = value
+        return self
+
+    def getTargetModuleId(self):
+        return self.targetModuleId
+
+    def setTargetModuleId(self, value):
+        if value is not None:
+            self.targetModuleId = value
+        return self
+
+    def getTargetModuleRef(self):
+        return self.targetModuleRef
+
+    def setTargetModuleRef(self, value):
+        if value is not None:
+            self.targetModuleRef = value
+        return self
+
 
 class BswModuleEntry(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
@@ -109,18 +145,53 @@ class BswModuleEntry(ARElement):
         result = []
 
         result.append("short_name             : %s" % self.short_name)
-        if self.serviceId != None:
+        if self.serviceId is not None:
             result.append("service_id             : %d" % self.serviceId)
-        if self.isReentrant != None:
+        if self.isReentrant is not None:
             result.append("is_reentrant           : %s" % self.isReentrant)
-        if self.isSynchronous != None:
+        if self.isSynchronous is not None:
             result.append("is_synchronous         : %s" % self.isSynchronous)
-        if self.callType != None:
+        if self.callType is not None:
             result.append("call_type              : %s" % self.callType)
-        if self.execution_context != None:
+        if self.executionContext is not None:
             result.append("execution_context      : %s" % self.executionContext)
-        if self.sw_service_impl_policy != None:
+        if self.swServiceImplPolicy is not None:
             result.append("sw_service_impl_policy : %s" % self.swServiceImplPolicy)
 
         return "\n".join(result)
-    
+
+
+class BswModuleClientServerEntry(Referrable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.encapsulatedEntryRef = None                        # type: RefType
+        self.isReentrant = None                                 # type: Boolean
+        self.isSynchronous = None                               # type: Boolean
+
+    def getEncapsulatedEntryRef(self):
+        return self.encapsulatedEntryRef
+
+    def setEncapsulatedEntryRef(self, value):
+        if value is not None:
+            self.encapsulatedEntryRef = value
+        return self
+
+    def getIsReentrant(self):
+        return self.isReentrant
+
+    def setIsReentrant(self, value):
+        if value is not None:
+            self.isReentrant = value
+        return self
+
+    def getIsSynchronous(self):
+        return self.isSynchronous
+
+    def setIsSynchronous(self, value):
+        if value is not None:
+            self.isSynchronous = value
+        return self
+
+
+    

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

@@ -1,9 +1,14 @@
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.SoftwareComponentDocumentation import SwComponentDocumentation
+from ....M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleClientServerEntry, BswModuleDependency
 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 ....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import VariableDataPrototype
+from typing import List
+
 
 class BswModuleDescription(ARElement):
     '''
@@ -18,56 +23,157 @@ 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]
+
+    def getBswModuleDependencies(self):
+        return self.bswModuleDependencies
+
+    def setBswModuleDependencies(self, value):
+        if value is not None:
+            self.bswModuleDependencies = value
+        return self
+
+    def getBswModuleDocumentation(self):
+        return self.bswModuleDocumentation
 
-        # PROVIDED-ENTRYS
-        self.implementedEntryRefs = []                 # type: List[RefType]
+    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
 
-        self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
-        self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
+    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 createProvidedClientServerEntry(self, short_name: str) -> BswModuleClientServerEntry:
+        if (not self.IsElementExists(short_name)):
+            entry = BswModuleClientServerEntry(self, short_name)
+            self.addElement(entry)
+            self.providedClientServerEntries.append(entry)
+        return self.getElement(short_name)
+
+    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 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 getProvidedModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
-        return sorted(self.providedModeGroups.values(), key=lambda v: v.short_name)
+    def getRequiredClientServerEntries(self):
+        return self.requiredClientServerEntries
+
+    def createRequiredClientServerEntry(self, short_name: str) -> BswModuleClientServerEntry:
+        if (not self.IsElementExists(short_name)):
+            entry = BswModuleClientServerEntry(self, short_name)
+            self.addElement(entry)
+            self.requiredClientServerEntries.append(entry)
+        return self.getElement(short_name)
+
+    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/Implementation.py

@@ -7,9 +7,9 @@ from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTy
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 
 
-class ImplementationProps(Referrable, metaclass = ABCMeta):
+class ImplementationProps(Referrable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == ImplementationProps:
+        if type(self) is ImplementationProps:
             raise NotImplementedError("ImplementationProps is an abstract class.")
         
         super().__init__(parent, short_name)
@@ -35,12 +35,13 @@ class Code(Identifiable):
         self.artifactDescriptors.append(desc)
         return self
 
-    def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
+    def getArtifactDescriptors(self, category: str = "") -> List[AutosarEngineeringObject]:
         if (category == ""):
             return self.artifactDescriptors
         else:
             return list(filter(lambda a: a.getCategory().getText() == category, self.artifactDescriptors))
 
+
 class Compiler(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -77,7 +78,8 @@ class Compiler(Identifiable):
     def setVersion(self, value):
         self.version = value
         return self
-    
+
+
 class DependencyOnArtifact(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -101,9 +103,9 @@ class DependencyOnArtifact(Identifiable):
         return self
 
 
-class Implementation(PackageableElement, metaclass = ABCMeta):
+class Implementation(PackageableElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == Implementation:
+        if type(self) is Implementation:
             raise NotImplementedError("Implementation is an abstract class.")
 
         super().__init__(parent, short_name)
@@ -131,8 +133,8 @@ class Implementation(PackageableElement, metaclass = ABCMeta):
         self.buildActionManifestRef = value
         return self
 
-    def getCodeDescriptors(self)-> List[Code]:
-        return list(filter(lambda a : isinstance(a, Code), self.elements.values()))
+    def getCodeDescriptors(self) -> List[Code]:
+        return list(filter(lambda a: isinstance(a, Code), self.elements.values()))
 
     def createCodeDescriptor(self, short_name: str) -> Code:
         if (short_name not in self.elements):

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

@@ -4,13 +4,15 @@ 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"
     ENUM_NON_REENTRANT = "nonReentrant"
     ENUM_SINGLE_CORE_REENTRANT = "singleCoreReentrant"
 
+
 class ExclusiveArea(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -18,16 +20,15 @@ class ExclusiveArea(Identifiable):
 
 class ExecutableEntity(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == ExecutableEntity:
+        if type(self) is ExecutableEntity:
             raise NotImplementedError("ExecutableEntity is an abstract class.")
 
         super().__init__(parent, short_name)
 
         self.activationReasons = []                 # type: List[ExecutableEntityActivationReason]
-        self.canEnterExclusiveAreaRefs = []         # type: List[RefType]  
+        self.canEnterExclusiveAreaRefs = []         # type: List[RefType]
         self.minimumStartInterval = None            # type: ARFloat
-        self.reentrancyLevel = None                 # 
-        
+        self.reentrancyLevel = None                 # type: ReentrancyLevelEnum
         self.swAddrMethodRef = None                 # type: RefType
 
     def getActivationReasons(self):
@@ -73,7 +74,7 @@ class ExecutableEntity(Identifiable, metaclass=ABCMeta):
 
 class InternalBehavior(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == InternalBehavior:
+        if type(self) is InternalBehavior:
             raise NotImplementedError("InternalBehavior is an abstract class.")
         super().__init__(parent, short_name)
 
@@ -109,6 +110,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):

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

@@ -3,11 +3,45 @@ from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject im
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, PositiveInteger, RefType, TRefType
 
+
+class ModeDeclarationGroupPrototypeMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.firstModeGroupRef = None                           # type: RefType
+        self.modeDeclarationMappingSetRef = None                # type: RefType
+        self.secondModeGroupRef = None                          # type: RefType
+
+    def getFirstModeGroupRef(self):
+        return self.firstModeGroupRef
+
+    def setFirstModeGroupRef(self, value):
+        if value is not None:
+            self.firstModeGroupRef = value
+        return self
+
+    def getModeDeclarationMappingSetRef(self):
+        return self.modeDeclarationMappingSetRef
+
+    def setModeDeclarationMappingSetRef(self, value):
+        if value is not None:
+            self.modeDeclarationMappingSetRef = value
+        return self
+
+    def getSecondModeGroupRef(self):
+        return self.secondModeGroupRef
+
+    def setSecondModeGroupRef(self, value):
+        if value is not None:
+            self.secondModeGroupRef = value
+        return self
+
+
 class ModeDeclaration(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.value = None                           # type: ARNumerical
+        self.value = None                                               # type: ARNumerical
 
     def setValue(self, value):
         self.value = value
@@ -38,6 +72,7 @@ class ModeRequestTypeMap(ARObject):
         self.modeGroupRef = value
         return self
 
+
 class ModeDeclarationGroup(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -56,7 +91,7 @@ class ModeDeclarationGroup(Identifiable):
         return self.elements[short_name]
 
     def getModeDeclarations(self) -> List[ModeDeclaration]:
-        return list(sorted(filter(lambda a: isinstance(a, ModeDeclaration), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, ModeDeclaration), self.elements.values()), key=lambda o: o.short_name))
 
     def setInitialModeRef(self, ref: RefType):
         self.initialModeRef = ref
@@ -110,4 +145,4 @@ class ModeDeclarationGroupPrototype(Identifiable):
 
     def setTypeTRef(self, value):
         self.typeTRef = value
-        return self
+        return self