Portgraph

https://docs.rs/portgraph/0.16.0/
Admin
Portgraph is a data structure library for graphs with node ports, enabling efficient representation...
Tokens:627,142
Snippets:2,792
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Perform topological sort on a PortGraph

Source: https://docs.rs/portgraph/0.16.0/portgraph/algorithms/fn.toposort.html

Example demonstrating how to initialize a PortGraph and execute a topological sort starting from a specific node.

```rust
let mut graph: PortGraph = PortGraph::new();
let node_a = graph.add_node(2, 2);
let node_b = graph.add_node(2, 2);
let node_c = graph.add_node(2, 2);
graph.link_nodes(node_a, 0, node_b, 0).unwrap();
graph.link_nodes(node_a, 1, node_c, 0).unwrap();

// Run a topological sort on the graph starting at node A.
let topo: TopoSort<_> = toposort(&graph, [node_a], Direction::Outgoing);
assert_eq!(topo.collect::<Vec<_>>(), [node_a, node_b, node_c]);
```

--------------------------------

### Example Usage

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/weights.rs.html

Demonstrates how to create, populate, and access weights for nodes and ports in a PortGraph.

```APIDOC
## Example

```rust
# use ::portgraph::*
# type PortGraph = ::portgraph::PortGraph<u32, u32, u16>;
# type Weights<N, P> = ::portgraph::Weights<N, P, u32, u32>;
let mut graph: PortGraph = PortGraph::new();
let mut weights = Weights::<usize, isize>::new();

// The weights must be set manually.
let node = graph.add_node(2, 2);
let [in0, in1, ..] = graph.inputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
let [out0, out1, ..] = graph.outputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
weights[node] = 42;
weights[in1] = 2;
weights[out0] = -1;
weights[out1] = -2;

/// Unset weights return the default value.
assert_eq!(weights[in0], 0);

// Graph operations that modify the keys have callbacks to update the weights.
graph.set_num_ports(node, 1, 3, |old, op| {
    op.new_index().map(|new| weights.ports.swap(old, new));
});

// The map does not track item removals, but the user can shrink it manually.
graph.remove_node(node);
weights.nodes.shrink_to(graph.node_count());
weights.ports.shrink_to(graph.port_count());
```
```

--------------------------------

### Add Node Example

Source: https://docs.rs/portgraph/0.16.0/portgraph/trait.PortMut.html

Demonstrates adding a node with specific input and output port counts.

```rust
let mut g: PortGraph = PortGraph::new();
let node = g.add_node(4, 3);
assert_eq!(g.inputs(node).count(), 4);
assert_eq!(g.outputs(node).count(), 3);
assert!(g.contains_node(node));
```

--------------------------------

### Link Ports Example

Source: https://docs.rs/portgraph/0.16.0/portgraph/trait.LinkMut.html

Demonstrates linking an output port to an input port using the link_ports method.

```rust
let mut g: PortGraph = PortGraph::new();
let node0 = g.add_node(0, 1);
let node1 = g.add_node(1, 0);
let node0_output = g.output(node0, 0).unwrap();
let node1_input = g.input(node1, 0).unwrap();
g.link_ports(node0_output, node1_input).unwrap();
assert_eq!(g.port_link(node0_output), Some(node1_input));
assert_eq!(g.port_link(node1_input), Some(node0_output));
```

--------------------------------

### Handle Link Errors

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Initial setup for testing error conditions when linking ports.

```rust
#[test]
fn link_ports_errors() {
    let mut g: PortGraph = PortGraph::new();
    let node0 = g.add_node(1, 1);
    let node1 = g.add_node(1, 1);
```

--------------------------------

### UnmanagedDenseMap Usage Example

Source: https://docs.rs/portgraph/0.16.0/portgraph/unmanaged/index.html

Demonstrates how to create, populate, and manage weights using UnmanagedDenseMap with PortGraph.

```APIDOC
## Example Usage of UnmanagedDenseMap with PortGraph

### Description
This example illustrates the creation and usage of `UnmanagedDenseMap` for storing node and port weights within a `PortGraph`. It covers adding nodes, setting weights, accessing default values for unset weights, and updating weights during graph modifications.

### Method
N/A (Illustrative Example)

### Endpoint
N/A (Illustrative Example)

### Parameters
N/A (Illustrative Example)

### Request Body
N/A (Illustrative Example)

### Request Example
```rust
let mut graph: PortGraph = PortGraph::new();
let mut node_weights = UnmanagedDenseMap::<NodeIndex, usize>::new();
let mut port_weights = UnmanagedDenseMap::<PortIndex, isize>::new();

let node = graph.add_node(2, 2);
let [in0, in1, ..] = graph.inputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
let [out0, out1, ..] = graph.outputs(node).collect::<Vec<_>>()[..] else { unreachable!() };

node_weights[node] = 42;
port_weights[in1] = 2;
port_weights[out0] = -1;
port_weights[out1] = -2;

assert_eq!(port_weights[in0], 0);

graph.set_num_ports(node, 1, 3, |old, op| {
    op.new_index().map(|new| port_weights.swap(old, new));
});

graph.remove_node(node);
node_weights.shrink_to(graph.node_count());
port_weights.shrink_to(graph.port_count());
```

### Response
N/A (Illustrative Example)

### Response Example
N/A (Illustrative Example)
```

--------------------------------

### Render PortGraph to Mermaid

