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

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

@@ -0,0 +1,246 @@
+from abc import ABCMeta
+from typing import List
+
+
+
+from .....ar_ref import RefType, TRefType
+from .....general_structure import ARElement, Identifiable
+from .....ar_object import ARBoolean, ARObject
+from ...common_structure.implementation import ImplementationProps
+from ..communication import ClientComSpec, ModeSwitchReceiverComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, PPortComSpec, ParameterRequireComSpec, QueuedReceiverComSpec, QueuedSenderComSpec, RPortComSpec, ServerComSpec
+from .instance_refs import InnerPortGroupInCompositionInstanceRef
+
+class SymbolProps(ImplementationProps):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+class PortPrototype(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.clientServerAnnotations = []
+        self.delegatedPortAnnotation = None
+        self.ioHwAbstractionServerAnnotations = []
+        self.modePortAnnotations = []
+        self.nvDataPortAnnotations = []
+        self.parameterPortAnnotations = []
+        self.senderReceiverAnnotations = []
+        self.triggerPortAnnotations = []
+
+    def getClientServerAnnotations(self):
+        return self.clientServerAnnotations
+
+    def addClientServerAnnotation(self, value):
+        self.clientServerAnnotations.append(value)
+        return self
+
+    def getDelegatedPortAnnotation(self):
+        return self.delegatedPortAnnotation
+
+    def setDelegatedPortAnnotation(self, value):
+        self.delegatedPortAnnotation = value
+        return self
+
+    def getIoHwAbstractionServerAnnotations(self):
+        return self.ioHwAbstractionServerAnnotations
+
+    def addIoHwAbstractionServerAnnotation(self, value):
+        self.ioHwAbstractionServerAnnotations.append(value)
+        return self
+
+    def getModePortAnnotations(self):
+        return self.modePortAnnotations
+
+    def addModePortAnnotation(self, value):
+        self.modePortAnnotations.append(value)
+        return self
+
+    def getNvDataPortAnnotations(self):
+        return self.nvDataPortAnnotations
+
+    def addNvDataPortAnnotation(self, value):
+        self.nvDataPortAnnotations.append(value)
+        return self
+
+    def getParameterPortAnnotations(self):
+        return self.parameterPortAnnotations
+
+    def addParameterPortAnnotation(self, value):
+        self.parameterPortAnnotations.append(value)
+        return self
+
+    def getSenderReceiverAnnotations(self):
+        return self.senderReceiverAnnotations
+
+    def addSenderReceiverAnnotation(self, value):
+        self.senderReceiverAnnotations.append(value)
+        return self
+
+    def getTriggerPortAnnotations(self):
+        return self.triggerPortAnnotations
+
+    def addTriggerPortAnnotation(self, value):
+        self.triggerPortAnnotations.append(value)
+        return self
+
+class AbstractProvidedPortPrototype(PortPrototype):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.provided_com_specs = []  # type: List[PPortComSpec]
+
+    def _validateRPortComSpec(self, com_spec: PPortComSpec):
+        if isinstance(com_spec, NonqueuedSenderComSpec):
+            if com_spec.dataElementRef == None:
+                raise ValueError(
+                    "operation of NonqueuedSenderComSpec is invalid")
+            if com_spec.dataElementRef.dest != "VARIABLE-DATA-PROTOTYPE":
+                raise ValueError(
+                    "Invalid operation dest of NonqueuedSenderComSpec")
+        elif isinstance(com_spec, ServerComSpec):
+            pass
+        elif isinstance(com_spec, QueuedSenderComSpec):
+            pass
+        elif isinstance(com_spec, ModeSwitchSenderComSpec):
+            pass
+        else:
+            raise ValueError("Unsupported com spec")
+
+    def addProvidedComSpec(self, com_spec):
+        self._validateRPortComSpec(com_spec)
+        self.provided_com_specs.append(com_spec)
+
+    def getProvidedComSpecs(self) -> List[PPortComSpec]:
+        return self.provided_com_specs
+
+    def getNonqueuedSenderComSpecs(self) -> List[NonqueuedSenderComSpec]:
+        return filter(lambda c: isinstance(c, NonqueuedSenderComSpec), self.provided_com_specs)
+
+
+class AbstractRequiredPortPrototype(PortPrototype):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.required_com_specs = []  # type: List[RPortComSpec]
+
+    def _validateRPortComSpec(self, com_spec: RPortComSpec):
+        if (isinstance(com_spec, ClientComSpec)):
+            if com_spec.getOperationRef() is not None:
+                if com_spec.getOperationRef().getDest() != "CLIENT-SERVER-OPERATION":
+                    raise ValueError("Invalid operation dest of ClientComSpec.")
+        elif isinstance(com_spec, NonqueuedReceiverComSpec):
+            if com_spec.getDataElementRef() is not None:
+                if com_spec.getDataElementRef().getDest() != "VARIABLE-DATA-PROTOTYPE":
+                    raise ValueError("Invalid date element dest of NonqueuedReceiverComSpec.")
+        elif isinstance(com_spec, QueuedReceiverComSpec):
+            pass
+        elif isinstance(com_spec, ModeSwitchReceiverComSpec):
+            pass
+        elif isinstance(com_spec, ParameterRequireComSpec):
+            if com_spec.getParameterRef() is not None:
+                if com_spec.getParameterRef().getDest() != "PARAMETER-DATA-PROTOTYPE":
+                    raise ValueError("Invalid parameter dest of ParameterRequireComSpec.")
+        else:
+            raise ValueError("Unsupported RPortComSpec <%s>" % type(com_spec))
+
+    def addRequiredComSpec(self, com_spec: RPortComSpec):
+        self._validateRPortComSpec(com_spec)
+        self.required_com_specs.append(com_spec)
+
+    def getRequiredComSpecs(self) -> List[RPortComSpec]:
+        return self.required_com_specs
+
+    def getClientComSpecs(self) -> List[ClientComSpec]:
+        return filter(lambda c: isinstance(c, ClientComSpec), self.required_com_specs)
+
+    def getNonqueuedReceiverComSpecs(self) -> List[NonqueuedReceiverComSpec]:
+        return filter(lambda c: isinstance(c, NonqueuedReceiverComSpec), self.required_com_specs)
+
+
+class PPortPrototype(AbstractProvidedPortPrototype):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.providedInterfaceTRef = None           # type: TRefType
+
+    def getProvidedInterfaceTRef(self):
+        return self.providedInterfaceTRef
+
+    def setProvidedInterfaceTRef(self, value):
+        self.providedInterfaceTRef = value
+        return self
+
+class RPortPrototype(AbstractRequiredPortPrototype):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.mayBeUnconnected = None                # type: ARBoolean
+        self.requiredInterfaceTRef = None           # type: TRefType
+
+    def getMayBeUnconnected(self):
+        return self.mayBeUnconnected
+
+    def setMayBeUnconnected(self, value):
+        self.mayBeUnconnected = value
+        return self
+
+    def getRequiredInterfaceTRef(self):
+        return self.requiredInterfaceTRef
+
+    def setRequiredInterfaceTRef(self, value):
+        self.requiredInterfaceTRef = value
+        return self
+
+class PortGroup(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._inner_group_iref = []    # type: List[InnerPortGroupInCompositionInstanceRef]
+        self._outer_port_ref = []      # type: List[RefType]
+
+    def addInnerGroupIRef(self, iref: InnerPortGroupInCompositionInstanceRef):
+        self._inner_group_iref.append(iref)
+
+    def getInnerGroupIRefs(self) -> List[InnerPortGroupInCompositionInstanceRef]:
+        return self._inner_group_iref
+    
+    def addOuterPortRef(self, ref: RefType):
+        self._outer_port_ref.append(ref)
+
+    def getOuterPortRefs(self) -> List[RefType]:
+        return self._outer_port_ref
+
+class SwComponentType(ARElement,  metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+    def createPPortPrototype(self, short_name: str) -> PPortPrototype:
+        prototype = PPortPrototype(self, short_name)
+        if (short_name not in self.elements):
+            self.elements[short_name] = prototype
+        return self.elements[short_name]
+
+    def createRPortPrototype(self, short_name) -> RPortPrototype:
+        prototype = RPortPrototype(self, short_name)
+        if (short_name not in self.elements):
+            self.elements[short_name] = prototype
+        return self.elements[short_name]
+    
+    def createPortGroup(self, short_name) -> PortGroup:
+        port_group = PortGroup(self, short_name)
+        if (short_name not in self.elements):
+            self.elements[short_name] = port_group
+        return self.elements[short_name]
+
+    def getPPortPrototypes(self) -> List[PPortPrototype]:
+        return list(sorted(filter(lambda c: isinstance(c, PPortPrototype), self.elements.values()), key= lambda o: o.short_name))
+
+    def getRPortPrototypes(self) -> List[RPortPrototype]:
+        return list(sorted(filter(lambda c: isinstance(c, RPortPrototype), self.elements.values()), key= lambda o: o.short_name))
+    
+    def getPortPrototypes(self) -> List[PortPrototype]:
+        return list(sorted(filter(lambda c: isinstance(c, PortPrototype), self.elements.values()), key= lambda o: o.short_name))
+    
+    def getPortGroups(self) -> List[PortGroup]:
+        return list(sorted(filter(lambda c: isinstance(c, PortGroup), self.elements.values()), key= lambda o: o.short_name))
+

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

@@ -1,5 +1,7 @@
 from abc import ABCMeta
-from .....ar_ref import AtpInstanceRef, RefType
+
+from ...generic_structure.abstract_structure import AtpInstanceRef
+from .....ar_ref import RefType
 
 
 class ModeGroupInAtomicSwcInstanceRef(AtpInstanceRef, metaclass = ABCMeta):
@@ -147,3 +149,33 @@ class RVariableInAtomicSwcInstanceRef(VariableInAtomicSwcInstanceRef):
     def setTargetDataElementRef(self, value):
         self.targetDataElementRef = value
         return self
+
+class InnerPortGroupInCompositionInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.baseRef = None                                         # type: RefType
+        self.contextRefs = []                                       # type: List[RefType]
+        self.targetRef = None                                       # type: RefType
+
+    def getBaseRef(self):
+        return self.baseRef
+
+    def setBaseRef(self, value):
+        self.baseRef = value
+        return self
+
+    def getContextRefs(self):
+        return self.contextRefs
+
+    def addContextRefs(self, value):
+        self.contextRefs.append(value)
+        return self
+
+    def getTargetRef(self):
+        return self.targetRef
+
+    def setTargetRef(self, value):
+        self.targetRef = value
+        return self
+

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

@@ -0,0 +1,154 @@
+from abc import ABCMeta
+from typing import List
+
+from ..components import SwComponentType
+from ..composition.instance_refs import PPortInCompositionInstanceRef, PortInCompositionTypeInstanceRef, RPortInCompositionInstanceRef
+from .....ar_ref import RefType
+from .....ar_object import ARObject
+from .....general_structure import Identifiable
+
+
+class SwComponentPrototype(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        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 SwConnector(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.mappingRef = None                      # type: RefType
+
+    def getMappingRef(self):
+        return self.mappingRef
+
+    def setMappingRef(self, value):
+        self.mappingRef = value
+        return self
+
+class AssemblySwConnector(SwConnector):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.providerIRef = None        # type: PPortInCompositionInstanceRef
+        self.requesterIRef = None       # type: RPortInCompositionInstanceRef
+
+    def getProviderIRef(self) -> PPortInCompositionInstanceRef:
+        return self.providerIRef
+
+    def setProviderIRef(self, value: PPortInCompositionInstanceRef):
+        self.providerIRef = value
+        return self
+
+    def getRequesterIRef(self) -> PPortInCompositionInstanceRef:
+        return self.requesterIRef
+
+    def setRequesterIRef(self, value: PPortInCompositionInstanceRef):
+        self.requesterIRef = value
+        return self
+
+class DelegationSwConnector(SwConnector):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        
+        self.innerPortIRref = None                          # type: PortInCompositionTypeInstanceRef
+        self.outerPortRef = None                            # type: RefType
+
+    def getInnerPortIRref(self):
+        return self.innerPortIRref
+
+    def setInnerPortIRref(self, value):
+        self.innerPortIRref = value
+        return self
+
+    def getOuterPortRef(self):
+        return self.outerPortRef
+
+    def setOuterPortRef(self, value):
+        self.outerPortRef = value
+        return self
+
+
+class PassThroughSwConnector(SwConnector):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.providedOuterPortRef = None                    # type: RefType
+        self.requiredOuterPortRef = None                    # type: RefType
+
+    def getProvidedOuterPortRef(self):
+        return self.providedOuterPortRef
+
+    def setProvidedOuterPortRef(self, value):
+        self.providedOuterPortRef = value
+        return self
+
+    def getRequiredOuterPortRef(self):
+        return self.requiredOuterPortRef
+
+    def setRequiredOuterPortRef(self, value):
+        self.requiredOuterPortRef = value
+        return self
+
+
+class CompositionSwComponentType(SwComponentType):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        
+        self.constantValueMappingRefs = []                      # type: List[RefType]
+        self.dataTypeMappingRefs = []                           # type: List[RefType]
+        self.instantiationRTEEventProps = []                    # type: List[InstantiationRTEEventProps]
+
+    def removeAllAssemblySwConnector(self):
+        for sw_connector in self.getAssemblySwConnectors():
+            self.elements.pop(sw_connector.short_name)
+
+    def removeAllDelegationSwConnector(self):
+        for sw_connector in self.getDelegationSwConnectors():
+            self.elements.pop(sw_connector.short_name)
+
+    def createAssemblySwConnector(self, short_name: str) -> AssemblySwConnector:
+        if (short_name not in self.elements):
+            connector = AssemblySwConnector(self, short_name)
+            self.elements[short_name] = connector
+        return self.elements[short_name]
+    
+    def createDelegationSwConnector(self, short_name: str) -> DelegationSwConnector:
+        if short_name not in self.elements:
+            connector = DelegationSwConnector(self, short_name)
+            self.elements[short_name] = connector
+        return self.elements[short_name]
+
+    def getAssemblySwConnectors(self) -> List[AssemblySwConnector]:
+        return list(sorted(filter(lambda e: isinstance(e, AssemblySwConnector), self.elements.values()), key = lambda c: c.short_name))
+    
+    def getDelegationSwConnectors(self) -> List[DelegationSwConnector]:
+        return list(sorted(filter(lambda e: isinstance(e, DelegationSwConnector), self.elements.values()), key = lambda c: c.short_name))
+    
+    def getSwConnectors(self) -> List[SwConnector]:
+        return list(sorted(filter(lambda e: isinstance(e, SwConnector), self.elements.values()), key = lambda c: c.short_name))
+    
+    def createSwComponentPrototype(self, short_name: str) -> SwComponentPrototype:
+        if (short_name not in self.elements):
+            connector = SwComponentPrototype(self, short_name)
+            self.elements[short_name] = connector
+        return self.elements[short_name] 
+
+    def getSwComponentPrototypes(self) -> List[SwComponentPrototype]:
+        return list(filter(lambda e: isinstance(e, SwComponentPrototype), self.elements.values()))
+    
+    def addDataTypeMapping(self, data_type_mapping_ref: RefType):
+        self.dataTypeMappingRefs.append(data_type_mapping_ref)
+
+    def getDataTypeMappings(self) -> List[RefType]:
+        return self.dataTypeMappingRefs     
+       
+        

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

@@ -0,0 +1,157 @@
+
+from abc import ABCMeta
+
+from .....ar_ref import RefType
+from ...generic_structure.abstract_structure import AtpInstanceRef
+
+
+class PortInCompositionTypeInstanceRef(AtpInstanceRef, metaclass = ABCMeta):
+    def __init__(self):
+        if type(self) == PortInCompositionTypeInstanceRef:
+            raise NotImplementedError("PortInCompositionTypeInstanceRef is an abstract class.")
+        
+        super().__init__()
+
+        self.abstractContextComponentRef = None                 # type: RefType
+        self.baseRef = None                                     # type: RefType
+        self.targetPortRef = None                               # type: RefType
+
+    def getAbstractContextComponentRef(self):
+        return self.abstractContextComponentRef
+
+    def setAbstractContextComponentRef(self, value):
+        self.abstractContextComponentRef = value
+        return self
+
+    def getBaseRef(self):
+        return self.baseRef
+
+    def setBaseRef(self, value):
+        self.baseRef = value
+        return self
+
+    def getTargetPortRef(self):
+        return self.targetPortRef
+
+    def setTargetPortRef(self, value):
+        self.targetPortRef = value
+        return self
+
+
+class PPortInCompositionInstanceRef(PortInCompositionTypeInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.contextComponentRef = None                         # type: RefType
+        self.targetPPortRef = None                              # type: RefType
+
+    def getContextComponentRef(self):
+        return self.contextComponentRef
+
+    def setContextComponentRef(self, value):
+        self.contextComponentRef = value
+        return self
+
+    def getTargetPPortRef(self):
+        return self.targetPPortRef
+
+    def setTargetPPortRef(self, value):
+        self.targetPPortRef = value
+        return self
+
+
+class RPortInCompositionInstanceRef(PortInCompositionTypeInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.contextComponentRef = None                         # type: RefType
+        self.targetRPortRef = None                              # type: RefType
+
+    def getContextComponentRef(self):
+        return self.contextComponentRef
+
+    def setContextComponentRef(self, value):
+        self.contextComponentRef = value
+        return self
+
+    def getTargetRPortRef(self):
+        return self.targetRPortRef
+
+    def setTargetRPortRef(self, value):
+        self.targetRPortRef = value
+        return self
+
+class OperationInAtomicSwcInstanceRef(AtpInstanceRef, metaclass=ABCMeta):
+    def __init__(self):
+        if type(self) == OperationInAtomicSwcInstanceRef:
+            raise NotImplementedError("OperationInAtomicSwcInstanceRef is an abstract class.")
+        
+        super().__init__()
+
+        self.baseRef = None                         # type: RefType
+        self.contextPortRef = None                  # type: RefType
+        self.targetOperationRef = None              # type: RefType
+
+    def getBaseRef(self):
+        return self.baseRef
+
+    def setBaseRef(self, value):
+        self.baseRef = value
+        return self
+
+    def getContextPortRef(self):
+        return self.contextPortRef
+
+    def setContextPortRef(self, value):
+        self.contextPortRef = value
+        return self
+
+    def getTargetOperationRef(self):
+        return self.targetOperationRef
+
+    def setTargetOperationRef(self, value):
+        self.targetOperationRef = value
+        return self
+
+class POperationInAtomicSwcInstanceRef(OperationInAtomicSwcInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.contextPPortRef = None                 # type: RefType
+        self.targetProvidedOperationRef = None      # type: RefType
+
+    def getContextPPortRef(self):
+        return self.contextPPortRef
+
+    def setContextPPortRef(self, value):
+        self.contextPPortRef = value
+        return self
+
+    def getTargetProvidedOperationRef(self):
+        return self.targetProvidedOperationRef
+
+    def setTargetProvidedOperationRef(self, value):
+        self.targetProvidedOperationRef = value
+        return self
+
+
+class ROperationInAtomicSwcInstanceRef(OperationInAtomicSwcInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.contextRPortRef = None                     # type: RefType
+        self.targetRequiredOperationRef = None          # type: RefType
+
+    def getContextRPortRef(self):
+        return self.contextRPortRef
+
+    def setContextRPortRef(self, value):
+        self.contextRPortRef = value
+        return self
+
+    def getTargetRequiredOperationRef(self):
+        return self.targetRequiredOperationRef
+
+    def setTargetRequiredOperationRef(self, value):
+        self.targetRequiredOperationRef = value
+        return self