Struct PortGraph 

pub struct PortGraph<N: IndexBase = u32, P: IndexBase = u32, PO: IndexBase = u16> { /* private fields */ }

An unlabelled port graph.

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.

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. PortGraph::compact_nodes and PortGraph::compact_ports to eliminate fragmentation in the index space.

Generic parameters

• N: The unsigned integer type used for node indices.
• P: The unsigned integer type used for port indices.
• PO: The unsigned integer type used for port offsets.

Implementations

impl<N: IndexBase, P: IndexBase, PO: IndexBase> PortGraph<N, P, PO>

pub fn new() -> Self

Create a new empty PortGraph.

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

Create a new empty PortGraph with preallocated capacity.

Trait Implementations

impl<N: Clone + IndexBase, P: Clone + IndexBase, PO: Clone + IndexBase> Clone for PortGraph<N, P, PO>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: IndexBase, P: IndexBase, PO: IndexBase> Debug for PortGraph<N, P, PO>

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

Formats the value using the given formatter.

impl<N: IndexBase, P: IndexBase, PO: IndexBase> Default for PortGraph<N, P, PO>

fn default() -> Self

Returns the “default value” for a type.

impl<N: IndexBase, P: IndexBase, PO: IndexBase> From<MultiPortGraph<N, P, PO>> for PortGraph<N, P, PO>

fn from(multi: MultiPortGraph<N, P, PO>) -> Self

Converts to this type from the input type.

impl<N: IndexBase, P: IndexBase, PO: IndexBase> From<PortGraph<N, P, PO>> for MultiPortGraph<N, P, PO>

fn from(graph: PortGraph<N, P, PO>) -> Self

Converts to this type from the input type.

impl<N: IndexBase, P: IndexBase, PO: IndexBase> LinkMut for PortGraph<N, P, PO>

fn link_ports( &mut self, port_a: PortIndex<P>, port_b: PortIndex<P>, ) -> Result<(Self::LinkEndpoint, Self::LinkEndpoint), LinkError<N, P, PO>>

Link an output port to an input port.

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

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<Self::NodeIndexBase>, from_output: usize, to: NodeIndex<Self::NodeIndexBase>, to_input: usize, ) -> Result<(Self::LinkEndpoint, Self::LinkEndpoint), LinkError<Self::NodeIndexBase, Self::PortIndexBase, Self::PortOffsetBase>>

Links two nodes at an input and output port offsets.

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

Links two nodes at an input and output port offsets.

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

Inserts another graph into this graph.

impl<N: IndexBase, P: IndexBase, PO: IndexBase> LinkView for PortGraph<N, P, PO>

type LinkEndpoint = PortIndex<P>

The identifier for the endpoints of a link.

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

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

fn link_count(&self) -> usize

Returns the number of links between ports.

fn get_connections( &self, from: NodeIndex<N>, to: NodeIndex<N>, ) -> 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 links( &self, node: NodeIndex<N>, 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<N>, ) -> 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<N>, direction: Direction, ) -> impl Iterator<Item = NodeIndex<N>> + 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<N>, ) -> impl Iterator<Item = NodeIndex<N>> + Clone

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

fn get_connection( &self, from: NodeIndex<Self::NodeIndexBase>, to: NodeIndex<Self::NodeIndexBase>, ) -> 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<Self::NodeIndexBase>, to: NodeIndex<Self::NodeIndexBase>, ) -> bool

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

fn port_link( &self, port: PortIndex<Self::PortIndexBase>, ) -> 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::NodeIndexBase>, ) -> 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<Self::NodeIndexBase>, ) -> 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<Self::NodeIndexBase>, ) -> impl Iterator<Item = NodeIndex<Self::NodeIndexBase>> + Clone

Iterates over the input neighbours of the node.

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

Iterates over the output neighbours of the node.

impl<N: PartialEq + IndexBase, P: PartialEq + IndexBase, PO: PartialEq + IndexBase> PartialEq for PortGraph<N, P, PO>

fn eq(&self, other: &PortGraph<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<N: IndexBase, P: IndexBase, PO: IndexBase> PortMut for PortGraph<N, P, PO>

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

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

fn remove_node(&mut self, node: NodeIndex<N>)

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<N>, incoming: usize, outgoing: usize, rekey: F, )

where F: FnMut(PortIndex<P>, PortOperation<P>),

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<N>, NodeIndex<N>),

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<N>, b: NodeIndex<N>)

Swaps the indices of two nodes.

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

where F: FnMut(PortIndex<P>, PortIndex<P>),

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<N: IndexBase, P: IndexBase, PO: IndexBase> PortView for PortGraph<N, P, PO>

type NodeIndexBase = N

The base unsigned integer type for node indices.

type PortIndexBase = P

The base unsigned integer type for port indices.

type PortOffsetBase = PO

The base unsigned integer type for port offsets.

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

Returns the direction of the port.

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

Returns the node that the port belongs to.

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

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

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

Returns the port index for a given node and offset.

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

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

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

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

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

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

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

Returns whether the port graph contains the node.

fn contains_port(&self, port: PortIndex<P>) -> 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 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<N>) -> usize

Returns the allocated port capacity for a specific node.

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

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

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

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

fn port_offsets( &self, node: NodeIndex<N>, 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<N>, ) -> impl Iterator<Item = PortOffset<PO>> + Clone

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

fn nodes_iter(&self) -> impl Iterator<Item = NodeIndex<N>> + Clone

Iterates over the nodes in the port graph.

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

Iterates over the ports in the port graph.

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

Iterates over all the input ports of the node.

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

Iterates over all the output ports of the node.

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

Returns the number of input ports of the node.

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

Returns the number of output ports of the node.

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

Iterates over all the input port offsets of the node.

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

Iterates over all the output port offsets of the node.

impl<N: IndexBase, P: IndexBase, PO: IndexBase> StructuralPartialEq for PortGraph<N, P, PO>