armodel 1.7.9__py3-none-any.whl → 1.8.1__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]
@@ -111,7 +116,6 @@ class AbstractAUTOSAR(CollectableElement):
         return CollectableElement.getElement(self, short_name)
 
     def getARPackages(self) -> List[ARPackage]:
-        # return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
         return list(sorted(self.arPackages.values(), key=lambda a: a.short_name))
 
     def createARPackage(self, short_name: str) -> ARPackage:
@@ -120,7 +124,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 +140,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 +246,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/BswModuleTemplate/BswBehavior.py

@@ -171,7 +171,7 @@ class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
             access = BswVariableAccess(self, short_name)
             self.addElement(access)
             self.dataReceivePoints.append(access)
-        return self.getElement(short_name)
+        return self.getElement(short_name, BswVariableAccess)
 
     def getDataSendPoints(self):
         return self.dataSendPoints
@@ -181,7 +181,7 @@ class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
             access = BswVariableAccess(self, short_name)
             self.addElement(access)
             self.dataSendPoints.append(access)
-        return self.getElement(short_name)
+        return self.getElement(short_name, BswVariableAccess)
 
     def getImplementedEntryRef(self):
         return self.implementedEntryRef
@@ -673,7 +673,7 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
 
     def getBswCalledEntities(self) -> List[BswCalledEntity]:
-        return list(filter(lambda a: isinstance(a, BswCalledEntity), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswCalledEntity), self.elements))
 
     def createBswSchedulableEntity(self, short_name: str) -> BswSchedulableEntity:
         if not self.IsElementExists(short_name):
@@ -683,7 +683,7 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
 
     def getBswSchedulableEntities(self) -> List[BswSchedulableEntity]:
-        return list(filter(lambda a: isinstance(a, BswSchedulableEntity), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswSchedulableEntity), self.elements))
     
     def createBswInterruptEntity(self, short_name: str) -> BswInterruptEntity:
         if not self.IsElementExists(short_name):
@@ -693,10 +693,10 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
 
     def getBswInterruptEntities(self) -> List[BswInterruptEntity]:
-        return list(filter(lambda a: isinstance(a, BswInterruptEntity), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswInterruptEntity), self.elements))
 
     def getBswModuleEntities(self) -> List[BswModuleEntity]:
-        return list(filter(lambda a: isinstance(a, BswModuleEntity), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswModuleEntity), self.elements))
 
     def createBswModeSwitchEvent(self, short_name: str) -> BswModeSwitchEvent:
         if not self.IsElementExists(short_name):
@@ -706,7 +706,7 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
 
     def getBswModeSwitchEvents(self) -> List[BswModeSwitchEvent]:
-        return list(filter(lambda a: isinstance(a, BswModeSwitchEvent), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswModeSwitchEvent), self.elements))
 
     def createBswTimingEvent(self, short_name: str) -> BswTimingEvent:
         if not self.IsElementExists(short_name):
@@ -716,7 +716,7 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
 
     def getBswTimingEvents(self) -> List[BswTimingEvent]:
-        return list(filter(lambda a: isinstance(a, BswTimingEvent), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswTimingEvent), self.elements))
 
     def createBswDataReceivedEvent(self, short_name: str) -> BswDataReceivedEvent:
         if not self.IsElementExists(short_name):
@@ -726,7 +726,7 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
 
     def getBswDataReceivedEvents(self) -> List[BswDataReceivedEvent]:
-        return list(filter(lambda a: isinstance(a, BswDataReceivedEvent), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswDataReceivedEvent), self.elements))
 
     def createBswInternalTriggerOccurredEvent(self, short_name: str) -> BswInternalTriggerOccurredEvent:
         if not self.IsElementExists(short_name):
@@ -736,7 +736,7 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
     
     def getBswInternalTriggerOccurredEvents(self) -> List[BswInternalTriggerOccurredEvent]:
-        return list(filter(lambda a: isinstance(a, BswInternalTriggerOccurredEvent), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswInternalTriggerOccurredEvent), self.elements))
     
     def createBswExternalTriggerOccurredEvent(self, short_name: str) -> BswExternalTriggerOccurredEvent:
         if not self.IsElementExists(short_name):
