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

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

@@ -6,16 +6,21 @@ from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBe
 from .....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype, VariableDataPrototype
 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, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, ModeSwitchedAckEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, BackgroundEvent
+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
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import SwcServiceDependency
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, Boolean, RefType, ARBoolean
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
-from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet, ModeAccessPoint, ModeSwitchPoint
+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.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
 
+
 class RunnableEntityArgument(ARObject):
     def __init__(self):
         super().__init__()
@@ -28,7 +33,8 @@ class RunnableEntityArgument(ARObject):
     def setSymbol(self, value):
         self.symbol = value
         return self
-    
+
+
 class AsynchronousServerCallResultPoint(AbstractAccessPoint):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -40,12 +46,14 @@ class AsynchronousServerCallResultPoint(AbstractAccessPoint):
 
     def setAsynchronousServerCallPointRef(self, value):
         self.asynchronousServerCallPointRef = value
-        return self    
+        return self
+
 
 class AsynchronousServerCallPoint(ServerCallPoint):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+
 class SynchronousServerCallPoint(ServerCallPoint):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -59,42 +67,57 @@ class SynchronousServerCallPoint(ServerCallPoint):
         self.calledFromWithinExclusiveAreaRef = value
         return self
 
+
 class RunnableEntity(ExecutableEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.arguments = []                             # type: List[RunnableEntityArgument]
-        self.asynchronousServerCallResultPoints = []    # type: List[AsynchronousServerCallResultPoint]
+        # type: List[RunnableEntityArgument]
+        self.arguments = []
+        # type: List[AsynchronousServerCallResultPoint]
+        self.asynchronousServerCallResultPoints = []
         self.canBeInvokedConcurrently = None            # type: ARBoolean
-        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, VariableAccess]
-        self.externalTriggeringPoints = {}              # type: Dict[str, ExternalTriggeringPoint]
-        self.internalTriggeringPoints = {}              # type: Dict[str, InternalTriggeringPoint]
+        # 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]
-        self.parameterAccesses = {}                     # type: Dict[str, ParameterAccess]
-        self.readLocalVariables = {}                    # type: Dict[str, VariableAccess]
-        self.serverCallPoints = {}                      # type: Dict[str, ServerCallPoint]
+        # type: Dict[str, ParameterAccess]
+        self.parameterAccesses = {}
+        # type: Dict[str, VariableAccess]
+        self.readLocalVariables = {}
+        # type: Dict[str, ServerCallPoint]
+        self.serverCallPoints = {}
         self.symbol = None                              # type: ARLiteral
-        self.waitPoints = {}                            # type: Dict[str, WaitPoint]
-        self.writtenLocalVariables = {}               # type: Dict[str, VariableAccess]
+        # type: Dict[str, WaitPoint]
+        self.waitPoints = {}
+        # type: Dict[str, VariableAccess]
+        self.writtenLocalVariables = {}
 
     def _createVariableAccess(self, short_name, variable_accesses: Dict[str, VariableAccess]):
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             variable_access = VariableAccess(self, short_name)
             variable_accesses[short_name] = variable_access
         return variable_accesses[short_name]
-    
+
     def getArguments(self):
         return self.arguments
 
     def addArgument(self, value):
         self.arguments.append(value)
         return self
-    
+
     def getCanBeInvokedConcurrently(self):
         return self.canBeInvokedConcurrently
 
@@ -103,25 +126,25 @@ class RunnableEntity(ExecutableEntity):
         return self
 
     def createDataReadAccess(self, short_name: str) -> VariableAccess:
-       return self._createVariableAccess(short_name, self.dataReadAccesses)
+        return self._createVariableAccess(short_name, self.dataReadAccesses)
 
     def getDataReadAccesses(self) -> List[VariableAccess]:
         return sorted(self.dataReadAccesses.values(), key=lambda v: v.short_name)
-    
+
     def createDataWriteAccess(self, short_name: str) -> VariableAccess:
-       return self._createVariableAccess(short_name, self.dataWriteAccesses)
+        return self._createVariableAccess(short_name, self.dataWriteAccesses)
 
     def getDataWriteAccesses(self) -> List[VariableAccess]:
         return sorted(self.dataWriteAccesses.values(), key=lambda v: v.short_name)
 
     def createDataReceivePointByArgument(self, short_name: str) -> VariableAccess:
