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

armodel/models/m2/autosar_templates/common_structure/implementation_data_types.py

@@ -0,0 +1,148 @@
+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
+
+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"
+
+    def __init__(self, parent, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.arrayImplPolicy = None             # type: ARLiteral
+        self.arraySize = None                   # type: ARNumerical
+        self.arraySizeHandling = None           # type: ARLiteral
+        self.arraySizeSemantics = None          # type: ARLiteral
+        self.isOptional = None                  # type: ARBoolean
+        self.swDataDefProps = None              # type: SwDataDefProps
+
+    def getArrayImplPolicy(self):
+        return self.arrayImplPolicy
+
+    def setArrayImplPolicy(self, value):
+        self.arrayImplPolicy = value
+        return self
+
+    def getArraySize(self):
+        return self.arraySize
+
+    def setArraySize(self, value):
+        self.arraySize = value
+        return self
+
+    def getArraySizeHandling(self):
+        return self.arraySizeHandling
+
+    def setArraySizeHandling(self, value):
+        self.arraySizeHandling = value
+        return self
+
+    def getArraySizeSemantics(self):
+        return self.arraySizeSemantics
+
+    def setArraySizeSemantics(self, value):
+        self.arraySizeSemantics = value
+        return self
+
+    def getIsOptional(self):
+        return self.isOptional
+
+    def setIsOptional(self, value):
+        self.isOptional = value
+        return self
+
+    def getSwDataDefProps(self):
+        return self.swDataDefProps
+
+    def setSwDataDefProps(self, value):
+        self.swDataDefProps = value
+        return self
+    
+    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()))
+
+
+class AbstractImplementationDataType(AutosarDataType, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AbstractImplementationDataType:
+            raise NotImplementedError("AbstractImplementationDataType is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+class ImplementationDataType(AbstractImplementationDataType):
+    CATEGORY_TYPE_REFERENCE = "TYPE_REFERENCE"
+    CATEGORY_TYPE_VALUE = "VALUE"
+    CATEGORY_TYPE_STRUCTURE = "STRUCTURE"
+    CATEGORY_DATA_REFERENCE = "DATA_REFERENCE"
+    CATEGORY_ARRAY = "ARRAY"
+
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        
+        self.sub_elements = []          # 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)
+        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) -> List[ImplementationDataTypeElement]:
+        elements = []
+        for sub_element in self.sub_elements:
+            elements.append(self.elements[sub_element])
+        return elements
+        # return filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements.values())
+
+    def getArrayElementType(self) -> str:
+        return self._array_type
+
+    def setArrayElementType(self, type: str):
+        self._array_type = type
+        return self
+
+    def setTypeEmitter(self, emitter: str):
+        self._type_emitter = emitter
+        return self
+    
+    def getTypeEmitter(self) -> str:
+        return self._type_emitter
+    
+    def setStructElementType(self, type: str):
+        self._struct_type = type
+        return self
+    
+    def getStructElementType(self) -> str:
+        return self._struct_type
+    
+    def createSymbolProps(self, short_name: str) -> SymbolProps:
+        if short_name not in self.element:
+            symbol_props = SymbolProps(self, short_name)
+            self.elements[short_name] = symbol_props
+            self.symbolProps = symbol_props
+        return self.symbolProps
+    
+    def getSymbolProps(self) -> SymbolProps:
+        return self.symbolProps

armodel/models/m2/autosar_templates/ecuc_description_template.py

@@ -0,0 +1,269 @@
+from abc import ABCMeta
+from typing import List
+
+from ..autosar_templates.generic_structure.abstract_structure import AnyInstanceRef
+from ..msr.documentation.block_elements import DocumentationBlock
+from ...annotation import Annotation
+from ...ar_ref import RefType
+from ...ar_object import ARBoolean, ARLiteral, ARNumerical, ARObject
+from ...general_structure import ARElement
+
+class EcucValueCollection(ARElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.ecucValueRefs = []
+        self.ecuExtractRef = None
+
+    def getEcucValueRefs(self) -> List[RefType]:
+        return self.ecucValueRefs
+
+    def addEcucValueRef(self, ref: RefType):
+        self.ecucValueRefs.append(ref)
+        return self
+
+    def getEcuExtractRef(self):
+        return self.ecuExtractRef
+
+    def setEcuExtractRef(self, value):
+        self.ecuExtractRef = value
+        return self
+    
+class EcucIndexableValue(ARObject, metaclass = ABCMeta):
+    def __init__(self):
+        if type(self) == EcucIndexableValue:
+            raise NotImplementedError("EcucIndexableValue is an abstract class.")
+        
+        super().__init__()
+
+class EcucAbstractReferenceValue(EcucIndexableValue, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == EcucAbstractReferenceValue:
+            raise NotImplementedError("EcucAbstractReferenceValue is an abstract class.")
+        
+        super().__init__()
+    
+class EcucParameterValue(EcucIndexableValue, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == EcucParameterValue:
+            raise NotImplementedError("EcucParameterValue is an abstract class.")
+        
+        super().__init__()
+
+        self.annotations = []                       # type: List[Annotation]
+        self.definitionRef = None                   # type: RefType
+        self.isAutoValue = None                     # type: ARBoolean
+
+    def getAnnotations(self) -> List[Annotation]:
+        return self.annotations
+
+    def addAnnotation(self, value: Annotation):
+        self.annotations.append(value)
+        return self
+
+    def getDefinitionRef(self) -> RefType:
+        return self.definitionRef
+
+    def setDefinitionRef(self, value: RefType):
+        self.definitionRef = value
+        return self
+
+    def getIsAutoValue(self) -> ARBoolean:
+        return self.isAutoValue
+
+    def setIsAutoValue(self, value: ARBoolean):
+        self.isAutoValue = value
+        return self
+
+class EcucAddInfoParamValue(EcucParameterValue):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None                           # type: DocumentationBlock
+
+    def getValue(self) -> DocumentationBlock:
+        return self.value
+
+    def setValue(self, value: DocumentationBlock):
+        self.value = value
+
+class EcucTextualParamValue(EcucParameterValue):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None                           # type: ARLiteral
+
+    def getValue(self) -> ARLiteral:
+        return self.value
+
+    def setValue(self, value:ARLiteral):
+        self.value = value
+
+
+class EcucNumericalParamValue(EcucParameterValue):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None                           # type: ARNumerical
+
+    def getValue(self) -> ARNumerical:
+        return self.value
+
+    def setValue(self, value: ARNumerical):
+        self.value = value
+
+class EcucAbstractReferenceValue(EcucIndexableValue, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == EcucAbstractReferenceValue:
+            raise NotImplementedError("EcucAbstractReferenceValue is an abstract class.")
+        
+        super().__init__()
+
+        self.annotations = []                       # type: List[Annotation]
+        self.definitionRef = None                   # type: RefType
+        self.isAutoValue = None                     # type: ARBoolean
+
+    def getAnnotations(self) -> List[Annotation]:
+        return self.annotations
+
+    def addAnnotation(self, value: Annotation):
+        self.annotations.append(value)
+        return self
+
+    def getDefinitionRef(self) -> RefType:
+        return self.definitionRef
+
+    def setDefinitionRef(self, value: RefType):
+        self.definitionRef = value
+        return self
+
+    def getIsAutoValue(self) -> ARBoolean:
+        return self.isAutoValue
+
+    def setIsAutoValue(self, value: ARBoolean):
+        self.isAutoValue = value
+        return self
+
+class EcucInstanceReferenceValue(EcucAbstractReferenceValue):
+    def __init__(self):
+        super().__init__()
+
+        self.valueIRef = None        # type: AnyInstanceRef
+
+    def getValueIRef(self) -> AnyInstanceRef:
+        return self.valueRef
+
+    def setValueIRef(self, value: AnyInstanceRef):
+        self.valueRef = value
+        return self
+
+class EcucReferenceValue(EcucAbstractReferenceValue):
+    def __init__(self):
+        super().__init__()
+
+        self.valueRef = None        # type: RefType
+
+    def getValueRef(self) -> RefType:
+        return self.valueRef
+
+    def setValueRef(self, value: RefType):
+        self.valueRef = value
+        return self
+
+class EcucContainerValue(ARElement, EcucIndexableValue):
+    def __init__(self, parent: ARObject, short_name: str):
+        ARElement.__init__(self, parent, short_name)
+
+        self.definitionRef = None                   # type: RefType
+        self.parameterValues = []                   # type: List[EcucParameterValue]
+        self.referenceValues = []                   # type: List[EcucAbstractReferenceValue]
+        self.subContainers = []                     # type: List[EcucContainerValue]
+
+    def getDefinitionRef(self) -> RefType:
+        return self.definitionRef
+
+    def setDefinitionRef(self, value: RefType):
+        self.definitionRef = value
+        return self
+
+    def getParameterValues(self)-> List[EcucParameterValue]:
+        return self.parameterValues
+
+    def addParameterValue(self, value: EcucParameterValue):
+        self.parameterValues.append(value)
+        return self
+
+    def getReferenceValues(self) -> EcucAbstractReferenceValue:
+        return self.referenceValues
+
+    def addReferenceValue(self, value: EcucAbstractReferenceValue):
+        self.referenceValues.append(value)
+        return self
+
+    def getSubContainers(self):
+        return self.subContainers
+
+    def createSubContainer(self, short_name):
+        if (short_name not in self.elements):
+            container_value = EcucContainerValue(self, short_name)
+            self.elements[short_name] = container_value
+            self.subContainers.append(container_value)
+        return self.elements[short_name]
+
+
+class EcucModuleConfigurationValues(ARElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.containers = []                        # type: List[EcucContainerValue]
+        self.definitionRef = None                   # type: RefType
+        self.ecucDefEdition = None                  # type: ARLiteral
+        self.implementationConfigVariant = None     # type: ARLiteral
+        self.moduleDescriptionRef = None            # type: RefType
+        self.postBuildVariantUsed = None            # type: ARBoolean
+
+    def createContainer(self, short_name: str) -> EcucContainerValue:
+        if (short_name not in self.elements):
+            container = EcucContainerValue(self, short_name)
+            self.elements[short_name] = container
+            self.containers.append(container)
+        return self.elements[short_name]
+
+    def getContainers(self) -> List[EcucContainerValue]:
+        return list(sorted(filter(lambda a: isinstance(a, EcucContainerValue), self.elements.values()), key= lambda o:o.short_name))
+
+    def getDefinitionRef(self) -> RefType:
+        return self.definitionRef
+
+    def setDefinitionRef(self, value: RefType):
+        self.definitionRef = value
+        return self
+
+    def getEcucDefEdition(self) -> ARLiteral:
+        return self.ecucDefEdition
+
+    def setEcucDefEdition(self, value: ARLiteral):
+        self.ecucDefEdition = value
+        return self
+
+    def getImplementationConfigVariant(self) -> ARLiteral:
+        return self.implementationConfigVariant
+
+    def setImplementationConfigVariant(self, value: ARLiteral):
+        self.implementationConfigVariant = value
+        return self
+
+    def getModuleDescriptionRef(self) -> RefType:
+        return self.moduleDescriptionRef
+
+    def setModuleDescriptionRef(self, value: RefType):
+        self.moduleDescriptionRef = value
+        return self
+
+    def getPostBuildVariantUsed(self) -> ARBoolean:
+        return self.postBuildVariantUsed
+
+    def setPostBuildVariantUsed(self, value: ARBoolean):
+        self.postBuildVariantUsed = value
+        return self
+

armodel/models/m2/autosar_templates/generic_structure/abstract_structure.py

@@ -0,0 +1,69 @@
+
+from abc import ABCMeta
+from typing import List
+
+from ....ar_ref import RefType
+from ....ar_object import ARObject
+
+
+class AtpInstanceRef(ARObject, metaclass = ABCMeta):
+    def __init__(self):
+
+        if type(self) == AtpInstanceRef:
+            raise NotImplementedError("AtpInstanceRef is an abstract class.")
+        
+        super().__init__()
+
+        self.atpBaseRef = None                  # type: RefType
+        self.atpContextElementRefs = []         # type: List[RefType]
+        self.atpTargetRef = None                # type: RefType
+
+    def getAtpBaseRef(self):
+        return self.atpBaseRef
+
+    def setAtpBaseRef(self, value):
+        self.atpBaseRef = value
+        return self
+
+    def getAtpContextElementRefs(self):
+        return self.atpContextElementRefs
+
+    def addAtpContextElementRef(self, value):
+        self.atpContextElementRefs.append(value)
+        return self
+
+    def getAtpTargetRef(self):
+        return self.atpTargetRef
+
+    def setAtpTargetRef(self, value):
+        self.atpTargetRef = value
+        return self
+
+class AnyInstanceRef(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.baseRef = None                             # type: RefType
+        self.contextElementRef = None                   # type: RefType
+        self.targetRef = None                           # type: RefType
+
+    def getBaseRef(self) -> RefType:
+        return self.baseRef
+
+    def setBaseRef(self, value: RefType):
+        self.baseRef = value
+        return self
+
+    def getContextElementRef(self) -> RefType:
+        return self.contextElementRef
+
+    def setContextElementRef(self, value: RefType):
+        self.contextElementRef = value
+        return self
+
+    def getTargetRef(self) -> RefType:
+        return self.targetRef
+
+    def setTargetRef(self, value:RefType):
+        self.targetRef = value
+        return self