Struct gamma::graph::HashGraph

pub struct HashGraph<N> { /* fields omitted */ }

An undirected, node-labeled Graph. Node, and edge order are undefined. Neighbor order remains stable. As such, HashGraph can be tought of as the hashed node counterpart to IndexGraph.

Note that not only is the order of edges obtained from #edges undefined, but the order in which nodes appear within each tuple is also undefined.

use std::collections::HashMap;
 
use gamma::graph::{ Graph, HashGraph, Error };
 
fn main() -> Result<(), Error> {
    let mut adjacency = HashMap::new();
 
    adjacency.insert('A', vec![ 'B' ]);
    adjacency.insert('B', vec![ 'A', 'C' ]);
    adjacency.insert('C', vec![ 'B' ]);
 
    let mut graph = HashGraph::build(adjacency)?;
 
    assert_eq!(graph.degree(&'B'), Ok(2));
 
    Ok(())
}

Implementations

impl<'a, N: 'a + Hash + Eq + Clone> HashGraph<N>

pub fn build(adjacency: HashMap<N, Vec<N>>) -> Result<Self, Error>

The elements of adjacency will be validated to ensure:

1. If there is a forward edge, there is a matching back edge.
2. There are no duplicate edges.
3. All targets are present as keys.
4. No loops (self-edges) are present.

If any test fails, an error is returned.

Trait Implementations

impl<'a, N: 'a + Hash + Eq + Clone> Graph<'a, N> for HashGraph<N>

type NodeIterator = Keys<'a, N, Vec<N>>

type NeighborIterator = Iter<'a, N>

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 edges(&'a self) -> Self::EdgeIterator

Iterates the edges of this graph.

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

Returns true if an edge exists between source and target.