-       return self._createVariableAccess(short_name, self.dataReceivePointByArguments)
+        return self._createVariableAccess(short_name, self.dataReceivePointByArguments)
 
     def getDataReceivePointByArguments(self) -> List[VariableAccess]:
         return sorted(self.dataReceivePointByArguments.values(), key=lambda v: v.short_name)
 
     def createDataReceivePointByValue(self, short_name: str) -> VariableAccess:
-       return self._createVariableAccess(short_name, self.dataReceivePointByValues)
+        return self._createVariableAccess(short_name, self.dataReceivePointByValues)
 
     def getDataReceivePointByValues(self) -> List[VariableAccess]:
         return sorted(self.dataReceivePointByValues.values(), key=lambda v: v.short_name)
@@ -130,45 +153,48 @@ class RunnableEntity(ExecutableEntity):
         return self._createVariableAccess(short_name, self.dataSendPoints)
 
     def getDataSendPoints(self) -> List[VariableAccess]:
-        return sorted(self.dataSendPoints.values(), key=lambda v: v.short_name)
+        # return sorted(self.dataSendPoints.values(), key=lambda v: v.short_name)
+        return self.dataSendPoints.values()
 
     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 sorted(self.readLocalVariables.values(), key=lambda v: v.short_name)
+        return self.readLocalVariables.values()
 
     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 sorted(self.writtenLocalVariables.values(), key=lambda v: v.short_name)
+        return self.writtenLocalVariables.values()
+
     def getParameterAccesses(self) -> List[ParameterAccess]:
-        return list(sorted(filter(lambda a: isinstance(a, ParameterAccess), self.elements.values()), key= lambda o:o.short_name))
-    
+        return list(sorted(filter(lambda a: isinstance(a, ParameterAccess), self.elements), key=lambda o: o.short_name))
+
     def createParameterAccess(self, short_name: str) -> ParameterAccess:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             access = ParameterAccess(self, short_name)
             self.addElement(access)
         return self.getElement(short_name)
-    
+
     def createSynchronousServerCallPoint(self, short_name: str) -> SynchronousServerCallPoint:
         if (short_name not in self.serverCallPoints):
             point = SynchronousServerCallPoint(self, short_name)
             self.addElement(point)
         return self.getElement(short_name)
-            #self.serverCallPoints[short_name] = server_call_point
-        #return self.serverCallPoints[short_name]
+        # self.serverCallPoints[short_name] = server_call_point
+        # return self.serverCallPoints[short_name]
 
     def createAsynchronousServerCallPoint(self, short_name: str) -> AsynchronousServerCallPoint:
         if (short_name not in self.serverCallPoints):
             point = AsynchronousServerCallPoint(self, short_name)
             self.addElement(point)
         return self.getElement(short_name)
-            #self.serverCallPoints[short_name] = server_call_point
-        #return self.serverCallPoints[short_name]
-    
+        # self.serverCallPoints[short_name] = server_call_point
+        # return self.serverCallPoints[short_name]
+
     def createAsynchronousServerCallResultPoint(self, short_name: str) -> AsynchronousServerCallResultPoint:
         if (short_name not in self.serverCallPoints):
             point = AsynchronousServerCallResultPoint(self, short_name)
@@ -176,42 +202,42 @@ class RunnableEntity(ExecutableEntity):
         return self.getElement(short_name)
 
     def getSynchronousServerCallPoint(self) -> List[SynchronousServerCallPoint]:
-        return list(sorted(filter(lambda a: isinstance(a, SynchronousServerCallPoint), self.elements.values()), key= lambda o:o.getShortName()))
-    
+        return list(sorted(filter(lambda a: isinstance(a, SynchronousServerCallPoint), self.elements), key=lambda o: o.getShortName()))
+
     def getAsynchronousServerCallPoint(self) -> List[AsynchronousServerCallPoint]:
-        return list(sorted(filter(lambda a: isinstance(a, AsynchronousServerCallPoint), self.elements.values()), key= lambda o:o.getShortName()))
-    
+        return list(sorted(filter(lambda a: isinstance(a, AsynchronousServerCallPoint), self.elements), key=lambda o: o.getShortName()))
+
     def getAsynchronousServerCallResultPoints(self) -> List[AsynchronousServerCallResultPoint]:
-        return list(sorted(filter(lambda a: isinstance(a, AsynchronousServerCallResultPoint), self.elements.values()), key= lambda o:o.getShortName()))
+        return list(sorted(filter(lambda a: isinstance(a, AsynchronousServerCallResultPoint), self.elements), key=lambda o: o.getShortName())) # noqa E501
 
     def getServerCallPoints(self) -> List[ServerCallPoint]:
