Struct portgraph::multiportgraph::MultiPortGraph

pub struct MultiPortGraph { /* private fields */ }

An unlabelled port graph that allows multiple links to the same ports.

A port graph consists of a collection of nodes identified by a NodeIndex. Each node has an ordered sequence of input and output ports, identified by a PortIndex that is unique within the graph. To optimize for the most common use case, the number of input and output ports of a node must be specified when the node is created. Multiple connections to the same PortIndex can be distinguished by their SubportIndex.

When a node and its associated ports are removed their indices will be reused on a best effort basis when a new node is added. The indices of unaffected nodes and ports remain stable.

Implementations

impl MultiPortGraph

pub fn new() -> Self

Create a new empty MultiPortGraph.

pub fn with_capacity(nodes: usize, ports: usize) -> Self

Create a new empty MultiPortGraph with preallocated capacity.

pub fn as_portgraph(&self) -> &PortGraph

Returns a reference to the internal plain portgraph.

This graph exposes the copy nodes as well as the main nodes.

pub fn pg_main_node(&self, node: NodeIndex) -> NodeIndex

Given a node in the underlying flat portgraph, returns the main node for it.

If the node is not a copy node, returns the node itself.

Trait Implementations

impl Clone for MultiPortGraph

fn clone(&self) -> MultiPortGraph

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MultiPortGraph

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MultiPortGraph

fn default() -> MultiPortGraph

Returns the “default value” for a type.

impl From<MultiPortGraph> for PortGraph

fn from(multi: MultiPortGraph) -> Self

Converts to this type from the input type.

impl From<PortGraph> for MultiPortGraph

fn from(graph: PortGraph) -> Self

Converts to this type from the input type.

impl LinkMut for MultiPortGraph

fn link_ports( &mut self, port_a: PortIndex, port_b: PortIndex ) -> Result<(SubportIndex, SubportIndex), LinkError>

Link an output port to an input port.

fn unlink_port(&mut self, port: PortIndex) -> Option<SubportIndex>

Unlinks all connections to the port. If the port was connected, returns one of the ports it was connected to.

fn link_nodes( &mut self, from: NodeIndex, from_output: usize, to: NodeIndex, to_input: usize ) -> Result<(Self::LinkEndpoint, Self::LinkEndpoint), LinkError>

Links two nodes at an input and output port offsets.

fn link_offsets( &mut self, node_a: NodeIndex, offset_a: PortOffset, node_b: NodeIndex, offset_b: PortOffset ) -> Result<(Self::LinkEndpoint, Self::LinkEndpoint), LinkError>

Links two nodes at an input and output port offsets.

fn insert_graph( &mut self, other: &impl LinkView ) -> Result<HashMap<NodeIndex, NodeIndex>, LinkError>

Inserts another graph into this graph.

impl LinkView for MultiPortGraph

type LinkEndpoint = SubportIndex

The identifier for the endpoints of a link.

type Neighbours<'a> = Neighbours<'a> where Self: 'a

Iterator over the neighbours of a node.

type NodeConnections<'a> = NodeConnections<'a> where Self: 'a

Iterator over the connections between two nodes.

type NodeLinks<'a> = NodeLinks<'a> where Self: 'a

Iterator over the links of a node. Returns pairs of source subport in the given node and target subport in the linked node.

type PortLinks<'a> = PortLinks<'a> where Self: 'a

Iterator over the links of a port. Returns pairs of source subport in the given ports and target subport in the linked port.

fn get_connections( &self, from: NodeIndex, to: NodeIndex ) -> Self::NodeConnections<'_>

Returns an iterator over every pair of matching ports connecting from with to.

fn port_links(&self, port: PortIndex) -> Self::PortLinks<'_>

Returns the port that the given port is linked to.

fn links(&self, node: NodeIndex, direction: Direction) -> Self::NodeLinks<'_>

Iterates over the connected links of the node in the given direction.

fn all_links(&self, node: NodeIndex) -> Self::NodeLinks<'_>

Iterates over the connected input and output links of the node in sequence.

