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

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

@@ -1,10 +1,11 @@
 from abc import ABCMeta
 from typing import Dict
 
-class ARObject(metaclass = ABCMeta):
+
+class ARObject(metaclass=ABCMeta):
     def __init__(self):
-        if type(self) == ARObject:
-            raise NotImplementedError("ARObject is an abstract class.")
+        if type(self) is ARObject:
+            raise TypeError("ARObject is an abstract class.")
 
         self.parent = None              # type: ARObject
         self.checksum = None            # type: str
@@ -13,4 +14,4 @@ class ARObject(metaclass = ABCMeta):
         self.uuid = None                # type: str
 
     def getTagName(self, tag: str, nsmap: Dict) -> str:
-        return tag.replace("{%s}" % nsmap["xmlns"], "")
+        return tag.replace("{%s}" % nsmap["xmlns"], "")

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

@@ -6,14 +6,14 @@ from .....M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageO
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, CategoryString
 from abc import ABCMeta
-from typing import List
+from typing import Dict, List
 
 
 class Referrable(ARObject, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
 
         if type(self) is Referrable:
-            raise NotImplementedError("Referrable is an abstract class.")
+            raise TypeError("Referrable is an abstract class.")
         
         ARObject.__init__(self)
 
@@ -45,7 +45,7 @@ class Referrable(ARObject, metaclass=ABCMeta):
 class MultilanguageReferrable(Referrable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) is MultilanguageReferrable:
-            raise NotImplementedError("MultilanguageReferrable is an abstract class.")
+            raise TypeError("MultilanguageReferrable is an abstract class.")
 
         super().__init__(parent, short_name)
 
@@ -63,40 +63,61 @@ class MultilanguageReferrable(Referrable, metaclass=ABCMeta):
 class CollectableElement(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) is CollectableElement:
-            raise NotImplementedError("CollectableElement is an abstract class.")
+            raise TypeError("CollectableElement is an abstract class.")
         
-        self.elements = {}              # type: dict[str, Referrable]
+        # super().__init__()
+        
+        self.elements: List[Referrable] = []
+        self.element_mappings: Dict[str, List[Referrable]] = {}
 
     def getTotalElement(self) -> int:
-        # return len(list(filter(lambda a: not isinstance(a, ARPackage) , self.elements.values())))
-        return len(self.elements.values())
-
-    def removeElement(self, key):
-        if key not in self.elements:
-            raise KeyError("Invalid key <%s> for removing element" % key)
-        self.elements.pop(key)
+        # return len(list(filter(lambda a: not isinstance(a, ARPackage) , self.elements)))
+        return len(self.elements)
+
+    def removeElement(self, short_name: str, type=None):
+        if short_name not in self.element_mappings:
+            raise KeyError("Invalid key <%s> for removing element" % short_name)
+        if type is None:
+            item = self.element_mappings[short_name][0]
+        else:
+            item = next(filter(lambda a: isinstance(a, type), self.element_mappings[short_name]))
+        if item is not None:
+            self.elements.remove(item)
+            self.element_mappings[short_name].remove(item)
 
     def getElements(self):
-        return self.elements.values()
+        return self.elements
 
     def addElement(self, element: Referrable):
         short_name = element.getShortName()
-        if not self.IsElementExists(short_name):
-            self.elements[short_name] = element
-
-    def getElement(self, short_name: str) -> Referrable:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name, type(element)):
+            self.elements.append(element)
+            if short_name not in self.element_mappings:
+                self.element_mappings[short_name] = []
+            self.element_mappings[short_name].append(element)
+
+    def getElement(self, short_name: str, type=None) -> Referrable:
+        if (short_name not in self.element_mappings):
             return None
-        return self.elements[short_name]
+        if type is not None:
+            result = list(filter(lambda a: isinstance(a, type), self.element_mappings[short_name]))
+            if len(result) == 0:
+                return None
+            return result[0]
+        return self.element_mappings[short_name][0]
     
-    def IsElementExists(self, short_name: str) -> bool:
-        return short_name in self.elements
+    def IsElementExists(self, short_name: str, type=None) -> bool:
+        if type is None:
+            return short_name in self.element_mappings
+        if short_name in self.element_mappings:
+            return any(isinstance(a, type) for a in self.element_mappings[short_name])
+        return False
 
 
 class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) is Identifiable:
-            raise NotImplementedError("Identifiable is an abstract class.")
+            raise TypeError("Identifiable is an abstract class.")
         
         MultilanguageReferrable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