Source: https://docs.rs/portgraph/0.16.0/portgraph/render/struct.MermaidFormatter.html

Example showing how to construct a graph, define a hierarchy, and generate a mermaid string.

```rust
let mut graph: PortGraph = PortGraph::new();
let n1 = graph.add_node(3, 2);
let n2 = graph.add_node(0, 1);
let n3 = graph.add_node(1, 0);
graph.link_nodes(n2, 0, n3, 0).unwrap();

let mut hier = Hierarchy::new();
hier.push_child(n2, n1).unwrap();
hier.push_child(n3, n1).unwrap();

let mermaid = graph.mermaid_format().with_hierarchy(&hier).finish();
```

--------------------------------

### Remove Node Example

Source: https://docs.rs/portgraph/0.16.0/portgraph/trait.PortMut.html

Demonstrates removing a node and verifying that associated ports are unlinked.

```rust
let mut g: PortGraph = PortGraph::new();
let node0 = g.add_node(1, 1);
let node1 = g.add_node(1, 1);
let out0 = g.outputs(node0).nth(0).unwrap();
let out1 = g.outputs(node1).nth(0).unwrap();
let in0 = g.inputs(node0).nth(0).unwrap();
let in1 = g.inputs(node1).nth(0).unwrap();
g.link_ports(out0, in1);
g.link_ports(out1, in0);
g.remove_node(node0);
assert!(!g.contains_node(node0));
assert!(g.port_link(g.outputs(node1).nth(0).unwrap()).is_none());
assert!(g.port_link(g.inputs(node1).nth(0).unwrap()).is_none());
```

--------------------------------

### Initialize DotFormatter

Source: https://docs.rs/portgraph/0.16.0/portgraph/render/trait.DotFormat.html

Use `dot_format` to get a `DotFormatter` instance for the graph. This is the required method for the `DotFormat` trait.

```rust
fn dot_format(&self) -> DotFormatter<'_, Self>
```

--------------------------------

### Mermaid Graph Definition Example

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/render/mermaid.rs.html

This is an example of a Mermaid graph definition. It specifies the direction and nodes with connections.

```mermaid
graph LR
1[1]
1-->2
2[2]
```

--------------------------------

### Get Outgoing Port Index

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Convenience function to get an outgoing port index by node and offset.

```rust
fn output(&self, node: NodeIndex<N>, offset: usize) -> Option<PortIndex<P>> {
        self.port_index(node, PortOffset::new_outgoing(offset))
    }
```

--------------------------------

### PortGraph Hierarchy Example

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/hierarchy.rs.html

Demonstrates adding nodes, establishing parent-child relationships, and managing the hierarchy. Shows how to insert nodes before others and how to handle node removal and re-keying after graph modifications.

```rust
# use ::portgraph::*
# use ::portgraph::PortGraph;
# use ::portgraph::Hierarchy;
let mut graph: PortGraph = PortGraph::new();
let mut hierarchy = Hierarchy::new();

let parent = graph.add_node(0, 0);
assert!(hierarchy.is_root(parent));
assert_eq!(hierarchy.child_count(parent), 0);

// Add some children.
let child_0 = graph.add_node(0, 0);
let child_1 = graph.add_node(0, 0);
hierarchy.push_child(child_1, parent).unwrap();
hierarchy.insert_before(child_0, child_1).unwrap();

assert_eq!(hierarchy.child_count(parent), 2);
assert_eq!(hierarchy.children(parent).collect::<Vec<_>>(), vec![child_0, child_1]);

assert_eq!(hierarchy.parent(child_0), Some(parent));
assert_eq!(hierarchy.prev(child_0), None);
assert_eq!(hierarchy.next(child_0), Some(child_1));

// Modifications to the graph must be manually propagated to the hierarchy.
graph.remove_node(parent);
hierarchy.remove(parent);

assert!(hierarchy.is_root(child_0));
assert!(hierarchy.is_root(child_1));
assert_eq!(hierarchy.next(child_0), None);

graph.compact_nodes(|old, new| {
    hierarchy.rekey(old, new);
});
hierarchy.shrink_to(graph.node_count());

```

--------------------------------

### Initialize and Link Nodes in PortGraph

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Sets up a PortGraph by adding nodes with specified input and output ports, and then establishing links between them. This is a foundational step for building graph structures.

```rust
let mut g: PortGraph = PortGraph::new();
        let x = g.add_node(3, 2);
        let a = g.add_node(1, 1);
        let b = g.add_node(2, 2);
        let c = g.add_node(1, 1);
        g.link_nodes(a, 0, b, 0).unwrap();
        g.link_nodes(b, 0, b, 1).unwrap();
        g.link_nodes(b, 1, c, 0).unwrap();
        g.link_nodes(c, 0, a, 0).unwrap();
```

```rust
let mut g: PortGraph = PortGraph::new();
        // Add dummy nodes to produce different node ids than in the other graph.
        g.add_node(0, 0);
        g.add_node(0, 0);
        let node0g = g.add_node(1, 1);
        let node1g = g.add_node(1, 1);
        g.link_nodes(node0g, 0, node1g, 0)?;
```

```rust
let mut g: PortGraph = PortGraph::new();
        let n0 = g.add_node(0, 2);
        let n1 = g.add_node(2, 1);
        g.link_nodes(n0, 0, n1, 0).unwrap();
```

--------------------------------

### Get Incoming Port Index

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Convenience function to get an incoming port index by node and offset.

