armodel 1.3.0__py3-none-any.whl → 1.4.3__py3-none-any.whl

armodel/models/sw_component.py

@@ -1,11 +1,17 @@
 from typing import List, Dict
 from abc import ABCMeta
+
+from .service_mapping import RoleBasedPortAssignment
+from .per_instance_memory import PerInstanceMemory
+from .service_needs import NvBlockNeeds, RoleBasedDataAssignment, ServiceNeeds
+from .ar_object import ARBoolean, ARLiteral
 from .general_structure import ARElement, Identifiable, ARObject
-from .ar_ref import AutosarVariableRef, RefType, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, ProvidedPortPrototypeInstanceRef
-from .ar_ref import RequiredPortPrototypeInstanceRef, RVariableInAtomicSwcInstanceRef, RModeInAtomicSwcInstanceRef
-from .port_prototype import RPortPrototype, PPortPrototype
-from .data_prototype import VariableDataPrototype
-from .common_structure import ExecutableEntity, InternalBehavior
+from .ar_ref import AutosarParameterRef, AutosarVariableRef, InnerPortGroupInCompositionInstanceRef, ParameterInAtomicSWCTypeInstanceRef,  POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef, TRefType
+from .ar_ref import RefType, PortInCompositionTypeInstanceRef, PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
+from .ar_ref import RVariableInAtomicSwcInstanceRef, RModeInAtomicSwcInstanceRef
+from .port_prototype import RPortPrototype, PPortPrototype, PortPrototype
+from .data_prototype import ParameterDataPrototype, VariableDataPrototype
+from .common_structure import ExecutableEntity, InternalBehavior, ValueSpecification
 
 class VariableAccess(Identifiable):
     def __init__(self, parent: ARObject, short_name):
@@ -15,15 +21,23 @@ class VariableAccess(Identifiable):
         self.parent = parent
         self.local_variable_ref = None  # type: RefType
 
-class ExecutableEntity(Identifiable):
+class AbstractAccessPoint(Identifiable):
+    __metaclass__ = ABCMeta
+
     def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AbstractAccessPoint:
+            raise NotImplementedError("ARObject is an abstract class.")
+        
         super().__init__(parent, short_name)
 
-class AbstractAccessPoint(Identifiable):
-    __metaclass__ = ABCMeta
+        self.return_value_provision = None  
 
+class ParameterAccess(AbstractAccessPoint):
     def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name) 
+        super().__init__(parent, short_name)
+
+        self.accessed_parameter = None  # type: AutosarParameterRef
+        self.sw_data_def_props = None   #   
 
 class ServerCallPoint(AbstractAccessPoint):
     __metaclass__ = ABCMeta
@@ -31,7 +45,7 @@ class ServerCallPoint(AbstractAccessPoint):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
         self.operation_iref = None  # type: ROperationInAtomicSwcInstanceRef
-        self.timeout = 0
+        self.timeout = None         # type: float
 
 class SynchronousServerCallPoint(ServerCallPoint):
     def __init__(self, parent: ARObject, short_name: str):
@@ -58,21 +72,21 @@ class InternalTriggeringPoint(AbstractAccessPoint):
 class RunnableEntity(ExecutableEntity):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
-        self.can_be_invoked_concurrently = False        # Type: bool
-        self.data_read_accesses = {}                    # Type: Dict[VariableAccess]
-        self.data_received_point_by_arguments = {}      # Type: Dict[VariableAccess]
-        self.data_received_point_by_values = {}         # Type: Dict[VariableAccess]
-        self.data_send_points = {}                      # Type: Dict[VariableAccess]
-        self.data_write_accesses = {}                   # Type: Dict[VariableAccess]
-        self.written_local_variables = {}               # Type: Dict[VariableAccess]
-        self.read_local_variables = {}                  # Type: Dict[VariableAccess]
+        self.can_be_invoked_concurrently = None         # Type: ARBoolean
+        self.data_read_accesses = {}                    # Type: Dict[str, VariableAccess]
+        self.data_received_point_by_arguments = {}      # Type: Dict[str, VariableAccess]
+        self.data_received_point_by_values = {}         # Type: Dict[str, VariableAccess]
+        self.data_send_points = {}                      # Type: Dict[str, VariableAccess]
+        self.data_write_accesses = {}                   # Type: Dict[str, VariableAccess]
+        self.written_local_variables = {}               # Type: Dict[str, VariableAccess]
+        self.read_local_variables = {}                  # Type: Dict[str, VariableAccess]
         self.external_triggering_points = {}            # Type: Dict[InternalTriggeringPoint]
         self.internal_triggering_points = {}
         self.mode_access_points = {}
         self.mode_switch_points = {}
-        self.parameter_accesses = {}
-        self.server_call_points = {}                    # Type: Dict[ServerCallPoint]
-        self.wait_points = {}                           # Type: Dict[WaitPoint]
+        self.parameter_accesses = {}                    # Type: Dict[str, ParameterAccess]
+        self.server_call_points = {}                    # Type: Dict[str, ServerCallPoint]
+        self.wait_points = {}                           # Type: Dict[str, WaitPoint]
         self.symbol = ""
 
     def _createVariableAccess(self, short_name, variable_accesses: Dict[str, VariableAccess]):
@@ -86,6 +100,12 @@ class RunnableEntity(ExecutableEntity):
 
     def getDataReadAccesses(self) -> List[VariableAccess]:
         return sorted(self.data_read_accesses.values(), key=lambda v: v.short_name)
+    
+    def createDataWriteAccess(self, short_name: str) -> VariableAccess:
+       return self._createVariableAccess(short_name, self.data_write_accesses)
+
+    def getDataWriteAccesses(self) -> List[VariableAccess]:
+        return sorted(self.data_write_accesses.values(), key=lambda v: v.short_name)
 
     def createDataReceivePointByArgument(self, short_name: str) -> VariableAccess:
        return self._createVariableAccess(short_name, self.data_received_point_by_arguments)
@@ -117,6 +137,15 @@ class RunnableEntity(ExecutableEntity):
     def getWrittenLocalVariables(self) -> List[VariableAccess]:
         return sorted(self.written_local_variables.values(), key=lambda v: v.short_name)
     
+    def createParameterAccess(self, short_name: str) -> ParameterAccess:
+        if (short_name not in self.server_call_points):
+            parameter_access = ParameterAccess(self, short_name)
+            self.parameter_accesses[short_name] = parameter_access
+        return self.parameter_accesses[short_name]
+    
+    def getParameterAccesses(self) -> List[ParameterAccess]:
+        return sorted(self.parameter_accesses.values(), key= lambda o: o.short_name)
+    
     def createSynchronousServerCallPoint(self, short_name: str) -> SynchronousServerCallPoint:
         if (short_name not in self.server_call_points):
             server_call_point = SynchronousServerCallPoint(self, short_name)
@@ -154,7 +183,15 @@ class AbstractEvent(Identifiable):
 class RTEEvent(AbstractEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
-        self.start_on_event_ref = None # type: RefType
+
+        self.start_on_event_ref = None  # type: RefType
+        self.disabled_mode_irefs = []   # type: List[RModeInAtomicSwcInstanceRef]
+
+    def addDisabledModeIRef(self, iref: RModeInAtomicSwcInstanceRef):
+        self.disabled_mode_irefs.append(iref)
+
+    def getDisabledModeIRefs(self) -> List[RModeInAtomicSwcInstanceRef]:
+        return self.disabled_mode_irefs
 
 class AsynchronousServerCallReturnsEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
@@ -178,16 +215,22 @@ class SwcModeSwitchEvent(RTEEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._activation = ""     
-        self.mode_irefs = []       # type: List[RModeInAtomicSwcInstanceRef]
+        self._activation = None             # type: ARLiteral
+        self.mode_irefs = []                # type: List[RModeInAtomicSwcInstanceRef]
+
+    def addModeIRef(self, iref: RModeInAtomicSwcInstanceRef):
+        self.mode_irefs.append(iref)
+
+    def getModeIRefs(self) -> List[RModeInAtomicSwcInstanceRef]:
+        return self.mode_irefs
 
     @property
-    def activation(self) -> str:
+    def activation(self) -> ARLiteral:
         return self._activation
 
     @activation.setter
-    def activation(self, value: str):
-        if value not in ("ON-ENTRY", "ON-EXIT", "ON-TRANSITION"):
+    def activation(self, value: ARLiteral):
+        if value.getValue() not in ("ON-ENTRY", "ON-EXIT", "ON-TRANSITION"):
             raise ValueError("Invalid activation <%s> of SwcModeSwitchEvent <%s>" % (value, self.short_name))
         self._activation = value
 
@@ -228,10 +271,93 @@ class InternalTriggerOccurredEvent(RTEEvent):
 
         self.event_source_ref = None    # type: RefType  
 
+class PortDefinedArgumentValue(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.value = None                   # type: ValueSpecification
+        self.value_type = None              # type: TRefType
+            
+class PortAPIOption(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.enable_take_address = None     # type: ARBoolean
+        self.indirect_api = None            # type: ARBoolean
+        self.port_ref = None                # type: RefType
+        self._port_arg_values = []          # type: List[PortDefinedArgumentValue]
+
+    def addPortArgValue(self, value:PortDefinedArgumentValue):
+        self._port_arg_values.append(value)
+
+    def getPortArgValues(self) -> List[PortDefinedArgumentValue]:
+        return self._port_arg_values
+
+class ServiceDependency(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+class SwcServiceDependency(ServiceDependency):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._assigned_data = []
+        self._assigned_ports = []
+        
+    def AddAssignedData(self, data: RoleBasedDataAssignment):
+        self._assigned_data.append(data)
+
+    def getAssignedData(self) -> List[RoleBasedDataAssignment]:
+        return self._assigned_data
+
+    def AddAssignedPort(self, data: RoleBasedPortAssignment):
+        self._assigned_ports.append(data)
+
+    def getAssignedPorts(self) -> List[RoleBasedPortAssignment]:
+        return self._assigned_ports
+    
+    def createNvBlockNeeds(self, short_name: str) -> NvBlockNeeds:
+        if (short_name not in self.elements):
+            event = NvBlockNeeds(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+    
+    def getNvBlockNeeds(self) -> List[NvBlockNeeds]:
+        return sorted(filter(lambda c: isinstance(c, NvBlockNeeds), self.elements.values()), key=lambda e: e.short_name)
+
+    def getServiceNeeds(self) -> List[ServiceNeeds]:
+        return sorted(filter(lambda c: isinstance(c, ServiceNeeds), self.elements.values()), key=lambda e: e.short_name)
+    
 class SwcInternalBehavior(InternalBehavior):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.handle_termination_and_restart = None      # type: str
+        self.supports_multiple_instantiation = None     # type: ARBoolean
+        self._explicit_inter_runnable_variables = []    # type: List[VariableDataPrototype]
+        self._implicit_inter_runnable_variables = []    # type: List[VariableDataPrototype]
+        self._per_instance_memories = []                # type: List[PerInstanceMemory]
+        self._per_instance_parameters = []              # type: List[ParameterDataPrototype]
+        self._port_api_options = []                     # type: List[PortAPIOption]
+
+    def getExplicitInterRunnableVariables(self) -> List[VariableDataPrototype]:
+        return self._explicit_inter_runnable_variables
+    
+    def getImplicitInterRunnableVariables(self) -> List[VariableDataPrototype]:
+        return self._implicit_inter_runnable_variables
+    
+    def getPerInstanceMemories(self) -> List[PerInstanceMemory]:
+        return self._per_instance_memories
+    
+    def getParameterDataPrototypes(self) -> List[ParameterDataPrototype]:
+        return self._per_instance_parameters
+    
+    def addPortAPIOption(self, option: PortAPIOption):
+        self._port_api_options.append(option)
+
+    def getPortAPIOptions(self) -> List[PortAPIOption]:
+        return self._port_api_options
+
     def createOperationInvokedEvent(self, short_name: str) -> OperationInvokedEvent:
         if (short_name not in self.elements):
             event = OperationInvokedEvent(self, short_name)
@@ -267,8 +393,14 @@ class SwcInternalBehavior(InternalBehavior):
             event = InternalTriggerOccurredEvent(self, short_name)
             self.elements[short_name] = event
         return self.elements[short_name]
+    
+    def createSwcServiceDependency(self, short_name: str) -> SwcServiceDependency:
+        if (short_name not in self.elements):
+            event = SwcServiceDependency(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
 
-    def getEvents(self) -> List[RTEEvent]:
+    def getRteEvents(self) -> List[RTEEvent]:
         return sorted(filter(lambda c: isinstance(c, RTEEvent), self.elements.values()), key=lambda e: e.short_name)
 
     def getOperationInvokedEvents(self) -> List[OperationInvokedEvent]:
@@ -289,6 +421,9 @@ class SwcInternalBehavior(InternalBehavior):
     def getInternalTriggerOccurredEvents(self) -> List[InternalTriggerOccurredEvent]:
         return sorted(filter(lambda c: isinstance(c, InternalTriggerOccurredEvent), self.elements.values()), key= lambda e: e.short_name)
     
+    def getSwcServiceDependencies(self) -> List[SwcServiceDependency]:
+        return sorted(filter(lambda c: isinstance(c, SwcServiceDependency), self.elements.values()), key= lambda e: e.short_name)
+    
     def getEvent(self, short_name: str) -> RTEEvent:
         if (not isinstance(self.elements[short_name], RTEEvent)):
             raise ValueError("Invalid Event Type <%s> of <%s>" % type(self.elements[short_name]), short_name)
@@ -298,6 +433,28 @@ class SwcInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             prototype = VariableDataPrototype(self, short_name)
             self.elements[short_name] = prototype
+            self._explicit_inter_runnable_variables.append(prototype)
+        return self.elements[short_name]
+    
+    def createImplicitInterRunnableVariable(self, short_name: str) -> VariableDataPrototype:
+        if (short_name not in self.elements):
+            prototype = VariableDataPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self._implicit_inter_runnable_variables.append(prototype)
+        return self.elements[short_name]
+    
+    def createPerInstanceMemory(self, short_name: str) -> PerInstanceMemory:
+        if (short_name not in self.elements):
+            memory = PerInstanceMemory(self, short_name)
+            self.elements[short_name] = memory
+            self._per_instance_memories.append(memory)
+        return self.elements[short_name]
+    
+    def createParameterDataPrototype(self, short_name: str) -> ParameterDataPrototype:
+        if (short_name not in self.elements):
+            prototype = ParameterDataPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self._per_instance_parameters.append(prototype)
         return self.elements[short_name]
 
     def getVariableDataPrototypes(self) -> List[VariableDataPrototype]:
@@ -314,6 +471,25 @@ class SwcInternalBehavior(InternalBehavior):
     
     def getRunnableEntity(self, short_name) -> RunnableEntity:
         return self.elements[short_name]
+    
+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
@@ -322,22 +498,34 @@ class SwComponentType(ARElement):
         super().__init__(parent, short_name)
 
     def createPPortPrototype(self, short_name: str) -> PPortPrototype:
+        prototype = PPortPrototype(self, short_name)
         if (short_name not in self.elements):
-            prototype = PPortPrototype(self, short_name)
             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):
-            prototype = RPortPrototype(self, short_name)
             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(filter(lambda c: isinstance(c, PPortPrototype), self.elements.values()))
+        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(filter(lambda c: isinstance(c, RPortPrototype), self.elements.values()))
+        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))
 
 class AtomicSwComponentType(SwComponentType):
     __metaclass__ = ABCMeta
@@ -397,22 +585,22 @@ class AssemblySwConnector(SwConnector):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.provider_iref = None   # type: ProvidedPortPrototypeInstanceRef
-        self.requester_iref = None  # type: RequiredPortPrototypeInstanceRef
+        self.provider_iref = None   # type: PPortInCompositionInstanceRef
+        self.requester_iref = None  # type: RPortInCompositionInstanceRef
 
 class DelegationSwConnector(SwConnector):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.inner_port_iref = None # type: RefType
-        self.outer_port_iref = None # type: RefType
+        self.inner_port_iref = None # type: PortInCompositionTypeInstanceRef
+        self.outer_port_ref  = None # type: RefType
 
 class PassThroughSwConnector(SwConnector):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.provided_outer_port_iref = None # type: RefType
-        self.required_outer_port_iref = None # type: RefType
+        self.provided_outer_port_ref = None # type: RefType
+        self.required_outer_port_ref = None # type: RefType
 
 class SwComponentPrototype(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
@@ -425,18 +613,38 @@ class CompositionSwComponentType(SwComponentType):
         super().__init__(parent, short_name)
 
         self.constant_value_mapping_refs = []   # type: List[RefType]
-        self.data_type_mapping_refs = []        # type: List[RefType]
+        self._data_type_mapping_refs = []       # type: List[RefType]
         self.instantiation_rte_event_props = [] # 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] 
+        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(filter(lambda e: isinstance(e, AssemblySwConnector), self.elements.values()))
-
+        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)
@@ -444,4 +652,10 @@ class CompositionSwComponentType(SwComponentType):
         return self.elements[short_name] 
 
     def getSwComponentPrototypes(self) -> List[SwComponentPrototype]:
-        return list(filter(lambda e: isinstance(e, SwComponentPrototype), self.elements.values()))
+        return list(filter(lambda e: isinstance(e, SwComponentPrototype), self.elements.values()))
+    
+    def addDataTypeMapping(self, data_type_mapping_ref: RefType):
+        self._data_type_mapping_refs.append(data_type_mapping_ref)
+
+    def getDataTypeMappings(self) -> List[RefType]:
+        return self._data_type_mapping_refs

armodel/models/unit.py

@@ -0,0 +1,14 @@
+
+from .ar_object import ARLiteral, ARObject
+from .general_structure import ARElement
+
+
+class SingleLanguageUnitNames(ARLiteral):
+    def __init__(self) -> None:
+        super().__init__()
+
+class Unit(ARElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.display_name = None    # type: SingleLanguageUnitNames