fn neighbours( &self, node: NodeIndex, direction: Direction ) -> Self::Neighbours<'_>

Iterates over neighbour nodes in the given direction. May contain duplicates if the graph has multiple links between nodes.

fn all_neighbours(&self, node: NodeIndex) -> Self::Neighbours<'_>

Iterates over the input and output neighbours of the node in sequence.

fn link_count(&self) -> usize

Returns the number of links between ports.

fn get_connection( &self, from: NodeIndex, to: NodeIndex ) -> Option<(Self::LinkEndpoint, Self::LinkEndpoint)>

Checks whether there is a directed link between the two nodes and returns the first matching pair of ports.

fn connected(&self, from: NodeIndex, to: NodeIndex) -> bool

Checks whether there is a directed link between the two nodes.

fn port_link(&self, port: PortIndex) -> Option<Self::LinkEndpoint>

Return the link to the provided port, if not connected return None. If this port has multiple connected subports, an arbitrary one is returned.

fn input_links(&self, node: NodeIndex) -> Self::NodeLinks<'_>

Iterates over the connected input links of the node. Shorthand for LinkView::links.

fn output_links(&self, node: NodeIndex) -> Self::NodeLinks<'_>

Iterates over the connected output links of the node. Shorthand for LinkView::links.

fn input_neighbours(&self, node: NodeIndex) -> Self::Neighbours<'_>

Iterates over the input neighbours of the node. Shorthand for LinkView::neighbours.

fn output_neighbours(&self, node: NodeIndex) -> Self::Neighbours<'_>

Iterates over the output neighbours of the node. Shorthand for LinkView::neighbours.

impl MultiMut for MultiPortGraph

fn link_subports( &mut self, subport_from: SubportIndex, subport_to: SubportIndex ) -> Result<(), LinkError>

Link an output subport to an input subport.

fn unlink_subport(&mut self, subport: SubportIndex) -> Option<SubportIndex>

Unlinks the port and returns the subport it was linked to. Returns None when the port was not linked.

impl MultiView for MultiPortGraph

type NodeSubports<'a> = NodeSubports<'a> where Self: 'a

Iterator over all the subports of a node.

fn subport_link(&self, subport: SubportIndex) -> Option<SubportIndex>

Return the subport linked to the given port. If the port is not connected, return None.

fn subports( &self, node: NodeIndex, direction: Direction ) -> Self::NodeSubports<'_>

Iterates over all the subports of the node in the given direction.

fn all_subports(&self, node: NodeIndex) -> Self::NodeSubports<'_>

Iterates over the input and output subports of the node in sequence.

fn subport_inputs(&self, node: NodeIndex) -> Self::NodeSubports<'_>

Iterates over all the input subports of the node.

fn subport_outputs(&self, node: NodeIndex) -> Self::NodeSubports<'_>

Iterates over all the output subports of the node.

impl PartialEq for MultiPortGraph

fn eq(&self, other: &MultiPortGraph) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PortMut for MultiPortGraph

fn add_node(&mut self, incoming: usize, outgoing: usize) -> NodeIndex

Adds a node to the portgraph with a given number of input and output ports.

fn remove_node(&mut self, node: NodeIndex)

Remove a node from the port graph. All ports of the node will be unlinked and removed as well. Does nothing if the node does not exist.

fn clear(&mut self)

Removes all nodes and ports from the port graph.

fn reserve(&mut self, nodes: usize, ports: usize)

Reserves enough capacity to insert at least the given number of additional nodes and ports.

fn set_num_ports<F>( &mut self, node: NodeIndex, incoming: usize, outgoing: usize, rekey: F )

where F: FnMut(PortIndex, PortOperation),

Changes the number of ports of the node to the given incoming and outgoing counts.

fn compact_nodes<F>(&mut self, rekey: F)

where F: FnMut(NodeIndex, NodeIndex),

Compacts the storage of nodes in the portgraph as much as possible. Note that node indices won’t necessarily be consecutive after this process.

fn swap_nodes(&mut self, a: NodeIndex, b: NodeIndex)

