List<Set<PlanFragmentId>> schedulePhases = ImmutableList.copyOf(new TopologicalOrderIterator<>(componentGraph)); return schedulePhases;
TopologicalOrderIterator it = new TopologicalOrderIterator<Node, Object>(subgraph); int stateIndex = 0; while (it.hasNext()) {
/** * 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); }
GraphIterator<String, DefaultEdge> graphIterator = new TopologicalOrderIterator<>(namespaceDAG); while (graphIterator.hasNext()) { final String namespace = graphIterator.next();
/** * 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 ); }
@Override public Iterator<Node> getTopologicalOrderIterator() { return new TopologicalOrderIterator<Node, DefaultEdge>(this.g); }
@Override public Iterator<Process> getOrderedTopologicalIterator( Comparator<Process> comparator ) { return new TopologicalOrderIterator<>( graph, new PriorityQueue<>( 10, comparator ) ); }
public TopologicalOrderIterator<Flow, Integer> getTopologicalIterator() { return new TopologicalOrderIterator<>( this, new PriorityQueue<>( 10, new Comparator<Flow>() { @Override public int compare( Flow lhs, Flow rhs ) { return Integer.valueOf( lhs.getSubmitPriority() ).compareTo( rhs.getSubmitPriority() ); } } ) ); }
public static Iterator<FlowElement> getTopologicalIterator( ElementGraph graph ) { if( graph == null ) return Collections.emptyIterator(); return new TopologicalOrderIterator<>( directed( graph ) ); }
public TopologicalOrderIterator<Duct, Integer> getTopologicalOrderIterator() { try { return new TopologicalOrderIterator( ductGraph ); } catch( RuntimeException exception ) { LOG.error( "failed creating topological iterator", exception ); printGraphError(); throw exception; } }
private void complete(final Action action, final Map<Class<?>, Agreement> approvals) { DirectedGraph<Class<?>, DefaultEdge> dag = createDag(approvals); // TODO Cache topological order TopologicalOrderIterator<Class<?>, DefaultEdge> iterator = new TopologicalOrderIterator<>(dag); executeInOrder(action, iterator, new ArrayList<StoreCallback>()); }
public TopologicalOrderIterator<Duct, Integer> getReversedTopologicalOrderIterator() { try { return new TopologicalOrderIterator( getReversedGraph() ); } catch( RuntimeException exception ) { LOG.error( "failed creating reversed topological iterator", exception ); printGraphError(); throw exception; } }
/** * 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; }
public static Iterator<FlowElement> getReverseTopologicalIterator( ElementGraph graph ) { return new TopologicalOrderIterator<>( new EdgeReversedGraph<>( directed( 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); }
public Stream<T> getBuildChain() throws CycleDetectedException { DefaultDirectedGraph<T, DefaultEdge> graph = builder.build(); ensureNoCycle(graph); return Iterators.toStream(new TopologicalOrderIterator<>(graph)); }