## cascading.flow.planner
Class ElementGraphs

    java.lang.Object
      cascading.flow.planner.ElementGraphs

    public class ElementGraphs

extends Object

Constructor Summary
`ElementGraphs()`

Method Summary
`static List<List<FlowElement>>` `asPathList(List<org.jgrapht.GraphPath<FlowElement,Scope>> paths)`
`static Map<Integer,Integer>` `countOrderedDirectPathsBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph, FlowElement from, Splice to)` for every incoming stream to the splice, gets the count of paths.
`static Map<Integer,Integer>` `countOrderedDirectPathsBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph, FlowElement from, Splice to, boolean skipTaps)`
`static int` `countPaths(Map<Integer,Integer> pathCounts)`
`static int` `countTypesBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph, FlowElement from, Splice to, Class type)`
`static List<org.jgrapht.GraphPath<FlowElement,Scope>>` `getAllDirectPathsBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph, FlowElement from, FlowElement to)` All paths that lead from to to without crossing a Tap/Group boundary
`static List<org.jgrapht.GraphPath<FlowElement,Scope>>` `getAllShortestPathsBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph, FlowElement from, FlowElement to)` Method getAllShortestPathsBetween ...
`static boolean` `isBothAccumulatedAndStreamedPath(Map<Integer,Integer> pathCounts)`
`static boolean` `isOnlyAccumulatedPath(Map<Integer,Integer> pathCounts)`
`static boolean` `isOnlyStreamedPath(Map<Integer,Integer> pathCounts)`
`static int` `pathPositionInto(org.jgrapht.GraphPath<FlowElement,Scope> path, Splice to)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ElementGraphs

    public ElementGraphs()

Method Detail

### getAllShortestPathsBetween

    public static List<org.jgrapht.GraphPath<FlowElement,Scope>> getAllShortestPathsBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph,
                                                                                            FlowElement from,
                                                                                            FlowElement to)

  Method getAllShortestPathsBetween ...

  Parameters:
    `graph` -
    `from` - of type FlowElement
    `to` - of type FlowElement
  Returns:
    List<GraphPath<FlowElement, Scope>>

### asPathList

    public static List<List<FlowElement>> asPathList(List<org.jgrapht.GraphPath<FlowElement,Scope>> paths)

### getAllDirectPathsBetween

    public static List<org.jgrapht.GraphPath<FlowElement,Scope>> getAllDirectPathsBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph,
                                                                                          FlowElement from,
                                                                                          FlowElement to)

  All paths that lead from to to without crossing a Tap/Group boundary

  Parameters:
    `graph` -
    `from` -
    `to` -
  Returns:
    of type List

### countTypesBetween

    public static int countTypesBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph,
                                        FlowElement from,
                                        Splice to,
                                        Class type)

### countOrderedDirectPathsBetween

    public static Map<Integer,Integer> countOrderedDirectPathsBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph,
                                                                      FlowElement from,
                                                                      Splice to)

  for every incoming stream to the splice, gets the count of paths.

  covers the case where a source may cross multiple joins to the current join and still land on the lhs or rhs.

  Parameters:
    `graph` -
    `from` -
    `to` -
  Returns:
    of type Map

### countOrderedDirectPathsBetween

    public static Map<Integer,Integer> countOrderedDirectPathsBetween(org.jgrapht.graph.SimpleDirectedGraph<FlowElement,Scope> graph,
                                                                      FlowElement from,
                                                                      Splice to,
                                                                      boolean skipTaps)

### isBothAccumulatedAndStreamedPath

    public static boolean isBothAccumulatedAndStreamedPath(Map<Integer,Integer> pathCounts)

### isOnlyStreamedPath

    public static boolean isOnlyStreamedPath(Map<Integer,Integer> pathCounts)

### isOnlyAccumulatedPath

    public static boolean isOnlyAccumulatedPath(Map<Integer,Integer> pathCounts)

### countPaths

    public static int countPaths(Map<Integer,Integer> pathCounts)

### pathPositionInto

    public static int pathPositionInto(org.jgrapht.GraphPath<FlowElement,Scope> path,
                                       Splice to)

Copyright © 2007-2014 Concurrent, Inc. All Rights Reserved.