Struct MultiPortGraph 

pub struct MultiPortGraph<N: Unsigned = u32, P: Unsigned = u32, PO: Unsigned = u16> { /* 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<PO: Unsigned> MultiPortGraph<u32, u32, PO>

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<u32, u32, PO>

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<N: Clone + Unsigned, P: Clone + Unsigned, PO: Clone + Unsigned> Clone for MultiPortGraph<N, P, PO>

fn clone(&self) -> MultiPortGraph<N, P, PO>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<PO: Unsigned> Debug for MultiPortGraph<u32, u32, PO>

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

Formats the value using the given formatter.

impl<N: Default + Unsigned, P: Default + Unsigned, PO: Default + Unsigned> Default for MultiPortGraph<N, P, PO>

fn default() -> MultiPortGraph<N, P, PO>

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<PO: Unsigned> LinkMut for MultiPortGraph<u32, u32, PO>

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

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<Self::PortOffsetBase>>

Links two nodes at an input and output port offsets.

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

Links two nodes at an input and output port offsets.

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

Inserts another graph into this graph.

impl<PO: Unsigned> LinkView for MultiPortGraph<u32, u32, PO>

type LinkEndpoint = SubportIndex

The identifier for the endpoints of a link.

fn link_count(&self) -> usize

Returns the number of links between ports.

fn get_connections( &self, from: NodeIndex, to: NodeIndex, ) -> impl Iterator<Item = (Self::LinkEndpoint, Self::LinkEndpoint)> + Clone

Returns an iterator over every pair of matching ports connecting from to to, i.e. in that direction.

fn port_links( &self, port: PortIndex, ) -> impl Iterator<Item = (Self::LinkEndpoint, Self::LinkEndpoint)> + Clone

Returns the port (or ports if this is a MultiView) that the given port is linked to.

fn links( &self, node: NodeIndex, direction: Direction, ) -> impl Iterator<Item = (Self::LinkEndpoint, Self::LinkEndpoint)> + Clone

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

fn all_links( &self, node: NodeIndex, ) -> impl Iterator<Item = (Self::LinkEndpoint, Self::LinkEndpoint)> + Clone

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

fn neighbours( &self, node: NodeIndex, direction: Direction, ) -> impl Iterator<Item = NodeIndex> + Clone

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, ) -> impl Iterator<Item = NodeIndex> + Clone

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

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, ) -> impl Iterator<Item = (Self::LinkEndpoint, Self::LinkEndpoint)> + Clone

Iterates over the connected input links of the node. Shorthand for LinkView::links(Direction::Incoming).

fn output_links( &self, node: NodeIndex, ) -> impl Iterator<Item = (Self::LinkEndpoint, Self::LinkEndpoint)> + Clone

Iterates over the connected output links of the node. Shorthand for LinkView::links(Direction::Outgoing)..

fn input_neighbours( &self, node: NodeIndex, ) -> impl Iterator<Item = NodeIndex> + Clone

Iterates over the input neighbours of the node.

fn output_neighbours( &self, node: NodeIndex, ) -> impl Iterator<Item = NodeIndex> + Clone

Iterates over the output neighbours of the node.

impl<PO: Unsigned> MultiMut for MultiPortGraph<u32, u32, PO>

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

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<PO: Unsigned> MultiView for MultiPortGraph<u32, u32, PO>

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, ) -> impl Iterator<Item = SubportIndex> + Clone

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

fn all_subports( &self, node: NodeIndex, ) -> impl Iterator<Item = SubportIndex> + Clone

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

fn subport_inputs( &self, node: NodeIndex, ) -> impl Iterator<Item = Self::LinkEndpoint> + Clone

Iterates over all the input subports of the node.

fn subport_outputs( &self, node: NodeIndex, ) -> impl Iterator<Item = Self::LinkEndpoint> + Clone

Iterates over all the output subports of the node.

impl<N: PartialEq + Unsigned, P: PartialEq + Unsigned, PO: PartialEq + Unsigned> PartialEq for MultiPortGraph<N, P, PO>

fn eq(&self, other: &MultiPortGraph<N, P, PO>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<PO: Unsigned> PortMut for MultiPortGraph<u32, u32, PO>

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<PO: Unsigned> PortView for MultiPortGraph<u32, u32, PO>

type PortOffsetBase = PO

The base unsigned integer type for port offsets.

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) -> impl Iterator<Item = NodeIndex> + Clone

Iterates over the nodes in the port graph.

fn ports_iter(&self) -> impl Iterator<Item = PortIndex> + Clone

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 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<PO>>

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

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

Returns the port index for a given node and offset.

fn ports( &self, node: NodeIndex, direction: Direction, ) -> impl Iterator<Item = PortIndex> + Clone

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

fn all_ports(&self, node: NodeIndex) -> impl Iterator<Item = PortIndex> + Clone

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, ) -> impl Iterator<Item = PortOffset<PO>> + Clone

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

fn all_port_offsets( &self, node: NodeIndex, ) -> impl Iterator<Item = PortOffset<PO>> + Clone

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

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

Returns the allocated port capacity for a specific node.

fn inputs(&self, node: NodeIndex) -> impl Iterator<Item = PortIndex> + Clone

Iterates over all the input ports of the node.

fn outputs(&self, node: NodeIndex) -> impl Iterator<Item = PortIndex> + Clone

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, ) -> impl Iterator<Item = PortOffset<Self::PortOffsetBase>> + Clone

Iterates over all the input port offsets of the node.

fn output_offsets( &self, node: NodeIndex, ) -> impl Iterator<Item = PortOffset<Self::PortOffsetBase>> + Clone

Iterates over all the output port offsets of the node.

impl<N: Unsigned, P: Unsigned, PO: Unsigned> StructuralPartialEq for MultiPortGraph<N, P, PO>