```rust
fn input(&self, node: NodeIndex<N>, offset: usize) -> Option<PortIndex<P>> {
        self.port_index(node, PortOffset::new_incoming(offset))
    }
```

--------------------------------

### Mermaid Diagram Output Example

Source: https://docs.rs/portgraph/0.16.0/portgraph/render/trait.MermaidFormat.html

This is an example of the mermaid string output generated by the `mermaid_format` method when including hierarchy.

```mermaid
graph LR
    subgraph 0 [0]
        direction LR
        1[1]
        1-->2
        2[2]
    end
```

--------------------------------

### Using Weights with PortGraph

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/weights.rs.html

Demonstrates how to initialize weights, assign values to nodes and ports, and handle weight updates during graph modifications.

```rust
# use ::portgraph::*;
# type PortGraph = ::portgraph::PortGraph<u32, u32, u16>;
# type Weights<N, P> = ::portgraph::Weights<N, P, u32, u32>;
let mut graph: PortGraph = PortGraph::new();
let mut weights = Weights::<usize, isize>::new();

// The weights must be set manually.
let node = graph.add_node(2, 2);
let [in0, in1, ..] = graph.inputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
let [out0, out1, ..] = graph.outputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
weights[node] = 42;
weights[in1] = 2;
weights[out0] = -1;
weights[out1] = -2;

/// Unset weights return the default value.
assert_eq!(weights[in0], 0);

// Graph operations that modify the keys have callbacks to update the weights.
graph.set_num_ports(node, 1, 3, |old, op| {
    op.new_index().map(|new| weights.ports.swap(old, new));
});

// The map does not track item removals, but the user can shrink it manually.
graph.remove_node(node);
weights.nodes.shrink_to(graph.node_count());
weights.ports.shrink_to(graph.port_count());
```

--------------------------------

### Starting a Subgraph in MermaidBuilder in Rust

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/render/mermaid.rs.html

Starts a new subgraph block in the Mermaid definition. It applies styling to the subgraph and increases the indentation level. Call `end_subgraph` to close the block. Subgraphs can be nested.

```rust
pub fn start_subgraph(&mut self, node: NodeIndex<G::NodeIndexBase>) {
    let style = self
        .node_style
        .as_mut()
        .map_or_else(NodeStyle::default, |f| f(node));
    let id = node.index().to_string();

    match &style {
        NodeStyle::Hidden => self.push_strings(&["subgraph ", id.as_ref(), " [ ]"]),
        NodeStyle::Boxed { label, .. } => self.push_strings(&[
            "subgraph ",
            id.as_ref(),
            " [",
            &encode_label(&id, label),
            "]",
        ]),
    }
    self.indent += 1;
    self.push_line("direction LR");

    if !style.attrs().is_empty() {

```

--------------------------------

### get

Source: https://docs.rs/portgraph/0.16.0/portgraph/multiportgraph/struct.Nodes.html

Returns an iterator over a subsection of the iterator.

```APIDOC
## fn get<R>(self, index: R) -> <R as IteratorIndex<Self>>::Output

### Description
Returns an iterator over a subsection of the iterator.

### Method
N/A (Function on iterator)

### Endpoint
N/A

### Parameters
- **index** (R) - Description: The index or range specifying the subsection.

### Request Example
N/A

### Response
- **<R as IteratorIndex<Self>>::Output** (Iterator) - Description: An iterator over the specified subsection.
```

--------------------------------

### Working with MultiPortGraph Regions

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/view/region.rs.html

Shows how to initialize a region from a MultiPortGraph and query subports.

```rust
// Multiports
        let multigraph = MultiPortGraph::from(graph);
        let region = Region::new(&multigraph, &hierarchy, root);
        let a_o1 = SubportIndex::new_unique(a_o1);
        assert_eq!(
            region.all_subports(a).collect_vec(),
            multigraph.all_subports(a).collect_vec()
        );
        assert_eq!(
            region.subports(a, Direction::Incoming).collect_vec(),
            multigraph.subports(a, Direction::Incoming).collect_vec()
        );
        assert_eq!(region.subport_link(a_o1), multigraph.subport_link(a_o1));

        Ok(())
    }
}
```

--------------------------------

### Get Iterator Section

Source: https://docs.rs/portgraph/0.16.0/portgraph/unmanaged/struct.UnmanagedIter.html

Method for retrieving a subsection of an iterator.

```APIDOC
## fn get<R>(self, index: R) -> <R as IteratorIndex<Self>>::Output
where Self: Sized,
R: IteratorIndex<Self>,

### Description
Returns an iterator over a subsection of the iterator.

### Method
`get`

### Endpoint
N/A (Iterator method)

### Parameters
- **index** (R): An index type that implements `IteratorIndex`.

### Response
The output type determined by the `IteratorIndex` implementation.
```

--------------------------------

### Initialize and Use UnmanagedDenseMap

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/unmanaged.rs.html

Demonstrates initializing UnmanagedDenseMap for nodes and ports, setting weights, and handling unset values. It also shows how the map interacts with graph operations like set_num_ports and node removal, including manual shrinking.

