Struct gamma::graph::StableGraph

pub struct StableGraph<N, E> { /* fields omitted */ }

Reference implementation of Graph and WeightedGraph.Implements an undirected, edge-weighted, graph. Node, neighbor, and edge iteration order are set by the build function and will remain stable.

use gamma::graph::{ Graph, StableGraph, Error };
 
fn main() -> Result<(), Error> {
    let mut graph = StableGraph::build(vec![ 0, 1, 2 ], vec![
        (0, 1, "a"),
        (1, 2, "b")
    ])?;
 
    assert_eq!(graph.is_empty(), false);
    assert_eq!(graph.order(), 3);
    assert_eq!(graph.size(), 2);
    assert_eq!(graph.nodes().collect::<Vec<_>>(), vec![ &0, &1, &2 ]);
    assert_eq!(graph.has_node(&0), true);
    assert_eq!(graph.neighbors(&1)?.collect::<Vec<_>>(), vec![ &0, &2 ]);
    assert_eq!(graph.degree(&1)?, 2);
    assert_eq!(graph.edges().collect::<Vec<_>>(), vec![
       (&0, &1), (&1, &2)
    ]);
    assert_eq!(graph.has_edge(&0, &1)?, true);
    assert_eq!(graph.has_edge(&1, &0)?, true);
    assert_eq!(graph.has_edge(&0, &2)?, false);
 
    Ok(())
}

Although nodes and edges must implement Clone, the can be done in a lightweight manner using reference counting (std::rc::Rc). Likewise, references implement Clone (efficiently), so they can be used as nodes if the resulting StableGraph is not moved.

Implementations

impl<N: Eq + Hash + Clone, E: Clone> StableGraph<N, E>

pub fn build(
    node_list: Vec<N>,
    edge_list: Vec<(N, N, E)>
) -> Result<Self, Error>

Trait Implementations

impl<'a, N: 'a + Hash + Eq, E: 'a> Graph<'a, N> for StableGraph<N, E>

type NodeIterator = Iter<'a, N>

type NeighborIterator = NeighborIterator<'a, N, E>

type EdgeIterator = EdgeIterator<'a, N>

fn is_empty(&self) -> bool

Returns true if there are no nodes, or false otherwise.

fn order(&self) -> usize

Returns the number of nodes in this graph.

fn size(&self) -> usize

Returns the number of edges in this graph.

fn nodes(&'a self) -> Self::NodeIterator

Iterates the nodes of this graph

fn has_node(&self, node: &N) -> bool

Returns true if node is a member, or false otherwise.

fn neighbors(&'a self, node: &N) -> Result<Self::NeighborIterator, Error>

Iterates the neighbors of node.

fn degree(&self, node: &N) -> Result<usize, Error>

Returns the number of neighbors connected to node.

fn has_edge(&self, source: &N, target: &N) -> Result<bool, Error>

Returns true if an edge exists between source and target.

fn edges(&'a self) -> Self::EdgeIterator

Iterates the edges of this graph.

impl<'a, N: 'a + Eq + Hash, E: 'a> WeightedGraph<'a, N, E> for StableGraph<N, E>

fn weight(&self, source: &N, target: &N) -> Result<Option<&E>, Error>

Returns the weight between source and target.