Struct Graph 

pub struct Graph<T, E> { /* private fields */ }

图结构主实现 使用缓存行对齐优化，减少 false sharing

Implementations

impl<T, E> Graph<T, E>

pub fn directed() -> Self

创建新的有向图

pub fn undirected() -> Self

创建新的无向图

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

创建带预分配容量的有向图

pub fn is_empty(&self) -> bool

检查图是否为空

pub fn clear(&mut self)

清空图

pub fn get_edge_by_nodes( &self, from: NodeIndex, to: NodeIndex, ) -> GraphResult<&E>

通过节点索引获取边数据

Trait Implementations

impl<T: Clone, E: Clone> Clone for Graph<T, E>

fn clone(&self) -> Graph<T, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, E> Debug for Graph<T, E>

where T: Debug, E: Debug,

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

Formats the value using the given formatter.

impl<'de, T, E> Deserialize<'de> for Graph<T, E>

where T: Deserialize<'de>, E: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, E> GraphBase for Graph<T, E>

type NodeData = T

节点数据类型

type EdgeData = E

边数据类型

fn node_count(&self) -> usize

获取节点数量

fn edge_count(&self) -> usize

获取边数量

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

检查是否包含节点

fn contains_edge(&self, index: EdgeIndex) -> bool

检查是否包含边

fn is_empty(&self) -> bool

检查是否为空图

impl<T, E> GraphOps for Graph<T, E>

fn add_node(&mut self, data: T) -> GraphResult<NodeIndex>

添加节点

fn remove_node(&mut self, index: NodeIndex) -> GraphResult<T>

删除节点，返回节点数据

fn add_edge( &mut self, from: NodeIndex, to: NodeIndex, data: E, ) -> GraphResult<EdgeIndex>

添加边

fn remove_edge(&mut self, index: EdgeIndex) -> GraphResult<E>

删除边，返回边数据

fn update_node(&mut self, index: NodeIndex, data: T) -> GraphResult<T>

更新节点数据，返回旧数据

fn update_edge(&mut self, index: EdgeIndex, data: E) -> GraphResult<E>

更新边数据，返回旧数据

fn reserve(&mut self, additional_nodes: usize, additional_edges: usize)

预分配容量

fn clear(&mut self)

清空图

impl<T, E> GraphQuery for Graph<T, E>

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

获取节点的邻居迭代器

快照语义

迭代器在创建时捕获目标节点的邻居快照：

• 返回的迭代器包含创建时的所有有效邻居
• 迭代期间图的修改不会影响迭代器返回的内容
• 如果邻居节点在迭代期间被删除，该节点会被跳过

推荐用法

// 安全：迭代器持有快照，迭代期间可以修改图
for neighbor in graph.neighbors(node) {
    println!("{:?}", graph[neighbor]);
}

fn incident_edges(&self, node: NodeIndex) -> impl Iterator<Item = EdgeIndex>

获取节点的关联边迭代器

快照语义

迭代器在创建时捕获关联边的快照：

• 返回的迭代器包含创建时的所有有效边
• 迭代期间图的修改不会影响迭代器返回的内容
• 如果边在迭代期间被删除，该边会被跳过

推荐用法

// 安全：迭代器持有快照，迭代期间可以修改图
for edge_idx in graph.incident_edges(node) {
    println!("{:?}", graph.get_edge(edge_idx).unwrap());
}

fn get_node(&self, index: NodeIndex) -> GraphResult<&T>

获取节点引用

fn get_edge(&self, index: EdgeIndex) -> GraphResult<&E>

获取边引用

fn edge_endpoints( &self, index: EdgeIndex, ) -> GraphResult<(NodeIndex, NodeIndex)>

获取边的端点

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

检查是否存在从 from 到 to 的边

fn out_degree(&self, node: NodeIndex) -> GraphResult<usize>

获取节点的出度

fn in_degree(&self, node: NodeIndex) -> GraphResult<usize>

获取节点的入度（有向图）

fn degree(&self, node: NodeIndex) -> GraphResult<usize>

获取节点的总度数

fn nodes(&self) -> impl Iterator<Item = NodeRef<'_, T>>

获取所有节点迭代器

fn edges(&self) -> impl Iterator<Item = EdgeRef<'_, E>>

获取所有边迭代器

impl<T, E> GraphTensorExt<T, E> for Graph<T, E>

where T: Clone, E: Clone,

fn to_tensor_representation( &self, ) -> Result<(DenseTensor, GraphAdjacencyMatrix), TensorError>

where T: AsRef<[f64]> + Clone, E: Clone,

Convert graph to tensor representation

fn adjacency_matrix(&self) -> Result<GraphAdjacencyMatrix, TensorError>

Get adjacency matrix as sparse tensor

fn node_features(&self, num_features: usize) -> Result<DenseTensor, TensorError>

where T: AsRef<[f64]> + Clone,

Extract node features as tensor

fn feature_extractor(&self) -> GraphFeatureExtractor<'_, T, E>

Create feature extractor

impl<T, E> Index<NodeIndex> for Graph<T, E>

type Output = T

The returned type after indexing.

fn index(&self, index: NodeIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, E> IndexMut<NodeIndex> for Graph<T, E>

Safety

此实现使用 panic! 而非 Result，因为 IndexMut trait 不允许返回 Result。 对于需要安全访问的场景，请使用 get_node_mut() 方法。

Panics

Panics if:

• 节点索引超出范围 (index.index() >= self.nodes.len())
• 节点已被删除 (slot.is_occupied() == false)
• Generation 不匹配，索引已失效

示例

use god_gragh::graph::{Graph, traits::GraphOps};

let mut graph = Graph::<i32, f64>::directed();
let node = graph.add_node(42).unwrap();
graph.remove_node(node).unwrap();

// 这将 panic，因为节点已被删除
graph[node] = 100;

fn index_mut(&mut self, index: NodeIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T, E> Serialize for Graph<T, E>

where T: Serialize, E: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.