Struct NamedGraph 

pub struct NamedGraph<NodeName, NodeData, EdgeData, Ty = Undirected>
where
    NodeName: Clone + Hash + Eq + Send + Sync + Debug,
    Ty: EdgeType,
{ /* private fields */ }

Generic named graph wrapper (inspired by NamedGraphs.jl)

Provides a mapping between arbitrary node name types (NodeName) and internal NodeIndex. This allows using meaningful identifiers (coordinates, strings, etc.) instead of raw indices.

Type Parameters

• NodeName: Node name type (must be Clone, Hash, Eq, Send, Sync, Debug)
• NodeData: Node weight/data type
• EdgeData: Edge weight/data type
• Ty: Edge type (Directed or Undirected, default: Undirected)

Implementations

impl<NodeName, NodeData, EdgeData, Ty> NamedGraph<NodeName, NodeData, EdgeData, Ty>

where NodeName: Clone + Hash + Eq + Send + Sync + Debug, Ty: EdgeType,

pub fn new() -> Self

Create a new empty NamedGraph.

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

Create a new NamedGraph with initial capacity.

pub fn add_node( &mut self, node_name: NodeName, data: NodeData, ) -> Result<NodeIndex, String>

Add a node with the given name and data.

Returns an error if the node already exists.

pub fn has_node(&self, node_name: &NodeName) -> bool

Check if a node exists.

pub fn node_index(&self, node_name: &NodeName) -> Option<NodeIndex>

Get the NodeIndex for a node name.

pub fn node_name(&self, node: NodeIndex) -> Option<&NodeName>

Get the node name for a NodeIndex.

pub fn rename_node( &mut self, old_name: &NodeName, new_name: NodeName, ) -> Result<(), String>

Rename an existing node without changing its data or incident edges.

Returns an error if the old node doesn’t exist or the new name is already in use.

pub fn node_data(&self, node_name: &NodeName) -> Option<&NodeData>

Get a reference to the data of a node (by node name).

pub fn node_data_mut(&mut self, node_name: &NodeName) -> Option<&mut NodeData>

Get a mutable reference to the data of a node (by node name).

pub fn node_weight(&self, node: NodeIndex) -> Option<&NodeData>

Get a reference to the data of a node (by NodeIndex).

pub fn node_weight_mut(&mut self, node: NodeIndex) -> Option<&mut NodeData>

Get a mutable reference to the data of a node (by NodeIndex).

pub fn add_edge( &mut self, n1: &NodeName, n2: &NodeName, weight: EdgeData, ) -> Result<EdgeIndex, String>

where EdgeData: Clone,

Add an edge between two nodes.

Returns an error if either node doesn’t exist.

pub fn edge_weight(&self, n1: &NodeName, n2: &NodeName) -> Option<&EdgeData>

Get the weight of an edge between two nodes.

pub fn edge_weight_mut( &mut self, n1: &NodeName, n2: &NodeName, ) -> Option<&mut EdgeData>

Get a mutable reference to the weight of an edge between two nodes.

pub fn neighbors(&self, node_name: &NodeName) -> Vec<&NodeName>

Get all neighbors of a node.

pub fn node_names(&self) -> Vec<&NodeName>

Get all node names.

pub fn node_count(&self) -> usize

Get the number of nodes.

pub fn edge_count(&self) -> usize

Get the number of edges.

pub fn remove_node(&mut self, node_name: &NodeName) -> Option<NodeData>

Remove a node and all its edges.

Returns the node data if the node existed.

pub fn remove_edge(&mut self, n1: &NodeName, n2: &NodeName) -> Option<EdgeData>

Remove an edge between two nodes.

Returns the edge weight if the edge existed.

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

Check if a node exists in the internal graph.

pub fn graph(&self) -> &StableGraph<NodeData, EdgeData, Ty>

Get a reference to the internal graph.

This allows direct access to petgraph algorithms that work with NodeIndex.

pub fn graph_mut(&mut self) -> &mut StableGraph<NodeData, EdgeData, Ty>

Get a mutable reference to the internal graph.

Warning: Directly modifying the internal graph can break the node-name-to-index mapping. Use the provided methods instead.

pub fn euler_tour_edges( &self, root: &NodeName, ) -> Option<Vec<(NodeIndex, NodeIndex)>>

Perform an Euler tour traversal starting from the given root node.

The Euler tour visits each edge exactly twice (once in each direction), forming a closed walk that covers all edges. This is useful for sweep algorithms where we need to visit all nodes while maintaining the canonical center at a single point.

Algorithm

Uses DFS with backtracking. When visiting a node:

1. For each unvisited neighbor, record the edge and recurse
2. When backtracking, record the edge back to the parent

Returns

A vector of directed edges (from, to) in traversal order. Each undirected edge appears twice: once as (u, v) and once as (v, u).

Example

For a Y-shaped tree with root at center C:

    A
    |
B - C - D

Starting from C, the tour might be: [(C,A), (A,C), (C,B), (B,C), (C,D), (D,C)]

pub fn euler_tour_edges_by_index( &self, root: NodeIndex, ) -> Vec<(NodeIndex, NodeIndex)>

Perform an Euler tour traversal starting from the given root NodeIndex.

See Self::euler_tour_edges for details.

pub fn euler_tour_vertices(&self, root: &NodeName) -> Option<Vec<NodeIndex>>

Perform an Euler tour traversal and return the vertex sequence.

This returns the sequence of vertices visited, including repeated visits. Each vertex appears multiple times based on its degree in the tree.

Returns

A vector of NodeIndex in visitation order, or None if root doesn’t exist.

Example

For a chain A - B - C starting from B:

• Edges: [(B,A), (A,B), (B,C), (C,B)]
• Vertices: [B, A, B, C, B]

pub fn euler_tour_vertices_by_index(&self, root: NodeIndex) -> Vec<NodeIndex>

Perform an Euler tour traversal and return the vertex sequence by NodeIndex.

See Self::euler_tour_vertices for details.

Trait Implementations

impl<NodeName, NodeData, EdgeData, Ty> Clone for NamedGraph<NodeName, NodeData, EdgeData, Ty>

where NodeName: Clone + Hash + Eq + Send + Sync + Debug, NodeData: Clone, EdgeData: Clone, Ty: EdgeType,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<NodeName, NodeData, EdgeData, Ty> Debug for NamedGraph<NodeName, NodeData, EdgeData, Ty>

where NodeName: Clone + Hash + Eq + Send + Sync + Debug, NodeData: Debug, EdgeData: Debug, Ty: EdgeType,

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

Formats the value using the given formatter.

impl<NodeName, NodeData, EdgeData, Ty> Default for NamedGraph<NodeName, NodeData, EdgeData, Ty>

where NodeName: Clone + Hash + Eq + Send + Sync + Debug, Ty: EdgeType,

fn default() -> Self

Returns the “default value” for a type.