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

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

@@ -3,7 +3,7 @@ from .....M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeRequest
 from .....M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpType
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
-from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType, String
 from .....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationArrayElement, ApplicationRecordElement
 from .....M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps
 from abc import ABCMeta
@@ -50,9 +50,17 @@ class ApplicationArrayDataType(ApplicationCompositeDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.dynamic_array_size_profile = None      # type: ARLiteral
+        self.dynamicArraySizeProfile = None         # type: String
         self.element = None                         # type: ApplicationArrayElement
 
+    def getDynamicArraySizeProfile(self):
+        return self.dynamicArraySizeProfile
+
+    def setDynamicArraySizeProfile(self, value):
+        if value is not None:
+            self.dynamicArraySizeProfile = value
+        return self
+
     def createApplicationArrayElement(self, short_name: str) -> ApplicationArrayElement:
         if (short_name not in self.elements):
             array_element = ApplicationArrayElement(self, short_name)
@@ -60,7 +68,6 @@ class ApplicationArrayDataType(ApplicationCompositeDataType):
             self.element = self.elements[short_name]
         return self.elements[short_name]
 
-
 class ApplicationRecordDataType(ApplicationCompositeDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)

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

@@ -4,6 +4,7 @@ from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Integer, Na
 from ..SystemTemplate.InstanceRefs import VariableDataPrototypeInSystemInstanceRef
 from typing import List
 
+
 class EndToEndDescription(ARObject):
     def __init__(self):
         super().__init__()
@@ -41,7 +42,8 @@ class EndToEndDescription(ARObject):
         return self
 
     def getDataIds(self) -> List[PositiveInteger]:
-        return sorted(self.dataIds, key = lambda a: a)
+        # return sorted(self.dataIds, key = lambda a: a.getValue())
+        return self.dataIds
 
     def addDataId(self, id: PositiveInteger):
         self.dataIds.append(id)
@@ -104,6 +106,7 @@ class EndToEndProtectionVariablePrototype(ARObject):
     def getReceiverIrefs(self) -> List[VariableDataPrototypeInSystemInstanceRef]:
         return self._receiverIRefs
 
+
 class EndToEndProtectionISignalIPdu(ARObject):
     def __init__(self):
         super().__init__()
@@ -146,21 +149,25 @@ class EndToEndProtection(Identifiable):
         return self.endToEndProfile
 
     def setEndToEndProfile(self, value):
-        self.endToEndProfile = value
+        if value is not None:
+            self.endToEndProfile = value
         return self
 
     def getEndToEndProtectionISignalIPdus(self):
         return self.endToEndProtectionISignalIPdus
 
     def addEndToEndProtectionISignalIPdu(self, value):
-        self.endToEndProtectionISignalIPdus.append(value)
+        if value is not None:
+            self.endToEndProtectionISignalIPdus.append(value)
         return self
 
     def getEndToEndProtectionVariablePrototypes(self) -> List[EndToEndProtectionVariablePrototype]:
         return self.endToEndProtectionVariablePrototypes
     
-    def addEndToEndProtectionVariablePrototype(self, prototype: EndToEndProtectionVariablePrototype):
-        self.endToEndProtectionVariablePrototypes.append(prototype)
+    def addEndToEndProtectionVariablePrototype(self, value: EndToEndProtectionVariablePrototype):
+        if value is not None:
+            self.endToEndProtectionVariablePrototypes.append(value)
+        return self
 
 
 class EndToEndProtectionSet(Identifiable):
@@ -174,4 +181,4 @@ class EndToEndProtectionSet(Identifiable):
         return self.elements[short_name]
 
     def getEndToEndProtections(self) -> List[EndToEndProtection]:
-        return sorted(filter(lambda c: isinstance(c, EndToEndProtection), self.elements.values()), key= lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, EndToEndProtection), self.elements.values()), key=lambda e: e.short_name)

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

