int stateIndex = 0; while (it.hasNext()) { Node n = (Node) it.next(); if (n instanceof ProcessorNode) { ProcessorNode pn = (ProcessorNode) n;
@Override public List<Flow> getFlows() { List<Flow> flows = new LinkedList<Flow>(); TopologicalOrderIterator<Flow, Integer> topoIterator = flowGraph.getTopologicalIterator(); while( topoIterator.hasNext() ) flows.add( topoIterator.next() ); return flows; }
/** * Gets the (found) dependencies of the add-on, including transitive dependencies. * * @return a set containing the dependencies of the add-on * @see AddOn#getIdsAddOnDependencies() */ public Set<AddOn> getDependencies() { if (dependencies == null) { dependencies = new HashSet<>(); for (TopologicalOrderIterator<AddOn, DefaultEdge> it = new TopologicalOrderIterator<>(dependencyTree); it.hasNext();) { dependencies.add(it.next()); } dependencies.remove(addOn); } return Collections.unmodifiableSet(dependencies); }
/** * This method will * <ul> * <li>Order the {@link #predicateDependencyGraph} using a top down approach</li> * <li>Then reverse the list and add them into the field {@link #predicatesInBottomUp} </li> * </ul> */ private void generateOrderedDepGraph() { TopologicalOrderIterator<Predicate, DefaultEdge> iter = new TopologicalOrderIterator<Predicate, DefaultEdge>(predicateDependencyGraph); while (iter.hasNext()){ Predicate pred = iter.next(); predicatesInBottomUp.add(pred); } Collections.reverse(predicatesInBottomUp); }
/** * This method will * <ul> * <li>Order the {@link #predicateDependencyGraph} using a top down approach</li> * <li>Then reverse the list and add them into the field {@link #predicatesInBottomUp} </li> * </ul> */ private void generateOrderedDepGraph() { TopologicalOrderIterator<Predicate, DefaultEdge> iter = new TopologicalOrderIterator<Predicate, DefaultEdge>(predicateDependencyGraph); while (iter.hasNext()){ Predicate pred = iter.next(); predicatesInBottomUp.add(pred); } Collections.reverse(predicatesInBottomUp); }
private void verifyNoCycles() { Set<Flow> flows = new HashSet<>(); TopologicalOrderIterator<Flow, Integer> topoIterator = new TopologicalOrderIterator<Flow, Integer>( this ); while( topoIterator.hasNext() ) flows.add( topoIterator.next() ); if( flows.size() != vertexSet().size() ) throw new CascadeException( "there are likely cycles in the set of given flows, topological iterator cannot traverse flows with cycles" ); }
private List<Annotation> getOrderedReferences(DefaultDirectedGraph<Annotation, DefaultEdge> g) { CycleDetector<Annotation, DefaultEdge> cycleDetector = new CycleDetector<Annotation, DefaultEdge>(g); if (cycleDetector.detectCycles()) { throw new CycleException(cycleDetector); } List<Annotation> ret = new ArrayList<Annotation>(); TopologicalOrderIterator<Annotation, DefaultEdge> orderIterator = new TopologicalOrderIterator<Annotation, DefaultEdge>(g); while (orderIterator.hasNext()) { ret.add(orderIterator.next()); } return ret; }
/** Calls prepare starting at the tail and working backwards */ public void prepare() { TopologicalOrderIterator<Duct, Integer> iterator = getReversedTopologicalOrderIterator(); while( iterator.hasNext() ) iterator.next().prepare(); }
/** Calls cleanup starting at the head and working forwards */ public void cleanup() { TopologicalOrderIterator<Duct, Integer> iterator = getTopologicalOrderIterator(); while( iterator.hasNext() ) iterator.next().cleanup(); }
private void build(Task task, ImmutableList.Builder<RunnableTaskDag> entriesBuilder, ImmutableMap.Builder<TaskId, Task> tasksBuilder) { DefaultDirectedGraph<TaskId, DefaultEdge> graph = new DefaultDirectedGraph<>(DefaultEdge.class); worker(graph, task, null, tasksBuilder, Sets.newHashSet()); CycleDetector<TaskId, DefaultEdge> cycleDetector = new CycleDetector<>(graph); if ( cycleDetector.detectCycles() ) { throw new RuntimeException("The Task DAG contains cycles: " + task); } TopologicalOrderIterator<TaskId, DefaultEdge> orderIterator = new TopologicalOrderIterator<>(graph); while ( orderIterator.hasNext() ) { TaskId taskId = orderIterator.next(); Set<DefaultEdge> taskIdEdges = graph.edgesOf(taskId); Set<TaskId> processed = taskIdEdges .stream() .map(graph::getEdgeSource) .filter(edge -> !edge.equals(taskId) && !edge.getId().equals("")) .collect(Collectors.toSet()); entriesBuilder.add(new RunnableTaskDag(taskId, processed)); } }
new TopologicalOrderIterator<>(graph); iterator.hasNext(); ) { String ifaceName = iterator.next(); deactivateInterfaceIfNeeded(allInterfaces.get(ifaceName));
private void initializeNewJobsMap() { synchronized( jobsMap ) { // keep topo order TopologicalOrderIterator<Flow, Integer> topoIterator = flowGraph.getTopologicalIterator(); while( topoIterator.hasNext() ) { Flow flow = topoIterator.next(); cascadeStats.addFlowStats( flow.getFlowStats() ); CascadeJob job = new CascadeJob( flow ); jobsMap.put( flow.getName(), job ); List<CascadeJob> predecessors = new ArrayList<CascadeJob>(); for( Flow predecessor : Graphs.predecessorListOf( flowGraph, flow ) ) predecessors.add( (CascadeJob) jobsMap.get( predecessor.getName() ) ); job.init( predecessors ); } } }
/** * Perform the entire sort operation */ private void sort() { DefaultDirectedWeightedGraph<RuleProvider, DefaultEdge> graph = new DefaultDirectedWeightedGraph<>( DefaultEdge.class); for (RuleProvider provider : providers) { graph.addVertex(provider); } addProviderRelationships(graph); checkForCycles(graph); List<RuleProvider> result = new ArrayList<>(this.providers.size()); TopologicalOrderIterator<RuleProvider, DefaultEdge> iterator = new TopologicalOrderIterator<>(graph); while (iterator.hasNext()) { RuleProvider provider = iterator.next(); result.add(provider); } this.providers = Collections.unmodifiableList(result); int index = 0; for (RuleProvider provider : this.providers) { if (provider instanceof AbstractRuleProvider) ((AbstractRuleProvider) provider).setExecutionIndex(index++); } }
/** * Perform the entire sort operation */ private void sort() { DefaultDirectedWeightedGraph<RuleProvider, DefaultEdge> graph = new DefaultDirectedWeightedGraph<>( DefaultEdge.class); for (RuleProvider provider : providers) { graph.addVertex(provider); } addProviderRelationships(graph); checkForCycles(graph); List<RuleProvider> result = new ArrayList<>(this.providers.size()); TopologicalOrderIterator<RuleProvider, DefaultEdge> iterator = new TopologicalOrderIterator<>(graph); while (iterator.hasNext()) { RuleProvider provider = iterator.next(); result.add(provider); } this.providers = Collections.unmodifiableList(result); int index = 0; for (RuleProvider provider : this.providers) { if (provider instanceof AbstractRuleProvider) ((AbstractRuleProvider) provider).setExecutionIndex(index++); } }
List<Observable<EnunciateContext>> leafModules = new ArrayList<Observable<EnunciateContext>>(); while (graphIt.hasNext()) { String module = graphIt.next(); Observable<EnunciateContext> moduleWork;
List<Observable<EnunciateContext>> leafModules = new ArrayList<Observable<EnunciateContext>>(); while (graphIt.hasNext()) { String module = graphIt.next(); Observable<EnunciateContext> moduleWork;
final Class<?> store = iterator.next(); final StoreCallback callback = callbacks.get(store); diagnostics.onExecute(store, action);
flowElement = iterator.next();
ServiceTree convertFrom(final ServiceDAG serviceDAG) { final IServiceDAGVertex<?> applicationVertex = serviceDAG.findVertex(APPLICATION_VERTEX_KEY).get(); final ServiceTree serviceTree = new ServiceTree(applicationVertex); // Reverse the edges of the service graph before we perform our walk. // We do this because the service graph is built with the root vertex // at the bottom. And this moves it to the top. final DirectedGraph<IServiceDAGVertex<?>,DefaultEdge> reversedGraph = new EdgeReversedGraph<>(serviceDAG); final TopologicalOrderIterator<IServiceDAGVertex<?>, DefaultEdge> topoOrder = new TopologicalOrderIterator<>(reversedGraph); // Walk the graph in topographical order and use the tree conversion listener // to convert the DAG into a tree final ServiceTreeConversionListener listener = new ServiceTreeConversionListener(applicationVertex, serviceTree, reversedGraph); topoOrder.addTraversalListener(listener); while (topoOrder.hasNext()) { topoOrder.next(); } return serviceTree; }
public void printBoundGraph( String filename ) { LOG.info( "writing stream bound graph to {}", filename ); DirectedMultigraph<Duct, Integer> graph = new DirectedMultigraph<>( new EdgeFactory<Duct, Integer>() { int count = 0; @Override public Integer createEdge( Duct sourceVertex, Duct targetVertex ) { return count++; } } ); TopologicalOrderIterator<Duct, Integer> iterator = getTopologicalOrderIterator(); while( iterator.hasNext() ) { Duct previous = iterator.next(); if( graph.containsVertex( previous ) || previous instanceof Extent ) continue; graph.addVertex( previous ); addNext( graph, previous ); } Util.printGraph( filename, graph ); }