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

armodel/cli/arxml_format_cli.py

@@ -69,6 +69,7 @@ def main():
     ap = argparse.ArgumentParser()
     ap.description = "arxml-format ver: %s" % version
     ap.add_argument("-v", "--verbose", required=False, help="Print debug information", action="store_true")
+    ap.add_argument("--log", required=False, help="Log all information to file")
     ap.add_argument("-w", "--warning", required=False, help="Skip the error and report it as warning message", action="store_true")
     ap.add_argument("--remove-admin-data", required=False, help="Remove all the AdminData", action="store_true")
     ap.add_argument("INPUT", help="The path of AUTOSAR ARXML file")

armodel/models/M2/AUTOSARTemplates/AutosarTopLevelStructure.py

@@ -1,19 +1,24 @@
 from typing import Dict, List
 
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 
+from ...utils.uuid_mgr import UUIDMgr
 from ...M2.MSR.AsamHdo.SpecialData import Sdg
 from ...M2.MSR.AsamHdo import AdminData
 from ...M2.MSR.AsamHdo.BaseTypes import SwBaseType
 from ...M2.MSR.Documentation.TextModel.BlockElements import DocumentationBlock
+
 from ...M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
 from ...M2.AUTOSARTemplates.CommonStructure.Implementation import Implementation
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import CollectableElement, Referrable
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage
 from ...M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationDataType, DataTypeMap
-from ...M2.AUTOSARTemplates.SWComponentTemplate.Components import CompositionSwComponentType
+from ...M2.AUTOSARTemplates.SWComponentTemplate.Components import AtomicSwComponentType, CompositionSwComponentType, PortPrototype
+from ...M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import VariableDataPrototype
 from ...M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
 from ...M2.AUTOSARTemplates.SystemTemplate import RootSwCompositionPrototype, System
+from ...M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import SystemSignal, SystemSignalGroup
 
 
 class FileInfoComment(ARObject):
@@ -93,7 +98,7 @@ class AbstractAUTOSAR(CollectableElement):
         self._behavior_impl_maps = {}                       # type: Dict[str, str]
         self._impl_behavior_maps = {}                       # type: Dict[str, str]
 
-        self.uuid_objects = {}                              # type: Dict[str, ARObject]
+        self.uuid_mgr = UUIDMgr()
 
         self.systems = {}                                   # type: Dict[str, System]
         self.compositionSwComponentTypes = {}               # type: Dict[str, CompositionSwComponentType]
@@ -120,7 +125,14 @@ class AbstractAUTOSAR(CollectableElement):
             self.arPackages[short_name] = ar_package
         return self.arPackages[short_name]
 
-    def find(self, referred_name: str) -> Referrable:
+    def find(self, referred) -> Referrable:
+        if isinstance(referred, RefType):
+            referred_name = referred.getValue()
+            referred_type = referred.getDest()
+        else:
+            referred_name = referred
+            referred_type = None
+
         short_name_list = referred_name.split("/")
         element = AUTOSAR.getInstance()
         for short_name in short_name_list:
@@ -129,17 +141,46 @@ class AbstractAUTOSAR(CollectableElement):
             element = element.getElement(short_name)
             if (element is None):
                 return element
-            #    raise ValueError("The %s of reference <%s> does not exist." % (short_name, referred_name))
+        
+        # validate the dest
+        if referred_type is not None and referred_type != "":
+            base_type = self.getDestType(element)
+            if base_type != referred_type:
+                raise ValueError("The type does not matched of <%s> (Dest: %s, Actual: %s)" % (referred_name, referred_type, base_type))
+        
         return element
     
