Struct rs_graph::adapters::network::Network

pub struct Network<G>(_);

The network graph adaptor.

It is meant to be used by borrowing the underlying graph.

let g = classes::cycle::<LinkedListGraph>(5);
let n = Network::new(&g);

The network inherits all trait implementations from the underlying graph. In particular, if the underlying graph implements IndexGraph then nodes and edges of the network are numbered, too:

• The node_id is the same as in the underlying graph,
• the edge with id i is mapped to the edges 2*i (forward edge) and 2*i+1 (backward edge).

Methods

impl<'a, G> Network<G> where
    G: Digraph<'a>, 

pub fn new(g: G) -> Self

Create a new network adapter wrapping g.

pub fn as_graph(&self) -> &G

Return a reference to the underlying graph.

pub fn into_graph(self) -> G

Return the underlying graph.

pub fn from_edge(&self, e: G::Edge) -> NetworkEdge<G::Edge>

Return the forward edge corresponding the edge e in the underlying graph.

Trait Implementations

impl<G: Clone> Clone for Network<G>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Copy> Copy for Network<G>

impl<'a, G> Directed<'a> for Network<G> where
    G: Digraph<'a>, 

type OutEdge = NetworkOutEdge<G::IncidentEdge>

Type of a graph iterator over edges leaving a node.

type InEdge = NetworkInEdge<G::IncidentEdge>

Type of a graph iterator over edges entering a node.

type IncidentEdge = NetworkIncidentEdge<G::IncidentEdge>

Type of an iterator over all incident edges.

type DirectedEdge = NetworkDirectedEdge<Self::Edge>

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 Network<&'a G> where
    G: 'a + Directed<'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<'a, G> GraphSize<'a> for Network<G> where
    G: Digraph<'a>, 

type NodeIter = G::NodeIter

Type of an iterator over all nodes.

type EdgeIter = NetworkEdgeIter<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 Network<&'a G> where
    G: Directed<'a>, 

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

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

impl<'a, G> GraphType<'a> for Network<G> where
    G: Digraph<'a>, 

type Node = G::Node

Type of a node.

type Edge = NetworkEdge<G::Edge>

Type of an edge.

impl<'a, G> IndexGraph<'a> for Network<G> where
    G: Digraph<'a> + 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 Network<&'a G> where
    G: Directed<'a> + IndexGraph<'a>, 

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

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

impl<'a, G> Undirected<'a> for Network<G> where
    G: Digraph<'a>, 

type Neigh = NetworkEdge<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 Network<&'a G> where
    G: Directed<'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)