# Struct dsp::Inputs
[−]
[src]

pub struct Inputs<F, N> { // some fields omitted }

A walker object for walking over nodes that are inputs to some node.

## Trait Implementations

`impl<F, N> Walker<Graph<F, N>> for Inputs<F, N>`

[src]

`type Index = usize`

The unsigned integer type used for node and edge indices.

`fn next(&mut self, graph: &Graph<F, N>) -> Option<(EdgeIndex, NodeIndex)>`

The next (connection, node) input pair to some node in our walk for the given **Graph**.

`fn next_edge(&mut self, graph: &Graph<F, N>) -> Option<EdgeIndex>`

The next input connection to some node in our walk for the given **Graph**.

`fn next_node(&mut self, graph: &Graph<F, N>) -> Option<NodeIndex>`

The next input node to some node in our walk for the given **Graph**.

`fn count(self, graph: &G) -> usize`

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

`fn last(self, graph: &G) -> Option<(EdgeIndex<Self::Index>, NodeIndex<Self::Index>)>`

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

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

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

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

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

`fn nth(self, graph: &G, n: usize) -> Option<(EdgeIndex<Self::Index>, NodeIndex<Self::Index>)>`

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

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

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

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

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

`fn chain<O>(self, other: O) -> Chain<G, Self::Index, Self, O> where 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 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>`

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 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 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>`

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>`

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<(EdgeIndex<Self::Index>, NodeIndex<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`

Repeats the walker endlessly.

`fn fold<B, F>(self, init: B, graph: &G, f: F) -> B where 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 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>`

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

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

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