+    def getDestType(self, type) -> str:
+        if isinstance(type, ImplementationDataType):
+            return "IMPLEMENTATION-DATA-TYPE"
+        return ""
+    
+    def findAtomicSwComponentType(self, referred) -> AtomicSwComponentType:
+        return self.find(referred)
+    
+    def findSystemSignal(self, referred) -> SystemSignal:
+        return self.find(referred)
+    
+    def findSystemSignalGroup(self, referred) -> SystemSignalGroup:
+        return self.find(referred)
+    
+    def findPort(self, referred: str) -> PortPrototype:
+        return self.find(referred)
+    
+    def findVariableDataPrototype(self, referred) -> VariableDataPrototype:
+        return self.find(referred)
+    
+    def findImplementationDataType(self, referred) -> ImplementationDataType:
+        return self.find(referred)
+    
     def getDataType(self, data_type: ImplementationDataType) -> ImplementationDataType:
         if (isinstance(data_type, ImplementationDataType) or isinstance(data_type, SwBaseType)):
             if (data_type.category == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
                 referred_type = self.find(data_type.swDataDefProps.implementationDataTypeRef.value)
                 return self.getDataType(referred_type)
             if (data_type.category == ImplementationDataType.CATEGORY_DATA_REFERENCE):
-                if (data_type.swDataDefProps.swPointerTargetProps.target_category == "VALUE"):
-                    referred_type = self.find(data_type.swDataDefProps.swPointerTargetProps.sw_data_def_props.baseTypeRef.value)
+                if (data_type.swDataDefProps.swPointerTargetProps.getTargetCategory() == "VALUE"):
+                    referred_type = self.find(data_type.swDataDefProps.swPointerTargetProps.getSwDataDefProps().getBaseTypeRef())
                     return self.getDataType(referred_type)
             return data_type
         else:
@@ -206,14 +247,12 @@ class AbstractAUTOSAR(CollectableElement):
                 self.compositionSwComponentTypes[short_name] = sw_component_type
         return self
     
-    def getARObjectByUUID(self, uuid: str):
-        if uuid in self.uuid_objects:
-            return self.uuid_objects[uuid]
-        return None
+    def getARObjectByUUID(self, uuid: str) -> List[ARObject]:
+        return self.uuid_mgr.getObjects()
 
     def addARObject(self, value: ARObject):
         if value is not None:
-            self.uuid_objects[value.uuid] = value
+            self.uuid_mgr.addObject(value)
         return self
     
     def setARRelease(self, release: str):

armodel/models/M2/AUTOSARTemplates/CommonStructure/ImplementationDataTypes.py

@@ -8,10 +8,12 @@ from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTy
 from ....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import AutosarDataType
 from ....M2.AUTOSARTemplates.SWComponentTemplate.Components import SymbolProps
 
+
 class AbstractImplementationDataTypeElement(Identifiable):
     def __init__(self, parent, short_name: str):
         super().__init__(parent, short_name)
 
+
 class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
     ARRAY_SIZE_SEMANTICS_FIXED_SIZE = "FIXED-SIZE"
     ARRAY_SIZE_SEMANTICS_VARIABLE_SIZE = "VARIABLE_SIZE"
@@ -30,45 +32,51 @@ class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
         return self.arrayImplPolicy
 
     def setArrayImplPolicy(self, value):
-        self.arrayImplPolicy = value
+        if value is not None:
+            self.arrayImplPolicy = value
         return self
 
     def getArraySize(self):
         return self.arraySize
 
     def setArraySize(self, value):
-        self.arraySize = value
+        if value is not None:
+            self.arraySize = value
         return self
 
     def getArraySizeHandling(self):
         return self.arraySizeHandling
 
     def setArraySizeHandling(self, value):
-        self.arraySizeHandling = value
+        if value is not None:
+            self.arraySizeHandling = value
         return self
 
     def getArraySizeSemantics(self):
         return self.arraySizeSemantics
 
     def setArraySizeSemantics(self, value):
-        self.arraySizeSemantics = value
+        if value is not None:
+            self.arraySizeSemantics = value
         return self
 
     def getIsOptional(self):
         return self.isOptional
 
     def setIsOptional(self, value):
-        self.isOptional = value
+        if value is not None:
+            self.isOptional = value
         return self
 
     def getSwDataDefProps(self):
         return self.swDataDefProps
 
     def setSwDataDefProps(self, value):
-        self.swDataDefProps = value
+        if value is not None:
+            self.swDataDefProps = value
         return self
-    
-    def createImplementationDataTypeElement(self, short_name: str): # type: (...) -> ImplementationDataTypeElement
+
+    def createImplementationDataTypeElement(self, short_name: str):  # type: (...) -> ImplementationDataTypeElement
         if (short_name not in self.elements):
             event = ImplementationDataTypeElement(self, short_name)
             self.elements[short_name] = event
@@ -78,13 +86,14 @@ class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
         return list(filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements.values()))
 
 