```rust
let mut graph: PortGraph = PortGraph::new();
let mut node_weights = UnmanagedDenseMap::<NodeIndex, usize>::new();
let mut port_weights = UnmanagedDenseMap::<PortIndex, isize>::new();

// The weights must be set manually.
let node = graph.add_node(2, 2);
let [in0, in1, ..] = graph.inputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
let [out0, out1, ..] = graph.outputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
node_weights[node] = 42;
port_weights[in1] = 2;
port_weights[out0] = -1;
port_weights[out1] = -2;

/// Unset weights return the default value.
assert_eq!(port_weights[in0], 0);

// Graph operations that modify the keys use callbacks to update the weights.
graph.set_num_ports(node, 1, 3, |old, op| {
    op.new_index().map(|new| port_weights.swap(old, new));
});

// The map does not track item removals, but the user can shrink the map manually.
graph.remove_node(node);
node_weights.shrink_to(graph.node_count());
port_weights.shrink_to(graph.port_count());

```

--------------------------------

### Get Sub-iterator

Source: https://docs.rs/portgraph/0.16.0/portgraph/algorithms/struct.PostOrder.html

Returns an iterator over a subsection of the original iterator.

```APIDOC
## fn get<R>(self, index: R) -> <R as IteratorIndex<Self>>::Output

### Description
Returns an iterator over a subsection of the iterator.

### Method
`get`

### Endpoint
N/A (Method on Iterator)

### Parameters
#### Query Parameters
- **index** (R: IteratorIndex<Self>) - Required - The index or range to get the subsection from.
```

--------------------------------

### Create and manipulate a PortGraph

Source: https://docs.rs/portgraph/0.16.0/index.html

Demonstrates initializing a PortGraph, adding nodes with specific port counts, linking ports, and performing a topological sort.

```rust
use ::portgraph::*;
use ::portgraph::algorithms::{toposort, TopoSort};

type PortGraph = ::portgraph::PortGraph<u32, u32, u16>;

// Create a graph with two nodes, each with two input and two output ports
let mut graph: PortGraph = PortGraph::new();
let node_a = graph.add_node(2, 2);
let node_b = graph.add_node(2, 2);

// Link the first output port of node A to the first input port of node B
graph.link_nodes(node_a, 0, node_b, 0).unwrap();

// Get globally unique indices for the ports, and link them directly
let port_a = graph.output(node_a, 1).unwrap();
let port_b = graph.input(node_b, 1).unwrap();
graph.link_ports(port_a, port_b).unwrap();

// Run a topological sort on the graph starting at node A.
let topo: TopoSort<_> = toposort(&graph, [node_a], Direction::Outgoing);
assert_eq!(topo.collect::<Vec<_>>(), [node_a, node_b]);
```

--------------------------------

### Get Child Count

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/hierarchy.rs.html

Returns the number of direct children a node has.

```rust
pub fn child_count(&self, node: NodeIndex<N>) -> usize {
        self.get(node).children_count.to_usize()
    }
```

--------------------------------

### Get Filter Context

Source: https://docs.rs/portgraph/0.16.0/portgraph/view/filter/type.NodeFiltered.html

Retrieves a reference to the context associated with the filter.

```rust
pub fn context(&self) -> &Ctx

```

--------------------------------

### DotFormatter Initialization and Configuration

Source: https://docs.rs/portgraph/0.16.0/portgraph/render/struct.DotFormatter.html

Demonstrates how to initialize and configure the DotFormatter for a PortGraph.