@@ -5,7 +5,8 @@ from .....M2.AUTOSARTemplates.CommonStructure import TextValueSpecification
 from .....M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger
 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, ArgumentDirectionEnum, PositiveInteger
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, ArgumentDirectionEnum, Boolean
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import 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
@@ -13,9 +14,10 @@ from .....M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpType
 from .....M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpFeature
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 
-class PortInterface(AtpType, metaclass = ABCMeta):
+
+class PortInterface(AtpType, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == PortInterface:
+        if type(self) is PortInterface:
             raise NotImplementedError("PortInterface is an abstract class.")
         super().__init__(parent, short_name)
 
@@ -36,12 +38,14 @@ class PortInterface(AtpType, metaclass = ABCMeta):
         self.serviceKind = value
         return self
 
-class DataInterface(PortInterface, metaclass = ABCMeta):
+
+class DataInterface(PortInterface, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == DataInterface:
+        if type(self) is DataInterface:
             raise NotImplementedError("DataInterface is an abstract class.")
         super().__init__(parent, short_name)
 
+
 class NvDataInterface(DataInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -55,6 +59,7 @@ class NvDataInterface(DataInterface):
         self.nvDatas.append(value)
         return self
 
+
 class ParameterInterface(DataInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -62,15 +67,15 @@ class ParameterInterface(DataInterface):
         self.parameters = []                        # type: List[ParameterDataPrototype]
 
     def getParameters(self):
-        return list(sorted(filter(lambda a : isinstance(a, ParameterDataPrototype), self.elements.values()), key = lambda a: a.short_name))
+        return self.parameters
+
+    def createParameterDataPrototype(self, short_name: str) -> ParameterDataPrototype:
+        prototype = ParameterDataPrototype(self, short_name)
+        self.addElement(prototype)
+        self.parameters.append(prototype)
+        return prototype
+
 
-    def createParameter(self, short_name: str) -> ParameterDataPrototype:
-        if (short_name not in self.elements):
-            parameter = ParameterDataPrototype(self, short_name)
-            self.elements[short_name] = parameter
-            self.parameters.append(parameter)
-        return self.elements[short_name]
-    
 class InvalidationPolicy(ARObject):
     def __init__(self):
         super().__init__()
@@ -91,7 +96,8 @@ class InvalidationPolicy(ARObject):
     def setHandleInvalid(self, value):
         self.handleInvalid = value
         return self
-    
+
+
 class MetaDataItem(ARObject):
     def __init__(self):
         super().__init__()
@@ -112,7 +118,8 @@ class MetaDataItem(ARObject):
     def setMetaDataItemType(self, value):
         self.metaDataItemType = value
         return self
-    
+
+
 class MetaDataItemSet(ARObject):
     def __init__(self):
         super().__init__()
@@ -134,6 +141,7 @@ class MetaDataItemSet(ARObject):
         self.metaDataItems.append(value)
         return self
 
+
 class SenderReceiverInterface(DataInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -167,7 +175,7 @@ class SenderReceiverInterface(DataInterface):
     def getDataElement(self, short_name) -> VariableDataPrototype:
         if (short_name in self.elements):
             data_element = self.elements[short_name]
-            #if (not isinstance(data_element, VariableDataPrototype)):
+            # if (not isinstance(data_element, VariableDataPrototype)):
             #    raise IndexError("%s is not data element." % short_name)
             return data_element
         raise IndexError("data element <%s> can not be found." % short_name)
@@ -180,34 +188,38 @@ class SenderReceiverInterface(DataInterface):
     def getInvalidationPolicys(self) -> List[InvalidationPolicy]:
         return list(filter(lambda c: isinstance(c, InvalidationPolicy), self.invalidationPolicies))
 
+
 class ArgumentDataPrototype(AutosarDataPrototype):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
         self.direction = None                               # type: ArgumentDirectionEnum
-        # type: ServerArgumentImplPolicyEnum
-        self.serverArgumentImplPolicy = None
+        self.serverArgumentImplPolicy = None                # type: ServerArgumentImplPolicyEnum
 
     def getDirection(self):
         return self.direction
 
     def setDirection(self, value):
-        self.direction = value
+        if value is not None:
+            self.direction = value
         return self
 
     def getServerArgumentImplPolicy(self):
         return self.serverArgumentImplPolicy
 
     def setServerArgumentImplPolicy(self, value):
-        self.serverArgumentImplPolicy = value
+        if value is not None:
+            self.serverArgumentImplPolicy = value
         return self
 
+
 class ApplicationError(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
         self.error_code = None                  # type: ARNumerical
 
+
 class ClientServerOperation(AtpFeature):
     """
         An operation declared within the scope of a client/server interface.
@@ -233,27 +245,34 @@ class ClientServerOperation(AtpFeature):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._arguments = []
-        self._possible_error_refs = []  # type: List[RefType]
+        self.arguments = []                                                     # type: List[ArgumentDataPrototype]
+        self.possibleErrorRefs = []                                             # type: List[RefType]
 
-    def addArgumentDataPrototype(self, prototype: ArgumentDataPrototype):
-        self._arguments.append(prototype)
+    def getArguments(self):
+        return self.arguments
 
-    def getArgumentDataPrototypes(self) -> List[ArgumentDataPrototype]:
-        return self._arguments
+    def createArgumentDataPrototype(self, short_name):
+        if not self.IsElementExists(short_name):
+            prototype = ArgumentDataPrototype(self, short_name)
+            self.addElement(prototype)
+            self.arguments.append(prototype)
+        return self.getElement(short_name)
 
-    def addPossibleErrorRef(self, possible_error_ref: RefType):
-        self._possible_error_refs.append(possible_error_ref)
+    def getPossibleErrorRefs(self):
+        return self.possibleErrorRefs
 
-    def getPossbileErrorRefs(self) -> List[RefType]:
-        return self._possible_error_refs
+    def addPossibleErrorRef(self, value):
+        if value is not None:
+            self.possibleErrorRefs.append(value)
+        return self
 
 
 class ClientServerInterface(PortInterface):
     """
         A client/server interface declares a number of operations that can be invoked on a server by a client.
         Package: M2::AUTOSARTemplates::SWComponentTemplate::PortInterface
-        Base: ARElement, ARObject, AtpBlueprint, AtpBlueprintable, AtpClassifier , AtpType, CollectableElement, Identifiable, MultilanguageReferrable, PackageableElement, PortInterface, Referrable
+        Base: ARElement, ARObject, AtpBlueprint, AtpBlueprintable, AtpClassifier , AtpType, CollectableElement, Identifiable, MultilanguageReferrable,
+              PackageableElement, PortInterface, Referrable
 
         Methods:
         --------
@@ -283,13 +302,15 @@ class ClientServerInterface(PortInterface):
 
     def getPossibleErrors(self) -> List[ApplicationError]:
         return list(filter(lambda c: isinstance(c, ApplicationError), self.elements.values()))
-    
+
+
 class TriggerInterface(PortInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
         self._triggers = []             # type: Trigger
 
+
 class ModeSwitchInterface(PortInterface):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -303,14 +324,16 @@ 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):
+class PortInterfaceMapping(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == PortInterface:
+        if type(self) is PortInterfaceMapping:
             raise NotImplementedError("PortInterfaceMapping is an abstract class.")
         super().__init__(parent, short_name)
 
+
 class ClientServerApplicationErrorMapping(ARObject):
     def __init__(self):
         super().__init__()
@@ -331,11 +354,11 @@ class ClientServerApplicationErrorMapping(ARObject):
     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
@@ -425,7 +448,6 @@ class DataPrototypeMapping(ARObject):
         return self
 
 
-
 class ClientServerInterfaceMapping(PortInterfaceMapping):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -479,3 +501,54 @@ class PortInterfaceMappingSet(ARElement):
             self.addElement(mapping)
             self.portInterfaceMappings.append(mapping)
         return self.getElement(short_name)
+
+
+class TextTableMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.bitfieldTextTableMaskFirst = None                  # type: PositiveInteger
+        self.bitfieldTextTableMaskSecond = None                 # type: PositiveInteger
+        self.identicalMapping = None                            # type: Boolean
+        self.mappingDirection = None                            # type: MappingDirectionEnum
+        self.valuePairs = []                                    # type: List[TextTableValuePair]
+
+    def getBitfieldTextTableMaskFirst(self):
+        return self.bitfieldTextTableMaskFirst
+
+    def setBitfieldTextTableMaskFirst(self, value):
+        if value is not None:
+            self.bitfieldTextTableMaskFirst = value
+        return self
+
+    def getBitfieldTextTableMaskSecond(self):
+        return self.bitfieldTextTableMaskSecond
+
+    def setBitfieldTextTableMaskSecond(self, value):
+        if value is not None:
+            self.bitfieldTextTableMaskSecond = value
+        return self
+
+    def getIdenticalMapping(self):
+        return self.identicalMapping
+
+    def setIdenticalMapping(self, value):
+        if value is not None:
+            self.identicalMapping = value
+        return self
+
+    def getMappingDirection(self):
+        return self.mappingDirection
+
+    def setMappingDirection(self, value):
+        if value is not None:
+            self.mappingDirection = value
+        return self
+
+    def getValuePairs(self):
+        return self.valuePairs
+
+    def setValuePairs(self, value):
+        if value is not None:
+            self.valuePairs = value
+        return self

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

@@ -10,4 +10,12 @@ class AbstractAccessPoint(Identifiable, metaclass = ABCMeta):
         
         super().__init__(parent, short_name)
 
-        self.return_value_provision = None  
+        self.returnValueProvision = None                                    # type: RteApiReturnValueProvisionEnum
+
+    def getReturnValueProvision(self):
+        return self.returnValueProvision
+
+    def setReturnValueProvision(self, value):
+        if value is not None:
+            self.returnValueProvision = value
+        return self

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

@@ -1,5 +1,6 @@
-from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
 from typing import List
+
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, Identifier, RefType
 from .....M2.AUTOSARTemplates.SWComponentTemplate.RPTScenario import ModeAccessPointIdent
 from .....M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AccessCount import AbstractAccessPoint
@@ -30,7 +31,7 @@ class ModeSwitchPoint(AbstractAccessPoint):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.modeGroupIRef = None           # type: PModeGroupInAtomicSwcInstanceRef
+        self.modeGroupIRef = None                                   # type: PModeGroupInAtomicSwcInstanceRef
 
     def getModeGroupIRef(self):
         return self.modeGroupIRef
@@ -44,8 +45,8 @@ class IncludedModeDeclarationGroupSet(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.mode_declaration_group_refs = []           # type: List[RefType]
-        self.prefix = None                              # type: ARLiteral
+        self.mode_declaration_group_refs = []                       # type: List[RefType]
+        self.prefix = None                                          # type: Identifier
 
     def addModeDeclarationGroupRef(self, ref: RefType):
         self.mode_declaration_group_refs.append(ref)

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

@@ -105,7 +105,7 @@ class DataReceiveErrorEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.dataIRef = None
+        self.dataIRef = None            
 
     def getDataIRef(self):
         return self.dataIRef
@@ -118,13 +118,14 @@ class OperationInvokedEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.operationIRef = None      # type: POperationInAtomicSwcInstanceRef
+        self.operationIRef = None                                   # type: POperationInAtomicSwcInstanceRef
 
     def getOperationIRef(self):
         return self.operationIRef
 
     def setOperationIRef(self, value):
-        self.operationIRef = value
+        if value is not None:
+            self.operationIRef = value
         return self
 
 class InitEvent(RTEEvent):
@@ -150,29 +151,46 @@ class TimingEvent(RTEEvent):
         return self.offset
 
     def setOffset(self, value):
-        self.offset = value
+        if value is not None:
+            self.offset = value
         return self
 
     def getPeriod(self):
         return self.period
 
     def setPeriod(self, value):
-        self.period = value
+        if value is not None:
+            self.period = value
         return self
 
 class InternalTriggerOccurredEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.eventSourceRef = None                      # type: RefType
+        self.eventSourceRef = None                                  # type: RefType
 
     def getEventSourceRef(self):
         return self.eventSourceRef
 
     def setEventSourceRef(self, value):
-        self.eventSourceRef = value
+        if value is not None:
+            self.eventSourceRef = value
         return self
 
 class BackgroundEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
+        super().__init__(parent, short_name)
+
+class ModeSwitchedAckEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.eventSourceRef = None                                  # type: RefType
+
+    def getEventSourceRef(self):
+        return self.eventSourceRef
+
+    def setEventSourceRef(self, value):
+        if value is not None:
+            self.eventSourceRef = value
+        return self

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

@@ -6,12 +6,12 @@ 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, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, BackgroundEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, ModeSwitchedAckEvent, OperationInvokedEvent, RTEEvent, 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 ModeAccessPoint, ModeSwitchPoint
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet, ModeAccessPoint, ModeSwitchPoint
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.Trigger import InternalTriggeringPoint
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
@@ -290,6 +290,14 @@ class SwcInternalBehavior(InternalBehavior):
 
     def getIncludedDataTypeSets(self) -> List[IncludedDataTypeSet]:
         return self.includedDataTypeSets
+    
+    def getIncludedModeDeclarationGroupSets(self):
+        return self.includedModeDeclarationGroupSets
+
+    def addIncludedModeDeclarationGroupSet(self, value):
+        if value is not None:
+            self.includedModeDeclarationGroupSets.append(value)
+        return self
 
     def createOperationInvokedEvent(self, short_name: str) -> OperationInvokedEvent:
         if (short_name not in self.elements):
@@ -338,6 +346,18 @@ class SwcInternalBehavior(InternalBehavior):
             event = SwcServiceDependency(self, short_name)
             self.elements[short_name] = event
         return self.elements[short_name]
+    
+    def createModeSwitchedAckEvent(self, short_name: str) -> ModeSwitchedAckEvent:
+        if (short_name not in self.elements):
+            event = ModeSwitchedAckEvent(self, short_name)
+            self.addElement(event)
+        return self.getElement(short_name)
+    
+    def createBackgroundEvent(self, short_name: str) -> BackgroundEvent:
+        if (short_name not in self.elements):
+            event = BackgroundEvent(self, short_name)
+            self.addElement(event)
+        return self.getElement(short_name)
 
     def getRteEvents(self) -> List[RTEEvent]:
         return sorted(filter(lambda c: isinstance(c, RTEEvent), self.elements.values()), key=lambda e: e.short_name)
@@ -359,6 +379,12 @@ class SwcInternalBehavior(InternalBehavior):
 
     def getInternalTriggerOccurredEvents(self) -> List[InternalTriggerOccurredEvent]:
         return sorted(filter(lambda c: isinstance(c, InternalTriggerOccurredEvent), self.elements.values()), 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)
+    
+    def getBackgroundEvents(self) -> List[BackgroundEvent]:
+        return sorted(filter(lambda c: isinstance(c, BackgroundEvent), self.elements.values()), 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)
@@ -367,10 +393,6 @@ class SwcInternalBehavior(InternalBehavior):
         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]
-    
-    
-
-    
 
     def createImplicitInterRunnableVariable(self, short_name: str) -> VariableDataPrototype:
         if (short_name not in self.elements):