@@ -153,21 +174,21 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMet
 class PackageableElement(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) is PackageableElement:
-            raise NotImplementedError("PackageableElement is an abstract class.")
+            raise TypeError("PackageableElement is an abstract class.")
         super().__init__(parent, short_name)
 
 
 class ARElement(PackageableElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) is ARElement:
-            raise NotImplementedError("ARElement is an abstract class.")
+            raise TypeError("ARElement is an abstract class.")
         super().__init__(parent, short_name)
 
 
 class Describable(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) is Describable:
-            raise NotImplementedError("Describable is an abstract class.")
+            raise TypeError("Describable is an abstract class.")
 
         super().__init__()
 

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

@@ -465,7 +465,7 @@ class TRefType(RefType):
 
 
 class DiagRequirementIdString(ARLiteral):
-    '''
+    r'''
         This string denotes an Identifier for a requirement.
 
         Tags:
@@ -491,7 +491,7 @@ class ArgumentDirectionEnum(AREnum):
 
 
 class Ip4AddressString(ARLiteral):
-    '''
+    r'''
         This is used to specify an IP4 address. Notation: 255.255.255.255
         
         Tags
@@ -504,7 +504,7 @@ class Ip4AddressString(ARLiteral):
 
 
 class Ip6AddressString(ARLiteral):
-    '''
+    r'''
         This is used to specify an IP6 address. Notation: FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF
         Alternative notations, short-cuts with duplicate colons like ::, etc. or mixtures using colons and dots, are
         not allowed.
@@ -550,3 +550,33 @@ class CategoryString(ARLiteral):
 class ByteOrderEnum(AREnum):
     def __init__(self):
         super().__init__([])
+
+
+class DateTime(ARLiteral):
+    r'''
+        A datatype representing a timestamp. The smallest granularity is 1 second.
+        This datatype represents a timestamp in the format yyyy-mm-dd followed by an optional time. The lead-in
+        character for the time is "T" and the format is hh:mm:ss. In addition, a time zone designator shall be
+        specified. The time zone designator can either be "Z" (for UTC) or the time offset to UTC, i.e. (+|-)hh:mm.
+        
+        Examples:
+            2009-07-23
+            2009-07-23T14:38:00+01:00
+            2009-07-23T13:38:00Z
+        Tags:
+            xml.xsd.customType=DATE
+            xml.xsd.pattern=([0-9]{4}-[0-9]{2}-[0-9]{2})(T[0-9]{2}:[0-9]{2}:[0-9]{2}(Z|([+\-][0-9]{2}:[0-9]{2})))?
+            xml.xsd.type=string
+    '''
+    def __init__(self):
+        super().__init__()
+
+
+class VerbatimString(ARLiteral):
+    def __init__(self):
+        super().__init__()
+
+
+class RegularExpression(ARLiteral):
+    def __init__(self):
+        super().__init__()

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

@@ -310,13 +310,11 @@ class AtomicSwComponentType(SwComponentType, metaclass=ABCMeta):
         return self.internalBehavior
 
     def createSwcInternalBehavior(self, short_name) -> SwcInternalBehavior:
-        if (short_name not in self.elements):
-            if (len(list(filter(lambda e: isinstance(e, SwcInternalBehavior), self.elements.values()))) >= 1):
-                raise ValueError("The internal behavior of <%s> can not more than 1" % self.short_name)
+        if (not self.IsElementExists(short_name)):
             behavior = SwcInternalBehavior(self, short_name)
-            self.elements[short_name] = behavior
+            self.addElement(behavior)
             self.internalBehavior = behavior
-        return self.elements[short_name]
+        return self.getElement(short_name, SwcInternalBehavior)
 
     def getSymbolProps(self):
         return self.symbolProps
@@ -329,7 +327,7 @@ class AtomicSwComponentType(SwComponentType, metaclass=ABCMeta):
     '''
     @property
     def internal_behavior(self) -> SwcInternalBehavior:
-        return next(filter(lambda e: isinstance(e, SwcInternalBehavior), self.elements.values()))
+        return next(filter(lambda e: isinstance(e, SwcInternalBehavior), self.elements))
     '''
 
 
@@ -418,42 +416,42 @@ class CompositionSwComponentType(SwComponentType):
 
     def removeAllAssemblySwConnector(self):
         for sw_connector in self.getAssemblySwConnectors():
