Struct rs_graph::reversedigraph::ReverseDigraph

pub struct ReverseDigraph<G>(_);

A digraph wrapping an existing graph with edges in opposite directions.

The sets of outgoing and incoming edges handled by the methods of Digraph and Network are swapped, so incoming edges becoming outgoing edges and vice versa.

Example

use rs_graph::{Graph, Digraph, IndexGraph, ReverseDigraph, LinkedListGraph};
use rs_graph::reverse;
use rs_graph::classes::star;

let g = star::<LinkedListGraph>(42);
assert_eq!(g.num_nodes(), 43);
assert_eq!(g.num_edges(), 42);
assert!(g.edges().all(|e| g.node_id(g.src(e)) == 0 && g.node_id(g.snk(e)) > 0));
assert!(g.outedges(g.id2node(0)).all(|(_,v)| g.node_id(v) > 0));
assert!(g.inedges(g.id2node(0)).all(|(_,v)| g.node_id(v) == 0));
assert_eq!(g.outedges(g.id2node(0)).count(), 42);
assert_eq!(g.inedges(g.id2node(0)).count(), 0);

// Can be used by wrapping a reference.
{
    let g = reverse(&g);
    assert_eq!(g.num_nodes(), 43);
    assert_eq!(g.num_edges(), 42);
}

// Or by conversion.
let g = reverse(g);
assert_eq!(g.num_nodes(), 43);
assert_eq!(g.num_edges(), 42);
assert!(g.edges().all(|e| g.node_id(g.snk(e)) == 0 && g.node_id(g.src(e)) > 0));
assert!(g.outedges(g.id2node(0)).all(|(_,v)| g.node_id(v) == 0));
assert!(g.inedges(g.id2node(0)).all(|(_,v)| g.node_id(v) > 0));
assert_eq!(g.outedges(g.id2node(0)).count(), 0);
assert_eq!(g.inedges(g.id2node(0)).count(), 42);

Trait Implementations

impl<'a, G> Graph<'a> for ReverseDigraph<G> where     G: Graph<'a>,

type Node = G::Node

Type of a node.

type Edge = G::Edge

Type of an edge.

type NodeIter = G::NodeIter

Type of an iterator over all nodes.

type EdgeIter = G::EdgeIter

Type of an iterator over all edges.

type NeighIter = G::NeighIter

Type of an iterator over incident edges.

fn num_nodes(&self) -> usize

Return the number of nodes.

fn num_edges(&self) -> usize

Return the number of edges.

fn enodes(&'a self, e: Self::Edge) -> (Self::Node, Self::Node)

Return the nodes connected by an edge.

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

Return an iterator over all nodes.

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

Return an iterator over all edges.

fn neighs(&'a self, u: Self::Node) -> Self::NeighIter

Return an iterator over the edges adjacent to some node.

impl<'a, G> IndexGraph<'a> for ReverseDigraph<G> where     G: IndexGraph<'a>,

fn node_id(&self, u: Self::Node) -> usize

Return a unique id associated with a node.

fn id2node(&'a self, id: usize) -> Self::Node

Return the node associated with the given id.

fn edge_id(&self, e: Self::Edge) -> usize

Return a unique id associated with an edge.

fn id2edge(&'a self, id: usize) -> Self::Edge

Return the edge associated with the given id.

impl<'a, G> Digraph<'a> for ReverseDigraph<G> where     G: Digraph<'a>,

type OutEdgeIter = G::InEdgeIter

Type of an iterator over the forward edges leaving a node.

type InEdgeIter = G::OutEdgeIter

Type of an iterator over the backward edges entering a node.

fn src(&'a self, e: Self::Edge) -> Self::Node

Return the source node of an edge.

fn snk(&'a self, e: Self::Edge) -> Self::Node

Return the sink node of an edge.

fn outedges(&'a self, u: Self::Node) -> Self::OutEdgeIter

Return an iterator over the outgoing edges of a node.

fn inedges(&'a self, u: Self::Node) -> Self::InEdgeIter

Return an iterator over the incoming edges of a node.

impl<'a, G> Network<'a> for ReverseDigraph<G> where     G: Network<'a>,

fn is_reverse(&self, e: Self::Edge, f: Self::Edge) -> bool

Return true if e is the reverse edge of f.

fn reverse(&'a self, e: Self::Edge) -> Self::Edge

Return the reverse edge of e.

fn is_forward(&self, e: Self::Edge) -> bool

Return true if e is a forward edge.

fn forward(&'a self, e: Self::Edge) -> Self::Edge

Return the forward edge of e.

fn is_backward(&self, e: Self::Edge) -> bool

Return true if e is a backward edge.

fn backward(&'a self, e: Self::Edge) -> Self::Edge

Return the backward edge of e.

fn bisrc(&'a self, e: Self::Edge) -> Self::Node

Return the source of the directed edge e.

fn bisnk(&'a self, e: Self::Edge) -> Self::Node

Return the sink of the directed edge e.

impl<'a, G> IndexNetwork<'a> for ReverseDigraph<G> where     G: IndexNetwork<'a>,

fn biedge_id(&self, e: Self::Edge) -> usize

Return a unique id associated with a directed edge.

fn id2biedge(&'a self, id: usize) -> Self::Edge

Return the edge associated with the given id.

impl<G> From<G> for ReverseDigraph<G>

fn from(g: G) -> Self

Performs the conversion.