Struct Graph 

pub struct Graph<N = (), E = ()> { /* private fields */ }

Graph container for nodes and edges

Implementations

impl<N, E> Graph<N, E>

pub fn apply_node_drag( &mut self, selected_nodes: &HashSet<NodeId>, delta: Position, ) -> Result<()>

Apply drag operation to selected nodes

pub fn apply_node_drag_with_bounds( &mut self, selected_nodes: &HashSet<NodeId>, delta: Position, bounds: Option<Rect>, ) -> Result<()>

Apply drag operation with bounds constraint

pub fn apply_node_drag_with_snap( &mut self, selected_nodes: &HashSet<NodeId>, delta: Position, grid_size: f64, ) -> Result<()>

Apply drag operation with grid snapping

pub fn apply_node_drag_with_constraint<F>( &mut self, selected_nodes: &HashSet<NodeId>, delta: Position, constraint: F, ) -> Result<()>

where F: Fn(Position) -> Position,

Apply drag operation with custom constraint function

pub fn create_drag_operation( &self, selected_nodes: &HashSet<NodeId>, delta: Position, ) -> Result<DragOperation>

Create a drag operation for undo/redo support

impl<N, E> Graph<N, E>

where N: Clone, E: Clone,

pub fn has_cycle(&self) -> bool

Check if the graph contains any cycles using DFS-based cycle detection

Uses Depth-First Search with recursion stack tracking to detect back edges. Time complexity: O(V + E), Space complexity: O(V)

pub fn creates_cycle(&self, source: &NodeId, target: &NodeId) -> bool

Check if adding an edge from source to target would create a cycle

This is useful for preventing cycles during interactive edge creation. Time complexity: O(V + E), Space complexity: O(V)

pub fn find_cycle(&self) -> Option<Vec<NodeId>>

Find a cycle in the graph, returning the cycle path if found

Returns the first cycle found, or None if the graph is acyclic. The returned path represents the nodes in the cycle. Time complexity: O(V + E), Space complexity: O(V)

pub fn topological_sort(&self) -> Result<Vec<NodeId>>

Perform topological sort on the graph using Kahn’s algorithm

Returns a valid topological ordering of nodes, or Err if the graph contains cycles. A topological sort is a linear ordering where for every directed edge (u, v), vertex u comes before v in the ordering. Time complexity: O(V + E), Space complexity: O(V)

impl<N, E> Graph<N, E>

pub fn add_handle_edge(&mut self, edge: Edge<E>) -> Result<()>

Add an edge with handle validation

pub fn get_handle_connections( &self, node_id: &NodeId, handle_id: &HandleId, ) -> Vec<&Edge<E>>

Get all edges connected to a specific handle

This method provides accurate connection counting by examining all edges in the graph that reference the specified handle.

pub fn can_handle_accept_connection( &self, node_id: &NodeId, handle_id: &HandleId, ) -> bool

Check if a handle can accept new connections (respects connection limits)

This method provides accurate connection limit validation by counting current connections and comparing against the handle’s limit.

impl<N, E> Graph<N, E>

pub fn new() -> Self

Create a new empty graph

pub fn add_node(&mut self, node: Node<N>) -> Result<()>

Add a node to the graph

pub fn remove_node(&mut self, node_id: &NodeId) -> Result<Node<N>>

Remove a node and all connected edges

pub fn get_node(&self, node_id: &NodeId) -> Option<&Node<N>>

Get a reference to a node

pub fn get_node_mut(&mut self, node_id: &NodeId) -> Option<&mut Node<N>>

Get a mutable reference to a node

pub fn add_edge(&mut self, edge: Edge<E>) -> Result<()>

Add an edge to the graph

pub fn remove_edge(&mut self, edge_id: &EdgeId) -> Result<Edge<E>>

Remove an edge

pub fn get_edge(&self, edge_id: &EdgeId) -> Option<&Edge<E>>

Get a reference to an edge

pub fn get_edge_mut(&mut self, edge_id: &EdgeId) -> Option<&mut Edge<E>>

Get a mutable reference to an edge

pub fn nodes(&self) -> impl Iterator<Item = &Node<N>>

Get all nodes

pub fn nodes_mut(&mut self) -> impl Iterator<Item = &mut Node<N>>

Get all nodes mutably

pub fn edges(&self) -> impl Iterator<Item = &Edge<E>>

Get all edges

pub fn edges_mut(&mut self) -> impl Iterator<Item = &mut Edge<E>>

Get all edges mutably

pub fn node_count(&self) -> usize

Get node count

pub fn edge_count(&self) -> usize

Get edge count

pub fn is_empty(&self) -> bool

Check if graph is empty

pub fn clear(&mut self)

Clear all nodes and edges

pub fn get_connected_edges(&self, node_id: &NodeId) -> Vec<&Edge<E>>

Get edges connected to a node

pub fn get_incoming_edges(&self, node_id: &NodeId) -> Vec<&Edge<E>>

Get incoming edges for a node

pub fn get_outgoing_edges(&self, node_id: &NodeId) -> Vec<&Edge<E>>

Get outgoing edges for a node

pub fn are_connected(&self, source: &NodeId, target: &NodeId) -> bool

Check if two nodes are connected

pub fn node_ids(&self) -> impl Iterator<Item = &NodeId>

Get all node IDs

pub fn edge_ids(&self) -> impl Iterator<Item = &EdgeId>

Get all edge IDs

pub fn bounds(&self) -> Option<Rect>

where N: Clone,

Calculate bounding rectangle of all nodes

pub fn handle_at_position( &self, point: Position, handle_size: f64, ) -> Option<(&NodeId, &Handle)>

Find handle at position in the graph

pub fn get_handles_by_type( &self, handle_type: HandleType, ) -> Vec<(&NodeId, &Handle)>

Get all handles of a specific type in the graph

pub fn create_edge_creator(&self) -> EdgeCreator

Create a new edge creator for this graph

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug, E: Debug> Debug for Graph<N, E>

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

Formats the value using the given formatter.

impl<N, E> Default for Graph<N, E>

fn default() -> Self

Returns the “default value” for a type.

impl<N: PartialEq, E: PartialEq> PartialEq for Graph<N, E>

fn eq(&self, other: &Graph<N, E>) -> 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, E> StructuralPartialEq for Graph<N, E>