def connect_subject(self, handle): line = self.line assert line # TODO: connect opposite side again (in case it's a join/fork or # decision/merge node) c1 = self.get_connected(line.head) c2 = self.get_connected(line.tail) assert c1 and c2 assert isinstance(c1.subject, UML.ActivityNode) if isinstance(c1.subject, UML.ObjectNode) or isinstance( c2.subject, UML.ObjectNode): relation: UML.ActivityEdge = self.relationship_or_new( UML.ObjectFlow, UML.ObjectFlow.source, UML.ObjectFlow.target) else: relation = self.relationship_or_new(UML.ControlFlow, UML.ControlFlow.source, UML.ControlFlow.target) line.subject = relation relation.activity = c1.subject.activity opposite = line.opposite(handle) otc = self.get_connected(opposite) if opposite and isinstance(otc, (ForkNodeItem, DecisionNodeItem)): adapter = Connector(otc, line) adapter.combine_nodes()
def unlink(self): c1 = self._connections.get_connection(self.head) c2 = self._connections.get_connection(self.tail) if c1 and c2: adapter = Connector(c1.connected, self) adapter.disconnect(self.head) super().unlink()
def connectable(line, handle, element): connector = Connector(element, line) for port in element.ports(): allow = connector.allow(handle, port) if allow: return True return False
def disconnect_subject(self, handle): super().disconnect_subject(handle) line = self.line opposite = line.opposite(handle) otc = self.get_connected(opposite) if opposite and isinstance(otc, (ForkNodeItem, DecisionNodeItem)): adapter = Connector(otc, line) adapter.decombine_nodes()
def connected_proxy_port_item(diagram, element_factory): proxy_port_item = diagram.create(ProxyPortItem) block_item = diagram.create(BlockItem, subject=element_factory.create(sysml.Block)) connector = Connector(block_item, proxy_port_item) connector.connect(proxy_port_item.handles()[0], block_item.ports()[0]) return proxy_port_item
def unlink(self): assert self.canvas canvas = self.canvas c1 = canvas.get_connection(self.head) c2 = canvas.get_connection(self.tail) if c1 and c2: adapter = Connector(c1.connected, self) adapter.disconnect(self.head) super().unlink()
def allow(self, line, handle, item, port=None): """Glue line's handle to an item. If port is not provided, then first port is used. """ if port is None and len(item.ports()) > 0: port = item.ports()[0] adapter = Connector(item, line) return adapter.allow(handle, port)
def test_connect_proxy_port_to_block(diagram, block_item, proxy_port_item): connector = Connector(block_item, proxy_port_item) connected = connector.connect(proxy_port_item.handles()[0], block_item.ports()[0]) assert connected assert proxy_port_item.subject assert proxy_port_item.subject.encapsulatedClassifier is block_item.subject assert proxy_port_item.subject in block_item.subject.ownedPort
def __call__(self): handle = self.handle item = self.item connections = self.connections cinfo = connections.get_connection(handle) if self.disable: log.debug(f"Not disconnecting {item}.{handle} (disabled)") else: log.debug(f"Disconnecting {item}.{handle}") if cinfo: adapter = Connector(cinfo.connected, item) adapter.disconnect(handle)
def __call__(self): handle = self.handle item = self.item connections = self.connections cinfo = connections.get_connection(handle) if self.disable: log.debug(f"Disconnect callback disabled for {item}.{handle} (disabled)") else: log.debug(f"Disconnect callback {item}.{handle}") if cinfo: adapter = Connector(cinfo.connected, item) adapter.disconnect(handle) self.item.handle( ItemDisconnected(self.item, self.handle, cinfo.connected, cinfo.port) )
def connect(self, handle, port): lifeline = self.element.subject exec_spec: UML.ExecutionSpecification = self.line.subject model = self.element.model if not exec_spec: exec_spec = model.create(UML.BehaviorExecutionSpecification) self.line.subject = exec_spec start_occurence: UML.ExecutionOccurrenceSpecification = model.create( UML.ExecutionOccurrenceSpecification ) start_occurence.covered = lifeline start_occurence.execution = exec_spec finish_occurence: UML.ExecutionOccurrenceSpecification = model.create( UML.ExecutionOccurrenceSpecification ) finish_occurence.covered = lifeline finish_occurence.execution = exec_spec canvas = self.canvas if canvas.get_parent(self.line) is not self.element: reparent(canvas, self.line, self.element) for cinfo in canvas.get_connections(connected=self.line): Connector(self.line, cinfo.item).connect(cinfo.handle, cinfo.port) return True
def connect(self, handle, port): lifeline = self.element.subject exec_spec = self.line.subject model = self.element.model if not exec_spec: exec_spec = model.create(UML.BehaviorExecutionSpecification) self.line.subject = exec_spec start_occurence: UML.ExecutionOccurrenceSpecification = model.create( UML.ExecutionOccurrenceSpecification) start_occurence.covered = lifeline start_occurence.execution = exec_spec finish_occurence: UML.ExecutionOccurrenceSpecification = model.create( UML.ExecutionOccurrenceSpecification) finish_occurence.covered = lifeline finish_occurence.execution = exec_spec if lifeline.interaction: exec_spec.enclosingInteraction = lifeline.interaction diagram = self.diagram if self.line.parent is not self.element: self.line.parent = self.element for cinfo in diagram.connections.get_connections(connected=self.line): Connector(self.line, cinfo.item).connect(cinfo.handle, cinfo.port) return True
def disconnect(self, handle): exec_spec: Optional[UML.ExecutionSpecification] = self.line.subject del self.line.subject if exec_spec and not exec_spec.presentation: exec_spec.unlink() for cinfo in self.canvas.get_connections(connected=self.line): Connector(self.line, cinfo.item).disconnect(cinfo.handle)
def test_disconnect_proxy_port_to_block(diagram, block_item, proxy_port_item): connector = Connector(block_item, proxy_port_item) connector.connect(proxy_port_item.handles()[0], block_item.ports()[0]) connector.disconnect(proxy_port_item.handles()[0]) assert proxy_port_item.subject is None assert proxy_port_item.diagram
def disconnect(self, handle): exec_spec: Optional[UML.ExecutionSpecification] = self.line.subject del self.line.subject if exec_spec: exec_spec.unlink() canvas = self.canvas if canvas.get_parent(self.line) is self.element: new_parent = canvas.get_parent(self.element) reparent(canvas, self.line, new_parent) for cinfo in canvas.get_connections(connected=self.line): Connector(self.line, cinfo.item).disconnect(cinfo.handle)
def disconnect(self, handle): exec_spec: Optional[UML.ExecutionSpecification] = self.line.subject del self.line.subject if exec_spec: exec_spec.unlink() diagram = self.diagram if self.line.parent is self.element: new_parent = self.element.parent self.line.parent = new_parent # type: ignore[assignment] for cinfo in diagram.connections.get_connections(connected=self.line): Connector(self.line, cinfo.item).disconnect(cinfo.handle)
def connect(self, handle, _port): parent_exec_spec = self.element.subject if not parent_exec_spec: # Can connect child exec spec if parent is not connected return True connected_item: Optional[UML.Presentation[UML.Element]] connected_item = self.get_connected(self.element.handles()[0]) assert connected_item Connector(connected_item, self.line).connect(handle, None) reparent(self.canvas, self.line, self.element) return True
def connect(self, sink): """Create connection at handle level and at model level.""" handle = self.handle item = self.item cinfo = self.connections.get_connection(handle) if cinfo and cinfo.connected is sink.item: # reconnect only constraint - leave model intact log.debug("performing reconnect constraint") self.glue(sink) constraint = sink.constraint(item, handle) self.connections.reconnect_item( item, handle, sink.port, constraint=constraint ) return adapter = Connector(sink.item, item) if cinfo: # first disconnect but disable disconnection handle as # reconnection is going to happen try: connect = adapter.reconnect except AttributeError: connect = adapter.connect else: cinfo.callback.disable = True self.disconnect() else: # new connection connect = adapter.connect self.glue(sink) if not sink.port: print("No port found", item, sink.item) return self.connect_handle(sink) # adapter requires both ends to be connected. connect(handle, sink.port) item.handle(ItemConnected(item, handle, sink.item, sink.port))
def connect(self, sink): """ Create connection at handle level and at model level. """ handle = self.handle item = self.item cinfo = item.canvas.get_connection(handle) try: callback = DisconnectHandle(self.item, self.handle) if cinfo and cinfo.connected is sink.item: # reconnect only constraint - leave model intact log.debug("performing reconnect constraint") constraint = sink.port.constraint(item.canvas, item, handle, sink.item) item.canvas.reconnect_item(item, handle, sink.port, constraint=constraint) elif cinfo: # first disconnect but disable disconnection handle as # reconnection is going to happen adapter = Connector(sink.item, item) try: connect = adapter.reconnect except AttributeError: connect = adapter.connect else: cinfo.callback.disable = True self.disconnect() # new connection self.connect_handle(sink, callback=callback) # adapter requires both ends to be connected. connect(handle, sink.port) else: # new connection adapter = Connector(sink.item, item) self.connect_handle(sink, callback=callback) adapter.connect(handle, sink.port) except Exception: log.error("Error during connect", exc_info=True)
def test_query(comment, commentline): assert Connector(comment, commentline)
def allow(self, sink): adapter = Connector(sink.item, self.item) return adapter and adapter.allow(self.handle, sink.port)
def test_connection_is_allowed(diagram, block_item, proxy_port_item): connector = Connector(block_item, proxy_port_item) assert isinstance(connector, BlockProperyProxyPortConnector) assert connector.allow(proxy_port_item.handles()[0], block_item.ports()[0])
otc = self.get_connected(opposite) if opposite and isinstance(otc, (ForkNodeItem, DecisionNodeItem)): adapter = Connector(otc, line) adapter.combine_nodes() def disconnect_subject(self, handle): super().disconnect_subject(handle) line = self.line opposite = line.opposite(handle) otc = self.get_connected(opposite) if opposite and isinstance(otc, (ForkNodeItem, DecisionNodeItem)): adapter = Connector(otc, line) adapter.decombine_nodes() Connector.register(ActionItem, FlowItem)(FlowConnect) Connector.register(ActivityNodeItem, FlowItem)(FlowConnect) Connector.register(ObjectNodeItem, FlowItem)(FlowConnect) Connector.register(SendSignalActionItem, FlowItem)(FlowConnect) Connector.register(AcceptEventActionItem, FlowItem)(FlowConnect) class FlowForkDecisionNodeConnect(FlowConnect): """Abstract class with common behaviour for Fork/Join node and Decision/Merge node.""" element: Union[ForkNodeItem, DecisionNodeItem] fork_node_cls: Type[UML.ControlNode] join_node_cls: Type[UML.ControlNode] def allow(self, handle, port):
def allow(line, handle, item, port=None) -> bool: if port is None and len(item.ports()) > 0: port = item.ports()[0] adapter = Connector(item, line) return adapter.allow(handle, port)