/** * */ @Override public Set<Equivalences<T>> getSuper(Equivalences<T> v) { Set<Equivalences<T>> result = new LinkedHashSet<>(); BreadthFirstIterator<Equivalences<T>, DefaultEdge> iterator = new BreadthFirstIterator<Equivalences<T>, DefaultEdge>(dag, v); while (iterator.hasNext()) { Equivalences<T> parent = iterator.next(); result.add(parent); } return Collections.unmodifiableSet(result); }
private List<Set<V>> lazyFindConnectedSets() { if (connectedSets == null) { connectedSets = new ArrayList<>(); Set<V> vertexSet = graph.vertexSet(); if (!vertexSet.isEmpty()) { BreadthFirstIterator<V, E> i = new BreadthFirstIterator<>(graph); i.addTraversalListener(new MyTraversalListener()); while (i.hasNext()) { i.next(); } } } return connectedSets; }
private void bfs(Graph<V, E> graph, V root, List<List<V>> levels) { BreadthFirstIterator<V, E> bfs = new BreadthFirstIterator<>(graph, root); while (bfs.hasNext()) { V u = bfs.next(); if (levels.size() < bfs.getDepth(u) + 1) { levels.add(new ArrayList<>()); } levels.get(bfs.getDepth(u)).add(u); } }
private void dumpGraph() { if (!tracer.isLoggable(Level.FINER)) { return; } assertNoCycles(); Iterator<HepRelVertex> bfsIter = new BreadthFirstIterator<HepRelVertex, DefaultEdge>( graph, root); StringBuilder sb = new StringBuilder(); sb.append(Util.lineSeparator); sb.append("Breadth-first from root: {"); sb.append(Util.lineSeparator); while (bfsIter.hasNext()) { HepRelVertex vertex = bfsIter.next(); sb.append(" "); sb.append(vertex); sb.append(" = "); RelNode rel = vertex.getCurrentRel(); sb.append(rel); sb.append(", rowcount=" + RelMetadataQuery.getRowCount(rel)); sb.append(", cumulative cost=" + getCost(rel)); sb.append(Util.lineSeparator); } sb.append("}"); tracer.finer(sb.toString()); }
V v1 = computeFarthestVertex(new BreadthFirstIterator<>(graph, r)); BreadthFirstIterator<V, E> bfs = new BreadthFirstIterator<>(graph, v1); V v2 = computeFarthestVertex(bfs); v2 = bfs.getParent(v2);
new BreadthFirstIterator<Object, DefaultEdge>(g); i.hasNext();)
/** * */ @Override public Set<Equivalences<T>> getSuper(Equivalences<T> v) { Set<Equivalences<T>> result = new LinkedHashSet<>(); BreadthFirstIterator<Equivalences<T>, DefaultEdge> iterator = new BreadthFirstIterator<Equivalences<T>, DefaultEdge>(dag, v); while (iterator.hasNext()) { Equivalences<T> parent = iterator.next(); result.add(parent); } return Collections.unmodifiableSet(result); }
if ( vertexSet.size() > 0 ) final BreadthFirstIterator< Spot, DefaultWeightedEdge > i = new BreadthFirstIterator< >( lGraph, null ); i.addTraversalListener( new MyTraversalListener() ); while ( i.hasNext() ) i.next();
public static <Node, G extends Graph> Iterator<Node> getNodeIterator( SearchOrder searchOrder, G graph ) { if( searchOrder == null ) return new TopologicalOrderIterator( graph ); // faster than getVertexSet().iterator() Node node = null; if( graph.containsVertex( Extent.head ) ) { if( !searchOrder.isReversed() ) node = (Node) Extent.head; else node = (Node) Extent.tail; } switch( searchOrder ) { case Depth: return new DepthFirstIterator( graph, node ); case Breadth: return new BreadthFirstIterator( graph, node ); case Topological: return new TopologicalOrderIterator( graph ); // TODO: uses a equality based hashmap internally, will fail if relying on identity case ReverseDepth: return new DepthFirstIterator( new EdgeReversedGraph( graph ), node ); case ReverseBreadth: return new BreadthFirstIterator( new EdgeReversedGraph( graph ), node ); case ReverseTopological: return new TopologicalOrderIterator( new EdgeReversedGraph( graph ) ); // TODO: uses a equality based hashmap internally, will fail if relying on identity } throw new IllegalStateException( "unknown order: " + searchOrder ); } }
public Set<InfoVertex<T, C>> connectedSetOf(InfoVertex<T, C> vertex) { Set<InfoVertex<T, C>> connectedSet = vertexToConnectedSet.get(vertex); if (connectedSet == null) { connectedSet = new HashSet<InfoVertex<T, C>>(); final BreadthFirstIterator<InfoVertex<T, C>, DependencyEdge> i = new BreadthFirstIterator<InfoVertex<T, C>, DependencyEdge>( graph, vertex); while (i.hasNext()) { connectedSet.add(i.next()); } vertexToConnectedSet.put(vertex, connectedSet); } return connectedSet; }
if ( vertexSet.size() > 0 ) final BreadthFirstIterator< Spot, DefaultWeightedEdge > i = new BreadthFirstIterator< >( lGraph, null ); i.addTraversalListener( new MyTraversalListener() ); while ( i.hasNext() ) i.next();
BreadthFirstIterator<Change, DefaultEdge> dependencyIterator = new BreadthFirstIterator<Change, DefaultEdge>(graph, change);
public Set<InfoVertex<T, C>> connectedSetOf(InfoVertex<T, C> vertex) { Set<InfoVertex<T, C>> connectedSet = vertexToConnectedSet.get(vertex); if (connectedSet == null) { connectedSet = new HashSet<InfoVertex<T, C>>(); final BreadthFirstIterator<InfoVertex<T, C>, DependencyEdge> i = new BreadthFirstIterator<InfoVertex<T, C>, DependencyEdge>( graph, vertex); while (i.hasNext()) { connectedSet.add(i.next()); } vertexToConnectedSet.put(vertex, connectedSet); } return connectedSet; }
ILLGraph illGraph = new ILLGraph(combinedDao, localPageDao, miDao); BreadthFirstIterator<LocalId, ILLEdge> bfi = new BreadthFirstIterator<LocalId, ILLEdge>(illGraph); List<ConnectedComponentHandler> ccHandlers = new ArrayList<ConnectedComponentHandler>(); ccHandlers.add(new Conceptualign3ConnectedComponentHandler(minLang, maxEdge, true, this.localPageDao)); bfi.addTraversalListener(listener); while (bfi.hasNext()){ LocalId localId = bfi.next();
BreadthFirstIterator<Change, DefaultEdge> dependencyIterator = new BreadthFirstIterator<Change, DefaultEdge>(graph, change);
/** * Returns a set of all vertices that are in the maximally connected component together with the * specified vertex. For more on maximally connected component, see * <a href="http://www.nist.gov/dads/HTML/maximallyConnectedComponent.html"> * http://www.nist.gov/dads/HTML/maximallyConnectedComponent.html</a>. * * @param vertex the vertex for which the connected set to be returned. * * @return a set of all vertices that are in the maximally connected component together with the * specified vertex. */ public Set<V> connectedSetOf(V vertex) { Set<V> connectedSet = vertexToConnectedSet.get(vertex); if (connectedSet == null) { connectedSet = new HashSet<>(); BreadthFirstIterator<V, E> i = new BreadthFirstIterator<>(graph, vertex); while (i.hasNext()) { connectedSet.add(i.next()); } vertexToConnectedSet.put(vertex, connectedSet); } return connectedSet; }
/** * */ @Override public Set<Equivalences<T>> getSub(Equivalences<T> v) { Set<Equivalences<T>> result = cacheSub.get(v); if (result == null) { result = new LinkedHashSet<>(); BreadthFirstIterator<Equivalences<T>, DefaultEdge> iterator = new BreadthFirstIterator<Equivalences<T>, DefaultEdge>( new EdgeReversedGraph<>(dag), v); while (iterator.hasNext()) { Equivalences<T> child = iterator.next(); result.add(child); } result = Collections.unmodifiableSet(result); cacheSub.put(v, result); } return result; }
/** * */ @Override public Set<Equivalences<T>> getSub(Equivalences<T> v) { Set<Equivalences<T>> result = cacheSub.get(v); if (result == null) { result = new LinkedHashSet<>(); BreadthFirstIterator<Equivalences<T>, DefaultEdge> iterator = new BreadthFirstIterator<Equivalences<T>, DefaultEdge>( new EdgeReversedGraph<>(dag), v); while (iterator.hasNext()) { Equivalences<T> child = iterator.next(); result.add(child); } result = Collections.unmodifiableSet(result); cacheSub.put(v, result); } return result; }
public Set<String> getSubclasses(String className) { String classNameWithDots = ResourceList.getClassNameFromResourcePath(className); if (subclassCache.containsKey(classNameWithDots)) return subclassCache.get(classNameWithDots); if (!inheritanceGraph.containsVertex(classNameWithDots)) { LoggingUtils.logWarnAtMostOnce(logger, "Class not in inheritance graph: " + classNameWithDots); return new LinkedHashSet<>(); } // TreeSet so that classes are sorted by name and thus deterministic across platforms Set<String> result = new TreeSet<String>(); BreadthFirstIterator<String, DefaultEdge> bfi = new BreadthFirstIterator<String, DefaultEdge>( inheritanceGraph, classNameWithDots); while (bfi.hasNext()) { result.add(bfi.next()); } subclassCache.put(classNameWithDots, result); return result; }