Struct rs_graph::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<G: Clone> Clone for ReverseDigraph<G>

fn clone(&self) -> ReverseDigraph<G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Copy> Copy for ReverseDigraph<G>

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

type OutEdge = G::InEdge

Type of a graph iterator over edges leaving a node.

type InEdge = G::OutEdge

Type of a graph iterator over edges entering a node.

type IncidentEdge = G::IncidentEdge

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 first_out(&'a self, u: Self::Node) -> Option<Self::OutEdge>

Return an iterator over the edges leaving a node.

fn next_out(&'a self, it: Self::OutEdge) -> Option<Self::OutEdge>

Advance the iterator to the next outgoing edge.

fn get_out(&'a self, it: &Self::OutEdge) -> (Self::Edge, Self::Node)

Return the edge and sink node of an outgoing edge iterator.

fn first_in(&'a self, u: Self::Node) -> Option<Self::InEdge>

Return an iterator over the edges entering a node.

fn next_in(&'a self, it: Self::InEdge) -> Option<Self::InEdge>

Advance the iterator to the next incoming edge.

fn get_in(&'a self, it: &Self::InEdge) -> (Self::Edge, Self::Node)

Return the edge and sink node of an incoming edge iterator.

fn first_incident(&'a self, u: Self::Node) -> Option<Self::IncidentEdge>

Return an iterator over the edges entering a node.

fn next_incident(&'a self, it: Self::IncidentEdge) -> Option<Self::IncidentEdge>

Advance the iterator to the next incoming edge.

fn get_incident(
    &'a self,
    it: &Self::IncidentEdge
) -> (Self::DirectedEdge, Self::Node)

Return the edge and sink node of an incoming edge iterator.

Important traits for OutEdgeIter<'a, G>

impl<'a, G> Iterator for OutEdgeIter<'a, G> where
    G: Directed<'a>,  type Item = (G::Edge, G::Node);

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

Return an iterator over the outgoing edges of a node.

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

Return access to the outgoing arcs via an Adjacencies trait.

Important traits for InEdgeIter<'a, G>

impl<'a, G> Iterator for InEdgeIter<'a, G> where
    G: Directed<'a>,  type Item = (G::Edge, G::Node);

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

Return an iterator over the incoming edges of a node.

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

Return access to the incoming arcs via an Adjacencies trait.

Important traits for IncidentEdgeIter<'a, G>

impl<'a, G> Iterator for IncidentEdgeIter<'a, G> where
    G: Directed<'a>,  type Item = (G::DirectedEdge, G::Node);

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

Return access to all incident edges of a node.

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

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

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

fn first_out(&self, u: Self::Node) -> Option<Self::OutEdge>

fn next_out(&self, it: Self::OutEdge) -> Option<Self::OutEdge>

fn get_out(&self, it: &Self::OutEdge) -> (Self::Edge, Self::Node)

fn first_in(&self, u: Self::Node) -> Option<Self::InEdge>

fn next_in(&self, it: Self::InEdge) -> Option<Self::InEdge>

fn get_in(&self, it: &Self::InEdge) -> (Self::Edge, Self::Node)

fn first_incident(&self, u: Self::Node) -> Option<Self::IncidentEdge>

fn next_incident(&self, it: Self::IncidentEdge) -> Option<Self::IncidentEdge>

fn get_incident(
    &self,
    it: &Self::IncidentEdge
) -> (Self::DirectedEdge, Self::Node)

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

fn from(g: G) -> Self

Performs the conversion.

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

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

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

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

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

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

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

type Neigh = G::Neigh

Type of a graph iterator over all incident edges.

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

Return the nodes connected by an edge.

fn first_neigh(&'a self, u: Self::Node) -> Option<Self::Neigh>

Return an iterator over the edges adjacent to some node.

fn next_neigh(&'a self, it: Self::Neigh) -> Option<Self::Neigh>

Advance the iterator to the next adjacent edge.

fn get_neigh(&'a self, it: &Self::Neigh) -> (Self::Edge, Self::Node)

Return the edge and neighboring node of an iterator.

Important traits for NeighIter<'a, G>

impl<'a, G> Iterator for NeighIter<'a, G> where
    G: Undirected<'a>,  type Item = (G::Edge, G::Node);

fn neighs(&'a self, u: Self::Node) -> NeighIter<Self> 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<G> where
    G: UndirectedRef<'a>, 

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

fn first_neigh(&self, u: Self::Node) -> Option<Self::Neigh>

fn next_neigh(&self, it: Self::Neigh) -> Option<Self::Neigh>

fn get_neigh(&self, it: &Self::Neigh) -> (Self::Edge, Self::Node)