Struct rs_graph::ReverseDigraph

pub struct ReverseDigraph<'a, 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: Clone> Clone for ReverseDigraph<'a, G>

fn clone(&self) -> ReverseDigraph<'a, G>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, G: Copy> Copy for ReverseDigraph<'a, G>

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

type OutIt = ReverseWrapIt<G::InIt>

Type of a graph iterator over edges leaving a node.

type InIt = ReverseWrapIt<G::OutIt>

Type of a graph iterator over edges entering a node.

type IncidentIt = ReverseIncidentIt<G::IncidentIt>

Type of an iterator over all incident edges.

type DirectedEdge = ReverseDirectedEdge<G::DirectedEdge>

Type of a directed edge.

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 out_iter(&'a self, u: Self::Node) -> Self::OutIt

Return a graph iterator over the edges leaving a node.

fn in_iter(&'a self, u: Self::Node) -> Self::InIt

Return a graph iterator over the edges leaving a node.

fn incident_iter(&'a self, u: Self::Node) -> Self::IncidentIt

Return an iterator over all directed edges incident with a node.

fn outedges(&'a self, u: Self::Node) -> GraphIter<'a, Self, Self::OutIt> where
    Self: Sized, 

Return an iterator over the edges leaving a node.

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

Return access to the outgoing arcs via an Adjacencies trait.

fn inedges(&'a self, u: Self::Node) -> GraphIter<'a, Self, Self::InIt> where
    Self: Sized, 

Return an iterator over the edges leaving a node.

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

Return access to the incoming arcs via an Adjacencies trait.

fn incident_edges(
    &'a self,
    u: Self::Node
) -> GraphIter<'a, Self, Self::IncidentIt> where
    Self: Sized, 

Return an iterator over all directed edges incident with a node.

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

fn src(&self, u: Self::Edge) -> Self::Node

fn snk(&self, u: Self::Edge) -> Self::Node

fn out_iter(&self, u: Self::Node) -> Self::OutIt

fn in_iter(&self, u: Self::Node) -> Self::InIt

fn incident_iter(&self, u: Self::Node) -> Self::IncidentIt

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

type NodeIt = ReverseWrapIt<G::NodeIt>

Type of an iterator over all nodes.

type EdgeIt = ReverseWrapIt<G::EdgeIt>

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_iter(&self) -> Self::NodeIt

Return a graph iterator over all nodes.

fn edges_iter(&self) -> Self::EdgeIt

Return a graph iterator over all edges.

fn nodes(&'a self) -> NodeIterator<'a, Self> where
    Self: Sized, 

Return an iterator over all nodes.

fn edges(&'a self) -> EdgeIterator<'a, Self> where
    Self: Sized, 

Return an iterator over all edges.

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

fn nodes_iter(&self) -> Self::NodeIt

fn edges_iter(&self) -> Self::EdgeIt

fn nodes<'b>(&'b self) -> GraphIter<'b, Self, Self::NodeIt> where
    Self: Sized,
    'a: 'b, 

fn edges<'b>(&'b self) -> GraphIter<'b, Self, Self::EdgeIt> where
    Self: Sized,
    'a: 'b, 

impl<'a, 'g: 'a, G> GraphType<'a> for ReverseDigraph<'g, G> where
    G: GraphType<'g>, 

type Node = G::Node

Type of a node.

type Edge = G::Edge

Type of an edge.

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

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

Return a unique id associated with a node.

fn id2node(&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(&self, id: usize) -> Self::Edge

Return the edge associated with the given id.

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

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

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

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

type NeighIt = ReverseWrapIt<G::NeighIt>

Type of a graph iterator over all incident edges.

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

Return the nodes connected by an edge.

fn neigh_iter(&self, u: Self::Node) -> Self::NeighIt

Return a graph iterator over the edges adjacent to some node.

fn neighs(&'a self, u: Self::Node) -> GraphIter<'a, Self, Self::NeighIt> where
    Self: Sized, 

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

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

fn neigh_iter(&self, u: Self::Node) -> Self::NeighIt