-        return list(sorted(filter(lambda a: isinstance(a, ServerCallPoint), self.elements.values()), key= lambda o:o.getShortName()))
+        return list(sorted(filter(lambda a: isinstance(a, ServerCallPoint), self.elements), key=lambda o: o.getShortName()))
 
     def createInternalTriggeringPoint(self, short_name: str) -> InternalTriggeringPoint:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             point = InternalTriggeringPoint(self, short_name)
-            self.elements[point.short_name] = point
-        return self.elements[short_name]
+            self.addElement(point)
+        return self.getElement(short_name, InternalTriggeringPoint)
 
     def getInternalTriggeringPoints(self) -> List[InternalTriggeringPoint]:
         return filter(lambda o: isinstance(o, InternalTriggeringPoint), self.elements)
-    
+
     def getModeAccessPoints(self) -> List[ModeAccessPoint]:
         return self.modeAccessPoints
-    
+
     def addModeAccessPoint(self, value):
         self.modeAccessPoints.append(value)
-    
+
     def getModeSwitchPoints(self) -> List[ModeSwitchPoint]:
-        return list(sorted(filter(lambda a: isinstance(a, ModeSwitchPoint), self.elements.values()), key= lambda o:o.short_name))
-    
+        return list(sorted(filter(lambda a: isinstance(a, ModeSwitchPoint), self.elements), key=lambda o: o.short_name))
+
     def createModeSwitchPoint(self, short_name: str) -> ModeSwitchPoint:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             access = ModeSwitchPoint(self, short_name)
-            self.elements[short_name] = access
+            self.addElement(access)
             self.modeSwitchPoints.append(access)
-        return self.elements[short_name]
-    
+        return self.getElement(short_name, ModeSwitchPoint)
+
     def getSymbol(self):
         return self.symbol
 
@@ -224,29 +250,44 @@ class SwcInternalBehavior(InternalBehavior):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.arTypedPerInstanceMemories = []                        # type: List[VariableDataPrototype]
-        self.events = []                                            # type: List[RTEEvent]
-        self.exclusiveAreaPolicies = []                             # type: List[SwcExclusiveAreaPolicy]
-        self.explicitInterRunnableVariables = []                    # type: List[VariableDataPrototype]
+        # type: List[VariableDataPrototype]
+        self.arTypedPerInstanceMemories = []
+        # type: List[RTEEvent]
+        self.events = []
+        # type: List[SwcExclusiveAreaPolicy]
+        self.exclusiveAreaPolicies = []
+        # type: List[VariableDataPrototype]
+        self.explicitInterRunnableVariables = []
         self.handleTerminationAndRestart = None                     # type: str
-        self.implicitInterRunnableVariables = []                    # type: List[VariableDataPrototype]
-        self.includedDataTypeSets = []                              # type: List[IncludedDataTypeSet]
-        self.includedModeDeclarationGroupSets = []                  # type: List[IncludedModeDeclarationGroupSet]
-        self.instantiationDataDefProps = []                         # type: List[InstantiationDataDefProps]
-        self.perInstanceMemories = []                               # type: List[PerInstanceMemory]
-        self.perInstanceParameters = []                             # type: List[ParameterDataPrototype]
-        self.portAPIOptions = []                                    # type: List[PortAPIOption]
-        self.runnables = []                                         # type: List[RunnableEntity]
-        self.serviceDependencies = []                               # type: List[SwcServiceDependency]
-        self.sharedParameters = []                                  # type: List[ParameterDataPrototype]
+        # type: List[VariableDataPrototype]
+        self.implicitInterRunnableVariables = []
+        # type: List[IncludedDataTypeSet]
+        self.includedDataTypeSets = []
+        # type: List[IncludedModeDeclarationGroupSet]
+        self.includedModeDeclarationGroupSets = []
+        # type: List[InstantiationDataDefProps]
+        self.instantiationDataDefProps = []
+        # type: List[PerInstanceMemory]
+        self.perInstanceMemories = []
+        # type: List[ParameterDataPrototype]
+        self.perInstanceParameters = []
+        # type: List[PortAPIOption]
+        self.portAPIOptions = []
+        # type: List[RunnableEntity]
+        self.runnables = []
+        # type: List[SwcServiceDependency]
+        self.serviceDependencies = []
+        # type: List[ParameterDataPrototype]
+        self.sharedParameters = []
         self.supportsMultipleInstantiation = None                   # type: Boolean
