N
- Node parameter type@Beta @DoNotMock(value="Implement with a lambda, or use GraphBuilder to build a Graph with the desired edges") public interface SuccessorsFunction<N>
This interface is meant to be used as the type of a parameter to graph algorithms (such as breadth first traversal) that only need a way of accessing the successors of a node in a graph.
public <N> someGraphAlgorithm(N startNode, SuccessorsFunction<N> successorsFunction);
you will invoke it depending on the graph representation you're using.
If you have an instance of one of the primary common.graph
types (Graph
,
ValueGraph
, and Network
):
someGraphAlgorithm(startNode, graph);
This works because those types each implement SuccessorsFunction
. It will also work with
any other implementation of this interface.
If you have your own graph implementation based around a custom node type MyNode
,
which has a method getChildren()
that retrieves its successors in a graph:
someGraphAlgorithm(startNode, MyNode::getChildren);
If you have some other mechanism for returning the successors of a node, or one that doesn't
return an Iterable<? extends N>
, then you can use a lambda to perform a more general
transformation:
someGraphAlgorithm(startNode, node -> ImmutableList.of(node.leftChild(), node.rightChild()));
Graph algorithms that need additional capabilities (accessing both predecessors and
successors, iterating over the edges, etc.) should declare their input to be of a type that
provides those capabilities, such as Graph
, ValueGraph
, or Network
.
See the Guava User Guide for the common.graph
package ("Graphs Explained") for
additional documentation, including notes for
implementors
Modifier and Type | Method and Description |
---|---|
Iterable<? extends N> |
successors(N node)
Returns all nodes in this graph adjacent to
node which can be reached by traversing
node 's outgoing edges in the direction (if any) of the edge. |
Iterable<? extends N> successors(N node)
node
which can be reached by traversing
node
's outgoing edges in the direction (if any) of the edge.
This is not the same as "all nodes reachable from node
by following outgoing
edges". For that functionality, see Graphs.reachableNodes(Graph, Object)
.
Some algorithms that operate on a SuccessorsFunction
may produce undesired results
if the returned Iterable
contains duplicate elements. Implementations of such
algorithms should document their behavior in the presence of duplicates.
The elements of the returned Iterable
must each be:
Map
keys (see the Guava User Guide's section on
graph elements for details)
IllegalArgumentException
- if node
is not an element of this graphCopyright © 2010–2019. All rights reserved.