-            self.elements.pop(sw_connector.short_name)
+            self.elements.remove(sw_connector)
 
     def removeAllDelegationSwConnector(self):
         for sw_connector in self.getDelegationSwConnectors():
-            self.elements.pop(sw_connector.short_name)
+            self.elements.remove(sw_connector)
 
     def createAssemblySwConnector(self, short_name: str) -> AssemblySwConnector:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             connector = AssemblySwConnector(self, short_name)
-            self.elements[short_name] = connector
-        return self.elements[short_name]
+            self.addElement(connector)
+        return self.getElement(short_name, AssemblySwConnector)
 
     def createDelegationSwConnector(self, short_name: str) -> DelegationSwConnector:
-        if short_name not in self.elements:
+        if not self.IsElementExists(short_name):
             connector = DelegationSwConnector(self, short_name)
-            self.elements[short_name] = connector
-        return self.elements[short_name]
+            self.addElement(connector)
+        return self.getElement(short_name, DelegationSwConnector)
 
     def getAssemblySwConnectors(self) -> List[AssemblySwConnector]:
-        return list(sorted(filter(lambda e: isinstance(e, AssemblySwConnector), self.elements.values()), key=lambda c: c.short_name))
+        return list(sorted(filter(lambda e: isinstance(e, AssemblySwConnector), self.elements), key=lambda c: c.short_name))
 
     def getDelegationSwConnectors(self) -> List[DelegationSwConnector]:
-        return list(sorted(filter(lambda e: isinstance(e, DelegationSwConnector), self.elements.values()), key=lambda c: c.short_name))
+        return list(sorted(filter(lambda e: isinstance(e, DelegationSwConnector), self.elements), key=lambda c: c.short_name))
 
     # def getSwConnectors(self) -> List[SwConnector]:
-    #    return list(sorted(filter(lambda e: isinstance(e, SwConnector), self.elements.values()), key=lambda c: c.short_name))
+    #    return list(sorted(filter(lambda e: isinstance(e, SwConnector), self.elements), key=lambda c: c.short_name))
 
     def getSwConnectors(self) -> List[SwConnector]:
-        return list(filter(lambda e: isinstance(e, SwConnector), self.elements.values()))
+        return list(filter(lambda e: isinstance(e, SwConnector), self.elements))
 
     def createSwComponentPrototype(self, short_name: str) -> SwComponentPrototype:
-        if (not self.IsElementExists(short_name)):
+        if not self.IsElementExists(short_name):
             prototype = SwComponentPrototype(self, short_name)
             self.addElement(prototype)
             self.components.append(prototype)
-        return self.getElement(short_name)
+        return self.getElement(short_name, SwComponentPrototype)
 
     def getComponents(self) -> List[SwComponentPrototype]:
         return self.components

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

@@ -8,10 +8,11 @@ from .....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import
 from .....M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps
 from abc import ABCMeta
 