-        self.variationPointProxies = []                             # type: VariationPointProxy
+        # type: VariationPointProxy
+        self.variationPointProxies = []
 
     def getArTypedPerInstanceMemories(self) -> List[VariableDataPrototype]:
         return self.arTypedPerInstanceMemories
-    
+
     def createArTypedPerInstanceMemory(self, short_name: str) -> VariableDataPrototype:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             prototype = VariableDataPrototype(self, short_name)
             self.addElement(prototype)
             self.arTypedPerInstanceMemories.append(prototype)
@@ -254,14 +295,14 @@ class SwcInternalBehavior(InternalBehavior):
 
     def getExplicitInterRunnableVariables(self) -> List[VariableDataPrototype]:
         return self.explicitInterRunnableVariables
-    
+
     def createExplicitInterRunnableVariable(self, short_name: str) -> VariableDataPrototype:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             prototype = VariableDataPrototype(self, short_name)
             self.addElement(prototype)
             self.explicitInterRunnableVariables.append(prototype)
         return self.getElement(short_name)
-    
+
     def getHandleTerminationAndRestart(self):
         return self.handleTerminationAndRestart
 
@@ -269,7 +310,6 @@ class SwcInternalBehavior(InternalBehavior):
         self.handleTerminationAndRestart = value
         return self
 
-
     def getImplicitInterRunnableVariables(self) -> List[VariableDataPrototype]:
         return self.implicitInterRunnableVariables
 
@@ -290,7 +330,7 @@ class SwcInternalBehavior(InternalBehavior):
 
     def getIncludedDataTypeSets(self) -> List[IncludedDataTypeSet]:
         return self.includedDataTypeSets
-    
+
     def getIncludedModeDeclarationGroupSets(self):
         return self.includedModeDeclarationGroupSets
 
@@ -300,145 +340,149 @@ class SwcInternalBehavior(InternalBehavior):
         return self
 
     def createOperationInvokedEvent(self, short_name: str) -> OperationInvokedEvent:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = OperationInvokedEvent(self, short_name)
             self.addElement(event)
-        return self.getElement(short_name)
+        return self.getElement(short_name, OperationInvokedEvent)
 
     def createTimingEvent(self, short_name: str) -> TimingEvent:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = TimingEvent(self, short_name)
             self.addElement(event)
-        return self.getElement(short_name)
+        return self.getElement(short_name, TimingEvent)
 
     def createInitEvent(self, short_name: str) -> InitEvent:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = InitEvent(self, short_name)
             self.addElement(event)
-        return self.getElement(short_name)
-    
+        return self.getElement(short_name, InitEvent)
+
     def createAsynchronousServerCallReturnsEvent(self, short_name: str) -> AsynchronousServerCallReturnsEvent:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = AsynchronousServerCallReturnsEvent(self, short_name)
             self.addElement(event)
-        return self.getElement(short_name)
+        return self.getElement(short_name, AsynchronousServerCallReturnsEvent)
 
     def createDataReceivedEvent(self, short_name: str) -> DataReceivedEvent:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = DataReceivedEvent(self, short_name)
             self.addElement(event)
-        return self.getElement(short_name)
+        return self.getElement(short_name, DataReceivedEvent)
 
     def createSwcModeSwitchEvent(self, short_name: str) -> SwcModeSwitchEvent:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = SwcModeSwitchEvent(self, short_name)
             self.addElement(event)
-        return self.getElement(short_name)
+        return self.getElement(short_name, SwcModeSwitchEvent)
 
     def createInternalTriggerOccurredEvent(self, short_name: str) -> InternalTriggerOccurredEvent:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = InternalTriggerOccurredEvent(self, short_name)
             self.addElement(event)
