Struct daggy::walker::Chain [] [src]

pub struct Chain<G, Ix, A, B> {
    // some fields omitted
}

Walks the entirety of a before walking the entirety of b.

Trait Implementations

impl<G, Ix, A, B> Walker<G> for Chain<G, Ix, A, B> where Ix: IndexType, A: Walker<G, Index=Ix>, B: Walker<G, Index=Ix>
[src]

type Index = Ix

The unsigned integer type used for node and edge indices.

fn next(&mut self, graph: &G) -> Option<IndexPair<Ix>>

Fetch the EdgeIndex and NodeIndex to the next neighbour in our walk through the given Graph. Read more

fn next_edge(&mut self, graph: &G) -> Option<EdgeIndex<Self::Index>>

The next edge in our walk for the given Graph.

fn next_node(&mut self, graph: &G) -> Option<NodeIndex<Self::Index>>

The next node in our walk for the given Graph.

fn count(self, graph: &G) -> usize where Self: Sized

Counts all the steps in the entire walk of the given graph.

fn last(self, graph: &G) -> Option<IndexPair<Self::Index>> where Self: Sized

Walks the whole walk until reaching and returning the last edge node pair.

fn last_edge(self, graph: &G) -> Option<EdgeIndex<Self::Index>> where Self: Sized

Walks the whole walk until reaching and returning the last edge.

fn last_node(self, graph: &G) -> Option<NodeIndex<Self::Index>> where Self: Sized

Walks the whole walk until reaching and returning the last node.

fn nth(self, graph: &G, n: usize) -> Option<IndexPair<Self::Index>> where Self: Sized

Walks "n" number of steps and produces the resulting edge node pair.

fn nth_edge(self, graph: &G, n: usize) -> Option<EdgeIndex<Self::Index>> where Self: Sized

Walks "n" number of steps and produces the resulting edge.

fn nth_node(self, graph: &G, n: usize) -> Option<NodeIndex<Self::Index>> where Self: Sized

Walks "n" number of steps and produces the resulting node.

fn chain<O>(self, other: O) -> Chain<G, Self::Index, Self, O> where Self: Sized, O: Walker<G, Index=Self::Index>

Produces a walker that will walk the entirey of self before walking the entirey of other.

fn filter<P>(self, predicate: P) -> Filter<Self, P> where Self: Sized, P: FnMut(&G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>) -> bool

Creates a walker that applies the predicate to each element returned by this walker. The only elements that will be yielded are those that make the predicate evaluate to true. Read more

fn peekable(self) -> Peekable<G, Self::Index, Self> where Self: Sized

Creates a walker that has a .peek(&graph) method that returns an optional next neighbor.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where Self: Sized, P: FnMut(&G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>) -> bool

Creates a walker that invokes the predicate on elements until it returns false. Once the predicate returns false, that element and all further elements are yielded. Read more

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where Self: Sized, P: FnMut(&G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>) -> bool

Creates a walker that yields elements so long as the predicate returns true. After the predicate returns false for the first time, no further elements will be yielded. Read more

fn skip(self, n: usize) -> Skip<G, Self::Index, Self> where Self: Sized

Creates a walker that skips the first n steps of this walk, and then yields all further steps. Read more

fn take(self, n: usize) -> Take<G, Self::Index, Self> where Self: Sized

Creates a walker that yields the first n steps of this walk.

fn all<P>(&mut self, graph: &G, predicate: P) -> bool where P: FnMut(&G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>) -> bool

Tests whether the predicate holds true for all steps in the walk.

fn any<P>(&mut self, graph: &G, predicate: P) -> bool where P: FnMut(&G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>) -> bool

Tests whether any step in the walk satisfies the given predicate. Read more

fn find<P>(&mut self, graph: &G, predicate: P) -> Option<IndexPair<Self::Index>> where P: FnMut(&G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>) -> bool

Returns the first edge node index pair satisfying the specified predicate. Read more

fn find_edge<P>(&mut self, graph: &G, predicate: P) -> Option<EdgeIndex<Self::Index>> where P: FnMut(&G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>) -> bool

Returns the edge index satisfying the specified predicate. Read more

fn find_node<P>(&mut self, graph: &G, predicate: P) -> Option<NodeIndex<Self::Index>> where P: FnMut(&G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>) -> bool

Returns the node index satisfying the specified predicate. Read more

fn cycle(self) -> Cycle<G, Self::Index, Self> where Self: Clone + Sized

Repeats the walker endlessly.

fn fold<B, F>(self, init: B, graph: &G, f: F) -> B where Self: Sized, F: FnMut(B, &G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>) -> B

Performs a fold operation over the entire walker, returning the eventual state at the end of the walk. Read more

fn inspect<F>(self, f: F) -> Inspect<Self, F> where Self: Sized, F: FnMut(&G, EdgeIndex<Self::Index>, NodeIndex<Self::Index>)

Creates a walker that calls a function with a reference to each index pair before yielding them. This is often useful for debugging a walker pipeline. Read more

fn iter(self, graph: &G) -> Iter<G, Self::Index, Self> where Self: Sized

Converts the walker into an iterator yielding index pairs. Read more

fn iter_weights(self, graph: &G) -> IterWeights<G, Self::Index, Self> where Self: Sized

Converts the walker into an iterator yielding (&e, &n), where e is the edge weight for the next EdgeIndex and n is the node weight for the next NodeIndex. Read more

Derived Implementations

impl<G: Debug, Ix: Debug, A: Debug, B: Debug> Debug for Chain<G, Ix, A, B>
[src]

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<G: Clone, Ix: Clone, A: Clone, B: Clone> Clone for Chain<G, Ix, A, B>
[src]

fn clone(&self) -> Chain<G, Ix, A, B>

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more