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

armodel/models/M2/AUTOSARTemplates/GenericStructure/GeneralTemplateClasses/ARPackage.py

@@ -1,7 +1,4 @@
 from typing import Dict, List
-
-
-
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Boolean, Identifier, RefType, ReferrableSubtypesEnum
 from .....M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
 from .....M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingExtensions import SwcTiming

armodel/models/M2/AUTOSARTemplates/GenericStructure/GeneralTemplateClasses/Identifiable.py

@@ -13,6 +13,7 @@ class Referrable(ARObject, metaclass = ABCMeta):
 
         if type(self) == Referrable:
             raise NotImplementedError("Referrable is an abstract class.")
+        
         ARObject.__init__(self)
 
         self.parent = parent
@@ -61,6 +62,7 @@ class CollectableElement(ARObject, metaclass = ABCMeta):
     def __init__(self):
         if type(self) == CollectableElement:
             raise NotImplementedError("CollectableElement is an abstract class.")
+        
         self.elements = {}              # type: dict[str, Referrable]
 
     def getTotalElement(self) -> int:
@@ -87,6 +89,7 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass = ABCM
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == Identifiable:
             raise NotImplementedError("Identifiable is an abstract class.")
+        
         MultilanguageReferrable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
 

armodel/models/M2/AUTOSARTemplates/GenericStructure/GeneralTemplateClasses/PrimitiveTypes.py

@@ -340,6 +340,35 @@ class Identifier(ARLiteral):
     def __init__(self):
         super().__init__()
 
