armodel 1.6.1__py3-none-any.whl → 1.6.3__py3-none-any.whl

armodel/models/{m2/autosar_templates/common_structure/implementation_data_types.py → M2/AUTOSARTemplates/CommonStructure/ImplementationDataTypes.py}

@@ -1,11 +1,15 @@
 from abc import ABCMeta
 from typing import List
 
-from ...msr.data_dictionary.data_def_properties import SwDataDefProps
-from ....general_structure import Identifiable
-from ....ar_object import ARBoolean, ARLiteral, ARNumerical, ARObject
-from ....datatype import AutosarDataType
-from ..sw_component_template.components import SymbolProps
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical
+
+from ...MSR.DataDictionary.DataDefProperties import SwDataDefProps
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean
+from ..SWComponentTemplate.Datatype.Datatypes import AutosarDataType
+from ..SWComponentTemplate.Components import SymbolProps
 
 class AbstractImplementationDataTypeElement(Identifiable):
     def __init__(self, parent, short_name: str):
@@ -85,6 +89,7 @@ class AbstractImplementationDataType(AutosarDataType, metaclass = ABCMeta):
         super().__init__(parent, short_name)
 
 class ImplementationDataType(AbstractImplementationDataType):
+
     CATEGORY_TYPE_REFERENCE = "TYPE_REFERENCE"
     CATEGORY_TYPE_VALUE = "VALUE"
     CATEGORY_TYPE_STRUCTURE = "STRUCTURE"
@@ -93,17 +98,22 @@ 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.sub_elements = []          # type: List[str]
-        self.symbolProps = None         # type: SymbolProps
-        self._type_emitter = None       # type: ARLiteral
+        self.subElements = []                           # type: List[str]
+        self.symbolProps = None                         # type: SymbolProps
+        self._type_emitter = None                       # type: ARLiteral
 
         self._array_type = None         # ImplementationDataType
         self._struct_type = None        # ImplementationDataType
 
     
     def createImplementationDataTypeElement(self, short_name: str) -> ImplementationDataTypeElement:     
-        self.sub_elements.append(short_name)
+        self.subElements.append(short_name)
         if (short_name not in self.elements):
             event = ImplementationDataTypeElement(self, short_name)
             self.elements[short_name] = event
@@ -111,7 +121,7 @@ class ImplementationDataType(AbstractImplementationDataType):
 
     def getImplementationDataTypeElements(self) -> List[ImplementationDataTypeElement]:
         elements = []
-        for sub_element in self.sub_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())

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