Swaps the indices of two nodes.

fn compact_ports<F>(&mut self, rekey: F)

where F: FnMut(PortIndex, PortIndex),

Compacts the storage of ports in the portgraph as much as possible. Note that indices won’t necessarily be consecutive after this process.

fn shrink_to_fit(&mut self)

Shrinks the underlying buffers to the fit the data.

impl PortView for MultiPortGraph

type Nodes<'a> = Nodes<'a> where Self: 'a

Iterator over the nodes of the graph.

type Ports<'a> = Ports<'a> where Self: 'a

Iterator over the ports of the graph.

type NodePorts<'a> = NodePorts where Self: 'a

Iterator over the ports of a node.

type NodePortOffsets<'a> = NodePortOffsets where Self: 'a

Iterator over the port offsets in a node.

fn port_direction(&self, port: impl Into<PortIndex>) -> Option<Direction>

Returns the direction of the port.

fn port_node(&self, port: impl Into<PortIndex>) -> Option<NodeIndex>

Returns the node that the port belongs to.

fn port_offset(&self, port: impl Into<PortIndex>) -> Option<PortOffset>

Returns the index of a port within its node’s port list.

fn port_index(&self, node: NodeIndex, offset: PortOffset) -> Option<PortIndex>

Returns the port index for a given node, direction, and offset.

fn ports(&self, node: NodeIndex, direction: Direction) -> Self::NodePorts<'_>

Iterates over all the ports of the node in the given direction.

fn all_ports(&self, node: NodeIndex) -> Self::NodePorts<'_>

Iterates over the input and output ports of the node in sequence.

fn input(&self, node: NodeIndex, offset: usize) -> Option<PortIndex>

Returns the input port at the given offset in the node.

fn output(&self, node: NodeIndex, offset: usize) -> Option<PortIndex>

Returns the output port at the given offset in the node.

fn num_ports(&self, node: NodeIndex, direction: Direction) -> usize

Returns the number of ports of the node in the given direction.

fn port_offsets( &self, node: NodeIndex, direction: Direction ) -> Self::NodePortOffsets<'_>

Iterates over all the port offsets of the node in the given direction.

fn all_port_offsets(&self, node: NodeIndex) -> Self::NodePortOffsets<'_>

Iterates over the input and output port offsets of the node in sequence.

fn contains_node(&self, node: NodeIndex) -> bool

Returns whether the port graph contains the node.

fn contains_port(&self, port: PortIndex) -> bool

Returns whether the port graph contains the port.

fn is_empty(&self) -> bool

Returns whether the port graph has no nodes nor ports.

fn node_count(&self) -> usize

Returns the number of nodes in the port graph.

fn port_count(&self) -> usize

Returns the number of ports in the port graph.

fn nodes_iter(&self) -> Self::Nodes<'_>

Iterates over the nodes in the port graph.

fn ports_iter(&self) -> Self::Ports<'_>

Iterates over the ports in the port graph.

fn node_capacity(&self) -> usize

Returns the capacity of the underlying buffer for nodes.

fn port_capacity(&self) -> usize

Returns the capacity of the underlying buffer for ports.

fn node_port_capacity(&self, node: NodeIndex) -> usize

Returns the allocated port capacity for a specific node.

fn inputs(&self, node: NodeIndex) -> Self::NodePorts<'_>

Iterates over all the input ports of the node.

fn outputs(&self, node: NodeIndex) -> Self::NodePorts<'_>

Iterates over all the output ports of the node.

fn num_inputs(&self, node: NodeIndex) -> usize

Returns the number of input ports of the node.

fn num_outputs(&self, node: NodeIndex) -> usize

Returns the number of output ports of the node.

fn input_offsets(&self, node: NodeIndex) -> Self::NodePortOffsets<'_>

Iterates over all the input port offsets of the node.

fn output_offsets(&self, node: NodeIndex) -> Self::NodePortOffsets<'_>

Iterates over all the output port offsets of the node.

impl StructuralPartialEq for MultiPortGraph