armodel 1.7.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

armodel/cli/arxml_dump_cli.py

@@ -52,8 +52,8 @@ def show_type(indent: int, data_type: ImplementationDataType):
 def show_data_type_mapping(indent: int, mapping_set: DataTypeMappingSet):
     print("%s- Data Mapping Set <%s>:" % (" " * indent, mapping_set.short_name))
     for mapping in mapping_set.getDataTypeMaps():
-        print("%s- appl: %s" % (" " * (indent + 2), mapping.application_data_type_ref.value))
-        print("%s- impl: %s" % (" " * (indent + 4), mapping.implementation_data_type_ref.value))
+        print("%s- appl: %s" % (" " * (indent + 2), mapping.applicationDataTypeRef.value))
+        print("%s- impl: %s" % (" " * (indent + 4), mapping.implementationDataTypeRef.value))
 
 def show_behavior(indent:int, behavior: SwcInternalBehavior):
     print("%s-Behavior: %s" % (" " * indent, behavior.short_name))

armodel/models/M2/AUTOSARTemplates/AutosarTopLevelStructure.py

@@ -1,10 +1,28 @@
 from typing import Dict, List
+
+from ...M2.MSR.AsamHdo.SpecialData import Sdg
+from ...M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ...M2.MSR.AsamHdo import AdminData
 from ...M2.MSR.AsamHdo.BaseTypes import SwBaseType
+from ..MSR.Documentation.TextModel.BlockElements import DocumentationBlock
 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.CommonStructure.ImplementationDataTypes import ImplementationDataType
 
+class FileInfoComment(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.sdgs = []                                      # type: List[Sdg]
+
+    def getSdgs(self):
+        return self.sdgs
+
+    def setSdgs(self, value):
+        self.sdgs = value
+        return self
+
 class AbstractAUTOSAR(CollectableElement):
     def __init__(self):
         super().__init__()
@@ -14,10 +32,32 @@ class AbstractAUTOSAR(CollectableElement):
         self.schema_location = ""
         self._appl_impl_type_maps = {}
         self._impl_appl_type_maps = {}
-        
 
-        self._ar_packages = {}                  # type: Dict[str, ARPackage]
-        self.short_name_mappings = {}           # type: Dict[str, str]
+        self.adminData = None                               # type: AdminData
+        self.arPackages = {}                                # type: Dict[str, ARPackage]
+        self.fileInfoComment = None                         # type: FileInfoComment
+        self.introduction = None                            # type: DocumentationBlock
+
+    def getAdminData(self):
+        return self.adminData
+
+    def setAdminData(self, value):
+        self.adminData = value
+        return self
+
+    def getFileInfoComment(self):
+        return self.fileInfoComment
+
+    def setFileInfoComment(self, value):
+        self.fileInfoComment = value
+        return self
+
+    def getIntroduction(self):
+        return self.introduction
+
+    def setIntroduction(self, value):
+        self.introduction = value
+        return self
 
     def reload(self):
         pass
@@ -27,23 +67,23 @@ class AbstractAUTOSAR(CollectableElement):
         return ""
 
     def clear(self):
-        self._ar_packages = {}
+        self.arPackages = {}
         self.elements = {}
 
     def getElement(self, short_name: str) -> Referrable:
-        if (short_name in self._ar_packages):
-            return self._ar_packages[short_name]
+        if (short_name in self.arPackages):
+            return self.arPackages[short_name]
         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._ar_packages.values(), key= lambda a: a.short_name))
+        return list(sorted(self.arPackages.values(), key= lambda a: a.short_name))
 
     def createARPackage(self, short_name: str) -> ARPackage:
-        if (short_name not in self._ar_packages):
+        if (short_name not in self.arPackages):
             ar_package = ARPackage(self, short_name)
-            self._ar_packages[short_name] = ar_package
-        return self._ar_packages[short_name]
+            self.arPackages[short_name] = ar_package
+        return self.arPackages[short_name]
 
     def find(self, referred_name: str) -> Referrable:
         short_name_list = referred_name.split("/")
@@ -57,9 +97,6 @@ class AbstractAUTOSAR(CollectableElement):
             #    raise ValueError("The %s of reference <%s> does not exist." % (short_name, referred_name))
         return element
     
-    def findByShortName(self, short_name: str) -> Referrable:
-        pass
-
     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):
@@ -74,10 +111,10 @@ class AbstractAUTOSAR(CollectableElement):
             raise ValueError("%s is not ImplementationDataType." % data_type)
             
     def addDataTypeMap(self, data_type_map: DataTypeMap):
-        if (data_type_map.application_data_type_ref is None) or (data_type_map.implementation_data_type_ref is None):
+        if (data_type_map.applicationDataTypeRef is None) or (data_type_map.implementationDataTypeRef is None):
             return