@@ -0,0 +1,108 @@
+from abc import ABCMeta
+from enum import Enum
+from typing import List
+
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, RefType
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype
+
+class ReentrancyLevelEnum(Enum):
+
+    multicoreReentrant = "multicoreReentrant"
+    nonReentrant = "nonReentrant"
+    singleCoreReentrant = "singleCoreReentrant"
+
+
+class ExclusiveArea(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+
+class ExecutableEntity(Identifiable, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == ExecutableEntity:
+            raise NotImplementedError("ExecutableEntity is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.activationReason = None                # *
+        self.minimumStartInterval = None            # type: ARFloat
+        self.reentrancyLevel = None                 # 
+        self.canEnterExclusiveAreaRefs = []         # type: List[RefType]  
+        self.swAddrMethodRef = None                 # type: RefType
+
+    def getActivationReason(self):
+        return self.activationReason
+
+    def setActivationReason(self, value):
+        self.activationReason = value
+        return self
+
+    def getMinimumStartInterval(self):
+        return self.minimumStartInterval
+
+    def setMinimumStartInterval(self, value):
+        self.minimumStartInterval = value
+        return self
+
+    def getReentrancyLevel(self):
+        return self.reentrancyLevel
+
+    def setReentrancyLevel(self, value):
+        self.reentrancyLevel = value
+        return self
+
+    def getSwAddrMethodRef(self):
+        return self.swAddrMethodRef
+
+    def setSwAddrMethodRef(self, value):
+        self.swAddrMethodRef = value
+        return self
+
+    @property
+    def minimumStartIntervalMs(self) -> int:
+        if self.minimumStartInterval is not None:
+            return int(self.minimumStartInterval.getValue() * 1000)
+        return None
+
+    def addCanEnterExclusiveAreaRef(self, ref: RefType):
+        self.canEnterExclusiveAreaRefs.append(ref)
+
+    def getCanEnterExclusiveAreaRefs(self):
+        return self.canEnterExclusiveAreaRefs
+
+
+class InternalBehavior(Identifiable, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == InternalBehavior:
+            raise NotImplementedError("InternalBehavior is an abstract class.")
+        super().__init__(parent, short_name)
+
+        self.data_type_mapping_refs = []        # type: List[RefType]                       
+        self.constant_memories = []             # type: List[ParameterDataPrototype]
+
+    def addDataTypeMappingRef(self, ref: RefType):
+        self.data_type_mapping_refs.append(ref)
+
+    def getDataTypeMappingRefs(self) -> List[RefType]:
+        return self.data_type_mapping_refs
+
+    def createExclusiveArea(self, short_name: str) -> ExclusiveArea:
+        if (short_name not in self.elements):
+            event = ExclusiveArea(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def getExclusiveAreas(self) -> List[ExclusiveArea]:
+        return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
+
+    def createConstantMemory(self, short_name: str) -> ParameterDataPrototype:
+        if (short_name not in self.elements):
+            prototype = ParameterDataPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.constant_memories.append(prototype)
+        return self.elements[short_name]
+
+    def getConstantMemorys(self) -> List[ParameterDataPrototype]:
+        return self.constant_memories

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

@@ -0,0 +1,96 @@
+from typing import List
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, RefType, TRefType
+
+class ModeDeclaration(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.value = None                           # type: ARNumerical
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
+    def getValue(self) -> ARNumerical:
+        return self.value
+
+
+class ModeRequestTypeMap(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.implementation_data_type_ref = None           # type: RefType
+        self.mode_group_ref = None                        # type: RefType
+
+
+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
+
+    def createModeDeclaration(self, short_name: str) -> ModeDeclaration:
+        if (short_name not in self.elements):
+            spec = ModeDeclaration(self, short_name)
+            self.elements[short_name] = spec
+        return self.elements[short_name]
+
+    def getModeDeclarations(self) -> List[ModeDeclaration]:
+        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
+        return self
+
+    def getInitialModeRef(self) -> RefType:
+        return self._initial_mode_ref
+
+    def setOnTransitionValue(self, value):
+        if isinstance(value, int):
+            value = ARNumerical()
+            value.setValue(value)
+        self._on_transition_value = value
+        return self
+
+    def getOnTransitionValue(self) -> ARNumerical:
+        return self._on_transition_value
+
+
+class ModeDeclarationGroupPrototype(Identifiable):
+
+    """
+    The ModeDeclarationGroupPrototype specifies a set of Modes (ModeDeclarationGroup) which is provided or required in the given context.
+    """
+
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._swCalibrationAccess = None        # type: str
+        self.typeTRef = None                    # type: TRefType
+
+    @property
+    def sw_calibration_access(self):
+        return self._swCalibrationAccess
+
+    @sw_calibration_access.setter
+    def sw_calibration_access(self, value):
+        if (value not in ("notAccessible", "readOnly", "readWrite")):
+            raise ValueError("Invalid SwCalibrationAccess <%s> of ModeDeclarationGroupPrototype <%s>" % (value, self.short_name))
+        self._swCalibrationAccess = value
+
+    def getSwCalibrationAccess(self):
+        return self.swCalibrationAccess
+
+    def setSwCalibrationAccess(self, value):
+        self.swCalibrationAccess = value
+        return self
+
+    def getTypeTRef(self):
+        return self.typeTRef
+
+    def setTypeTRef(self, value):
+        self.typeTRef = value
+        return self

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

@@ -0,0 +1,72 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
+
+
+import re
+from typing import List
+
+
+class MemorySection(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._alignment = None              # type: ARLiteral
+        self.size = None
+        self.options = []                   # type: List[ARLiteral]
+        self.swAddrMethodRef = None         # type: RefType
+        self.symbol = None                  # type: ARLiteral
+
+    def getAlignment(self):
+        return self.alignment
+
+    def setAlignment(self, value):
+        self.alignment = value
+        return self
+
+    def getSize(self):
+        return self.size
+
+    def setSize(self, value):
+        self.size = value
+        return self
+
+    def getSwAddrMethodRef(self):
+        return self.swAddrMethodRef
+
+    def setSwAddrMethodRef(self, value):
+        self.swAddrMethodRef = value
+        return self
+
+    def getSymbol(self):
+        return self.symbol
+
+    def setSymbol(self, value):
+        self.symbol = value
+        return self
+
+    @property
+    def alignment(self) -> ARLiteral:
+        return self._alignment
+
+    @alignment.setter
+    def alignment(self, value: ARLiteral):
+        if value is not None and value.getValue() != "":
+            match = False
+            if value.getValue() in ("UNKNOWN", "UNSPECIFIED", "BOOLEAN", "PTR"):
+                self._alignment = value
+                match = True
+            else:
+                m = re.match(r'^\d+', value.value)
+                if m:
+                    self._alignment = value
+                    match = True
+
+            if not match:
+                raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.getShortName()))
+
+    def addOption(self, option: ARLiteral):
+        self.options.append(option)
+
+    def getOptions(self) -> List[ARLiteral]:
+        return self.options

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

@@ -0,0 +1,22 @@
+from . import *
+
+from .MemorySectionUsage import MemorySection
+from ...GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ...GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from typing import List
+
+class ResourceConsumption(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+    def createMemorySection(self, short_name: str) -> MemorySection:
+        if (short_name not in self.elements):
+            entry = MemorySection(self, short_name)
+            self.elements[short_name] = entry
+        return self.elements[short_name]
+
+    def getMemorySections(self) -> List[MemorySection]:
+        return list(filter(lambda a : isinstance(a, MemorySection), self.elements.values()))
+
+    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)

armodel/models/{service_needs.py → M2/AUTOSARTemplates/CommonStructure/ServiceNeeds.py}

@@ -1,10 +1,8 @@
-
 from abc import ABCMeta
-
-from .m2.autosar_templates.sw_component_template.swc_internal_behavior.instance_refs_usage import AutosarParameterRef, AutosarVariableRef
-from .general_structure import Identifiable
-from .ar_ref import RefType
-from .ar_object import ARBoolean, ARLiteral, ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARLiteral, RefType
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, AutosarVariableRef
 
 
 class RoleBasedDataAssignment(ARObject):
@@ -16,13 +14,15 @@ class RoleBasedDataAssignment(ARObject):
         self.used_parameter_element = None  # type: AutosarParameterRef
         self.used_pim_ref = None            # type: RefType
 
+
 class ServiceNeeds(Identifiable, metaclass = ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == ServiceNeeds:
             raise NotImplementedError("ServiceNeeds is an abstract class.")
-        
+
         super().__init__(parent, short_name)
 
+
 class NvBlockNeeds(ServiceNeeds):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)

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

@@ -0,0 +1,36 @@
+from typing import List
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+
+
+class SwcBswRunnableMapping(ARObject):
+    def __init__(self):
+        '''
+            Maps a BswModuleEntity to a RunnableEntity if it is implemented as part of a BSW
+            module (in the case of an AUTOSAR Service, a Complex Driver or an ECU
+            Abstraction). The mapping can be used by a tool to find relevant information on the
+            behavior, e.g. whether the bswEntity shall be running in interrupt context.
+
+        '''
+        super().__init__()
+
+        self.bswEntityRef   = None        # type: RefType
+        self.swcRunnableRef = None        # type: RefType
+
+
+class SwcBswMapping(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.bswBehaviorRef = None              # type: RefType
+        self._runnableMappings = []
+        self.swcBehaviorRef = None              # type: RefType
+        self.synchronizedModeGroups = []
+        self.synchronizedTriggers = []
+
+    def addRunnableMapping(self, mapping: SwcBswRunnableMapping):
+        self._runnableMappings.append(mapping)
+
+    def getRunnableMappings(self) -> List[SwcBswRunnableMapping]:
+        return self._runnableMappings

armodel/models/M2/AUTOSARTemplates/CommonStructure/SwcInternalBehavior/ModeDeclarationGroup.py

@@ -0,0 +1,27 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
+
+
+from typing import List
+
+
+class IncludedModeDeclarationGroupSet(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.mode_declaration_group_refs = []           # type: List[RefType]
+        self.prefix = None                              # type: ARLiteral
+
+    def addModeDeclarationGroupRef(self, ref: RefType):
+        self.mode_declaration_group_refs.append(ref)
+        return self
+
+    def getModeDeclarationGroupRefs(self) -> List[RefType]:
+        return self.mode_declaration_group_refs
+
+    def setPrefix(self, prefix: str):
+        self.prefix = prefix
+        return self
+
+    def getPrefix(self) -> ARLiteral:
+        return self.prefix

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

@@ -0,0 +1 @@
+from . import *

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

@@ -0,0 +1,9 @@
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+
+class Trigger(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.swImplPolicy = None    # type: str
+        self.triggerPeriod = None   # type: float

armodel/models/{m2/autosar_templates/common_structure → M2/AUTOSARTemplates/CommonStructure}/__init__.py

@@ -1,8 +1,11 @@
 from abc import ABCMeta
 from typing import List
 
-from armodel.models.general_structure import ARElement
-from ....ar_object import ARLiteral, ARNumerical, ARObject
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral
 
 class ValueSpecification(ARObject, metaclass = ABCMeta):
     '''

armodel/models/{m2/autosar_templates/generic_structure/abstract_structure.py → M2/AUTOSARTemplates/GenericStructure/AbstractStructure.py}

@@ -2,9 +2,10 @@
 from abc import ABCMeta
 from typing import List
 
-from ....ar_ref import RefType
-from ....ar_object import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable
 
+from .GeneralTemplateClasses.PrimitiveTypes import RefType
+from .GeneralTemplateClasses.ArObject import ARObject
 
 class AtpInstanceRef(ARObject, metaclass = ABCMeta):
     def __init__(self):
@@ -67,3 +68,25 @@ class AnyInstanceRef(ARObject):
     def setTargetRef(self, value:RefType):
         self.targetRef = value
         return self
+
+
+class AtpFeature(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AtpFeature:
+            raise NotImplementedError("AtpFeature is an abstract class.")
+        super().__init__(parent, short_name)
+
+
+class AtpStructureElement(AtpFeature, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AtpFeature:
+            raise NotImplementedError("AtpStructureElement is an abstract class.")
+        super().__init__(parent, short_name)
+
+
+class AtpType(ARElement, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AtpType:
+            raise NotImplementedError("AtpType is an abstract class.")
+
+        super().__init__(parent, short_name)