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

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

@@ -5,17 +5,19 @@ 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
+from .....M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroupPrototype, ModeDeclarationGroupPrototypeMapping
 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,28 +448,27 @@ class DataPrototypeMapping(ARObject):
         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 = []
+        self.errorMappings = []                                 # type: List[ClientServerApplicationErrorMapping]
+        self.operationMappings = []                             # type: List[ClientServerOperationMapping]
 
     def getErrorMappings(self):
         return self.errorMappings
 
-    def setErrorMappings(self, value):
-        self.errorMappings = value
+    def addErrorMapping(self, value):
+        if value is not None:
+            self.errorMappings.append(value)
         return self
 
     def getOperationMappings(self):
         return self.operationMappings
 
-    def setOperationMappings(self, value):
-        self.operationMappings = value
+    def addOperationMapping(self, value):
+        if value is not None:
+            self.operationMappings.append(value)
         return self
 
 
@@ -463,7 +485,29 @@ class VariableAndParameterInterfaceMapping(PortInterfaceMapping):
         self.dataMappings.append(value)
         return self
 
-   
+
+class ModeInterfaceMapping(PortInterfaceMapping):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        
+        self.modeMapping = None                         # type: ModeDeclarationGroupPrototypeMapping
+
+    def getModeMapping(self):
+        return self.modeMapping
+
+    def setModeMapping(self, value):
+        if value is not None:
+            self.modeMapping = value
+        return self
+
+
+class TriggerInterfaceMapping(PortInterfaceMapping):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.triggerMapping = []                            # type: List[TriggerMapping]
+
+ 
 class PortInterfaceMappingSet(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -473,9 +517,81 @@ class PortInterfaceMappingSet(ARElement):
     def getPortInterfaceMappings(self):
         return self.portInterfaceMappings
 
-    def createVariableAndParameterInterfaceMapping(self, short_name):
-        if (short_name not in self.elements):
+    def createVariableAndParameterInterfaceMapping(self, short_name: str):
+        if (not self.IsElementExists(short_name)):
             mapping = VariableAndParameterInterfaceMapping(self, short_name)
             self.addElement(mapping)
             self.portInterfaceMappings.append(mapping)
         return self.getElement(short_name)
+    
+    def createClientServerInterfaceMapping(self, short_name: str):
+        if (not self.IsElementExists(short_name)):
+            mapping = ClientServerInterfaceMapping(self, short_name)
+            self.addElement(mapping)
+            self.portInterfaceMappings.append(mapping)
+        return self.getElement(short_name)
+    
+    def createModeInterfaceMapping(self, short_name: str):
+        if (not self.IsElementExists(short_name)):
+            mapping = ModeInterfaceMapping(self, short_name)
+            self.addElement(mapping)
+            self.portInterfaceMappings.append(mapping)
+        return self.getElement(short_name)
+    
+    def createTriggerInterfaceMapping(self, short_name: str):
+        if (not self.IsElementExists(short_name)):
+            mapping = TriggerInterfaceMapping(self, short_name)
+            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/SoftwareComponentDocumentation.py

@@ -0,0 +1,80 @@
+from typing import List
+from .....models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+
+class SwComponentDocumentation(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.chapters = []                              # type: List[Chapter]
+        self.swCalibrationNotes = None                  # type: Chapter
+        self.swCarbDoc = None                           # type: Chapter
+        self.swDiagnosticsNotes = None                  # type: Chapter
+        self.swFeatureDef = None                        # type: Chapter
+        self.swFeatureDesc = None                       # type: Chapter
+        self.swMaintenanceNotes = None                  # type: Chapter
+        self.swTestDesc = None                          # type: sChapter
+
+    def getChapters(self):
+        return self.chapters
+
+    def addChapter(self, value):
+        if value is not None:
+            self.chapters.append(value)
+        return self
+
+    def getSwCalibrationNotes(self):
+        return self.swCalibrationNotes
+
+    def setSwCalibrationNotes(self, value):
+        if value is not None:
+            self.swCalibrationNotes = value
+        return self
+
+    def getSwCarbDoc(self):
+        return self.swCarbDoc
+
+    def setSwCarbDoc(self, value):
+        if value is not None:
+            self.swCarbDoc = value
+        return self
+
+    def getSwDiagnosticsNotes(self):
+        return self.swDiagnosticsNotes
+
+    def setSwDiagnosticsNotes(self, value):
+        if value is not None:
+            self.swDiagnosticsNotes = value
+        return self
+
+    def getSwFeatureDef(self):
+        return self.swFeatureDef
+
+    def setSwFeatureDef(self, value):
+        if value is not None:
+            self.swFeatureDef = value
+        return self
+
+    def getSwFeatureDesc(self):
+        return self.swFeatureDesc
+
+    def setSwFeatureDesc(self, value):
+        if value is not None:
+            self.swFeatureDesc = value
+        return self
+
+    def getSwMaintenanceNotes(self):
+        return self.swMaintenanceNotes
+
+    def setSwMaintenanceNotes(self, value):
+        if value is not None:
+            self.swMaintenanceNotes = value
+        return self
+
+    def getSwTestDesc(self):
+        return self.swTestDesc
+
+    def setSwTestDesc(self, value):
+        if value is not None:
+            self.swTestDesc = 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

@@ -5,6 +5,7 @@ from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject i
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType, TimeValue
 from typing import List
 
+
 class RTEEvent(AbstractEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -26,6 +27,7 @@ class RTEEvent(AbstractEvent):
         self.startOnEventRef = value
         return self
 
+
 class AsynchronousServerCallReturnsEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -53,6 +55,7 @@ class DataSendCompletedEvent(RTEEvent):
         self.eventSourceRef = value
         return self
 
+
 class DataWriteCompletedEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -66,6 +69,7 @@ class DataWriteCompletedEvent(RTEEvent):
         self.eventSourceRef = value
         return self
 
+
 class DataReceivedEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -101,11 +105,12 @@ class SwcModeSwitchEvent(RTEEvent):
         self.modeIRefs.append(value)
         return self
 
+
 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
@@ -114,6 +119,7 @@ class DataReceiveErrorEvent(RTEEvent):
         self.dataIRef = value
         return self
 
+
 class OperationInvokedEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -128,6 +134,7 @@ class OperationInvokedEvent(RTEEvent):
             self.operationIRef = value
         return self
 
+
 class InitEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -163,6 +170,7 @@ class TimingEvent(RTEEvent):
             self.period = value
         return self
 
+
 class InternalTriggerOccurredEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -177,10 +185,12 @@ class InternalTriggerOccurredEvent(RTEEvent):
             self.eventSourceRef = value
         return self
 
+
 class BackgroundEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+
 class ModeSwitchedAckEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)

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

@@ -1,8 +1,12 @@
 from typing import List
-from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds, DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds, EcuStateMgrUserNeeds, NvBlockNeeds, RoleBasedDataAssignment, ServiceNeeds
+from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds
+from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds
+from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DtcStatusChangeNotificationNeeds, EcuStateMgrUserNeeds, NvBlockNeeds
+from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import RoleBasedDataAssignment, ServiceNeeds, ServiceDependency
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Identifier, RefType
-from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import ServiceDependency
+
+
 class RoleBasedPortAssignment(ARObject):
     def __init__(self):
         super().__init__()
@@ -24,6 +28,7 @@ class RoleBasedPortAssignment(ARObject):
         self.role = value
         return self
 
+
 class SwcServiceDependency(ServiceDependency):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -91,6 +96,12 @@ class SwcServiceDependency(ServiceDependency):
             self.addElement(needs)
         return self.getElement(short_name)
     
+    def createDtcStatusChangeNotificationNeeds(self, short_name: str) -> DtcStatusChangeNotificationNeeds:
+        if (short_name not in self.elements):
+            needs = DtcStatusChangeNotificationNeeds(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)
     
@@ -108,6 +119,9 @@ class SwcServiceDependency(ServiceDependency):
     
     def getEcuStateMgrUserNeeds(self) -> List[EcuStateMgrUserNeeds]:
         return sorted(filter(lambda c: isinstance(c, EcuStateMgrUserNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
+    def getDtcStatusChangeNotificationNeeds(self) -> List[DtcStatusChangeNotificationNeeds]:
+        return sorted(filter(lambda c: isinstance(c, DtcStatusChangeNotificationNeeds), 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

@@ -11,7 +11,7 @@ from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMap
 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):