+class CIdentifier(ARLiteral):
+    '''
+        This datatype represents a string, that follows the rules of C-identifiers.
+        
+        Tags:
+            * xml.xsd.customType=C-IDENTIFIER
+            * xml.xsd.pattern=[a-zA-Z_][a-zA-Z0-9_]*
+            * xml.xsd.type=string
+    '''
+    def __init__(self):
+        super().__init__()
+
+        self.blueprintValue = None
+        self.namePattern = None
+
+    def getBlueprintValue(self):
+        return self.blueprintValue
+
+    def setBlueprintValue(self, value):
+        self.blueprintValue = value
+        return self
+
+    def getNamePattern(self):
+        return self.namePattern
+
+    def setNamePattern(self, value):
+        self.namePattern = value
+        return self
+
 class RevisionLabelString(ARLiteral):
     '''
         This primitive represents an internal AUTOSAR revision label which identifies an engineering object. It
@@ -404,4 +433,17 @@ class RefType(ARObject):
 
 class TRefType(RefType):
     def __init__(self):
-        super().__init__()
+        super().__init__()
+
+class DiagRequirementIdString(ARLiteral):
+    '''
+        This string denotes an Identifier for a requirement.
+
+        Tags:
+            * xml.xsd.customType=DIAG-REQUIREMENT-ID-STRING
+            * xml.xsd.pattern=[0-9a-zA-Z_\-]+
+            * xml.xsd.type=string
+    '''
+    def __init__(self):
+        super().__init__()
+

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/Communication.py

@@ -62,9 +62,22 @@ class CompositeNetworkRepresentation(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.leaf_element_iref = None           # type: ApplicationCompositeElementInPortInterfaceInstanceRef
-        self.network_representation = None      # type: SwDataDefProps
+        self.leafElementIRef = None                 # type: ApplicationCompositeElementInPortInterfaceInstanceRef
+        self.networkRepresentation = None           # type: SwDataDefProps
 
+    def getLeafElementIRef(self):
+        return self.leafElementIRef
+
+    def setLeafElementIRef(self, value):
+        self.leafElementIRef = value
+        return self
+
+    def getNetworkRepresentation(self):
+        return self.networkRepresentation
+
+    def setNetworkRepresentation(self, value):
+        self.networkRepresentation = value
+        return self
 
 class TransmissionAcknowledgementRequest(ARObject):
     def __init__(self):
@@ -205,7 +218,10 @@ class ReceiverComSpec(RPortComSpec):
         self.compositeNetworkRepresentations = []       # type: List[CompositeNetworkRepresentation]
         self.dataElementRef = None                      # type: RefType
         self.networkRepresentation = None               # type: SwDataDefProps
-        self.handleOutOfRange = None                    # type: ARLiteral
+        self.handleOutOfRange = None                    # type: HandleOutOfRangeEnum
+        self.handleOutOfRangeStatus = None              # type: HandleOutOfRangeStatusEnum
+        self.maxDeltaCounterInit = None                 # type: PositiveInteger
+        self.maxNoNewOrRepeatedData = None              # type: PositiveInteger
         self.usesEndToEndProtection = None              # type: ARBoolean     
 
     def getDataElementRef(self):
@@ -228,6 +244,28 @@ class ReceiverComSpec(RPortComSpec):
     def setHandleOutOfRange(self, value):
         self.handleOutOfRange = value
         return self
+    
+    def getHandleOutOfRangeStatus(self):
+        return self.handleOutOfRangeStatus
+
+    def setHandleOutOfRangeStatus(self, value):
+        self.handleOutOfRangeStatus = value
+        return self
+
+    def getMaxDeltaCounterInit(self):
+        return self.maxDeltaCounterInit
+
+    def setMaxDeltaCounterInit(self, value):
+        self.maxDeltaCounterInit = value
+        return self
+
+    def getMaxNoNewOrRepeatedData(self):
+        return self.maxNoNewOrRepeatedData
+
+    def setMaxNoNewOrRepeatedData(self, value):
+        self.maxNoNewOrRepeatedData = value
+        return self
+
 
     def getUsesEndToEndProtection(self):
         return self.usesEndToEndProtection

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

@@ -87,7 +87,7 @@ class AbstractProvidedPortPrototype(PortPrototype):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.provided_com_specs = []  # type: List[PPortComSpec]
+        self.providedComSpecs = []                  # type: List[PPortComSpec]
 
     def _validateRPortComSpec(self, com_spec: PPortComSpec):
         if isinstance(com_spec, NonqueuedSenderComSpec):
@@ -108,20 +108,20 @@ class AbstractProvidedPortPrototype(PortPrototype):
 
     def addProvidedComSpec(self, com_spec):
         self._validateRPortComSpec(com_spec)
-        self.provided_com_specs.append(com_spec)
+        self.providedComSpecs.append(com_spec)
 
     def getProvidedComSpecs(self) -> List[PPortComSpec]:
-        return self.provided_com_specs
+        return self.providedComSpecs
 
     def getNonqueuedSenderComSpecs(self) -> List[NonqueuedSenderComSpec]:
-        return filter(lambda c: isinstance(c, NonqueuedSenderComSpec), self.provided_com_specs)
+        return filter(lambda c: isinstance(c, NonqueuedSenderComSpec), self.providedComSpecs)
 
 
 class AbstractRequiredPortPrototype(PortPrototype):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.required_com_specs = []  # type: List[RPortComSpec]
+        self.requiredComSpecs = []                          # type: List[RPortComSpec]
 
     def _validateRPortComSpec(self, com_spec: RPortComSpec):
         if (isinstance(com_spec, ClientComSpec)):
@@ -145,16 +145,16 @@ class AbstractRequiredPortPrototype(PortPrototype):
 
     def addRequiredComSpec(self, com_spec: RPortComSpec):
         self._validateRPortComSpec(com_spec)
-        self.required_com_specs.append(com_spec)
+        self.requiredComSpecs.append(com_spec)
 
     def getRequiredComSpecs(self) -> List[RPortComSpec]:
-        return self.required_com_specs
+        return self.requiredComSpecs
 
     def getClientComSpecs(self) -> List[ClientComSpec]:
-        return filter(lambda c: isinstance(c, ClientComSpec), self.required_com_specs)
+        return filter(lambda c: isinstance(c, ClientComSpec), self.requiredComSpecs)
 
     def getNonqueuedReceiverComSpecs(self) -> List[NonqueuedReceiverComSpec]:
-        return filter(lambda c: isinstance(c, NonqueuedReceiverComSpec), self.required_com_specs)
+        return filter(lambda c: isinstance(c, NonqueuedReceiverComSpec), self.requiredComSpecs)
 
 
 class PPortPrototype(AbstractProvidedPortPrototype):
@@ -190,6 +190,35 @@ class RPortPrototype(AbstractRequiredPortPrototype):
     def setRequiredInterfaceTRef(self, value):
         self.requiredInterfaceTRef = value
         return self
+    
+class PRPortPrototype(PortPrototype):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.providedComSpecs = []                          # type: List[PPortComSpec]
+        self.requiredComSpecs = []                          # type: List[RPortComSpec]
+        self.providedRequiredInterface = None               # type: TRefType
+
+    def getProvidedComSpecs(self):
+        return self.providedComSpecs
+
+    def addProvidedComSpec(self, value):
+        self.providedComSpecs.append(value)
+        return self
+
+    def getRequiredComSpecs(self):
+        return self.requiredComSpecs
+
+    def addRequiredComSpec(self, value):
+        self.requiredComSpecs.append(value)
+        return self
+
+    def getProvidedRequiredInterface(self):
+        return self.providedRequiredInterface
+
+    def setProvidedRequiredInterface(self, value):
+        self.providedRequiredInterface = value
+        return self
 
 class PortGroup(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
@@ -215,16 +244,22 @@ class SwComponentType(ARElement, metaclass = ABCMeta):
         super().__init__(parent, short_name)
 
     def createPPortPrototype(self, short_name: str) -> PPortPrototype:
-        prototype = PPortPrototype(self, short_name)
         if (short_name not in self.elements):
-            self.elements[short_name] = prototype
-        return self.elements[short_name]
+            prototype = PPortPrototype(self, short_name)
+            self.addElement(prototype)
+        return self.getElement(short_name)
 
     def createRPortPrototype(self, short_name) -> RPortPrototype:
-        prototype = RPortPrototype(self, short_name)
         if (short_name not in self.elements):
-            self.elements[short_name] = prototype
-        return self.elements[short_name]
+            prototype = RPortPrototype(self, short_name)
+            self.addElement(prototype)
+        return self.getElement(short_name)
+    
+    def createPRPortPrototype(self, short_name) -> PRPortPrototype:
+        if (short_name not in self.elements):
+            prototype = PRPortPrototype(self, short_name)
+            self.addElement(prototype)
+        return self.getElement(short_name)
     
     def createPortGroup(self, short_name) -> PortGroup:
         port_group = PortGroup(self, short_name)
@@ -238,6 +273,9 @@ class SwComponentType(ARElement, metaclass = ABCMeta):
     def getRPortPrototypes(self) -> List[RPortPrototype]:
         return list(sorted(filter(lambda c: isinstance(c, RPortPrototype), self.elements.values()), key= lambda o: o.short_name))
     
+    def getPRPortPrototypes(self) -> List[PRPortPrototype]:
+        return list(sorted(filter(lambda c: isinstance(c, PRPortPrototype), self.elements.values()), key= lambda o: o.short_name))
+    
     def getPortPrototypes(self) -> List[PortPrototype]:
         return list(sorted(filter(lambda c: isinstance(c, PortPrototype), self.elements.values()), key= lambda o: o.short_name))
     

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/Datatype/Datatypes.py

@@ -81,25 +81,40 @@ class ApplicationRecordDataType(ApplicationCompositeDataType):
 class DataTypeMap(ARObject):
     def __init__(self):
 
-        self.application_data_type_ref = None       # type: RefType
-        self.implementation_data_type_ref = None    # type: RefType
+        self.applicationDataTypeRef = None                  # type: RefType
+        self.implementationDataTypeRef = None               # type: RefType
 
+    def getApplicationDataTypeRef(self):
+        return self.applicationDataTypeRef
+
+    def setApplicationDataTypeRef(self, value):
+        self.applicationDataTypeRef = value
+        return self
+
+    def getImplementationDataTypeRef(self):
+        return self.implementationDataTypeRef
+
+    def setImplementationDataTypeRef(self, value):
+        self.implementationDataTypeRef = value
+        return self
 
 class DataTypeMappingSet(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._dataTypeMaps = []                     # type: List[DataTypeMap]
-        self._modeRequestTypeMaps = []              # type: List[ModeRequestTypeMap]
+        self.dataTypeMaps = []                              # type: List[DataTypeMap]
+        self.modeRequestTypeMaps = []                       # type: List[ModeRequestTypeMap]
 
     def addDataTypeMap(self, type_map: DataTypeMap):
-        self._dataTypeMaps.append(type_map)
+        self.dataTypeMaps.append(type_map)
+        return self
 
     def getDataTypeMaps(self) -> List[DataTypeMap]:
-        return self._dataTypeMaps
+        return self.dataTypeMaps
 
     def addModeRequestTypeMap(self, map: ModeRequestTypeMap):
-        self._modeRequestTypeMaps.append(map)
+        self.modeRequestTypeMaps.append(map)
+        return self
 
     def getModeRequestTypeMaps(self) -> List[ModeRequestTypeMap]:
-        return self._modeRequestTypeMaps
+        return self.modeRequestTypeMaps

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

@@ -1,10 +1,11 @@
 from abc import ABCMeta
 from typing import List
 
+from .....M2.AUTOSARTemplates.CommonStructure import TextValueSpecification
 from .....M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, PositiveInteger
 from .....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype, VariableDataPrototype, AutosarDataPrototype
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean
 from .....M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroupPrototype
@@ -90,6 +91,48 @@ class InvalidationPolicy(ARObject):
     def setHandleInvalid(self, value):
         self.handleInvalid = value
         return self
+    
+class MetaDataItem(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.length = None                              # type: PositiveInteger
+        self.metaDataItemType = None                    # type: TextValueSpecification
+
+    def getLength(self):
+        return self.length
+
+    def setLength(self, value):
+        self.length = value
+        return self
+
+    def getMetaDataItemType(self):
+        return self.metaDataItemType
+
+    def setMetaDataItemType(self, value):
+        self.metaDataItemType = value
+        return self
+    
+class MetaDataItemSet(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.dataElementRefs = []                           # type: List[RefType]
+        self.metaDataItems = []                             # type: List[MetaDataItem]
+
+    def getDataElementRefs(self):
+        return self.dataElementRefs
+
+    def addDataElementRef(self, value):
+        self.dataElementRefs.append(value)
+        return self
+
+    def getMetaDataItems(self):
+        return self.metaDataItems
+
+    def addMetaDataItem(self, value):
+        self.metaDataItems.append(value)
+        return self
 
 class SenderReceiverInterface(DataInterface):
     def __init__(self, parent: ARObject, short_name: str):

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

@@ -1,5 +1,5 @@
 from typing import List
-from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import NvBlockNeeds, RoleBasedDataAssignment, ServiceNeeds
+from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagnosticCommunicationManagerNeeds, DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds, NvBlockNeeds, RoleBasedDataAssignment, ServiceNeeds
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Identifier, RefType
 from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import ServiceDependency
@@ -24,7 +24,6 @@ class RoleBasedPortAssignment(ARObject):
         self.role = value
         return self
 
-
 class SwcServiceDependency(ServiceDependency):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -46,12 +45,54 @@ class SwcServiceDependency(ServiceDependency):
 
     def createNvBlockNeeds(self, short_name: str) -> NvBlockNeeds:
         if (short_name not in self.elements):
-            event = NvBlockNeeds(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            needs = NvBlockNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createDiagnosticCommunicationManagerNeeds(self, short_name: str) -> DiagnosticCommunicationManagerNeeds:
+        if (short_name not in self.elements):
+            needs = DiagnosticCommunicationManagerNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createDiagnosticRoutineNeeds(self, short_name: str) -> DiagnosticRoutineNeeds:
+        if (short_name not in self.elements):
+            needs = DiagnosticRoutineNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createDiagnosticValueNeeds(self, short_name: str) -> DiagnosticValueNeeds:
+        if (short_name not in self.elements):
+            needs = DiagnosticValueNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createDiagnosticEventNeeds(self, short_name: str) -> DiagnosticEventNeeds:
+        if (short_name not in self.elements):
+            needs = DiagnosticEventNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
+    
+    def createCryptoServiceNeeds(self, short_name: str) -> CryptoServiceNeeds:
+        if (short_name not in self.elements):
+            needs = CryptoServiceNeeds(self, short_name)
+            self.addElement(needs)
+        return self.getElement(short_name)
 
     def getNvBlockNeeds(self) -> List[NvBlockNeeds]:
         return sorted(filter(lambda c: isinstance(c, NvBlockNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
+    def getDiagnosticCommunicationManagerNeeds(self) -> List[DiagnosticCommunicationManagerNeeds]:
+        return sorted(filter(lambda c: isinstance(c, DiagnosticCommunicationManagerNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
+    def getDiagnosticRoutineNeeds(self) -> List[DiagnosticRoutineNeeds]:
+        return sorted(filter(lambda c: isinstance(c, DiagnosticRoutineNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
+    def getDiagnosticEventNeeds(self) -> List[DiagnosticEventNeeds]:
+        return sorted(filter(lambda c: isinstance(c, DiagnosticEventNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
+    def getCryptoServiceNeeds(self) -> List[CryptoServiceNeeds]:
+        return sorted(filter(lambda c: isinstance(c, CryptoServiceNeeds), self.elements.values()), key=lambda e: e.short_name)
 
     def getServiceNeeds(self) -> List[ServiceNeeds]:
         return sorted(filter(lambda c: isinstance(c, ServiceNeeds), self.elements.values()), key=lambda e: e.short_name)

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

@@ -1,11 +1,12 @@
 from typing import Dict, List
 
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AccessCount import AbstractAccessPoint
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption
 from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
 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 DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import SwcServiceDependency
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType, ARBoolean
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
@@ -27,12 +28,8 @@ class RunnableEntityArgument(ARObject):
     def setSymbol(self, value):
         self.symbol = value
         return self
-
-class AsynchronousServerCallPoint(ServerCallPoint):
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-
-class AsynchronousServerCallResultPoint(ServerCallPoint):
+    
+class AsynchronousServerCallResultPoint(AbstractAccessPoint):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
@@ -43,7 +40,11 @@ class AsynchronousServerCallResultPoint(ServerCallPoint):
 
     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):
@@ -63,6 +64,7 @@ class RunnableEntity(ExecutableEntity):
         super().__init__(parent, short_name)
 
         self.arguments = []                             # type: List[RunnableEntityArgument]
+        self.asynchronousServerCallResultPoints = []    # type: List[AsynchronousServerCallResultPoint]
         self.canBeInvokedConcurrently = None            # type: ARBoolean
         self.dataReadAccesses = {}                      # type: Dict[str, VariableAccess]
         self.dataReceivePointByArguments = {}           # type: Dict[str, VariableAccess]
@@ -92,7 +94,7 @@ class RunnableEntity(ExecutableEntity):
     def addArgument(self, value):
         self.arguments.append(value)
         return self
-
+    
     def getCanBeInvokedConcurrently(self):
         return self.canBeInvokedConcurrently
 
@@ -148,29 +150,42 @@ class RunnableEntity(ExecutableEntity):
     def createParameterAccess(self, short_name: str) -> ParameterAccess:
         if (short_name not in self.elements):
             access = ParameterAccess(self, short_name)
-            self.elements[short_name] = access
-        return self.elements[short_name]
+            self.addElement(access)
+        return self.getElement(short_name)
     
     def createSynchronousServerCallPoint(self, short_name: str) -> SynchronousServerCallPoint:
         if (short_name not in self.serverCallPoints):
-            server_call_point = SynchronousServerCallPoint(self, short_name)
-            self.serverCallPoints[short_name] = server_call_point
-        return self.serverCallPoints[short_name]
+            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]
 
     def createAsynchronousServerCallPoint(self, short_name: str) -> AsynchronousServerCallPoint:
         if (short_name not in self.serverCallPoints):
-            server_call_point = AsynchronousServerCallPoint(self, short_name)
-            self.serverCallPoints[short_name] = server_call_point
-        return self.serverCallPoints[short_name]
+            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]
+    
+    def createAsynchronousServerCallResultPoint(self, short_name: str) -> AsynchronousServerCallResultPoint:
+        if (short_name not in self.serverCallPoints):
+            point = AsynchronousServerCallResultPoint(self, short_name)
+            self.addElement(point)
+        return self.getElement(short_name)
 
-    def getSynchronousServerCallPoint(self) -> List[ServerCallPoint]:
-        return filter(lambda o: isinstance(o, SynchronousServerCallPoint), self.getServerCallPoints())
+    def getSynchronousServerCallPoint(self) -> List[SynchronousServerCallPoint]:
+        return list(sorted(filter(lambda a: isinstance(a, SynchronousServerCallPoint), self.elements.values()), 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()))
     
-    def getAsynchronousServerCallPoint(self) -> List[ServerCallPoint]:
-        return filter(lambda o: isinstance(o, AsynchronousServerCallPoint), self.getServerCallPoints())
+    def getAsynchronousServerCallResultPoints(self) -> List[AsynchronousServerCallResultPoint]:
+        return list(sorted(filter(lambda a: isinstance(a, AsynchronousServerCallResultPoint), self.elements.values()), key= lambda o:o.getShortName()))
 
     def getServerCallPoints(self) -> List[ServerCallPoint]:
-        return sorted(self.serverCallPoints.values(), key=lambda v: v.short_name)
+        return list(sorted(filter(lambda a: isinstance(a, ServerCallPoint), self.elements.values()), key= lambda o:o.getShortName()))
 
     def createInternalTriggeringPoint(self, short_name: str) -> InternalTriggeringPoint:
         if (short_name not in self.elements):
@@ -245,38 +260,44 @@ class SwcInternalBehavior(InternalBehavior):
     def createOperationInvokedEvent(self, short_name: str) -> OperationInvokedEvent:
         if (short_name not in self.elements):
             event = OperationInvokedEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createTimingEvent(self, short_name: str) -> TimingEvent:
         if (short_name not in self.elements):
             event = TimingEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createInitEvent(self, short_name: str) -> InitEvent:
         if (short_name not in self.elements):
             event = InitEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
+    
+    def createAsynchronousServerCallReturnsEvent(self, short_name: str) -> AsynchronousServerCallReturnsEvent:
+        if (short_name not in self.elements):
+            event = AsynchronousServerCallReturnsEvent(self, short_name)
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createDataReceivedEvent(self, short_name: str) -> DataReceivedEvent:
         if (short_name not in self.elements):
             event = DataReceivedEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createSwcModeSwitchEvent(self, short_name: str) -> SwcModeSwitchEvent:
         if (short_name not in self.elements):
             event = SwcModeSwitchEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createInternalTriggerOccurredEvent(self, short_name: str) -> InternalTriggerOccurredEvent:
         if (short_name not in self.elements):
             event = InternalTriggerOccurredEvent(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def createSwcServiceDependency(self, short_name: str) -> SwcServiceDependency:
         if (short_name not in self.elements):