How to use

FlowNodeGraph

in

cascading.flow.planner.process

private void printFlowStep() {
  Iterator<FlowNode> iterator = getFlowNodeGraph().getTopologicalIterator();
  LOG.info("Step Cnt: {} ", getFlowNodeGraph().vertexSet().size());
  LOG.info("Edge Cnt: {} ", getFlowNodeGraph().edgeSet().size());
  LOG.info("Src Set: {} ", getFlowNodeGraph().getSourceElements());
  LOG.info("Snk Set: {} ", getFlowNodeGraph().getSinkElements());
  LOG.info("##############");
  while(iterator.hasNext()) {
    FlowNode next = iterator.next();
    LOG.info("Node cnt: {} ", next.getElementGraph().vertexSet().size());
    LOG.info("Edge cnt: {} ", next.getElementGraph().edgeSet().size());
    LOG.info("Nodes: {} ", next.getElementGraph().vertexSet());
    LOG.info("-----------");
  }
}

public FlowNodeGraph( FlowNodeFactory flowNodeFactory, FlowElementGraph flowElementGraph, List<? extends ElementGraph> nodeSubGraphs, Map<ElementGraph, List<? extends ElementGraph>> pipelineSubGraphsMap )
 {
 buildGraph( flowNodeFactory, flowElementGraph, nodeSubGraphs, pipelineSubGraphsMap );
 // consistently sets ordinal of node based on topological dependencies and tie breaking by the given Comparator
 Iterator<FlowNode> iterator = getOrderedTopologicalIterator();
 int ordinal = 0;
 int size = vertexSet().size();
 while( iterator.hasNext() )
  {
  BaseFlowNode next = (BaseFlowNode) iterator.next();
  next.setOrdinal( ordinal );
  next.setName( flowNodeFactory.makeFlowNodeName( next, size, ordinal ) );
  ordinal++;
  }
 }

private ElementGraph createStepElementGraph( FlowNodeGraph flowNodeGraph )
 {
 return ElementGraphs.asElementDirectedGraph( flowNodeGraph.getElementGraphs() ).bindExtents();
 }

protected void buildGraph( FlowNodeFactory flowNodeFactory, FlowElementGraph flowElementGraph, List<? extends ElementGraph> nodeSubGraphs, Map<ElementGraph, List<? extends ElementGraph>> pipelineSubGraphsMap )
 {
 if( pipelineSubGraphsMap == null )
  pipelineSubGraphsMap = Collections.emptyMap();
 for( ElementGraph nodeSubGraph : nodeSubGraphs )
  {
  List<? extends ElementGraph> pipelineGraphs = pipelineSubGraphsMap.get( nodeSubGraph );
  FlowNode flowNode = flowNodeFactory.createFlowNode( flowElementGraph, nodeSubGraph, pipelineGraphs );
  addVertex( flowNode );
  }
 bindEdges();
 }

protected FlowNodeGraph createFlowNodeGraph( List<ElementGraph> elementGraphs )
 {
 ElementGraph mapElementGraph = elementGraphs.get( 0 );
 ElementGraph reduceElementGraph = elementGraphs.size() == 2 ? elementGraphs.get( 1 ) : null;
 FlowNodeGraph flowNodeGraph = new FlowNodeGraph();
 int nodes = elementGraphs.size();
 FlowNode mapperNode = new BaseFlowNode( mapElementGraph, String.format( "(1/%s)", nodes ), 0 );
 flowNodeGraph.addVertex( mapperNode );
 if( nodes == 2 )
  {
  FlowNode reducerNode = new BaseFlowNode( reduceElementGraph, "(2/2)", 1 );
  flowNodeGraph.addVertex( reducerNode );
  flowNodeGraph.addEdge( mapperNode, reducerNode, new ProcessEdge( mapperNode, reducerNode ) );
  }
 return flowNodeGraph;
 }
}

Iterator<FlowNode> iterator = nodeGraph.getOrderedTopologicalIterator(); // ordering of nodes for consistent remote debugging
for( ProcessEdge processEdge : nodeGraph.edgeSet() )
 FlowNode edgeTargetFlowNode = nodeGraph.getEdgeTarget( processEdge );
 List<FlowNode> sourceNodes = nodeGraph.getElementSourceProcesses( flowElement );
  FlowNode edgeSourceFlowNode = nodeGraph.getEdgeSource( processEdge );
  Vertex sourceVertex = vertexMap.get( edgeSourceFlowNode );
   processedEdges.add( nodeGraph.getEdge( edgeSourceFlowNode, edgeTargetFlowNode ) );

