Type Definition conrod_core::graph::Children

type Children = Children<Node, Edge, u32>;

A Walker over some node’s child nodes.

Trait Implementations

impl Walker<Graph> for Children

type Index = u32

The unsigned integer type used for node and edge indices.

fn next(&mut self, graph: &Graph) -> Option<(EdgeIndex, Id)>

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

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

The next edge in our walk for the given Graph.

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

The next node in our walk for the given Graph.

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

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

pub 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.

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

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

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

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

pub 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.

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

Walks “n” number of steps and produces the resulting edge.

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

Walks “n” number of steps and produces the resulting node.

pub 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.

pub 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.

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

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

pub 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.

pub 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.

pub 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.

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

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

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

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

Repeats the walker endlessly.

pub 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.

pub 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.

pub fn iter(self, graph: &G) -> Iter<'_, G, Self::Index, Self>

Converts the walker into an iterator yielding index pairs.

pub 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.