-        self._appl_impl_type_maps[data_type_map.application_data_type_ref.value] = data_type_map.implementation_data_type_ref.value
-        self._impl_appl_type_maps[data_type_map.implementation_data_type_ref.value] = data_type_map.application_data_type_ref.value
+        self._appl_impl_type_maps[data_type_map.applicationDataTypeRef.value] = data_type_map.implementationDataTypeRef.value
+        self._impl_appl_type_maps[data_type_map.implementationDataTypeRef.value] = data_type_map.applicationDataTypeRef.value
 
     def convertToImplementationDataType(self, appl_data_type: str) -> ImplementationDataType:
         if (appl_data_type not in self._appl_impl_type_maps.keys()):

armodel/models/M2/AUTOSARTemplates/BswModuleTemplate/BswBehavior.py

@@ -1,7 +1,7 @@
 from ....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from ....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARFloat, ARNumerical
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARFloat, ARNumerical, TimeValue
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 from ....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
@@ -128,12 +128,10 @@ class BswCalledEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-
 class BswSchedulableEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-
 class BswInterruptEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -158,43 +156,50 @@ class BswEvent(Identifiable, metaclass=ABCMeta):
             raise NotImplementedError("BswEvent is an abstract class.")
         super().__init__(parent, short_name)
 
-        self.startsOnEventRef = None                    # type: RefType 
+        self.startsOnEventRef = None                    # type: RefType
 