-class AutosarDataType(AtpType, metaclass = ABCMeta):
+
+class AutosarDataType(AtpType, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == AutosarDataType:
-            raise NotImplementedError("AutosarDataType is an abstract class.")
+        if type(self) is AutosarDataType:
+            raise TypeError("AutosarDataType is an abstract class.")
 
         super().__init__(parent, short_name)
 
@@ -25,10 +26,10 @@ class AutosarDataType(AtpType, metaclass = ABCMeta):
         return self
 
 
-class ApplicationDataType(AutosarDataType, metaclass = ABCMeta):
+class ApplicationDataType(AutosarDataType, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == ApplicationDataType:
-            raise NotImplementedError("ApplicationDataType is an abstract class.")
+        if type(self) is ApplicationDataType:
+            raise TypeError("ApplicationDataType is an abstract class.")
 
         super().__init__(parent, short_name)
 
@@ -40,8 +41,8 @@ class ApplicationPrimitiveDataType(ApplicationDataType):
 
 class ApplicationCompositeDataType(ApplicationDataType, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == ApplicationCompositeDataType:
-            raise NotImplementedError("ApplicationCompositeDataType is an abstract class.")
+        if type(self) is ApplicationCompositeDataType:
+            raise TypeError("ApplicationCompositeDataType is an abstract class.")
 
         super().__init__(parent, short_name)
 
@@ -62,24 +63,25 @@ class ApplicationArrayDataType(ApplicationCompositeDataType):
         return self
 
     def createApplicationArrayElement(self, short_name: str) -> ApplicationArrayElement:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             array_element = ApplicationArrayElement(self, short_name)
-            self.elements[short_name] = array_element
-            self.element = self.elements[short_name]
-        return self.elements[short_name]
+            self.addElement(array_element)
+            self.element = array_element
+        return self.getElement(short_name, ApplicationArrayElement)
+
 
 class ApplicationRecordDataType(ApplicationCompositeDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.record_elements = []
+        self.record_elements: List[ApplicationRecordElement] = []
 
     def createApplicationRecordElement(self, short_name: str) -> ApplicationRecordElement:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             record_element = ApplicationRecordElement(self, short_name)
-            self.elements[short_name] = record_element
-            self.record_elements.append(self.elements[short_name])
-        return self.elements[short_name]
+            self.addElement(record_element)
+            self.record_elements.append(record_element)
+        return self.getElement(short_name, ApplicationRecordElement)
 
     def getApplicationRecordElements(self) -> List[ApplicationRecordElement]:
         return self.record_elements
@@ -105,12 +107,14 @@ class DataTypeMap(ARObject):
         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]
+        # type: List[ModeRequestTypeMap]
+        self.modeRequestTypeMaps = []
 
     def addDataTypeMap(self, type_map: DataTypeMap):
         self.dataTypeMaps.append(type_map)
@@ -124,4 +128,4 @@ class DataTypeMappingSet(ARElement):
         return self
 
     def getModeRequestTypeMaps(self) -> List[ModeRequestTypeMap]:
-        return self.modeRequestTypeMaps
+        return self.modeRequestTypeMaps

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

@@ -175,10 +175,10 @@ class EndToEndProtectionSet(Identifiable):
         super().__init__(parent, short_name)
 
     def createEndToEndProtection(self, short_name: str) -> EndToEndProtection:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             protection = EndToEndProtection(self, short_name)
-            self.elements[short_name] = protection
-        return self.elements[short_name]
+            self.addElement(protection)
+        return self.getElement(short_name, EndToEndProtection)
 
     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), key=lambda e: e.short_name)

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

@@ -2,7 +2,7 @@ from abc import ABCMeta
 from typing import List
 
 from .....M2.AUTOSARTemplates.CommonStructure import TextValueSpecification
-from .....M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger
+from .....M2.AUTOSARTemplates.CommonStructure.TriggerDeclaration import Trigger, TriggerMapping
 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, Boolean
@@ -164,21 +164,16 @@ class SenderReceiverInterface(DataInterface):
         return self
 
     def createDataElement(self, short_name) -> VariableDataPrototype:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             data_element = VariableDataPrototype(self, short_name)
-            self.elements[short_name] = data_element
-        return self.elements[short_name]
+            self.addElement(data_element)
+        return self.getElement(short_name, VariableDataPrototype)
 
     def getDataElements(self) -> List[VariableDataPrototype]:
-        return list(filter(lambda c: isinstance(c, VariableDataPrototype), self.elements.values()))
+        return list(filter(lambda c: isinstance(c, VariableDataPrototype), self.elements))
 
     def getDataElement(self, short_name) -> VariableDataPrototype:
-        if (short_name in self.elements):
-            data_element = self.elements[short_name]
-            # 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)
+        return self.getElement(short_name, VariableDataPrototype)
     
     def createInvalidationPolicy(self) -> InvalidationPolicy:
         policy = InvalidationPolicy(self)
@@ -193,7 +188,7 @@ class ArgumentDataPrototype(AutosarDataPrototype):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.direction = None                               # type: ArgumentDirectionEnum
+        self.direction: ArgumentDirectionEnum = None
         self.serverArgumentImplPolicy = None                # type: ServerArgumentImplPolicyEnum
 
     def getDirection(self):
@@ -286,22 +281,22 @@ class ClientServerInterface(PortInterface):
         super().__init__(parent, short_name)
 
     def createOperation(self, short_name: str) -> ClientServerOperation:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             operation = ClientServerOperation(self, short_name)
-            self.elements[short_name] = operation
-        return self.elements[short_name]
+            self.addElement(operation)
+        return self.getElement(short_name, ClientServerOperation)
 
     def createApplicationError(self, short_name: str) -> ApplicationError:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             error = ApplicationError(self, short_name)
-            self.elements[short_name] = error
-        return self.elements[short_name]
+            self.addElement(error)
+        return self.getElement(short_name, ApplicationError)
 
     def getOperations(self) -> List[ClientServerOperation]:
-        return list(filter(lambda c: isinstance(c, ClientServerOperation), self.elements.values()))
+        return list(filter(lambda c: isinstance(c, ClientServerOperation), self.elements))
 
     def getPossibleErrors(self) -> List[ApplicationError]:
-        return list(filter(lambda c: isinstance(c, ApplicationError), self.elements.values()))
+        return list(filter(lambda c: isinstance(c, ApplicationError), self.elements))
 
 
 class TriggerInterface(PortInterface):
@@ -318,13 +313,13 @@ class ModeSwitchInterface(PortInterface):
         self._modeGroup = []            # type: List[ModeDeclarationGroupPrototype]
 
     def createModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
-        prototype = ModeDeclarationGroupPrototype(self, short_name)
-        if (short_name not in self.elements):
-            self.elements[short_name] = prototype
-        return self.elements[short_name]
+        if not self.IsElementExists(short_name):
+            prototype = ModeDeclarationGroupPrototype(self, short_name)
+            self.addElement(prototype)
+        return self.getElement(short_name, ModeDeclarationGroupPrototype)
     
     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), key=lambda o: o.short_name))
 
 
 class PortInterfaceMapping(Identifiable, metaclass=ABCMeta):
