How to use cascading.flow.planner.iso.finder

public Match findAllMatchesOnPrimary( PlannerContext plannerContext, ElementGraph elementGraph, Set<FlowElement> excludes )
 {
 return findMatchesOnPrimary( new FinderContext( excludes ), plannerContext, elementGraph, false );
 }

public Match findFirstMatch( PlannerContext plannerContext, ElementGraph elementGraph )
 {
 return findFirstMatch( new FinderContext(), plannerContext, elementGraph );
 }

private Iterator<Node> getIterator( SearchOrder searchOrder )
 {
 return SearchOrder.getNodeIterator( searchOrder, getDelegate() );
 }

protected Match findFirstMatch( FinderContext finderContext, PlannerContext plannerContext, ElementGraph elementGraph )
 {
 Map<ElementExpression, FlowElement> mapping = findMapping( finderContext, plannerContext, elementGraph );
 return new Match( matchExpression, elementGraph, mapping, mapping.values(), getCapturedEdges( plannerContext, elementGraph, mapping ) );
 }

public GraphAssert( ExpressionGraph expressionGraph, String message, AssertionType assertionType )
 {
 this.finder = new GraphFinder( expressionGraph );
 this.message = message;
 if( assertionType != null )
  this.assertionType = assertionType;
 }

public Map<ElementExpression, FlowElement> findMapping( PlannerContext plannerContext, ElementGraph elementGraph )
 {
 return findMapping( new FinderContext(), plannerContext, elementGraph );
 }

public ElementSubGraph getMatched()
 {
 return match.getMatchedGraph();
 }

public Edge getEdge( int lhsVertex, int rhsVertex )
 {
 Node lhsNode = getVertex( lhsVertex );
 Node rhsNode = getVertex( rhsVertex );
 return getDelegate().getEdge( lhsNode, rhsNode );
 }

public Set<FlowElement> getIncludedElements()
 {
 return getCapturedElements( ElementCapture.Include );
 }

private boolean tryToComputeNext()
 {
 state = StateEnum.FAILED; // temporary pessimism
 next = computeNext();
 if( state != StateEnum.DONE )
  {
  state = StateEnum.READY;
  return true;
  }
 return false;
 }

public State copy()
 {
 return new State( this );
 }

public ElementExpression getMatcherNode( int vertex )
 {
 return matchGraph.getVertex( vertex );
 }

public FlowElement getElementNode( int vertex )
 {
 return elementGraph.getVertex( vertex );
 }

@Override
public final T next()
 {
 if( !hasNext() )
  throw new NoSuchElementException();
 state = StateEnum.NOT_READY;
 return next;
 }
}

public Match findFirstMatch( PlannerContext plannerContext, ElementGraph elementGraph, Set<FlowElement> exclusions )
 {
 return findFirstMatch( new FinderContext( exclusions ), plannerContext, elementGraph );
 }

public Match findAllMatchesOnPrimary( PlannerContext plannerContext, ElementGraph elementGraph )
 {
 return findMatchesOnPrimary( new FinderContext(), plannerContext, elementGraph, false );
 }

protected RecursiveGraphTransformer( ExpressionGraph expressionGraph )
 {
 this.expressionGraph = expressionGraph;
 this.finder = new GraphFinder( expressionGraph );
 this.findAllPrimaries = expressionGraph.supportsNonRecursiveMatch();
 }

public Set<FlowElement> getAnchors()
 {
 return match.getCapturedElements( ElementCapture.Primary );
 }

public Match findMatchesOnPrimary( PlannerContext plannerContext, ElementGraph elementGraph, boolean firstOnly, Set<FlowElement> excludes )
 {
 return findMatchesOnPrimary( new FinderContext( excludes ), plannerContext, elementGraph, firstOnly );
 }

public SubGraphTransformer( GraphTransformer graphTransformer, ExpressionGraph subGraphMatcher )
 {
 this.graphTransformer = graphTransformer;
 this.subGraphMatcher = subGraphMatcher;
 this.subGraphFinder = new GraphFinder( subGraphMatcher );
 this.findAllPrimaries = subGraphMatcher.supportsNonRecursiveMatch();
 }