```APIDOC
## Struct DotFormatter

Configurable mermaid formatter for a `PortGraph`.

### `new(graph: &'g G) -> Self`

Initialize a new `DotFormatter` for `graph`.

### `with_hierarchy(self, forest: &'g Hierarchy<G::NodeIndexBase>) -> Self`

Set the `Hierarchy` to use for the graph.

### `with_node_style(self, node_style: impl FnMut(NodeIndex<G::NodeIndexBase>) -> NodeStyle + 'g) -> Self`

Set the function to use to get the style of a node.

### `with_port_style(self, port_style: impl FnMut(PortIndex<G::PortIndexBase>) -> PortStyle + 'g) -> Self`

Set the function to use to get the style of a port.

### `with_edge_style(self, edge_style: impl FnMut(G::LinkEndpoint, G::LinkEndpoint) -> EdgeStyle + 'g) -> Self`

Set the function to use to get the style of an edge.

### `with_weights<'w, N, P>(self, weights: &'w Weights<N, P, G::NodeIndexBase, G::PortIndexBase>) -> Self`

Encode some `Weights` in the dot format.
This is a convenience method to set the node and port styles based on the weight values. It overrides any previous node or port style set.

### `finish(self) -> String`

Encode the graph in dot format.
```

--------------------------------

### Initialize PortGraph and Hierarchy for testing

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/view/flat_region.rs.html

Sets up a PortGraph and Hierarchy with multiple nodes and links for testing region functionalities. Includes error handling for link operations.

```rust
let mut graph = PortGraph::new();
        let other = graph.add_node(42, 0);
        let root = graph.add_node(1, 0);
        let a = graph.add_node(1, 2);
        let b = graph.add_node(0, 0);
        let c = graph.add_node(0, 0);
        graph.link_nodes(a, 0, other, 0)?;
        graph.link_nodes(a, 1, root, 0)?;
```

```rust
let mut hierarchy = Hierarchy::new();
        hierarchy.push_child(root, other)?;
        hierarchy.push_child(a, root)?;
        hierarchy.push_child(b, root)?;
        hierarchy.push_child(c, b)?;
```

--------------------------------

### Get Port Count

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Returns the total number of ports currently in the graph.

```rust
fn port_count(&self) -> usize {
        self.port_count
    }
```

--------------------------------

### Create and Link Nodes in PortGraph

Source: https://docs.rs/portgraph/0.16.0/portgraph

Demonstrates creating a PortGraph with typed nodes and ports, adding nodes, and linking them. Use this to set up basic graph structures.

```rust
use ::portgraph::*
use ::portgraph::algorithms::{toposort, TopoSort};

type PortGraph = ::portgraph::PortGraph<u32, u32, u16>;

// Create a graph with two nodes, each with two input and two output ports
let mut graph: PortGraph = PortGraph::new();
let node_a = graph.add_node(2, 2);
let node_b = graph.add_node(2, 2);

// Link the first output port of node A to the first input port of node B
graph.link_nodes(node_a, 0, node_b, 0).unwrap();

// Get globally unique indices for the ports, and link them directly
let port_a = graph.output(node_a, 1).unwrap();
let port_b = graph.input(node_b, 1).unwrap();
graph.link_ports(port_a, port_b).unwrap();

// Run a topological sort on the graph starting at node A.
let topo: TopoSort<_> = toposort(&graph, [node_a], Direction::Outgoing);
assert_eq!(topo.collect::<Vec<_>>(), [node_a, node_b]);
```

--------------------------------

### Get Node Count

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Returns the total number of nodes currently in the graph.

```rust
fn node_count(&self) -> usize {
        self.node_count
    }
```

--------------------------------

### DotFormatter Initialization and Configuration

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/render/dot.rs.html

This section covers the initialization of the DotFormatter and how to configure it with various styling options and hierarchy information.

```APIDOC
## DotFormatter Initialization and Configuration

### Description
Initializes a `DotFormatter` for a given `PortGraph` and provides methods to customize the DOT output.

### Methods

- **`new(graph: &'g G) -> Self`**
  Initializes a new `DotFormatter` for the provided `graph`.

- **`with_hierarchy(forest: &'g Hierarchy<G::NodeIndexBase>) -> Self`**
  Sets the `Hierarchy` to use for the graph. This is useful for representing hierarchical structures within the DOT output.

- **`with_node_style(node_style: impl FnMut(NodeIndex<G::NodeIndexBase>) -> NodeStyle + 'g) -> Self`**
  Sets a closure to determine the style of each node. The closure receives a `NodeIndex` and returns a `NodeStyle`.

- **`with_port_style(port_style: impl FnMut(PortIndex<G::PortIndexBase>) -> PortStyle + 'g) -> Self`**
  Sets a closure to determine the style of each port. The closure receives a `PortIndex` and returns a `PortStyle`.

- **`with_edge_style(edge_style: impl FnMut(G::LinkEndpoint, G::LinkEndpoint) -> EdgeStyle + 'g) -> Self`**
  Sets a closure to determine the style of each edge. The closure receives the source and destination `LinkEndpoint`s and returns an `EdgeStyle`.

- **`with_weights<'w, N, P>(weights: &'w Weights<N, P, G::NodeIndexBase, G::PortIndexBase>) -> Self`**
  A convenience method to set node and port styles based on provided `Weights`. This method overrides any previously set node or port styles.
  
  #### Type Parameters
  - **`'w`**: Lifetime parameter for the weights.
  - **`N`**: Type of node weights, must implement `Display` and `Clone`.
  - **`P`**: Type of port weights, must implement `Display` and `Clone`.

### Example Usage
```rust
let graph: PortGraph = ...;
let weights: Weights<...> = ...;

let formatter = DotFormatter::new(&graph)
    .with_hierarchy(&hierarchy)
    .with_weights(&weights);
```
```

--------------------------------

### GET /node_outgoing_ports

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Retrieves the range of outgoing port indices for a specified node.

```APIDOC
## GET /node_outgoing_ports

### Description
Returns the range of outgoing port indices for a given node index.

### Parameters
#### Query Parameters
- **node** (NodeIndex<N>) - Required - The index of the node to query.

### Response
#### Success Response (200)
- **Range<usize>** - The range of indices representing the outgoing ports of the node.
```

--------------------------------

### PortGraph Creation and Linking

Source: https://docs.rs/portgraph/0.16.0/portgraph

Demonstrates how to initialize a PortGraph, add nodes with specific port counts, and link ports between nodes.

```APIDOC
## POST /portgraph/create

### Description
Initializes a new PortGraph instance and adds nodes with defined input and output port counts.

### Method
POST

### Endpoint
/portgraph/create

### Request Body
- **input_ports** (u32) - Required - Number of input ports for the node
- **output_ports** (u32) - Required - Number of output ports for the node

### Request Example
{
  "input_ports": 2,
  "output_ports": 2
}

### Response
#### Success Response (200)
- **node_index** (NodeIndex) - The unique identifier for the created node

---

## POST /portgraph/link

### Description
Links two ports within the graph, either by node indices and offsets or by direct port indices.

### Method
POST

### Endpoint
/portgraph/link

### Request Body
- **source_node** (NodeIndex) - Required - The source node index
- **source_offset** (u16) - Required - The output port offset
- **target_node** (NodeIndex) - Required - The target node index
- **target_offset** (u16) - Required - The input port offset

### Request Example
{
  "source_node": 0,
  "source_offset": 0,
  "target_node": 1,
  "target_offset": 0
}

### Response
#### Success Response (200)
- **status** (string) - Success confirmation
```

--------------------------------

### Get Subport Link in MultiPortGraph

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/multiportgraph.rs.html

Retrieves the subport that is linked to the given subport, if any.

```rust
fn subport_link(&self, subport: SubportIndex<P>) -> Option<SubportIndex<P>> {
    let subport_index = self.get_subport_index(subport)?;
    let link = self.graph.port_link(subport_index)?;
    self.get_subport_from_index(link)
}
```

--------------------------------

### Initialize and Use Weights with PortGraph

Source: https://docs.rs/portgraph/0.16.0/portgraph/weights/index.html

Demonstrates initializing a `PortGraph` and `Weights` map, adding nodes and ports, assigning weights, and handling weight updates during graph operations. Unset weights return the default value.

```rust
let mut graph: PortGraph = PortGraph::new();
let mut weights = Weights::<usize, isize>::new();

// The weights must be set manually.
let node = graph.add_node(2, 2);
let [in0, in1, ..] = graph.inputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
let [out0, out1, ..] = graph.outputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
weights[node] = 42;
weights[in1] = 2;
weights[out0] = -1;
weights[out1] = -2;

/// Unset weights return the default value.
assert_eq!(weights[in0], 0);

// Graph operations that modify the keys have callbacks to update the weights.
graph.set_num_ports(node, 1, 3, |old, op| {
    op.new_index().map(|new| weights.ports.swap(old, new));
});

// The map does not track item removals, but the user can shrink it manually.
graph.remove_node(node);
weights.nodes.shrink_to(graph.node_count());
weights.ports.shrink_to(graph.port_count());

```

--------------------------------

### Get Link Count

Source: https://docs.rs/portgraph/0.16.0/portgraph/view/filter/type.NodeFiltered.html

Returns the total number of links between ports in the graph.

```rust
fn link_count(&self) -> usize

```

--------------------------------

### Get Port Links

Source: https://docs.rs/portgraph/0.16.0/portgraph/view/filter/type.NodeFiltered.html

Returns an iterator over the links connected to a specific port.

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

```

--------------------------------

### Manage Nodes and Ports

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Demonstrates adding nodes with specific port counts and verifying port properties and global iterators.

```rust
assert_eq!(graph.port_capacity(), 10);

let lengths = [(0, 1), (0, 0), (1, 0), (2, 1), (1, 6)];
let node_count = lengths.len();
let port_count = lengths
    .iter()
    .map(|(incoming, outgoing)| incoming + outgoing)
    .sum();

for (incoming, outgoing) in lengths.iter().copied() {
    let node = graph.add_node(incoming, outgoing);
    assert!(graph.contains_node(node));

    assert_eq!(graph.inputs(node).count(), incoming);
    assert_eq!(graph.outputs(node).count(), outgoing);
    assert_eq!(graph.num_ports(node, Direction::Incoming), incoming);
    assert_eq!(graph.num_ports(node, Direction::Outgoing), outgoing);
    assert_eq!(graph.all_ports(node).count(), incoming + outgoing);
    assert_eq!(graph.all_port_offsets(node).count(), incoming + outgoing);

    let inputs = graph
        .inputs(node)
        .enumerate()
        .map(|(i, port)| (i, port, Direction::Incoming));
    let outputs = graph
        .outputs(node)
        .enumerate()
        .map(|(i, port)| (i, port, Direction::Outgoing));
    for (i, port, dir) in inputs.chain(outputs) {
        let offset = PortOffset::new(dir, i);
        assert_eq!(graph.port_direction(port), Some(dir));
        assert_eq!(graph.port_offset(port), Some(offset));
        assert_eq!(graph.port_node(port), Some(node));
        assert_eq!(graph.port_index(node, offset), Some(port));
        assert_eq!(graph.port_link(port), None);
    }
}

// Global iterators
let nodes = graph.nodes_iter().take(2);
let nodes = nodes.chain(graph.nodes_iter().skip(2));
let nodes = nodes.collect::<Vec<_>>();
assert_eq!(
    nodes,
    (0..node_count).map(NodeIndex::new).collect::<Vec<_>>()
);

let ports = graph.ports_iter().take(2);
let ports = ports.chain(graph.ports_iter().skip(2));
let ports = ports.collect::<Vec<_>>();
assert_eq!(ports.len(), port_count);
assert_eq!(
    ports,
    (0..port_count).map(PortIndex::new).collect::<Vec<_>>()
);
```

--------------------------------

### GET /nodes/{node_index}/ports

Source: https://docs.rs/portgraph/0.16.0/portgraph/multiportgraph/struct.MultiPortGraph.html

Retrieves ports associated with a specific node.

```APIDOC
## GET /nodes/{node_index}/ports

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

### Method
GET

### Endpoint
/nodes/{node_index}/ports

### Parameters
#### Path Parameters
- **node_index** (NodeIndex) - Required - The index of the node

#### Query Parameters
- **direction** (Direction) - Required - The direction of ports to retrieve (input or output)
```

--------------------------------

### Get Graph from TopoConvexChecker

Source: https://docs.rs/portgraph/0.16.0/portgraph/algorithms/convex/struct.TopoConvexChecker.html

Returns a reference to the graph associated with the TopoConvexChecker instance.

```rust
pub fn graph(&self) -> &G
```

--------------------------------

### Example: Dominators on a Branching Graph

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/algorithms/dominators.rs.html

Demonstrates the usage of the `dominators` function on a sample branching graph. It shows how to create a graph, add nodes and links, compute the dominator tree, and assert the relationships between nodes.

```rust
# type PortGraph = ::portgraph::PortGraph<u32, u32, u16>;
# type DominatorTree = ::portgraph::algorithms::DominatorTree<u32>;
# use ::portgraph::algorithms::*
# use ::portgraph::*
let mut graph = PortGraph::with_capacity(5, 10);
let a = graph.add_node(0,2);
let b = graph.add_node(1,1);
let c = graph.add_node(2,1);
let d = graph.add_node(1,1);
let e = graph.add_node(1,0);

graph.link_nodes(a, 0, b, 0).unwrap();
graph.link_nodes(a, 1, d, 0).unwrap();
graph.link_nodes(b, 0, c, 0).unwrap();
graph.link_nodes(d, 0, c, 1).unwrap();
graph.link_nodes(c, 0, e, 0).unwrap();

let tree: DominatorTree = dominators(&graph, a, Direction::Outgoing);
assert_eq!(tree.root(), a);
assert_eq!(tree.immediate_dominator(a), None);
assert_eq!(tree.immediate_dominator(b), Some(a));
assert_eq!(tree.immediate_dominator(c), Some(a));
assert_eq!(tree.immediate_dominator(d), Some(a));
assert_eq!(tree.immediate_dominator(e), Some(c));
```

--------------------------------

### Initialize PortGraph

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Methods to instantiate a new PortGraph, either empty or with preallocated capacity.

```rust
    /// Create a new empty [`PortGraph`].
    pub fn new() -> Self {
        Self {
            node_meta: Vec::new(),
            port_link: Vec::new(),
            port_meta: Vec::new(),
            node_free: None.into(),
            port_free: Vec::new(),
            node_count: 0,
            port_count: 0,
            link_count: 0,
            _marker: PhantomData,
        }
    }

    /// Create a new empty [`PortGraph`] with preallocated capacity.
    pub fn with_capacity(nodes: usize, ports: usize) -> Self {
        Self {
            node_meta: Vec::with_capacity(nodes),
            port_link: Vec::with_capacity(ports),
            port_meta: Vec::with_capacity(ports),
            node_free: None.into(),
            port_free: Vec::new(),
            node_count: 0,
            port_count: 0,
            link_count: 0,
            _marker: PhantomData,
        }
    }
```

--------------------------------

### dominators

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/algorithms/dominators.rs.html

Computes a standard dominator tree for a given PortGraph starting from an entry node.

```APIDOC
## dominators

### Description
Returns a dominator tree for a PortGraph, where each node is dominated by its parent.

### Parameters
- **graph** (&PortGraph) - Required - The graph to analyze.
- **entry** (NodeIndex) - Required - The entry node for the dominator tree.
- **direction** (Direction) - Required - The direction of traversal (Outgoing or Incoming).
```

--------------------------------

### PortOrdering Methods

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/boundary.rs.html

Methods for querying reachability and comparing port orderings.

```APIDOC
## GET /reachable_ports

### Description
Returns the set of output ports that can be reached from a given incoming boundary port.

### Parameters
#### Request Body
- **port** (BoundaryPort) - Required - The incoming boundary port to query.

### Response
#### Success Response (200)
- **HashSet<BoundaryPort>** - A set of reachable output ports.

## GET /reaching_ports

### Description
Returns the set of input ports from which a given outgoing boundary port can be reached.

### Parameters
#### Request Body
- **port** (BoundaryPort) - Required - The outgoing boundary port to query.

### Response
#### Success Response (200)
- **HashSet<BoundaryPort>** - A set of reaching input ports.

## POST /is_stronger_than

### Description
Checks if the current PortOrdering is stronger than another. A relation P is stronger than Q if for every pair (i, o) in Q, P also contains the pair.

### Parameters
#### Request Body
- **other** (PortOrdering) - Required - The PortOrdering to compare against.

### Response
#### Success Response (200)
- **bool** - True if the current ordering is stronger.

## GET /missing_pairs

### Description
Returns an iterator of port pairs present in the 'other' ordering but missing in the current one.

### Parameters
#### Request Body
- **other** (PortOrdering) - Required - The reference PortOrdering.

### Response
#### Success Response (200)
- **Iterator<Item = (BoundaryPort, BoundaryPort)>** - Pairs missing from the current ordering.
```

--------------------------------

### Dropping and Collecting Methods

Source: https://docs.rs/portgraph/0.16.0/portgraph/portgraph/struct.Nodes.html

Methods for dropping elements from the start or end, and collecting into a Vec.

```APIDOC
## POST /api/dropping

### Description
Consume the first `n` elements from the iterator eagerly, and return the same iterator again.

### Method
POST

### Endpoint
/api/dropping

### Parameters
#### Request Body
- **n** (usize) - Required - The number of elements to drop from the beginning.

### Request Example
```json
{
  "iterator_state": "...",
  "n": 5
}
```

### Response
#### Success Response (200)
- **iterator_state** (string) - The updated iterator state after dropping elements.

#### Response Example
```json
{
  "iterator_state": "..."
}
```
```

```APIDOC
## POST /api/dropping_back

### Description
Consume the last `n` elements from the iterator eagerly, and return the same iterator again.

### Method
POST

### Endpoint
/api/dropping_back

### Parameters
#### Request Body
- **n** (usize) - Required - The number of elements to drop from the end.

### Request Example
```json
{
  "iterator_state": "...",
  "n": 3
}
```

### Response
#### Success Response (200)
- **iterator_state** (string) - The updated iterator state after dropping elements.

#### Response Example
```json
{
  "iterator_state": "..."
}
```
```

```APIDOC
## POST /api/collect_vec

### Description
Collects all items from the iterator into a `Vec`.

### Method
POST

### Endpoint
/api/collect_vec

### Request Example
```json
{
  "iterator_state": "..."
}
```

### Response
#### Success Response (200)
- **vec** (array) - The collected vector.

#### Response Example
```json
{
  "vec": [1, 2, 3, 4, 5]
}
```
```

--------------------------------

### Initialize PortGraph with Capacity

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/portgraph.rs.html

Creates a new `PortGraph` with pre-allocated capacity for nodes and ports, potentially improving performance by reducing reallocations. The initial counts for nodes, ports, and links are zero.

```rust
#[test]
fn add_nodes() {
    let mut graph: PortGraph = PortGraph::with_capacity(5, 10);
    assert_eq!(graph.node_count(), 0);
    assert_eq!(graph.node_capacity(), 5);
    assert_eq!(graph.port_count(), 0);
}
```

--------------------------------

### Function: toposort

Source: https://docs.rs/portgraph/0.16.0/portgraph/algorithms/fn.toposort.html

Performs a topological sort on a graph starting from specified source nodes.

```APIDOC
## Function: toposort

### Description
Returns an iterator over a `LinkView` in topological order. It implements Kahn’s algorithm, where tie-breaking within the same rank is done using a queue.

### Parameters
- **graph** (G) - Required - The graph type implementing `LinkView`.
- **source** (impl IntoIterator<Item = NodeIndex<G::NodeIndexBase>>) - Required - The starting nodes for the traversal.
- **direction** (Direction) - Required - The direction of the traversal (Incoming or Outgoing).

### Type Parameters
- **G** - The graph type implementing `LinkView`.
- **Map** - Secondary map used for graph traversal workspace (e.g., `BitVec`, `HashMap`, or `BTreeMap`).

### Request Example
```rust
let topo: TopoSort<_> = toposort(&graph, [node_a], Direction::Outgoing);
```

### Response
- **Returns** (TopoSort<'static, G, Map>) - An iterator yielding nodes in topological order.
```

--------------------------------

### Initialize Subgraph View

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/view/subgraph.rs.html

Constructs a new subgraph view from a base graph and a defined boundary. The initialization process is linear relative to the size of the subgraph.

```rust
pub fn new_subgraph(graph: G, boundary: Boundary<G::PortIndexBase>) -> Self {
        let nodes = boundary.internal_nodes(&graph).collect();
        Self {
            graph,
            nodes,
            boundary,
        }
    }
```

```rust
pub fn with_nodes(
        graph: G,
        nodes: impl IntoIterator<Item = NodeIndex<G::NodeIndexBase>>,
    ) -> Self {
        let ordered_nodes = nodes.into_iter().collect_vec();
        let nodes = ordered_nodes.iter().copied().collect();
        let boundary = collect_boundary_ports(&graph, ordered_nodes, &nodes);
        Self {
            graph,
            nodes,
            boundary,
        }
    }
```

--------------------------------

### Manage PortOrdering links

Source: https://docs.rs/portgraph/0.16.0/src/portgraph/boundary.rs.html

Internal methods to initialize a new ordering and add links between ports.

```rust
    pub(self) fn new(num_inputs: usize, num_outputs: usize) -> Self {
        Self {
            reachable: vec![HashSet::new(); num_inputs],
            reaching: vec![HashSet::new(); num_outputs],
        }
    }

    pub(self) fn add_order(&mut self, from: BoundaryPort, to: BoundaryPort) {
        debug_assert_eq!(from.direction, Direction::Incoming);
        debug_assert_eq!(to.direction, Direction::Outgoing);

        let from_index = self.index(from);
        let to_index = self.index(to);
        self.reachable[from_index].insert(to);
        self.reaching[to_index].insert(from);
    }
```

--------------------------------

### Initialize and manage UnmanagedDenseMap weights

Source: https://docs.rs/portgraph/0.16.0/portgraph/unmanaged/index.html

Demonstrates creating an UnmanagedDenseMap for nodes and ports, setting values, and handling weight updates during graph modifications.

```rust
let mut graph: PortGraph = PortGraph::new();
let mut node_weights = UnmanagedDenseMap::<NodeIndex, usize>::new();
let mut port_weights = UnmanagedDenseMap::<PortIndex, isize>::new();

// The weights must be set manually.
let node = graph.add_node(2, 2);
let [in0, in1, ..] = graph.inputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
let [out0, out1, ..] = graph.outputs(node).collect::<Vec<_>>()[..] else { unreachable!() };
node_weights[node] = 42;
port_weights[in1] = 2;
port_weights[out0] = -1;
port_weights[out1] = -2;

/// Unset weights return the default value.
assert_eq!(port_weights[in0], 0);

// Graph operations that modify the keys use callbacks to update the weights.
graph.set_num_ports(node, 1, 3, |old, op| {
    op.new_index().map(|new| port_weights.swap(old, new));
});

// The map does not track item removals, but the user can shrink the map manually.
graph.remove_node(node);
node_weights.shrink_to(graph.node_count());
port_weights.shrink_to(graph.port_count());
```
Tokens:
Raw