-class AbstractImplementationDataType(AutosarDataType, metaclass = ABCMeta):
+class AbstractImplementationDataType(AutosarDataType, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == AbstractImplementationDataType:
+        if type(self) is AbstractImplementationDataType:
             raise NotImplementedError("AbstractImplementationDataType is an abstract class.")
 
         super().__init__(parent, short_name)
 
+
 class ImplementationDataType(AbstractImplementationDataType):
 
     CATEGORY_TYPE_REFERENCE = "TYPE_REFERENCE"
@@ -99,12 +108,9 @@ class ImplementationDataType(AbstractImplementationDataType):
         self.dynamicArraySizeProfile = None             # type: String
         self.isStructWithOptionalElement = None         # type: Boolean
         
-        self.subElements = []                           # type: List[str]
+        self.subElements = []                           # type: List[ImplementationDataTypeElement]
         self.symbolProps = None                         # type: SymbolProps
-        self.typeEmitter = None                       # type: ARLiteral
-
-        #self._array_type = None         # ImplementationDataType
-        #self._struct_type = None        # ImplementationDataType
+        self.typeEmitter = None                         # type: ARLiteral
 
     def getDynamicArraySizeProfile(self):
         return self.dynamicArraySizeProfile
@@ -120,19 +126,15 @@ class ImplementationDataType(AbstractImplementationDataType):
         self.isStructWithOptionalElement = value
         return self
 
-    def createImplementationDataTypeElement(self, short_name: str) -> ImplementationDataTypeElement:     
-        self.subElements.append(short_name)
-        if (short_name not in self.elements):
-            event = ImplementationDataTypeElement(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+    def createImplementationDataTypeElement(self, short_name: str) -> ImplementationDataTypeElement:
+        if not self.IsElementExists(short_name):
+            type_element = ImplementationDataTypeElement(self, short_name)
+            self.addElement(type_element)
+            self.subElements.append(type_element)
+        return self.getElement(short_name)
 
-    def getImplementationDataTypeElements(self) -> List[ImplementationDataTypeElement]:
-        elements = []
-        for sub_element in self.subElements:
-            elements.append(self.elements[sub_element])
-        return elements
-        # return filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements.values())
+    def getSubElements(self) -> List[ImplementationDataTypeElement]:
+        return self.subElements
 
     def getArrayElementType(self) -> str:
         return self._array_type
@@ -163,4 +165,4 @@ class ImplementationDataType(AbstractImplementationDataType):
         return self.symbolProps
     
     def getSymbolProps(self) -> SymbolProps:
-        return self.symbolProps
+        return self.symbolProps

armodel/models/M2/AUTOSARTemplates/CommonStructure/ServiceNeeds.py

@@ -832,3 +832,8 @@ class CryptoServiceNeeds(ServiceNeeds):
 class EcuStateMgrUserNeeds(ServiceNeeds):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
+
+
+class DltUserNeeds(ServiceNeeds):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)

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

@@ -545,3 +545,8 @@ class CategoryString(ARLiteral):
         '''
     def __init__(self):
         super().__init__()
+
+
+class ByteOrderEnum(AREnum):
+    def __init__(self):
+        super().__init__([])

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

@@ -1,5 +1,6 @@
 from typing import List
 from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds
+from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DltUserNeeds
 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
@@ -49,59 +50,65 @@ class SwcServiceDependency(ServiceDependency):
         return self._assigned_ports
 
     def createNvBlockNeeds(self, short_name: str) -> NvBlockNeeds:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(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):
+        if (not self.IsElementExists(short_name)):
             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):
+        if (not self.IsElementExists(short_name)):
             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):
+        if (not self.IsElementExists(short_name)):
             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):
+        if (not self.IsElementExists(short_name)):
             needs = DiagnosticEventNeeds(self, short_name)
             self.addElement(needs)
         return self.getElement(short_name)
     
     def createDiagnosticEventInfoNeeds(self, short_name: str) -> DiagnosticEventInfoNeeds:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             needs = DiagnosticEventInfoNeeds(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):
+        if (not self.IsElementExists(short_name)):
             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):
+        if (not self.IsElementExists(short_name)):
             needs = EcuStateMgrUserNeeds(self, short_name)
             self.addElement(needs)
         return self.getElement(short_name)
     
     def createDtcStatusChangeNotificationNeeds(self, short_name: str) -> DtcStatusChangeNotificationNeeds:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             needs = DtcStatusChangeNotificationNeeds(self, short_name)
             self.addElement(needs)
         return self.getElement(short_name)
     
+    def createDltUserNeeds(self, short_name: str) -> DltUserNeeds:
+        if (not self.IsElementExists(short_name)):
+            needs = DltUserNeeds(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)
     
@@ -122,6 +129,9 @@ class SwcServiceDependency(ServiceDependency):
     
     def getDtcStatusChangeNotificationNeeds(self) -> List[DtcStatusChangeNotificationNeeds]:
         return sorted(filter(lambda c: isinstance(c, DtcStatusChangeNotificationNeeds), self.elements.values()), 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)
 
     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/SystemTemplate/DataMapping.py

@@ -1,6 +1,7 @@
 from abc import ABCMeta
 from typing import List
 
+from ....M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import VariableDataPrototypeInSystemInstanceRef
 from ....M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import TextTableMapping
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Integer, RefType
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
@@ -29,43 +30,43 @@ class SenderReceiverToSignalMapping(DataMapping):
         super().__init__()
 
         self.communicationDirection = None                          # type: CommunicationDirectionType
-        self.dataElementIRef = None
-        self.senderToSignalTextTableMapping = None
-        self.signalToReceiverTextTableMapping = None
-        self.systemSignalRef = None
+        self.dataElementIRef = None                                 # type: VariableDataPrototypeInSystemInstanceRef
+        self.senderToSignalTextTableMapping = None                  # type: TextTableMapping
+        self.signalToReceiverTextTableMapping = None                # type: TextTableMapping
+        self.systemSignalRef = None                                 # type: RefType
 
     def getCommunicationDirection(self):
         return self.communicationDirection
 
-    def setCommunicationDirection(self, value):
+    def setCommunicationDirection(self, value: CommunicationDirectionType):
         self.communicationDirection = value
         return self
 
     def getDataElementIRef(self):
         return self.dataElementIRef
 
-    def setDataElementIRef(self, value):
+    def setDataElementIRef(self, value: VariableDataPrototypeInSystemInstanceRef):
         self.dataElementIRef = value
         return self
 
     def getSenderToSignalTextTableMapping(self):
         return self.senderToSignalTextTableMapping
 
-    def setSenderToSignalTextTableMapping(self, value):
+    def setSenderToSignalTextTableMapping(self, value: TextTableMapping):
         self.senderToSignalTextTableMapping = value
         return self
 
     def getSignalToReceiverTextTableMapping(self):
         return self.signalToReceiverTextTableMapping
 
-    def setSignalToReceiverTextTableMapping(self, value):
+    def setSignalToReceiverTextTableMapping(self, value: TextTableMapping):
         self.signalToReceiverTextTableMapping = value
         return self
 
     def getSystemSignalRef(self):
         return self.systemSignalRef
 
-    def setSystemSignalRef(self, value):
+    def setSystemSignalRef(self, value: RefType):
         self.systemSignalRef = value
         return self
 
@@ -232,7 +233,7 @@ class SenderReceiverToSignalGroupMapping(DataMapping):
     def __init__(self):
         super().__init__()
 
-        self.dataElementIRef = None                         # type: RefType
+        self.dataElementIRef = None                         # type: VariableDataPrototypeInSystemInstanceRef
         self.signalGroupRef = None                          # type: RefType
         self.typeMapping = None                             # type: SenderRecCompositeTypeMapping
 

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/FibexCore/CoreTopology.py

@@ -441,16 +441,22 @@ class CommunicationController(Identifiable, metaclass=ABCMeta):
         return self
 
 
-class PncGatewayTypeEnum(Enum):
+class PncGatewayTypeEnum(AREnum):
     ENUM_ACTIVE = "active"
     ENUM_NONE = "none"
     ENUM_PASSIVE = "passive"
 
+    def __init__(self):
+        super().__init__([])
+
 
-class CommunicationDirectionType(Enum):
+class CommunicationDirectionType(AREnum):
     ENUM_IN = "in"
     ENUM_OUT = "out"
 
+    def __init__(self):
+        super().__init__([])
+
 
 class CommConnectorPort(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):

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

@@ -0,0 +1,35 @@
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+
+
+class AppOsTaskProxyToEcuTaskProxyMapping(Identifiable):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.appTaskProxyRef = None                         # type: RefType
+        self.ecuTaskProxyRef = None                         # type: RefType
+        self.offset = None                                  # type: RefType
+
+    def getAppTaskProxyRef(self):
+        return self.appTaskProxyRef
+
+    def setAppTaskProxyRef(self, value):
+        if value is not None:
+            self.appTaskProxyRef = value
+        return self
+
+    def getEcuTaskProxyRef(self):
+        return self.ecuTaskProxyRef
+
+    def setEcuTaskProxyRef(self, value):
+        if value is not None:
+            self.ecuTaskProxyRef = value
+        return self
+
+    def getOffset(self):
+        return self.offset
+
+    def setOffset(self, value):
+        if value is not None:
+            self.offset = value
+        return self

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

@@ -3,6 +3,7 @@ from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiabl
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 from ....M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import ComponentInSystemInstanceRef
 
+
 class SwcToImplMapping(Identifiable):
     def __init__(self, parent, short_name):
         super().__init__(parent, short_name)
@@ -25,3 +26,27 @@ class SwcToImplMapping(Identifiable):
         if value is not None:
             self.componentImplementationRef = value
         return self
+
+
+class ApplicationPartitionToEcuPartitionMapping(Identifiable):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.applicationPartitionRefs = []                      # type: List[RefType]
+        self.ecuPartitionRef = None                             # type: RefType
+
+    def getApplicationPartitionRefs(self):
+        return self.applicationPartitionRefs
+
+    def addApplicationPartitionRef(self, value):
+        if value is not None:
+            self.applicationPartitionRefs.append(value)
+        return self
+
+    def getEcuPartitionRef(self):
+        return self.ecuPartitionRef
+
+    def setEcuPartitionRef(self, value):
+        if value is not None:
+            self.ecuPartitionRef = value
+        return self

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

@@ -0,0 +1,83 @@
+from typing import List
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Boolean, RefType
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+
+
+class CryptoServiceMapping(Identifiable):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+
+class SecOcCryptoServiceMapping(CryptoServiceMapping):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.authenticationRef = None                           # type: RefType
+        self.cryptoServiceKeyRef = None                         # type: RefType
+        self.cryptoServiceQueueRef = None                       # type: RefType
+
+    def getAuthenticationRef(self):
+        return self.authenticationRef
+
+    def setAuthenticationRef(self, value):
+        if value is not None:
+            self.authenticationRef = value
+        return self
+
+    def getCryptoServiceKeyRef(self):
+        return self.cryptoServiceKeyRef
+
+    def setCryptoServiceKeyRef(self, value):
+        if value is not None:
+            self.cryptoServiceKeyRef = value
+        return self
+
+    def getCryptoServiceQueueRef(self):
+        return self.cryptoServiceQueueRef
+
+    def setCryptoServiceQueueRef(self, value):
+        if value is not None:
+            self.cryptoServiceQueueRef = value
+        return self
+
+
+class TlsCryptoServiceMapping(CryptoServiceMapping):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.keyExchangeRef = None                                  # type: RefType
+        self.tlsCipherSuites = []                                   # type: List[TlsCryptoCipherSuite]
+        self.useClientAuthenticationRequest = None                  # type: Boolean
+        self.useSecurityExtensionRecordSizeLimit = None             # type: Boolean
+
+    def getKeyExchangeRef(self):
+        return self.keyExchangeRef
+
+    def setKeyExchangeRef(self, value):
+        if value is not None:
+            self.keyExchangeRef = value
+        return self
+
+    def getTlsCipherSuites(self):
+        return self.tlsCipherSuites
+
+    def addTlsCipherSuite(self, value):
+        if value is not None:
+            self.tlsCipherSuites.append(value)
+        return self
+
+    def getUseClientAuthenticationRequest(self):
+        return self.useClientAuthenticationRequest
+
+    def setUseClientAuthenticationRequest(self, value):
+        if value is not None:
+            self.useClientAuthenticationRequest = value
+        return self
+
+    def getUseSecurityExtensionRecordSizeLimit(self):
+        return self.useSecurityExtensionRecordSizeLimit
+
+    def setUseSecurityExtensionRecordSizeLimit(self, value):
+        if value is not None:
+            self.useSecurityExtensionRecordSizeLimit = value
+        return self