-        return self.getElement(short_name)
+        return self.getElement(short_name, InternalTriggerOccurredEvent)
 
     def createSwcServiceDependency(self, short_name: str) -> SwcServiceDependency:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = SwcServiceDependency(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
-    
+            self.addElement(event)
+        return self.getElement(short_name, SwcServiceDependency)
+
     def createModeSwitchedAckEvent(self, short_name: str) -> ModeSwitchedAckEvent:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = ModeSwitchedAckEvent(self, short_name)
             self.addElement(event)
-        return self.getElement(short_name)
-    
+        return self.getElement(short_name, ModeSwitchedAckEvent)
+
     def createBackgroundEvent(self, short_name: str) -> BackgroundEvent:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             event = BackgroundEvent(self, short_name)
             self.addElement(event)
-        return self.getElement(short_name)
+        return self.getElement(short_name, BackgroundEvent)
 
     def getRteEvents(self) -> List[RTEEvent]:
-        return sorted(filter(lambda c: isinstance(c, RTEEvent), self.elements.values()), key=lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, RTEEvent), self.elements), key=lambda e: e.short_name)
 
     def getOperationInvokedEvents(self) -> List[OperationInvokedEvent]:
-        return sorted(filter(lambda c: isinstance(c, OperationInvokedEvent), self.elements.values()), key=lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, OperationInvokedEvent), self.elements), key=lambda e: e.short_name)
 
     def getInitEvents(self) -> List[InitEvent]:
-        return sorted(filter(lambda c: isinstance(c, InitEvent), self.elements.values()), key=lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, InitEvent), self.elements), key=lambda e: e.short_name)
 
     def getTimingEvents(self) -> List[TimingEvent]:
-        return sorted(filter(lambda c: isinstance(c, TimingEvent), self.elements.values()), key=lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, TimingEvent), self.elements), key=lambda e: e.short_name)
 
     def getDataReceivedEvents(self) -> List[DataReceivedEvent]:
-        return sorted(filter(lambda c: isinstance(c, DataReceivedEvent), self.elements.values()), key=lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, DataReceivedEvent), self.elements), key=lambda e: e.short_name)
 
     def getSwcModeSwitchEvents(self) -> List[SwcModeSwitchEvent]:
-        return sorted(filter(lambda c: isinstance(c, SwcModeSwitchEvent), self.elements.values()), key=lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, SwcModeSwitchEvent), self.elements), key=lambda e: e.short_name)
 
     def getInternalTriggerOccurredEvents(self) -> List[InternalTriggerOccurredEvent]:
-        return sorted(filter(lambda c: isinstance(c, InternalTriggerOccurredEvent), self.elements.values()), key= lambda e: e.short_name)
-    
+        return sorted(filter(lambda c: isinstance(c, InternalTriggerOccurredEvent), self.elements), key=lambda e: e.short_name)
+
     def getModeSwitchedAckEvents(self) -> List[ModeSwitchedAckEvent]:
-        return sorted(filter(lambda c: isinstance(c, ModeSwitchedAckEvent), self.elements.values()), key= lambda e: e.short_name)
-    
+        return sorted(filter(lambda c: isinstance(c, ModeSwitchedAckEvent), self.elements), key=lambda e: e.short_name)
+
     def getBackgroundEvents(self) -> List[BackgroundEvent]:
-        return sorted(filter(lambda c: isinstance(c, BackgroundEvent), self.elements.values()), key= lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, BackgroundEvent), self.elements), key=lambda e: e.short_name)
 
     def getSwcServiceDependencies(self) -> List[SwcServiceDependency]:
-        return sorted(filter(lambda c: isinstance(c, SwcServiceDependency), self.elements.values()), key= lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, SwcServiceDependency), self.elements), key=lambda e: e.short_name)
 
     def getEvent(self, short_name: str) -> RTEEvent:
+        '''
         if (not isinstance(self.elements[short_name], RTEEvent)):
-            raise ValueError("Invalid Event Type <%s> of <%s>" % type(self.elements[short_name]), short_name)
-        return self.elements[short_name]
+            raise ValueError("Invalid Event Type <%s> of <%s>" %
+                             type(self.elements[short_name]), short_name)
+        return self.elements[short_name]'
+        '''
+        return self.getElement(short_name, RTEEvent)
 
     def createImplicitInterRunnableVariable(self, short_name: str) -> VariableDataPrototype:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             prototype = VariableDataPrototype(self, short_name)
             self.addElement(prototype)
             self.implicitInterRunnableVariables.append(prototype)
         return self.getElement(short_name)
 
     def createPerInstanceMemory(self, short_name: str) -> PerInstanceMemory:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             memory = PerInstanceMemory(self, short_name)
             self.addElement(memory)
             self.perInstanceMemories.append(memory)
         return self.getElement(short_name)
 
     def createPerInstanceParameter(self, short_name: str) -> ParameterDataPrototype:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             prototype = ParameterDataPrototype(self, short_name)
             self.addElement(prototype)
             self.perInstanceParameters.append(prototype)
         return self.getElement(short_name)
 
     def getVariableDataPrototypes(self) -> List[VariableDataPrototype]:
