Struct daggy::walker::Peekable

pub struct Peekable<G, Ix, W> where
    Ix: IndexType,  { /* fields omitted */ }

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

Methods

impl<G, Ix, W> Peekable<G, Ix, W> where
    Ix: IndexType,
    W: Walker<G, Index = Ix>, 

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

The edge node index pair of the neighbor at the next step in our walk of the given graph.

pub fn peek_edge(&mut self, graph: &G) -> Option<EdgeIndex<Ix>>

The edge index of the neighbor at the next step in our walk of the given graph.

pub fn peek_node(&mut self, graph: &G) -> Option<NodeIndex<Ix>>

The node index of the neighbor at the next step in our walk of the given graph.

Trait Implementations

impl<G: Clone, Ix: Clone, W: Clone> Clone for Peekable<G, Ix, W> where
    Ix: IndexType, 

fn clone(&self) -> Peekable<G, Ix, W>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Debug, Ix: Debug, W: Debug> Debug for Peekable<G, Ix, W> where
    Ix: IndexType, 

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

Formats the value using the given formatter.

impl<G, Ix, W> Walker<G> for Peekable<G, Ix, W> where
    Ix: IndexType,
    W: Walker<G, Index = Ix>, 

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Important traits for Iter<'a, G, Ix, W>

impl<'a, G, Ix, W> Iterator for Iter<'a, G, Ix, W> where
    Ix: IndexType,
    W: Walker<G, Index = Ix>,  type Item = IndexPair<Ix>;

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

Converts the walker into an iterator yielding index pairs.

Important traits for IterWeights<'a, G, Ix, W>

impl<'a, G, Ix, W> Iterator for IterWeights<'a, G, Ix, W> where
    Ix: IndexType,
    W: Walker<G, Index = Ix>,
    G: Index<EdgeIndex<Ix>>,
    G: Index<NodeIndex<Ix>>,  type Item = (&'a <G as Index<EdgeIndex<Ix>>>::Output, &'a <G as Index<NodeIndex<Ix>>>::Output);

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.