+    def getStartsOnEventRef(self):
+        return self.startsOnEventRef
+
+    def setStartsOnEventRef(self, value):
+        self.startsOnEventRef = value
+        return self
 
 class BswOperationInvokedEvent(BswEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-
 class BswScheduleEvent(BswEvent, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == BswScheduleEvent:
             raise NotImplementedError("BswScheduleEvent is an abstract class.")
         super().__init__(parent, short_name)
 
-
 class BswModeSwitchEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._activation = ""
-
-    @property
-    def activation(self) -> str:
-        return self._activation
+        self.activation = None
 
-    @activation.setter
-    def activation(self, value: str):
-        if (value not in ()):
-            raise ValueError("Invalid activation <%s> of BswModeSwitchEvent <%s>" % (value, self.short_name))
-        self._activation = value
+    def getActivation(self):
+        return self.activation
 
+    def setActivation(self, value):
+        self.activation = value
+        return self
 
 class BswTimingEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.period = None          # type: ARFloat
+        self.period = None          # type: TimeValue
+
+    def getPeriod(self):
+        return self.period
+
+    def setPeriod(self, value):
+        self.period = value
+        return self
 
     @property
     def periodMs(self) -> int:
@@ -207,22 +212,39 @@ class BswDataReceivedEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.data_ref = None                # type: RefType
+        self.dataRef = None                # type: RefType
+
+    def getDataRef(self):
+        return self.dataRef
 
+    def setDataRef(self, value):
+        self.dataRef = value
+        return self
 
 class BswInternalTriggerOccurredEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.event_source_ref = None                # type: RefType
+        self.eventSourceRef = None                # type: RefType
 
+    def getEventSourceRef(self):
+        return self.eventSourceRef
 
+    def setEventSourceRef(self, value):
+        self.eventSourceRef = value
+        return self
 class BswModeSwitchAckRequest(ARObject):
     def __init__(self):
         super().__init__()
 
         self.timeout = None                         # type: ARFloat
 
+    def getTimeout(self):
+        return self.timeout
+
+    def setTimeout(self, value):
+        self.timeout = value
+        return self
 
 class BswModeSenderPolicy(ARObject):
     def __init__(self):

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

@@ -4,23 +4,23 @@ from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject im
 
 class DataFilterTypeEnum(AREnum):
 
-    maskedNewDiffersMaskedOld = "maskedNewDiffersMaskedOld"
-    maskedNewDiffersX = "maskedNewDiffersX"
-    maskedNewEqualsX = "maskedNewEqualsX"
-    never = "never"
-    newIsOutside = "newIsOutside"
-    newIsWithin = "newIsWithin"
-    oneEveryN = "oneEveryN"
+    MASKED_NEW_DIFFERS_MASKED_OLD = "maskedNewDiffersMaskedOld"
+    MASKED_NEW_DIFFERS_X = "maskedNewDiffersX"
+    MASKED_NEW_EQUALS_X = "maskedNewEqualsX"
+    NEVER = "never"
+    NEW_IS_OUTSIDE = "newIsOutside"
+    NEW_IS_WITHIN = "newIsWithin"
+    ONE_EVERY_N = "oneEveryN"
 
     def __init__(self):
         super().__init__((
-            self.maskedNewDiffersMaskedOld,
-            self.maskedNewDiffersX,
-            self.maskedNewEqualsX, 
-            self.never,
-            self.newIsOutside,
-            self.newIsWithin,
-            self.oneEveryN
+            DataFilterTypeEnum.MASKED_NEW_DIFFERS_MASKED_OLD,
+            DataFilterTypeEnum.MASKED_NEW_DIFFERS_X,
+            DataFilterTypeEnum.MASKED_NEW_EQUALS_X, 
+            DataFilterTypeEnum.NEVER,
+            DataFilterTypeEnum.NEW_IS_OUTSIDE,
+            DataFilterTypeEnum.NEW_IS_WITHIN,
+            DataFilterTypeEnum.ONE_EVERY_N
         ))
 
 

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

@@ -1,7 +1,7 @@
 from abc import ABCMeta
 from typing import List
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, Boolean, String
 from ....M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean
@@ -96,19 +96,30 @@ class ImplementationDataType(AbstractImplementationDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.arrayImplPolicy = None
-        self.arraySize = None
-        self.arraySizeHandling = None                   # type: ARLiteral
-        self.arraySizeSemantics = None                  # type: ARLiteral
+        self.dynamicArraySizeProfile = None             # type: String
+        self.isStructWithOptionalElement = None         # type: Boolean
         
         self.subElements = []                           # type: List[str]
         self.symbolProps = None                         # type: SymbolProps
-        self._type_emitter = None                       # type: ARLiteral
+        self.typeEmitter = None                       # type: ARLiteral
 
-        self._array_type = None         # ImplementationDataType
-        self._struct_type = None        # ImplementationDataType
+        #self._array_type = None         # ImplementationDataType
+        #self._struct_type = None        # ImplementationDataType
+
+    def getDynamicArraySizeProfile(self):
+        return self.dynamicArraySizeProfile
+
+    def setDynamicArraySizeProfile(self, value):
+        self.dynamicArraySizeProfile = value
+        return self
+
+    def getIsStructWithOptionalElement(self):
+        return self.isStructWithOptionalElement
+
+    def setIsStructWithOptionalElement(self, value):
+        self.isStructWithOptionalElement = value
+        return self
 
-    
     def createImplementationDataTypeElement(self, short_name: str) -> ImplementationDataTypeElement:     
         self.subElements.append(short_name)
         if (short_name not in self.elements):
@@ -131,11 +142,11 @@ class ImplementationDataType(AbstractImplementationDataType):
         return self
 
     def setTypeEmitter(self, emitter: str):
-        self._type_emitter = emitter
+        self.typeEmitter = emitter
         return self
     
     def getTypeEmitter(self) -> str:
-        return self._type_emitter
+        return self.typeEmitter
     
     def setStructElementType(self, type: str):
         self._struct_type = type

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

@@ -1,7 +1,7 @@
 from typing import List
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, RefType, TRefType
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, PositiveInteger, RefType, TRefType
 
 class ModeDeclaration(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
@@ -21,16 +21,33 @@ class ModeRequestTypeMap(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.implementation_data_type_ref = None           # type: RefType
-        self.mode_group_ref = None                        # type: RefType
+        self.implementationDataTypeRef = None               # type: RefType
+        self.modeGroupRef = None                            # type: RefType
 
+    def getImplementationDataTypeRef(self):
+        return self.implementationDataTypeRef
+
+    def setImplementationDataTypeRef(self, value):
+        self.implementationDataTypeRef = value
+        return self
+
+    def getModeGroupRef(self):
+        return self.modeGroupRef
+
+    def setModeGroupRef(self, value):
+        self.modeGroupRef = value
+        return self
 
 class ModeDeclarationGroup(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._initial_mode_ref = None                      # type: RefType
-        self._on_transition_value = None                   # type: ARNumerical
+        self.initialModeRef = None                          # type: RefType
+        self.modeDeclarations = []                          # type: ModeDeclaration
+        self.modeManagerErrorBehavior = None                # type: ModeErrorBehavior
+        self.modeTransition = None                          # type: ModeTransition
+        self.modeUserErrorBehavior = None                   # type: ModeErrorBehavior
+        self.onTransitionValue = None                       # type: PositiveInteger
 
     def createModeDeclaration(self, short_name: str) -> ModeDeclaration:
         if (short_name not in self.elements):
@@ -42,21 +59,21 @@ class ModeDeclarationGroup(Identifiable):
         return list(sorted(filter(lambda a: isinstance(a, ModeDeclaration), self.elements.values()), key= lambda o:o.short_name))
 
     def setInitialModeRef(self, ref: RefType):
-        self._initial_mode_ref = ref
+        self.initialModeRef = ref
         return self
 
     def getInitialModeRef(self) -> RefType:
-        return self._initial_mode_ref
+        return self.initialModeRef
 
     def setOnTransitionValue(self, value):
         if isinstance(value, int):
             value = ARNumerical()
             value.setValue(value)
-        self._on_transition_value = value
+        self.onTransitionValue = value
         return self
 
     def getOnTransitionValue(self) -> ARNumerical:
-        return self._on_transition_value
+        return self.onTransitionValue
 
 
 class ModeDeclarationGroupPrototype(Identifiable):

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

@@ -9,6 +9,7 @@ class MemorySection(Identifiable):
         super().__init__(parent, short_name)
 
         self._alignment = None              # type: ARLiteral
+        self.memClassSymbol = None          # type: ARLiteral
         self.size = None
         self.options = []                   # type: List[ARLiteral]
         self.swAddrMethodRef = None         # type: RefType
@@ -20,6 +21,13 @@ class MemorySection(Identifiable):
     def setAlignment(self, value):
         self.alignment = value
         return self
+    
+    def getMemClassSymbol(self):
+        return self.memClassSymbol
+
+    def setMemClassSymbol(self, value):
+        self.memClassSymbol = value
+        return self
 
     def getSize(self):
         return self.size