-        return sorted(filter(lambda c: isinstance(c, VariableDataPrototype), self.elements.values()), key=lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, VariableDataPrototype), self.elements), key=lambda e: e.short_name)
 
     def createRunnableEntity(self, short_name: str) -> RunnableEntity:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             runnable = RunnableEntity(self, short_name)
             self.addElement(runnable)
         return self.getElement(short_name)
 
     def getRunnableEntities(self) -> List[RunnableEntity]:
-        return sorted(filter(lambda c: isinstance(c, RunnableEntity), self.elements.values()), key=lambda r: r.short_name)
+        return sorted(filter(lambda c: isinstance(c, RunnableEntity), self.elements), key=lambda r: r.short_name)
 
     def getRunnableEntity(self, short_name) -> RunnableEntity:
-        return self.elements[short_name]
-    
+        return self.getElement(short_name, RunnableEntity)
+
     def getSharedParameters(self) -> List[ParameterDataPrototype]:
         return self.sharedParameters
-    
+
     def createSharedParameter(self, short_name: str) -> ParameterDataPrototype:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             memory = ParameterDataPrototype(self, short_name)
             self.addElement(memory)
             self.sharedParameters.append(memory)
-        return self.getElement(short_name) 
+        return self.getElement(short_name)
 
     def getSupportsMultipleInstantiation(self):
         return self.supportsMultipleInstantiation

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/FibexCore/CoreCommunication.py

@@ -72,14 +72,14 @@ class Frame(Identifiable, metaclass=ABCMeta):
         return self
 
     def createPduToFrameMapping(self, short_name: str) -> PduToFrameMapping:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             mapping = PduToFrameMapping(self, short_name)
-            self.elements[short_name] = mapping
+            self.addElement(mapping)
             self.pduToFrameMappings.append(mapping)
-        return self.elements[short_name]
+        return self.getElement(short_name, PduToFrameMapping)
 
     def getPduToFrameMappings(self) -> List[PduToFrameMapping]:
-        return list(sorted(filter(lambda a: isinstance(a, PduToFrameMapping), self.elements.values()), key=lambda o: o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, PduToFrameMapping), self.elements), key=lambda o: o.short_name))
 
 
 class ContainedIPduProps(ARObject):
@@ -542,11 +542,11 @@ class NmPdu(Pdu):
         return self.iSignalToIPduMappings
 
     def createISignalToIPduMapping(self, short_name: str) -> ISignalToIPduMapping:
-        if (not self.IsElementExists(short_name)):
+        if not self.IsElementExists(short_name):
             mapping = ISignalToIPduMapping(self, short_name)
             self.addElement(mapping)
             self.iSignalToIPduMappings.append(mapping)
-        return self.getElement(short_name)
+        return self.getElement(short_name, ISignalToIPduMapping)
 
     def getNmDataInformation(self):
         return self.nmDataInformation
@@ -633,11 +633,11 @@ class ISignalIPdu(IPdu):
         return self.iSignalToPduMappings
 
     def createISignalToPduMappings(self, short_name: str) -> ISignalToIPduMapping:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             mapping = ISignalToIPduMapping(self, short_name)
-            self.elements[short_name] = mapping
+            self.addElement(mapping)
             self.iSignalToPduMappings.append(mapping)
-        return self.elements[short_name]
+        return self.getElement(short_name, ISignalToIPduMapping)
 
     def getUnusedBitPattern(self):
         return self.unusedBitPattern
@@ -1219,7 +1219,7 @@ class SecureCommunicationPropsSet(Identifiable):
             props = SecureCommunicationAuthenticationProps(self, short_name)
             self.addElement(props)
             self.authenticationProps.append(props)
-        return self.getElement(short_name)
+        return self.getElement(short_name, SecureCommunicationAuthenticationProps)
 
     def getFreshnessProps(self):
         return self.freshnessProps
@@ -1229,4 +1229,4 @@ class SecureCommunicationPropsSet(Identifiable):
             props = SecureCommunicationFreshnessProps(self, short_name)
             self.addElement(props)
             self.freshnessProps.append(props)
-        return self.getElement(short_name)
+        return self.getElement(short_name, SecureCommunicationFreshnessProps)