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

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.Identifiable import ARElement, 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, ArgumentDirectionEnum, 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):
@@ -140,8 +183,24 @@ class SenderReceiverInterface(DataInterface):
 class ArgumentDataPrototype(AutosarDataPrototype):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
-        self.direction = ""
-        self.server_argument_impl_policy = ""
+
+        self.direction = None                               # type: ArgumentDirectionEnum
+        # type: ServerArgumentImplPolicyEnum
+        self.serverArgumentImplPolicy = None
+
+    def getDirection(self):
+        return self.direction
+
+    def setDirection(self, value):
+        self.direction = value
+        return self
+
+    def getServerArgumentImplPolicy(self):
+        return self.serverArgumentImplPolicy
+
+    def setServerArgumentImplPolicy(self, value):
+        self.serverArgumentImplPolicy = value
+        return self
 
 class ApplicationError(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
@@ -244,4 +303,179 @@ class ModeSwitchInterface(PortInterface):
         return self.elements[short_name]
     
     def getModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
-        return list(sorted(filter(lambda c: isinstance(c, ModeDeclarationGroupPrototype), self.elements.values()), key= lambda o: o.short_name))
+        return list(sorted(filter(lambda c: isinstance(c, ModeDeclarationGroupPrototype), self.elements.values()), key= lambda o: o.short_name))
+
+class PortInterfaceMapping(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == PortInterface:
+            raise NotImplementedError("PortInterfaceMapping is an abstract class.")
+        super().__init__(parent, short_name)
+
+class ClientServerApplicationErrorMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.firstApplicationErrorRef = None                    # type: RefType
+        self.secondApplicationErrorRef = None                   # type: RefType
+
+    def getFirstApplicationErrorRef(self):
+        return self.firstApplicationErrorRef
+
+    def setFirstApplicationErrorRef(self, value):
+        self.firstApplicationErrorRef = value
+        return self
+
+    def getSecondApplicationErrorRef(self):
+        return self.secondApplicationErrorRef
+
+    def setSecondApplicationErrorRef(self, value):
+        self.secondApplicationErrorRef = value
+        return self
+    
+class ClientServerOperationMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        
+        self.argumentMappings = []                              # type: List[DataPrototypeMapping]
+        self.firstOperationRef = None                           # type: RefType
+        self.firstToSecondDataTransformationRef = None          # type: RefType
+        self.secondOperationRef = None                          # type: RefType
+
+    def getArgumentMappings(self):
+        return self.argumentMappings
+
+    def addArgumentMapping(self, value):
+        self.argumentMappings.append(value)
+        return self
+
+    def getFirstOperationRef(self):
+        return self.firstOperationRef
+
+    def setFirstOperationRef(self, value):
+        self.firstOperationRef = value
+        return self
+
+    def getFirstToSecondDataTransformationRef(self):
+        return self.firstToSecondDataTransformationRef
+
+    def setFirstToSecondDataTransformationRef(self, value):
+        self.firstToSecondDataTransformationRef = value
+        return self
+
+    def getSecondOperationRef(self):
+        return self.secondOperationRef
+
+    def setSecondOperationRef(self, value):
+        self.secondOperationRef = value
+        return self
+    
+
+class DataPrototypeMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.firstDataPrototypeRef = None                       # type: RefType
+        self.firstToSecondDataTransformationRef = None          # type: RefType
+        self.secondDataPrototypeRef = None                      # type: RefType
+        self.secondToFirstDataTransformationRef = None          # type: RefType
+        self.subElementMappings = []                            # type: List[SubElementMapping]
+        self.textTableMappings = []                             # type: List[TextTableMapping]
+
+    def getFirstDataPrototypeRef(self):
+        return self.firstDataPrototypeRef
+
+    def setFirstDataPrototypeRef(self, value):
+        self.firstDataPrototypeRef = value
+        return self
+
+    def getFirstToSecondDataTransformationRef(self):
+        return self.firstToSecondDataTransformationRef
+
+    def setFirstToSecondDataTransformationRef(self, value):
+        self.firstToSecondDataTransformationRef = value
+        return self
+
+    def getSecondDataPrototypeRef(self):
+        return self.secondDataPrototypeRef
+
+    def setSecondDataPrototypeRef(self, value):
+        self.secondDataPrototypeRef = value
+        return self
+
+    def getSecondToFirstDataTransformationRef(self):
+        return self.secondToFirstDataTransformationRef
+
+    def setSecondToFirstDataTransformationRef(self, value):
+        self.secondToFirstDataTransformationRef = value
+        return self
+
+    def getSubElementMappings(self):
+        return self.subElementMappings
+
+    def setSubElementMappings(self, value):
+        self.subElementMappings = value
+        return self
+
+    def getTextTableMappings(self):
+        return self.textTableMappings
+
+    def setTextTableMappings(self, value):
+        self.textTableMappings = value
+        return self
+
+
+
+class ClientServerInterfaceMapping(PortInterfaceMapping):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        # type: ClientServerApplicationErrorMapping
+        self.errorMappings = []
+        # type: ClientServerOperationMapping
+        self.operationMappings = []
+
+    def getErrorMappings(self):
+        return self.errorMappings
+
+    def setErrorMappings(self, value):
+        self.errorMappings = value
+        return self
+
+    def getOperationMappings(self):
+        return self.operationMappings
+
+    def setOperationMappings(self, value):
+        self.operationMappings = value
+        return self
+
+
+class VariableAndParameterInterfaceMapping(PortInterfaceMapping):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.dataMappings = []                          # type: List[DataPrototypeMapping]
+
+    def getDataMappings(self):
+        return self.dataMappings
+
+    def addDataMapping(self, value):
+        self.dataMappings.append(value)
+        return self
+
+   
+class PortInterfaceMappingSet(ARElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.portInterfaceMappings = []                 # type: List[PortInterfaceMapping]
+
+    def getPortInterfaceMappings(self):
+        return self.portInterfaceMappings
+
+    def createVariableAndParameterInterfaceMapping(self, short_name):
+        if (short_name not in self.elements):
+            mapping = VariableAndParameterInterfaceMapping(self, short_name)
+            self.addElement(mapping)
+            self.portInterfaceMappings.append(mapping)
+        return self.getElement(short_name)

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, EcuStateMgrUserNeeds, 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,63 @@ 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 createEcuStateMgrUserNeeds(self, short_name: str) -> EcuStateMgrUserNeeds:
+        if (short_name not in self.elements):
+            needs = EcuStateMgrUserNeeds(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 getEcuStateMgrUserNeeds(self) -> List[EcuStateMgrUserNeeds]:
+        return sorted(filter(lambda c: isinstance(c, EcuStateMgrUserNeeds), 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,13 +1,14 @@
 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.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 ModeAccessPoint, ModeSwitchPoint
@@ -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[ServerCallPoint]:
-        return filter(lambda o: isinstance(o, AsynchronousServerCallPoint), self.getServerCallPoints())
+    def getAsynchronousServerCallPoint(self) -> List[AsynchronousServerCallPoint]:
+        return list(sorted(filter(lambda a: isinstance(a, AsynchronousServerCallPoint), self.elements.values()), 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()))
 
     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):
@@ -209,74 +224,89 @@ class SwcInternalBehavior(InternalBehavior):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.handle_termination_and_restart = None      # type: str
-        self.supports_multiple_instantiation = None     # type: ARBoolean
-        self.explicit_inter_runnable_variables = []     # type: List[VariableDataPrototype]
-        self.implicit_inter_runnable_variables = []     # type: List[VariableDataPrototype]
-        self.per_instance_memories = []                 # type: List[PerInstanceMemory]
-        self.per_instance_parameters = []               # type: List[ParameterDataPrototype]
-        self.port_api_options = []                      # type: List[PortAPIOption]
-        self.included_data_type_sets = []               # type: List[IncludedDataTypeSet]
+        self.arTypedPerInstanceMemories = []                        # type: List[VariableDataPrototype]
+        self.events = []                                            # type: List[RTEEvent]
+        self.exclusiveAreaPolicies = []                             # type: List[SwcExclusiveAreaPolicy]
+        self.explicitInterRunnableVariables = []                    # type: List[VariableDataPrototype]
+        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]
+        self.supportsMultipleInstantiation = None                   # type: Boolean
+        self.variationPointProxies = []                             # type: VariationPointProxy
 
     def getExplicitInterRunnableVariables(self) -> List[VariableDataPrototype]:
-        return self.explicit_inter_runnable_variables
+        return self.explicitInterRunnableVariables
 
     def getImplicitInterRunnableVariables(self) -> List[VariableDataPrototype]:
-        return self.implicit_inter_runnable_variables
+        return self.implicitInterRunnableVariables
 
     def getPerInstanceMemories(self) -> List[PerInstanceMemory]:
-        return self.per_instance_memories
+        return self.perInstanceMemories
 
     def getPerInstanceParameters(self) -> List[ParameterDataPrototype]:
-        return self.per_instance_parameters
+        return self.perInstanceParameters
 
     def addPortAPIOption(self, option: PortAPIOption):
-        self.port_api_options.append(option)
+        self.portAPIOptions.append(option)
 
     def getPortAPIOptions(self) -> List[PortAPIOption]:
-        return self.port_api_options
+        return self.portAPIOptions
 
     def addIncludedDataTypeSet(self, set: IncludedDataTypeSet):
-        self.included_data_type_sets.append(set)
+        self.includedDataTypeSets.append(set)
 
     def getIncludedDataTypeSets(self) -> List[IncludedDataTypeSet]:
-        return self.included_data_type_sets
+        return self.includedDataTypeSets
 
     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):
@@ -317,28 +347,28 @@ class SwcInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             prototype = VariableDataPrototype(self, short_name)
             self.elements[short_name] = prototype
-            self.explicit_inter_runnable_variables.append(prototype)
+            self.explicitInterRunnableVariables.append(prototype)
         return self.elements[short_name]
 
     def createImplicitInterRunnableVariable(self, short_name: str) -> VariableDataPrototype:
         if (short_name not in self.elements):
             prototype = VariableDataPrototype(self, short_name)
             self.elements[short_name] = prototype
-            self.implicit_inter_runnable_variables.append(prototype)
+            self.implicitInterRunnableVariables.append(prototype)
         return self.elements[short_name]
 
     def createPerInstanceMemory(self, short_name: str) -> PerInstanceMemory:
         if (short_name not in self.elements):
             memory = PerInstanceMemory(self, short_name)
             self.elements[short_name] = memory
-            self.per_instance_memories.append(memory)
+            self.perInstanceMemories.append(memory)
         return self.elements[short_name]
 
     def createPerInstanceParameter(self, short_name: str) -> ParameterDataPrototype:
         if (short_name not in self.elements):
             prototype = ParameterDataPrototype(self, short_name)
             self.elements[short_name] = prototype
-            self.per_instance_parameters.append(prototype)
+            self.perInstanceParameters.append(prototype)
         return self.elements[short_name]
 
     def getVariableDataPrototypes(self) -> List[VariableDataPrototype]:
@@ -356,3 +386,9 @@ class SwcInternalBehavior(InternalBehavior):
     def getRunnableEntity(self, short_name) -> RunnableEntity:
         return self.elements[short_name]
 
+    def getSupportsMultipleInstantiation(self):
+        return self.supportsMultipleInstantiation
+
+    def setSupportsMultipleInstantiation(self, value):
+        self.supportsMultipleInstantiation = value
+        return self

armodel/models/M2/AUTOSARTemplates/SystemTemplate/DataMapping.py

@@ -1,6 +1,8 @@
 from abc import ABCMeta
+
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import CommunicationDirectionType
 
 class DataMapping(ARObject, metaclass = ABCMeta):
     def __init__(self):
@@ -18,16 +20,23 @@ class DataMapping(ARObject, metaclass = ABCMeta):
         self.introduction = value
         return self
 
-
 class SenderReceiverToSignalMapping(DataMapping):
     def __init__(self):
         super().__init__()
 
+        self.communicationDirection = None                          # type: CommunicationDirectionType
         self.dataElementIRef = None
         self.senderToSignalTextTableMapping = None
         self.signalToReceiverTextTableMapping = None
         self.systemSignalRef = None
 
+    def getCommunicationDirection(self):
+        return self.communicationDirection
+
+    def setCommunicationDirection(self, value):
+        self.communicationDirection = value
+        return self
+
     def getDataElementIRef(self):
         return self.dataElementIRef