@@ -746,7 +746,7 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
     
     def getBswOperationInvokedEvents(self) -> List[BswOperationInvokedEvent]:
-        return list(filter(lambda a: isinstance(a, BswOperationInvokedEvent), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswOperationInvokedEvent), self.elements))
     
     def createBswOperationInvokedEvent(self, short_name: str) -> BswOperationInvokedEvent:
         if not self.IsElementExists(short_name):
@@ -756,7 +756,7 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
     
     def getBswExternalTriggerOccurredEvents(self) -> List[BswExternalTriggerOccurredEvent]:
-        return list(filter(lambda a: isinstance(a, BswExternalTriggerOccurredEvent), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswExternalTriggerOccurredEvent), self.elements))
     
     def createBswBackgroundEvent(self, short_name: str) -> BswBackgroundEvent:
         if not self.IsElementExists(short_name):
@@ -766,10 +766,10 @@ class BswInternalBehavior(InternalBehavior):
         return self.getElement(short_name)
     
     def getBswBackgroundEvents(self) -> List[BswBackgroundEvent]:
-        return list(filter(lambda a: isinstance(a, BswBackgroundEvent), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswBackgroundEvent), self.elements))
 
     def getBswEvents(self) -> List[BswEvent]:
-        return list(filter(lambda a: isinstance(a, BswEvent), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, BswEvent), self.elements))
 
     def addIncludedModeDeclarationGroupSet(self, group_set: IncludedModeDeclarationGroupSet):
         self.includedModeDeclarationGroupSets.append(group_set)

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

@@ -5,6 +5,7 @@ from ....M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstan
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable
 
+
 class FlatInstanceDescriptor(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -58,7 +59,7 @@ class FlatMap(ARElement):
         self.instances = []                                 # type: List[FlatInstanceDescriptor]
 
     def getInstances(self):
-        return list(sorted(filter(lambda a: isinstance(a, FlatInstanceDescriptor), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, FlatInstanceDescriptor), self.elements), key=lambda o: o.short_name))
 
     def createFlatInstanceDescriptor(self, short_name: str):
         if (short_name not in self.elements):
@@ -66,5 +67,3 @@ class FlatMap(ARElement):
             self.addElement(element)
             self.instances.append(element)
         return self.getElement(short_name)
-
-

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

@@ -134,7 +134,7 @@ class Implementation(PackageableElement, metaclass=ABCMeta):
         return self
 
     def getCodeDescriptors(self) -> List[Code]:
-        return list(filter(lambda a: isinstance(a, Code), self.elements.values()))
+        return list(filter(lambda a: isinstance(a, Code), self.elements))
 
     def createCodeDescriptor(self, short_name: str) -> Code:
         if (short_name not in self.elements):

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,61 +32,68 @@ 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) -> "ImplementationDataTypeElement":
+        if (not self.IsElementExists(short_name)):
+            type_element = ImplementationDataTypeElement(self, short_name)
+            self.addElement(type_element)
+        return self.getElement(short_name, 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
-        return self.elements[short_name]
-    
-    def getImplementationDataTypeElements(self):                    # type：(...) -> List[ImplementationDataTypeElement]
-        return list(filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements.values()))
+    def getImplementationDataTypeElements(self) -> List["ImplementationDataTypeElement"]:
+        return list(filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements))
 
 
-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/InternalBehavior.py

@@ -109,7 +109,7 @@ class InternalBehavior(Identifiable, metaclass=ABCMeta):
         return self.getElement(short_name)
 
     def getExclusiveAreas(self) -> List[ExclusiveArea]:
-        return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
+        return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements))
     
     def getStaticMemories(self):
         return self.staticMemories

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

@@ -85,13 +85,13 @@ class ModeDeclarationGroup(Identifiable):
         self.onTransitionValue = None                       # type: PositiveInteger
 
     def createModeDeclaration(self, short_name: str) -> ModeDeclaration:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             spec = ModeDeclaration(self, short_name)
