armodel 1.6.0__py3-none-any.whl → 1.6.2__py3-none-any.whl

armodel/models/m2/autosar_templates/sw_component_template/data_type/data_prototypes.py

@@ -0,0 +1,104 @@
+from abc import ABCMeta
+
+from .....ar_object import ARNumerical
+from .....ar_ref import RefType
+from ....msr.data_dictionary.data_def_properties import SwDataDefProps
+from ...common_structure import ValueSpecification
+from .....general_structure import AtpFeature, ARObject
+
+class AtpPrototype(AtpFeature, metaclass = ABCMeta):
+    def __init__(self, parent:ARObject, short_name: str):
+        if type(self) == AtpPrototype:
+            raise NotImplementedError("AtpPrototype is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+class DataPrototype(AtpPrototype, metaclass = ABCMeta):
+    def __init__(self, parent:ARObject, short_name: str):
+        if type(self) == DataPrototype:
+            raise NotImplementedError("DataPrototype is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.swDataDefProps = None          # type: SwDataDefProps
+
+    def getSwDataDefProps(self):
+        return self.swDataDefProps
+
+    def setSwDataDefProps(self, value):
+        self.swDataDefProps = value
+        return self
+    
+class AutosarDataPrototype(DataPrototype, metaclass = ABCMeta):
+    def __init__(self, parent:ARObject, short_name: str):
+        if type(self) == AutosarDataPrototype:
+            raise NotImplementedError("AutosarDataPrototype is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.typeTRef = None           
+
+    def getTypeTRef(self):
+        return self.typeTRef
+
+    def setTypeTRef(self, value):
+        self.typeTRef = value
+        return self
+
+class VariableDataPrototype(AutosarDataPrototype):
+    def __init__(self, parent:ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.initValue = None      # type: ValueSpecification
+
+    def getInitValue(self):
+        return self.initValue
+
+    def setInitValue(self, value):
+        self.initValue = value
+        return self
+
+class ApplicationCompositeElementDataPrototype(DataPrototype, metaclass = ABCMeta):
+    def __init__(self, parent:ARObject, short_name: str):
+        if type(self) == ApplicationCompositeElementDataPrototype:
+            raise NotImplementedError("ApplicationCompositeElementDataPrototype is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.typeTRef = None                    # type: RefType
+
+    def getTypeTRef(self):
+        return self.typeTRef
+
+    def setTypeTRef(self, value):
+        self.typeTRef = value
+        return self
+
+
+class ApplicationArrayElement(ApplicationCompositeElementDataPrototype):
+    def __init__(self, parent:ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.arraySizeHandling = None               # type: str
+        self.arraySizeSemantics = None              # type: str
+        self.indexDataTypeRef = None                # type: RefType
+        self.maxNumberOfElements = None             # type: ARNumerical
+
+class ApplicationRecordElement(ApplicationCompositeElementDataPrototype):
+    def __init__(self, parent:ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.isOptional = None
+
+class ParameterDataPrototype(AutosarDataPrototype):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.initValue = None                       # type: ValueSpecification
+
+    def getInitValue(self):
+        return self.initValue
+
+    def setInitValue(self, value):
+        self.initValue = value
+        return self

armodel/models/m2/autosar_templates/sw_component_template/port_interface/__init__.py

@@ -0,0 +1,243 @@
+from abc import ABCMeta
+from typing import List
+
+from ..data_type.data_prototypes import ParameterDataPrototype, VariableDataPrototype, AutosarDataPrototype
+from .....ar_object import ARBoolean, ARLiteral, ARNumerical
+from .....common_structure import ModeDeclarationGroupPrototype, Trigger
+from .....datatype import AtpType
+from .....general_structure import ARObject, Identifiable, AtpFeature
+from .....ar_ref import RefType
+
+class PortInterface(AtpType, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == PortInterface:
+            raise NotImplementedError("PortInterface is an abstract class.")
+        super().__init__(parent, short_name)
+
+        self.isService = None                       # type: ARBoolean
+        self.serviceKind = None                     # type: ARLiteral
+
+    def getIsService(self):
+        return self.isService
+
+    def setIsService(self, value):
+        self.isService = value
+        return self
+
+    def getServiceKind(self):
+        return self.serviceKind
+
+    def setServiceKind(self, value):
+        self.serviceKind = value
+        return self
+
+class DataInterface(PortInterface, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == DataInterface:
+            raise NotImplementedError("DataInterface is an abstract class.")
+        super().__init__(parent, short_name)
+
+class NvDataInterface(DataInterface):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.nvDatas = []       # type: List[VariableDataPrototype]
+
+    def getNvDatas(self):
+        return self.nvDatas
+
+    def setNvData(self, value):
+        self.nvDatas.append(value)
+        return self
+
+class ParameterInterface(DataInterface):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.parameters = []                        # type: List[ParameterDataPrototype]
+
+    def getParameters(self):
+        return list(sorted(filter(lambda a : isinstance(a, ParameterDataPrototype), self.elements.values()), key = lambda a: a.short_name))
+
+    def createParameter(self, short_name: str) -> ParameterDataPrototype:
+        if (short_name not in self.elements):
+            parameter = ParameterDataPrototype(self, short_name)
+            self.elements[short_name] = parameter
+            self.parameters.append(parameter)
+        return self.elements[short_name]
+    
+class InvalidationPolicy(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.dataElementRef = None                      # type: RefType
+        self.handleInvalid = None                       # type: ARLiteral
+
+    def getDataElementRef(self):
+        return self.dataElementRef
+
+    def setDataElementRef(self, value):
+        self.dataElementRef = value
+        return self
+
+    def getHandleInvalid(self):
+        return self.handleInvalid
+
+    def setHandleInvalid(self, value):
+        self.handleInvalid = value
+        return self
+
+class SenderReceiverInterface(DataInterface):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.invalidationPolicies = []                # type: List[InvalidationPolicy]
+        self.metaDataItemSets = []                    # type: List[MetaDataItemSet]
+
+    def getInvalidationPolicies(self):
+        return self.invalidationPolicies
+
+    def addInvalidationPolicy(self, value):
+        self.invalidationPolicies.append(value)
+        return self
+
+    def getMetaDataItemSets(self):
+        return self.metaDataItemSets
+
+    def addMetaDataItemSet(self, value):
+        self.metaDataItemSets.append(value)
+        return self
+
+    def createDataElement(self, short_name) -> VariableDataPrototype:
+        if (short_name not in self.elements):
+            data_element = VariableDataPrototype(self, short_name)
+            self.elements[short_name] = data_element
+        return self.elements[short_name]
+
+    def getDataElements(self) -> List[VariableDataPrototype]:
+        return list(filter(lambda c: isinstance(c, VariableDataPrototype), self.elements.values()))
+
+    def getDataElement(self, short_name) -> VariableDataPrototype:
+        if (short_name in self.elements):
+            data_element = self.elements[short_name]
+            #if (not isinstance(data_element, VariableDataPrototype)):
+            #    raise IndexError("%s is not data element." % short_name)
+            return data_element
+        raise IndexError("data element <%s> can not be found." % short_name)
+    
+    def createInvalidationPolicy(self) -> InvalidationPolicy:
+        policy = InvalidationPolicy(self)
+        self.invalidationPolicies.append(policy)
+        return policy
+    
+    def getInvalidationPolicys(self) -> List[InvalidationPolicy]:
+        return list(filter(lambda c: isinstance(c, InvalidationPolicy), self.invalidationPolicies))
+
+class ArgumentDataPrototype(AutosarDataPrototype):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        self.direction = ""
+        self.server_argument_impl_policy = ""
+
+class ApplicationError(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.error_code = None                  # type: ARNumerical
+
+class ClientServerOperation(AtpFeature):
+    """
+        An operation declared within the scope of a client/server interface.
+        Package: M2::AUTOSARTemplates::SWComponentTemplate::PortInterface
+        Base: ARObject, AtpClassifier , AtpFeature, AtpStructureElement, Identifiable, MultilanguageReferrable, Referrable
+
+        Attributes:
+        -----------
+        _argument: ArgumentDataPrototype (optional)
+            An argument of this ClientServerOperation
+
+        _possibleError: RefType -> ApplicationError (optional)
+            Possible errors that may by raised by the referring operation
+
+        Methods:
+        --------
+        addArgumentDataPrototype    add the argument
+        getArgumentDataPrototypes   get the arguments
+        addPossibleErrorRef         add the possible error
+        getPossbileErrorRefs        get the possible errors
+
+    """
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._arguments = []
+        self._possible_error_refs = []  # type: List[RefType]
+
+    def addArgumentDataPrototype(self, prototype: ArgumentDataPrototype):
+        self._arguments.append(prototype)
+
+    def getArgumentDataPrototypes(self) -> List[ArgumentDataPrototype]:
+        return self._arguments
+
+    def addPossibleErrorRef(self, possible_error_ref: RefType):
+        self._possible_error_refs.append(possible_error_ref)
+
+    def getPossbileErrorRefs(self) -> List[RefType]:
+        return self._possible_error_refs
+
+
+class ClientServerInterface(PortInterface):
+    """
+        A client/server interface declares a number of operations that can be invoked on a server by a client.
+        Package: M2::AUTOSARTemplates::SWComponentTemplate::PortInterface
+        Base: ARElement, ARObject, AtpBlueprint, AtpBlueprintable, AtpClassifier , AtpType, CollectableElement, Identifiable, MultilanguageReferrable, PackageableElement, PortInterface, Referrable
+
+        Methods:
+        --------
+        createOperation             create ClientServerOperation(s) of this ClientServerInterface.
+        createApplicationError      create Application errors that are defined as part of this interface
+        getOperations               get all ClientServerOperation(s) of this ClientServerInterface
+        getPossibleErrors           get all Application error(s) of this ClientServerInterface
+
+    """
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+    def createOperation(self, short_name: str) -> ClientServerOperation:
+        if (short_name not in self.elements):
+            operation = ClientServerOperation(self, short_name)
+            self.elements[short_name] = operation
+        return self.elements[short_name]
+
+    def createApplicationError(self, short_name: str) -> ApplicationError:
+        if (short_name not in self.elements):
+            error = ApplicationError(self, short_name)
+            self.elements[short_name] = error
+        return self.elements[short_name]
+
+    def getOperations(self) -> List[ClientServerOperation]:
+        return list(filter(lambda c: isinstance(c, ClientServerOperation), self.elements.values()))
+
+    def getPossibleErrors(self) -> List[ApplicationError]:
+        return list(filter(lambda c: isinstance(c, ApplicationError), self.elements.values()))
+    
+class TriggerInterface(PortInterface):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._triggers = []             # type: Trigger
+
+class ModeSwitchInterface(PortInterface):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._modeGroup = []            # type: List[ModeDeclarationGroupPrototype]
+
+    def createModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
+        prototype = ModeDeclarationGroupPrototype(self, short_name)
+        if (short_name not in self.elements):
+            self.elements[short_name] = prototype
+        return self.elements[short_name]
+    
+    def getModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
+        return list(sorted(filter(lambda c: isinstance(c, ModeDeclarationGroupPrototype), self.elements.values()), key= lambda o: o.short_name))

armodel/models/m2/autosar_templates/sw_component_template/port_interface/instance_refs.py

@@ -0,0 +1,39 @@
+from .....ar_ref import RefType
+from ...generic_structure.abstract_structure import AtpInstanceRef
+
+class ApplicationCompositeElementInPortInterfaceInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.baseRef = None                                         # type: RefType
+        self.contextDataPrototypeRef = None                         # type: RefType
+        self.rootDataPrototypeRef = None                            # type: RefType
+        self.targetDataPrototypeRef = None                          # type: RefType
+
+    def getBaseRef(self):
+        return self.baseRef
+
+    def setBaseRef(self, value):
+        self.baseRef = value
+        return self
+
+    def getContextDataPrototypeRef(self):
+        return self.contextDataPrototypeRef
+
+    def setContextDataPrototypeRef(self, value):
+        self.contextDataPrototypeRef = value
+        return self
+
+    def getRootDataPrototypeRef(self):
+        return self.rootDataPrototypeRef
+
+    def setRootDataPrototypeRef(self, value):
+        self.rootDataPrototypeRef = value
+        return self
+
+    def getTargetDataPrototypeRef(self):
+        return self.targetDataPrototypeRef
+
+    def setTargetDataPrototypeRef(self, value):
+        self.targetDataPrototypeRef = value
+        return self

armodel/models/m2/autosar_templates/sw_component_template/swc_internal_behavior/data_elements.py

@@ -1,12 +1,8 @@
-
-
-from .access_count import AbstractAccessPoint
-
 from .....general_structure import Identifiable
+from .....ar_object import ARLiteral, ARObject
 from ....msr.data_dictionary.data_def_properties import SwDataDefProps
-from .....ar_ref import AutosarParameterRef, AutosarVariableRef
-from .....ar_object import ARObject
-
+from ..swc_internal_behavior.instance_refs_usage import AutosarParameterRef, AutosarVariableRef
+from .access_count import AbstractAccessPoint
 class ParameterAccess(AbstractAccessPoint):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -32,10 +28,6 @@ class VariableAccess(Identifiable):
     def __init__(self, parent: ARObject, short_name):
         super().__init__(parent, short_name)
 
-        #self.accessedVariableRef = AutosarVariableRef()         # type: AutosarVariableRef
-        #self.accessedVariableRef.parent = self
-        #self.localVariableRef = None                               # type: RefType
-
         self.accessedVariableRef = None                             # type: AutosarVariableRef
         self.scope = None                                           # type: ARLiteral
 

armodel/models/m2/autosar_templates/sw_component_template/swc_internal_behavior/instance_refs_usage.py

@@ -0,0 +1,169 @@
+from typing import List
+
+from .....ar_object import ARObject
+from .....ar_ref import RefType
+from ...generic_structure.abstract_structure import AtpInstanceRef
+
+class ArVariableInImplementationDataInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.contextDataPrototypeRefs = []              # type: List[RefType]
+        self.portPrototypeRef = None                    # type: RefType
+        self.rootVariableDataPrototypeRef = None        # type: RefType
+        self.targetDataPrototypeRef = None              # type: RefType
+
+    def getContextDataPrototypeRefs(self):
+        return self.contextDataPrototypeRefs
+
+    def setContextDataPrototypeRefs(self, value):
+        self.contextDataPrototypeRefs = value
+        return self
+
+    def getPortPrototypeRef(self):
+        return self.portPrototypeRef
+
+    def setPortPrototypeRef(self, value):
+        self.portPrototypeRef = value
+        return self
+
+    def getRootVariableDataPrototypeRef(self):
+        return self.rootVariableDataPrototypeRef
+
+    def setRootVariableDataPrototypeRef(self, value):
+        self.rootVariableDataPrototypeRef = value
+        return self
+
+    def getTargetDataPrototypeRef(self):
+        return self.targetDataPrototypeRef
+
+    def setTargetDataPrototypeRef(self, value):
+        self.targetDataPrototypeRef = value
+        return self
+
+class VariableInAtomicSWCTypeInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.baseRef = None                             # type: RefType
+        self.contextDataPrototypeRefs = []              # type: List[RefType]
+        self.portPrototypeRef = None                    # type: RefType
+        self.rootVariableDataPrototypeRef = None        # type: RefType
+        self.targetDataPrototypeRef = None              # type: RefType
+
+    def getBaseRef(self):
+        return self.baseRef
+
+    def setBaseRef(self, value):
+        self.baseRef = value
+        return self
+
+    def getContextDataPrototypeRefs(self):
+        return self.contextDataPrototypeRefs
+
+    def addContextDataPrototypeRef(self, value):
+        self.contextDataPrototypeRefs.append(value)
+        return self
+
+    def getPortPrototypeRef(self):
+        return self.portPrototypeRef
+
+    def setPortPrototypeRef(self, value):
+        self.portPrototypeRef = value
+        return self
+
+    def getRootVariableDataPrototypeRef(self):
+        return self.rootVariableDataPrototypeRef
+
+    def setRootVariableDataPrototypeRef(self, value):
+        self.rootVariableDataPrototypeRef = value
+        return self
+
+    def getTargetDataPrototypeRef(self):
+        return self.targetDataPrototypeRef
+
+    def setTargetDataPrototypeRef(self, value):
+        self.targetDataPrototypeRef = value
+        return self
+    
+class AutosarVariableRef(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.autosarVariableIRef = None             # type: VariableInAtomicSWCTypeInstanceRef 
+        self.autosarVariableInImplDatatype = None   # type: ArVariableInImplementationDataInstanceRef
+        self.localVariableRef = None
+
+    def getAutosarVariableIRef(self):
+        return self.autosarVariableIRef
+
+    def setAutosarVariableIRef(self, value):
+        self.autosarVariableIRef = value
+        return self
+
+    def getAutosarVariableInImplDatatype(self):
+        return self.autosarVariableInImplDatatype
+
+    def setAutosarVariableInImplDatatype(self, value):
+        self.autosarVariableInImplDatatype = value
+        return self
+
+    def getLocalVariableRef(self):
+        return self.localVariableRef
+
+    def setLocalVariableRef(self, value):
+        self.localVariableRef = value
+        return self
+
+
+class ParameterInAtomicSWCTypeInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.baseRef = None                                         # type: RefType
+        self.contextDataPrototypeRef = None                         # type: RefType
+        self.portPrototypeRef = None                                # type: RefType
+        self.rootParameterDataPrototypeRef = None                   # type: RefType
+        self.targetDataPrototypeRef = None                          # type: RefType
+
+    def getBaseRef(self):
+        return self.baseRef
+
+    def setBaseRef(self, value):
+        self.baseRef = value
+        return self
+
+    def getContextDataPrototypeRef(self):
+        return self.contextDataPrototypeRef
+
+    def setContextDataPrototypeRef(self, value):
+        self.contextDataPrototypeRef = value
+        return self
+
+    def getPortPrototypeRef(self):
+        return self.portPrototypeRef
+
+    def setPortPrototypeRef(self, value):
+        self.portPrototypeRef = value
+        return self
+
+    def getRootParameterDataPrototypeRef(self):
+        return self.rootParameterDataPrototypeRef
+
+    def setRootParameterDataPrototypeRef(self, value):
+        self.rootParameterDataPrototypeRef = value
+        return self
+
+    def getTargetDataPrototypeRef(self):
+        return self.targetDataPrototypeRef
+
+    def setTargetDataPrototypeRef(self, value):
+        self.targetDataPrototypeRef = value
+        return self
+
+class AutosarParameterRef(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.autosar_parameter_iref = None          # type: ParameterInAtomicSWCTypeInstanceRef
+        self.local_parameter_ref = None             # type: RefType

armodel/models/m2/autosar_templates/sw_component_template/swc_internal_behavior/mode_declaration_group.py

@@ -1,9 +1,8 @@
 from .access_count import AbstractAccessPoint
-from ...sw_component_template.components.instance_refs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
+from ..components.instance_refs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
 from .....rpt_scenario import ModeAccessPointIdent
 from .....ar_object import ARObject
 
-
 class ModeAccessPoint(ARObject):
     def __init__(self):
         super().__init__()

armodel/models/m2/autosar_templates/sw_component_template/swc_internal_behavior/server_call.py

@@ -1,15 +1,16 @@
 from abc import ABCMeta
-from .....ar_ref import ROperationInAtomicSwcInstanceRef
-from .access_count import AbstractAccessPoint
 from .....ar_object import ARObject
+from ..composition.instance_refs import ROperationInAtomicSwcInstanceRef
+from .access_count import AbstractAccessPoint
+
 
 class ServerCallPoint(AbstractAccessPoint, metaclass = ABCMeta):
 
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.operationIRef = None  # type: ROperationInAtomicSwcInstanceRef
-        self.timeout = None         # type: float
+        self.operationIRef = None       # type: ROperationInAtomicSwcInstanceRef
+        self.timeout = None             # type: float
 
     def getOperationIRef(self):
         return self.operationIRef

armodel/models/m2/autosar_templates/system_template/instance_refs.py

@@ -0,0 +1,48 @@
+from typing import List
+from ....ar_ref import RefType
+from ..generic_structure.abstract_structure import AtpInstanceRef
+
+class VariableDataPrototypeInSystemInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.baseRef = None                                         # type: RefType
+        self.contextComponentRefs = []                              # type: List[RefType]
+        self.contextCompositionRef = None                           # type: RefType
+        self.contextPortRef = None                                  # type: RefType
+        self.targetDataPrototypeRef = None                          # type: RefType
+
+    def getBaseRef(self):
+        return self.baseRef
+
+    def setBaseRef(self, value):
+        self.baseRef = value
+        return self
+
+    def getContextComponentRefs(self):
+        return self.contextComponentRefs
+
+    def addContextComponentRef(self, value):
+        self.contextComponentRefs.append(value)
+        return self
+
+    def getContextCompositionRef(self):
+        return self.contextCompositionRef
+
+    def setContextCompositionRef(self, value):
+        self.contextCompositionRef = value
+        return self
+
+    def getContextPortRef(self):
+        return self.contextPortRef
+
+    def setContextPortRef(self, value):
+        self.contextPortRef = value
+        return self
+
+    def getTargetDataPrototypeRef(self):
+        return self.targetDataPrototypeRef
+
+    def setTargetDataPrototypeRef(self, value):
+        self.targetDataPrototypeRef = value
+        return self

armodel/models/m2_msr.py

@@ -123,6 +123,7 @@ class CompuScale(Compu):
         self.upperLimit = None                  # type: Limit
         self.compuInverseValue = None           # type: CompuConst
         self.compuScaleContents = None          # type: CompuScaleContents
+        self.short_label = None                 # type: ARLiteral
 
 class CompuScales(CompuContent):
     def __init__(self):