Struct daggy::petgraph::graph::WalkNeighbors

pub struct WalkNeighbors<Ix> {
    // some fields omitted
}

A “walker” object that can be used to step through the edge list of a node.

Created with .detach().

The walker does not borrow from the graph, so it lets you step through neighbors or incident edges while also mutating graph weights, as in the following example:

use petgraph::{Graph, Dfs, Incoming};

let mut gr = Graph::new();
let a = gr.add_node(0.);
let b = gr.add_node(0.);
let c = gr.add_node(0.);
gr.add_edge(a, b, 3.);
gr.add_edge(b, c, 2.);
gr.add_edge(c, b, 1.);

// step through the graph and sum incoming edges into the node weight
let mut dfs = Dfs::new(&gr, a);
while let Some(node) = dfs.next(&gr) {
    // use a detached neighbors walker
    let mut edges = gr.neighbors_directed(node, Incoming).detach();
    while let Some(edge) = edges.next_edge(&gr) {
        gr[node] += gr[edge];
    }
}

// check the result
assert_eq!(gr[a], 0.);
assert_eq!(gr[b], 4.);
assert_eq!(gr[c], 2.);

Methods

impl<Ix> WalkNeighbors<Ix> where Ix: IndexType

fn next<N, E, Ty>(&mut self, g: &Graph<N, E, Ty, Ix>) -> Option<(EdgeIndex<Ix>, NodeIndex<Ix>)> where Ty: EdgeType

Step to the next edge and its endpoint node in the walk for graph g.

The next node indices are always the others than the starting point where the WalkNeighbors value was created. For an Outgoing walk, the target nodes, for an Incoming walk, the source nodes of the edge.

fn next_node<N, E, Ty>(&mut self, g: &Graph<N, E, Ty, Ix>) -> Option<NodeIndex<Ix>> where Ty: EdgeType

fn next_edge<N, E, Ty>(&mut self, g: &Graph<N, E, Ty, Ix>) -> Option<EdgeIndex<Ix>> where Ty: EdgeType

Trait Implementations

impl<Ix> Clone for WalkNeighbors<Ix> where Ix: IndexType

fn clone(&self) -> WalkNeighbors<Ix>

Returns a copy of the value.

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

Performs copy-assignment from source.