-            self.elements[short_name] = spec
-        return self.elements[short_name]
+            self.addElement(spec)
+        return self.getElement(short_name, ModeDeclaration)
 
     def getModeDeclarations(self) -> List[ModeDeclaration]:
-        return list(sorted(filter(lambda a: isinstance(a, ModeDeclaration), self.elements.values()), key=lambda o: o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, ModeDeclaration), self.elements), key=lambda o: o.short_name))
 
     def setInitialModeRef(self, ref: RefType):
         self.initialModeRef = ref

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/__init__.py

@@ -24,10 +24,10 @@ class ResourceConsumption(Identifiable):
         return self.getElement(short_name)
 
     def getMemorySections(self) -> List[MemorySection]:
-        return list(sorted(filter(lambda a: isinstance(a, MemorySection), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, MemorySection), self.elements), key= lambda o:o.short_name))
 
     def getMemorySection(self, short_name: str) -> MemorySection:
-        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements.values()), None)
+        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements), None)
     
     def createMeasuredStackUsage(self, short_name: str) -> MeasuredStackUsage:
         if (short_name not in self.elements):
@@ -51,4 +51,4 @@ class ResourceConsumption(Identifiable):
         return self.getElement(short_name)
     
     def getStackUsages(self) -> List[StackUsage]:
-        return list(sorted(filter(lambda a: isinstance(a, StackUsage), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, StackUsage), self.elements), key= lambda o:o.short_name))

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/CommonStructure/Timing/TimingConstraint/ExecutionOrderConstraint.py

@@ -35,11 +35,11 @@ class ExecutionOrderConstraint(TimingConstraint):
         self.ordered_elements = []                      # type: List[EOCExecutableEntityRefAbstract]
 
     def createEOCExecutableEntityRef(self, short_name: str)-> EOCExecutableEntityRef:
-        if short_name not in self.elements:
+        if not self.IsElementExists(short_name):
             entity_ref = EOCExecutableEntityRef(self, short_name)
-            self.elements[short_name] = entity_ref
+            self.addElement(entity_ref)
             self.ordered_elements.append(entity_ref)
-        return self.elements[short_name]
+        return self.getElement(short_name, EOCExecutableEntityRef)
 
     def getOrderedElements(self) -> List[EOCExecutableEntityRefAbstract]:
         return self.ordered_elements

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingConstraint/TimingExtensions.py

@@ -18,11 +18,11 @@ class TimingExtension(Identifiable):
         self.timing_requirements = []           # Type: List[TimingConstraint]
 
     def createExecutionOrderConstraint(self, short_name: str)-> ExecutionOrderConstraint:
-        if short_name not in self.elements:
+        if not self.IsElementExists(short_name):
             constraint = ExecutionOrderConstraint(self, short_name)
-            self.elements[short_name] = constraint
+            self.addElement(constraint)
             self.timing_requirements.append(constraint)
-        return self.elements[short_name]
+        return self.getElement(short_name, ExecutionOrderConstraint)
 
     def getTimingRequirements(self) -> List[TimingConstraint]:
         return self.timing_requirements

armodel/models/M2/AUTOSARTemplates/ECUCDescriptionTemplate.py

@@ -1,10 +1,13 @@
 from abc import ABCMeta
 from typing import List
-from ..MSR.Documentation.TextModel.BlockElements import DocumentationBlock
+
+from ...M2.AUTOSARTemplates.ECUCParameterDefTemplate import EcucChoiceContainerDef, EcucContainerDef, EcucDefinitionElement, EcucParamConfContainerDef
+from ...M2.MSR.Documentation.TextModel.BlockElements import DocumentationBlock
 from ...M2.MSR.Documentation.Annotation import Annotation
 from ...M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, RefType, ARBoolean
+from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import AREnum, ARLiteral, ARNumerical, Boolean, CIdentifier, String
+from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, RefType
 from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
 
 
@@ -205,11 +208,11 @@ class EcucContainerValue(ARElement, EcucIndexableValue):
         return self.subContainers
 
     def createSubContainer(self, short_name):
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             container_value = EcucContainerValue(self, short_name)
-            self.elements[short_name] = container_value
+            self.addElement(container_value)
             self.subContainers.append(container_value)
