TopologicalOrderIterator it = new TopologicalOrderIterator<Node, Object>(subgraph); int stateIndex = 0; while (it.hasNext()) { Node n = (Node) it.next(); if (n instanceof ProcessorNode) { ProcessorNode pn = (ProcessorNode) n;
/** * Creates a new instance of the factory * * @param errorTypesEnum an {@link ErrorTypeDefinition} implementation indicating all the errors from an extension * @param extensionNamespace the namespace for the {@link ErrorModel} to be generated */ public ErrorsModelFactory(ErrorTypeDefinition<?>[] errorTypesEnum, String extensionNamespace) throws IllegalModelDefinitionException { this.extensionNamespace = extensionNamespace.toUpperCase(); final DirectedGraph<ErrorTypeDefinition, Pair<ErrorTypeDefinition, ErrorTypeDefinition>> graph = toGraph(errorTypesEnum); errorModelMap = new HashMap<>(); initErrorModelMap(errorModelMap); new TopologicalOrderIterator<>(graph).forEachRemaining(errorType -> { ErrorModel errorModel = toErrorModel(errorType, errorModelMap); errorModelMap.put(errorModel.toString(), errorModel); }); addConnectivityErrors(errorModelMap); }
List<Set<PlanFragmentId>> schedulePhases = ImmutableList.copyOf(new TopologicalOrderIterator<>(componentGraph)); return schedulePhases;
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; }
@Override public V next() { if (!hasNext()) { throw new NoSuchElementException(); } V result = cur; cur = null; if (nListeners != 0) { fireVertexFinished(createVertexTraversalEvent(result)); } return result; }
GraphIterator<String, DefaultEdge> graphIterator = new TopologicalOrderIterator<>(namespaceDAG); while (graphIterator.hasNext()) { final String namespace = graphIterator.next();
/** * 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); }
/** * Method getTopologicalIterator returns the topologicalIterator of this ElementGraph object. * * @return the topologicalIterator (type TopologicalOrderIterator) of this ElementGraph object. */ public TopologicalOrderIterator<FlowElement, Scope> getTopologicalIterator() { return new TopologicalOrderIterator<>( this.graph ); }
/** * Creates a new instance of the factory * * @param errorTypesEnum an {@link ErrorTypeDefinition} implementation indicating all the errors from an extension * @param extensionNamespace the namespace for the {@link ErrorModel} to be generated */ public ErrorsModelFactory(ErrorTypeDefinition<?>[] errorTypesEnum, String extensionNamespace) throws IllegalModelDefinitionException { this.extensionNamespace = extensionNamespace.toUpperCase(); final DirectedGraph<ErrorTypeDefinition, Pair<ErrorTypeDefinition, ErrorTypeDefinition>> graph = toGraph(errorTypesEnum); errorModelMap = new HashMap<>(); initErrorModelMap(errorModelMap); new TopologicalOrderIterator<>(graph).forEachRemaining(errorType -> { ErrorModel errorModel = toErrorModel(errorType, errorModelMap); errorModelMap.put(errorModel.toString(), errorModel); }); addConnectivityErrors(errorModelMap); }
/** * 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); }
@Override public Iterator<Node> getTopologicalOrderIterator() { return new TopologicalOrderIterator<Node, DefaultEdge>(this.g); }
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 ); } } }
/** * Computes the transitive closure of a directed acyclic graph in $O(nm)$ * * @param graph - Graph to compute transitive closure for. * @param <V> the graph vertex type * @param <E> the graph edge type */ public <V, E> void closeDirectedAcyclicGraph(DirectedAcyclicGraph<V, E> graph) { Deque<V> orderedVertices = new ArrayDeque<>(graph.vertexSet().size()); new TopologicalOrderIterator<>(graph).forEachRemaining(orderedVertices::addFirst); for (V vertex : orderedVertices) { for (V successor : Graphs.successorListOf(graph, vertex)) { for (V closureVertex : Graphs.successorListOf(graph, successor)) { graph.addEdge(vertex, closureVertex); } } } }
/** * 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); }
@Override public Iterator<Process> getOrderedTopologicalIterator( Comparator<Process> comparator ) { return new TopologicalOrderIterator<>( graph, new PriorityQueue<>( 10, comparator ) ); }
private void executeInOrder(final Action action, final TopologicalOrderIterator<Class<?>, DefaultEdge> iterator, final List<StoreCallback> acknowledgedCallbacks) { if (!iterator.hasNext()) { signalChange(acknowledgedCallbacks, action); unlock(); final Class<?> store = iterator.next(); final StoreCallback callback = callbacks.get(store); diagnostics.onExecute(store, action);
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" ); }