Java BreadthFirstIterator.hasNext方法代码示例

import org.jgrapht.traverse.BreadthFirstIterator; //导入方法依赖的package包/类
public Set<Integer> getLargestConnectedComponent()
{
	Set<Integer> largestConnectedSet = new TreeSet();
	Set<Integer> connectedSet;
	List<Integer> vs = new ArrayList(vertexSet());
	
	while(vs.size() > 0)
	{
		connectedSet = new TreeSet();
		BreadthFirstIterator<Integer, MyEdge> bfsi = new BreadthFirstIterator<Integer, MyEdge>(this, vs.get(0));
		while(bfsi.hasNext())
			connectedSet.add(bfsi.next());
		if(connectedSet.size() > largestConnectedSet.size())
			largestConnectedSet = connectedSet;
		vs.removeAll(connectedSet);
	}
	
	return largestConnectedSet;
}
 

import org.jgrapht.traverse.BreadthFirstIterator; //导入方法依赖的package包/类
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;
}
 

import org.jgrapht.traverse.BreadthFirstIterator; //导入方法依赖的package包/类
public Set<String> getSuperclasses(String className) {
	String classNameWithDots = ResourceList.getClassNameFromResourcePath(className);
	if (!inheritanceGraph.containsVertex(classNameWithDots)) {
		LoggingUtils.logWarnAtMostOnce(logger, "Class not in inheritance graph: " + classNameWithDots);
		return new LinkedHashSet<>();
	}
	EdgeReversedGraph<String, DefaultEdge> reverseGraph = new EdgeReversedGraph<String, DefaultEdge>(
	        inheritanceGraph);

	// TreeSet so that classes are sorted by name and thus deterministic across platforms
	Set<String> result = new TreeSet<>();
	BreadthFirstIterator<String, DefaultEdge> bfi = new BreadthFirstIterator<String, DefaultEdge>(
	        reverseGraph, classNameWithDots);
	while (bfi.hasNext()) {
		result.add(bfi.next());
	}
	return result;
}
 

import org.jgrapht.traverse.BreadthFirstIterator; //导入方法依赖的package包/类
public List<String> getOrderedSuperclasses(String className) {
	String classNameWithDots = ResourceList.getClassNameFromResourcePath(className);
	if (!inheritanceGraph.containsVertex(classNameWithDots)) {
		LoggingUtils.logWarnAtMostOnce(logger, "Class not in inheritance graph: " + classNameWithDots);
		return new LinkedList<>();
	}
	EdgeReversedGraph<String, DefaultEdge> reverseGraph = new EdgeReversedGraph<String, DefaultEdge>(
	        inheritanceGraph);
	List<String> orderedList = new LinkedList<>();
	BreadthFirstIterator<String, DefaultEdge> bfi = new BreadthFirstIterator<String, DefaultEdge>(
	        reverseGraph, classNameWithDots);
	while (bfi.hasNext()) {
		orderedList.add(bfi.next());
	}
	return orderedList;
}
 

import org.jgrapht.traverse.BreadthFirstIterator; //导入方法依赖的package包/类
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;
}
 

import org.jgrapht.traverse.BreadthFirstIterator; //导入方法依赖的package包/类
private void stopDirty()
{
   BreadthFirstIterator<AddonVertex, AddonDependencyEdge> iterator = new BreadthFirstIterator<AddonVertex, AddonDependencyEdge>(
            graph.getGraph());

   iterator.addTraversalListener(new TraversalListenerAdapter<AddonVertex, AddonDependencyEdge>()
   {
      @Override
      public void vertexTraversed(VertexTraversalEvent<AddonVertex> event)
      {
         if (event.getVertex().isDirty())
            lifecycleManager.stopAddon(event.getVertex().getAddon());
      };
   });

   while (iterator.hasNext())
      iterator.next();
}
 

import org.jgrapht.traverse.BreadthFirstIterator; //导入方法依赖的package包/类
private void stopRemoved()
{
   if (lastMasterGraph != null)
   {
      BreadthFirstIterator<AddonVertex, AddonDependencyEdge> iterator = new BreadthFirstIterator<AddonVertex, AddonDependencyEdge>(
               lastMasterGraph.getGraph());

      iterator.addTraversalListener(new TraversalListenerAdapter<AddonVertex, AddonDependencyEdge>()
      {
         @Override
         public void vertexTraversed(VertexTraversalEvent<AddonVertex> event)
         {
            if (event.getVertex().isDirty())
               lifecycleManager.stopAddon(event.getVertex().getAddon());
         };
      });

      while (iterator.hasNext())
         iterator.next();
   }
}
 

import org.jgrapht.traverse.BreadthFirstIterator; //导入方法依赖的package包/类
/**
 * After this, the tasks will be in priority order in "sorted"
 * Generates priorities by topological sort from the source, and then reversing
 */
private void sortTasks() {
	BreadthFirstIterator<TaskDefinition, Edge> orderIterator = 
			new BreadthFirstIterator<TaskDefinition, Edge>(graph);
	while (orderIterator.hasNext()) {
		sorted.add(orderIterator.next());
	}
	Collections.reverse(sorted);
}
 

import org.jgrapht.traverse.BreadthFirstIterator; //导入方法依赖的package包/类
/**
 * Rigourous Test :-)
 */
public void testBFS() {

	DefaultDirectedGraph<Vertex, Double> graph = new DefaultDirectedGraph<Vertex, Double>(
			Double.class);
	Vertex v = null;
	for (int i = 0; i < this.numOfVertices; i++) {
		v = new Vertex("v" + i);
		graph.addVertex(v);
	}
	
	// use last vertex as start point of search
	Vertex lastVertex = v;

	Set<Vertex> vertices = graph.vertexSet();

	// add edges to graph
	Random rand = new Random();
	Double nextEdge = 0.0;
	for (Vertex start : vertices)
		for (Vertex end : vertices)
			if (!start.equals(end) && !graph.containsEdge(start, end)) {
				nextEdge = rand.nextDouble();
				if (nextEdge > 0.9)
					graph.addEdge(start, end, nextEdge);
			}

	System.out.println("Vertices: " + vertices.size());
	System.out.println("Edges: " + graph.edgeSet().size());

	BreadthFirstIterator<Vertex, Double> bfsIter = new BreadthFirstIterator<Vertex, Double>(
			graph, lastVertex);

	BFS<Double> bfs = new BFS<Double>(graph);
	Vertex[] bfsResult = bfs.breadthFirstTree(lastVertex);

	for (int i = 0; i < this.numOfVertices && bfsIter.hasNext(); i++) {
		System.out.println(bfsResult[i] + " " + bfsIter.next());
	}

}