-        return self.elements[short_name]
+        return self.getElement(short_name, EcucContainerValue)
 
 
 class EcucModuleConfigurationValues(ARElement):
@@ -224,14 +227,14 @@ class EcucModuleConfigurationValues(ARElement):
         self.postBuildVariantUsed = None            # type: ARBoolean
 
     def createContainer(self, short_name: str) -> EcucContainerValue:
-        if (short_name not in self.elements):
+        if not self.IsElementExists(short_name):
             container = EcucContainerValue(self, short_name)
-            self.elements[short_name] = container
+            self.addElement(container)
             self.containers.append(container)
-        return self.elements[short_name]
+        return self.getElement(short_name, EcucContainerValue)
 
     def getContainers(self) -> List[EcucContainerValue]:
-        return list(sorted(filter(lambda a: isinstance(a, EcucContainerValue), self.elements.values()), key=lambda o: o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, EcucContainerValue), self.elements), key=lambda o: o.short_name))
 
     def getDefinitionRef(self) -> RefType:
         return self.definitionRef
@@ -267,3 +270,77 @@ class EcucModuleConfigurationValues(ARElement):
     def setPostBuildVariantUsed(self, value: ARBoolean):
         self.postBuildVariantUsed = value
         return self
+
+
+class EcucConditionSpecification(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        # self.conditionFormula: EcucConditionFormula = None     # 0..1 aggr Definition of the formula used to define existence dependencies.
+        # self.ecucQueries: List[EcucQuery] = []                  # *    aggr Query to the ECU Configuration Description.
+        # self.informalFormula: MlFormula = None                 # 0..1 aggr Informal description of the condition used to to define existence dependencies. # noqa E501
+
+
+class EcucConfigurationVariantEnum(AREnum):
+    def __init__(self):
+        super().__init__([])
+
+
+class EcucModuleDef(EcucDefinitionElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.apiServicePrefix: CIdentifier = None
+        self.containers: List[EcucContainerDef] = []
+        self.postBuildVariantSupport: Boolean = None
+        self.refinedModuleDefRef: RefType = None
+        self.supportedConfigVariants: List[EcucConfigurationVariantEnum] = []
+
+    def getApiServicePrefix(self) -> CIdentifier:
+        return self.apiServicePrefix
+
+    def setApiServicePrefix(self, value: CIdentifier):
+        if value is not None:
+            self.apiServicePrefix = value
+        return self
+
+    def getContainers(self) -> List[EcucContainerDef]:
+        return self.containers
+
+    def createEcucParamConfContainerDef(self, short_name: str) -> EcucParamConfContainerDef:
+        if (not self.IsElementExists(short_name)):
+            container_def = EcucParamConfContainerDef(self, short_name)
+            self.addElement(container_def)
+            self.containers.append(container_def)
+        return self.getElement(short_name)
+    
+    def createEcucChoiceContainerDef(self, short_name: str) -> EcucChoiceContainerDef:
+        if (not self.IsElementExists(short_name)):
+            container_def = EcucChoiceContainerDef(self, short_name)
+            self.addElement(container_def)
+            self.containers.append(container_def)
+        return self.getElement(short_name)
+
+    def getPostBuildVariantSupport(self) -> Boolean:
+        return self.postBuildVariantSupport
+
+    def setPostBuildVariantSupport(self, value: Boolean):
+        if value is not None:
+            self.postBuildVariantSupport = value
+        return self
+
+    def getRefinedModuleDefRef(self) -> RefType:
+        return self.refinedModuleDefRef
+
+    def setRefinedModuleDefRef(self, value: RefType):
+        if value is not None:
+            self.refinedModuleDefRef = value
+        return self
+
+    def getSupportedConfigVariants(self) -> List[EcucConfigurationVariantEnum]:
+        return self.supportedConfigVariants
+
+    def addSupportedConfigVariant(self, value: EcucConfigurationVariantEnum):
+        if value is not None:
+            self.supportedConfigVariants.append(value)
+        return self