Interface PredecessorsFunction<N>

  • Type Parameters:
    N - Node parameter type
    All Known Subinterfaces:<N>, Graph<N>, MutableGraph<N>, MutableNetwork<N,​E>, MutableValueGraph<N,​V>, Network<N,​E>, ValueGraph<N,​V>
    All Known Implementing Classes:
    AbstractGraph, AbstractNetwork, AbstractValueGraph, ImmutableGraph, ImmutableNetwork, ImmutableValueGraph

    @DoNotMock("Implement with a lambda, or use GraphBuilder to build a Graph with the desired edges")
    public interface PredecessorsFunction<N>
    A functional interface for graph-structured data.

    This interface is meant to be used as the type of a parameter to graph algorithms (such as topological sort) that only need a way of accessing the predecessors of a node in a graph.


    Given an algorithm, for example:
     public <N> someGraphAlgorithm(N startNode, PredecessorsFunction<N> predecessorsFunction);
    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 PredecessorsFunction. 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 getParents() that retrieves its predecessors in a graph:

     someGraphAlgorithm(startNode, MyNode::getParents);

    If you have some other mechanism for returning the predecessors of a node, or one that doesn't return a Iterable<? extends N>, then you can use a lambda to perform a more general transformation:

     someGraphAlgorithm(startNode, node -> ImmutableList.of(node.mother(), node.father()));

    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.

    Additional documentation

    See the Guava User Guide for the common.graph package ("Graphs Explained") for additional documentation, including notes for implementors

    Joshua O'Madadhain, Jens Nyman
    • Method Summary

      All Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      Iterable<? extends N> predecessors​(N node)
      Returns all nodes in this graph adjacent to node which can be reached by traversing node's incoming edges against the direction (if any) of the edge.
    • Method Detail

      • predecessors

        Iterable<? extends Npredecessors​(N node)
        Returns all nodes in this graph adjacent to node which can be reached by traversing node's incoming edges against the direction (if any) of the edge.

        Some algorithms that operate on a PredecessorsFunction 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:

        • Non-null
        • Usable as Map keys (see the Guava User Guide's section on graph elements for details)
        IllegalArgumentException - if node is not an element of this graph