ProcessEdge processEdge = Util.getFirst( getFlowNodeGraph().edgeSet() );
Iterator<FlowNode> iterator = getFlowNodeGraph().getTopologicalIterator();

@Override
public int getNumFlowNodes()
 {
 return flowNodeGraph.vertexSet().size();
 }

for( FlowNode current : step.getFlowNodeGraph().vertexSet() )
 if( step.getFlowNodeGraph().inDegreeOf( current ) == 0 )

flowNodeGraph.writeDOTNested( stepNodeElementGraphName, stepSubGraph );
flowNodeGraph.writeDOT( stepNodeGraphName );
Iterator<FlowNode> iterator = flowNodeGraph.getOrderedTopologicalIterator();

Iterator<FlowNode> iterator = flowStep.getFlowNodeGraph().getOrderedTopologicalIterator();

protected FlowNodeGraph createFlowNodeGraph( FlowStepFactory flowStepFactory, FlowElementGraph flowElementGraph, Map<ElementGraph, List<? extends ElementGraph>> pipelineSubGraphsMap, List<? extends ElementGraph> nodeSubGraphs )
 {
 return new FlowNodeGraph( flowStepFactory.getFlowNodeFactory(), flowElementGraph, nodeSubGraphs, pipelineSubGraphsMap );
 }
}

Iterator<FlowNode> iterator = flowNodeGraph.getTopologicalIterator();

Iterator<FlowNode> iterator = nodeGraph.getOrderedTopologicalIterator(); // ordering of nodes for consistent remote debugging
for( ProcessEdge processEdge : nodeGraph.edgeSet() )
 FlowNode edgeTargetFlowNode = nodeGraph.getEdgeTarget( processEdge );
 List<FlowNode> sourceNodes = nodeGraph.getElementSourceProcesses( flowElement );
  FlowNode edgeSourceFlowNode = nodeGraph.getEdgeSource( processEdge );
  Vertex sourceVertex = vertexMap.get( edgeSourceFlowNode );
   processedEdges.add( nodeGraph.getEdge( edgeSourceFlowNode, edgeTargetFlowNode ) );

protected FlowNodeGraph createFlowNodeGraph( List<ElementGraph> elementGraphs )
 {
 ElementGraph mapElementGraph = elementGraphs.get( 0 );
 ElementGraph reduceElementGraph = elementGraphs.size() == 2 ? elementGraphs.get( 1 ) : null;
 FlowNodeGraph flowNodeGraph = new FlowNodeGraph();
 int nodes = elementGraphs.size();
 FlowNode mapperNode = new BaseFlowNode( mapElementGraph, String.format( "(1/%s)", nodes ), 0 );
 flowNodeGraph.addVertex( mapperNode );
 if( nodes == 2 )
  {
  FlowNode reducerNode = new BaseFlowNode( reduceElementGraph, "(2/2)", 1 );
  flowNodeGraph.addVertex( reducerNode );
  flowNodeGraph.addEdge( mapperNode, reducerNode, new ProcessEdge( mapperNode, reducerNode ) );
  }
 return flowNodeGraph;
 }
}

ProcessEdge processEdge = Util.getFirst( getFlowNodeGraph().edgeSet() );
Iterator<FlowNode> iterator = getFlowNodeGraph().getTopologicalIterator();

public Set<FlowElement> getFlowElementsFor( Enum annotation )
 {
 Set<FlowElement> results = createIdentitySet();
 for( FlowNode flowNode : vertexSet() )
  results.addAll( flowNode.getFlowElementsFor( annotation ) );
 return results;
 }

for( FlowNode current : step.getFlowNodeGraph().vertexSet() )
 if( step.getFlowNodeGraph().inDegreeOf( current ) == 0 )

Iterator<FlowNode> iterator = flowStep.getFlowNodeGraph().getOrderedTopologicalIterator();

public LocalStepRunner( FlowProcess<Properties> flowProcess, LocalFlowStep step )
 {
 this.currentProcess = flowProcess;
 this.flowNode = Util.getFirst( step.getFlowNodeGraph().vertexSet() );
 this.streamGraph = new LocalStepStreamGraph( this.currentProcess, step, flowNode );
 this.heads = streamGraph.getHeads();
 }