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::LinkedListGraph;
use rs_graph::traits::*;
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> GraphType<'a> for ReverseDigraph<G> where
    G: GraphType<'a>, 

type Node = G::Node

Type of a node.

type Edge = G::Edge

Type of an edge.

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

type NodeIter = G::NodeIter

Type of an iterator over all nodes.

type EdgeIter = G::EdgeIter

Type of an iterator over all edges.

fn num_nodes(&self) -> usize

Return the number of nodes in the graph.

fn num_edges(&self) -> usize

Return the number of edges in the graph.

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

Return an iterator over all nodes.

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

Return an iterator over all edges.

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

type NeighIter = G::NeighIter

Type of an iterator over all incident edges.

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

Return the nodes connected by an edge.

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

Return an iterator over the edges adjacent to some node.

fn neighbors(&'a self) -> Neighbors<'a, Self> where
    Self: Sized, 

Return access to the neighbors via an Adjacencies trait.

impl<'a, G> Directed<'a> for ReverseDigraph<G> where
    G: Directed<'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.

fn outgoing(&'a self) -> OutEdges<'a, Self> where
    Self: Sized, 

Return access to the outgoing arcs via an Adjacencies trait.

fn incoming(&'a self) -> InEdges<'a, Self> where
    Self: Sized, 

Return access to the incoming arcs via an Adjacencies trait.

impl<'a, G> BiDirected<'a> for ReverseDigraph<G> where
    G: BiDirected<'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> 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> 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.