@@ -505,9 +500,58 @@ class TriggerInterfaceMapping(PortInterfaceMapping):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.triggerMapping = []                            # type: List[TriggerMapping]
+        self.triggerMapping: List[TriggerMapping] = []
+
+    def getTriggerMapping(self) -> List[TriggerMapping]:
+        return self.triggerMapping
+
+    def setTriggerMapping(self, value: List[TriggerMapping]):
+        if value is not None:
+            self.triggerMapping = value
+        return self
+
+
+class ModeDeclarationMapping(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.firstModeRefs: List[RefType] = []
+        self.secondModeRef: RefType = []
+
+    def getFirstModeRefs(self) -> List[RefType]:
+        return self.firstModeRefs
+
+    def addFirstModeRef(self, value: List[RefType]):
+        if value is not None:
+            self.firstModeRefs.append(value)
+        return self
+
+    def getSecondModeRef(self) -> RefType:
+        return self.secondModeRef
+
+    def setSecondModeRef(self, value: RefType):
+        if value is not None:
+            self.secondModeRef = value
+        return self
+
+
+class ModeDeclarationMappingSet(ARElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.modeDeclarationMappings: List[ModeDeclarationMapping] = []
+
+    def getModeDeclarationMappings(self) -> List[ModeDeclarationMapping]:
+        return self.modeDeclarationMappings
+
+    def createModeDeclarationMapping(self, short_name: str) -> ModeDeclarationMapping:
+        if (not self.IsElementExists(short_name)):
+            mapping = ModeDeclarationMapping(self, short_name)
+            self.addElement(mapping)
+            self.modeDeclarationMappings.append(mapping)
+        return self.getElement(short_name)
+
 
- 
 class PortInterfaceMappingSet(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)

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

@@ -110,28 +110,28 @@ class SwcServiceDependency(ServiceDependency):
         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)
+        return sorted(filter(lambda c: isinstance(c, NvBlockNeeds), self.elements), 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)
+        return sorted(filter(lambda c: isinstance(c, DiagnosticCommunicationManagerNeeds), self.elements), 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)
+        return sorted(filter(lambda c: isinstance(c, DiagnosticRoutineNeeds), self.elements), 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)
+        return sorted(filter(lambda c: isinstance(c, DiagnosticEventNeeds), self.elements), 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)
+        return sorted(filter(lambda c: isinstance(c, CryptoServiceNeeds), self.elements), 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)
+        return sorted(filter(lambda c: isinstance(c, EcuStateMgrUserNeeds), self.elements), 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)
+        return sorted(filter(lambda c: isinstance(c, DtcStatusChangeNotificationNeeds), self.elements), key=lambda e: e.short_name)
     
     def getDltUserNeeds(self) -> List[DltUserNeeds]:
-        return sorted(filter(lambda c: isinstance(c, DltUserNeeds), self.elements.values()), key=lambda e: e.short_name)
+        return sorted(filter(lambda c: isinstance(c, DltUserNeeds), self.elements), 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)
+        return sorted(filter(lambda c: isinstance(c, ServiceNeeds), self.elements), key=lambda e: e.short_name)