Struct LinkedGraph

pub struct LinkedGraph<N, E> {
    nodes: Vec<Node<N>>,
    edges: Vec<Edge<E>>,
}

A concrete graph implementation that supports:

• Nodes and/or edges labelled with custom data types (N and E respectively).
• Incremental addition of new nodes/edges (but not removal).
• Flat storage of node/edge data in a pair of vectors.
• Iteration over any node’s out-edges or in-edges, via linked lists threaded through the node/edge data.

Caution

This is an older graph implementation that is still used by some pieces of diagnostic/debugging code. New code that needs a graph data structure should consider using VecGraph instead, or implementing its own special-purpose graph with the specific features needed.

This graph implementation predates the later graph traits, and does not implement those traits, so it has its own implementations of a few basic graph algorithms.

Fields

nodes: Vec<Node<N>>

edges: Vec<Edge<E>>

Implementations

impl<N: Debug, E: Debug> LinkedGraph<N, E>

pub fn new() -> Self

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

pub fn all_nodes(&self) -> &[Node<N>]

pub fn len_nodes(&self) -> usize

pub fn all_edges(&self) -> &[Edge<E>]

pub fn len_edges(&self) -> usize

pub fn next_node_index(&self) -> NodeIndex

pub fn add_node(&mut self, data: N) -> NodeIndex

pub fn mut_node_data(&mut self, idx: NodeIndex) -> &mut N

pub fn node_data(&self, idx: NodeIndex) -> &N

pub fn node(&self, idx: NodeIndex) -> &Node<N>

pub fn next_edge_index(&self) -> EdgeIndex

pub fn add_edge( &mut self, source: NodeIndex, target: NodeIndex, data: E, ) -> EdgeIndex

pub fn edge(&self, idx: EdgeIndex) -> &Edge<E>

pub fn enumerated_nodes(&self) -> impl Iterator<Item = (NodeIndex, &Node<N>)>

pub fn enumerated_edges(&self) -> impl Iterator<Item = (EdgeIndex, &Edge<E>)>

pub fn each_node<'a>( &'a self, f: impl FnMut(NodeIndex, &'a Node<N>) -> bool, ) -> bool

Iterates over all edges defined in the graph.

pub fn each_edge<'a>( &'a self, f: impl FnMut(EdgeIndex, &'a Edge<E>) -> bool, ) -> bool

Iterates over all edges defined in the graph

pub fn outgoing_edges(&self, source: NodeIndex) -> AdjacentEdges<'_, N, E>

pub fn incoming_edges(&self, source: NodeIndex) -> AdjacentEdges<'_, N, E>

pub fn adjacent_edges( &self, source: NodeIndex, direction: Direction, ) -> AdjacentEdges<'_, N, E>

pub fn successor_nodes( &self, source: NodeIndex, ) -> impl Iterator<Item = NodeIndex>

pub fn predecessor_nodes( &self, target: NodeIndex, ) -> impl Iterator<Item = NodeIndex>

pub fn depth_traverse( &self, start: NodeIndex, direction: Direction, ) -> DepthFirstTraversal<'_, N, E>

pub fn nodes_in_postorder( &self, direction: Direction, entry_node: NodeIndex, ) -> Vec<NodeIndex>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes