Rust图数据结构库portgraph的使用

portgraph是一个用于带一级端口的有向图的数据结构库，提供高效的节点连接和拓扑操作功能。该库还包括用于节点和端口权重以及节点层次结构的二级数据结构。

主要特性

• pyo3: 通过pyo3启用Python绑定
• serde: 通过serde启用序列化和反序列化
• petgraph: 通过为PortGraph和MultiPortGraph实现petgraph::visit特性，实现与petgraph的互操作性

安装使用

在项目中运行以下Cargo命令：

cargo add portgraph

或者在Cargo.toml中添加：

portgraph = "0.15.2"

示例代码

use portgraph::PortGraph;

fn main() {
    // 创建一个新的PortGraph实例
    let mut graph = PortGraph::new();
    
    // 添加节点，每个节点可以指定输入端口和输出端口数量
    let node1 = graph.add_node(2, 1); // 2个输入端口，1个输出端口
    let node2 = graph.add_node(1, 2); // 1个输入端口，2个输出端口
    
    // 连接节点
    graph.link_nodes(node1, 0, node2, 0).unwrap(); // 将node1的输出端口0连接到node2的输入端口0
    
    // 检查连接
    assert!(graph.connected(node1, node2));
    
    // 获取节点的邻居
    let neighbors: Vec<_> = graph.neighbors(node1).collect();
    assert_eq!(neighbors, vec![node2]);
    
    // 移除连接
    graph.unlink_nodes(node1, node2).unwrap();
    
    // 移除节点
    graph.remove_node(node1);
    
    // 检查图是否为空
    assert_eq!(graph.node_count(), 1);
}

更复杂的示例

use portgraph::{PortGraph, PortView};

fn main() {
    let mut graph = PortGraph::new();
    
    // 创建多个节点
    let nodes: Vec<_> = (0..5).map(|i| {
        graph.add_node(i, 5 - i)  // 每个节点的输入端口数量递增，输出端口数量递减
    }).collect();
    
    // 创建复杂的连接模式
    for i in 0..nodes.len() {
        for j in 0..nodes.len() {
            if i != j {
                let input_ports = graph.input_count(nodes[j]);
                let output_ports = graph.output_count(nodes[i]);
                
                if input_ports > 0 && output_ports > 0 {
                    let port_in = j % input_ports;
                    let port_out = i % output_ports;
                    graph.link_nodes(nodes[i], port_out, nodes[j], port_in).unwrap();
                }
            }
        }
    }
    
    // 使用PortView遍历图结构
    let port_view = PortView::new(&graph);
    for node in port_view.nodes() {
        println!("Node {} has {} inputs and {} outputs",
                 node.index(),
                 port_view.input_count(node),
                 port_view.output_count(node));
    }
    
    // 拓扑排序
    if let Ok(order) = portgraph::algorithms::toposort(&port_view) {
        println!("Topological order: {:?}", order);
    }
}

完整示例demo

以下是一个完整的示例，展示如何使用portgraph创建一个简单的数据处理流程图：

use portgraph::{PortGraph, PortView, algorithms};
use std::collections::HashMap;

fn main() {
    // 创建一个新的PortGraph实例
    let mut graph = PortGraph::new();
    
    // 定义节点类型和端口数量
    let node_types = vec![
        ("DataSource", 0, 2),   // 数据源节点，0输入2输出
        ("Processor", 2, 2),   // 处理器节点，2输入2输出
        ("Sink", 2, 0),        // 数据接收节点，2输入0输出
    ];
    
    // 添加节点到图中
    let mut nodes = HashMap::new();
    for (i, (name, inputs, outputs)) in node_types.iter().enumerate() {
        let node = graph.add_node(*inputs, *outputs);
        nodes.insert(i, (name.to_string(), node));
        println!("Added node {}: {}", i, name);
    }
    
    // 连接节点创建数据流
    graph.link_nodes(nodes[&0].1, 0, nodes[&1].1, 0).unwrap(); // 数据源输出0 -> 处理器输入0
    graph.link_nodes(nodes[&0].1, 1, nodes[&1].1, 1).unwrap(); // 数据源输出1 -> 处理器输入1
    graph.link_nodes(nodes[&1].1, 0, nodes[&2].1, 0).unwrap(); // 处理器输出0 -> 接收器输入0
    graph.link_nodes(nodes[&1].1, 1, nodes[&2].1, 1).unwrap(); // 处理器输出1 -> 接收器输入1
    
    // 使用PortView分析图结构
    let port_view = PortView::new(&graph);
    
    // 打印图中所有节点信息
    println!("\nGraph structure:");
    for node in port_view.nodes() {
        println!("Node {} ({}): {} inputs, {} outputs",
                 node.index(),
                 nodes[&node.index()].0,
                 port_view.input_count(node),
                 port_view.output_count(node));
    }
    
    // 检查图的连通性
    println!("\nGraph connectivity:");
    for (i, (name, node)) in &nodes {
        let neighbors: Vec<_> = graph.neighbors(*node).collect();
        println!("Node {} ({}) is connected to: {:?}", i, name, neighbors);
    }
    
    // 执行拓扑排序
    if let Ok(order) = algorithms::toposort(&port_view) {
        println!("\nTopological order:");
        for node in order {
            println!("- Node {} ({})", node.index(), nodes[&node.index()].0);
        }
    }
    
    // 验证图的完整性
    assert_eq!(graph.node_count(), 3);
    assert_eq!(graph.edge_count(), 4);
    println!("\nGraph validation passed!");
}

许可证

该项目使用Apache License, Version 2.0许可证。