Java DirectedGraph.vertexSet方法代码示例

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
@Override
public DirectedGraph<Node, Triple> intersect(DirectedGraph<Node, Triple> baseGraph, DirectedGraph<Node, Triple> removalGraph) {
    DirectedGraph<Node, Triple> result = new DirectedSubgraph<>(baseGraph, removalGraph.vertexSet(), removalGraph.edgeSet());

    //Materialize the intersection
    //DirectedGraph<Node, Triple> tmp = createNew();
    //Graphs.addGraph(tmp, result);
    //result = tmp

    return result;
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
/**
 * Sorts the graph to provide a consistent topological ordering.
 *
 * @param graph          The input graph
 * @param subsetVertices The subset vertices of the graph we want to sort
 * @param comparator     The comparator on which to order the vertices to guarantee a consistent topological ordering
 */
public <T> ImmutableList<T> sortChanges(DirectedGraph<T, DefaultEdge> graph, RichIterable<T> subsetVertices, Comparator<? super T> comparator) {
    if (subsetVertices.toSet().size() != subsetVertices.size()) {
        throw new IllegalStateException("Unexpected state - have some dupe elements here: " + subsetVertices);
    }

    DirectedGraph<T, DefaultEdge> subsetGraph = new DirectedSubgraph<T, DefaultEdge>(
            graph, subsetVertices.toSet(), null);

    // At one point, we _thought_ that the DirectedSubGraph was dropping vertices that don't have edges, so we
    // manually add them back to the graph to ensure that we can still order them.
    // However, that no longer seems to be the case. We add a check here just in case this comes up again.
    if (subsetVertices.size() != subsetGraph.vertexSet().size()) {
        throw new IllegalArgumentException("This case should never happen! [subsetVertices: " + subsetVertices + ", subsetGraphVertices: " + subsetGraph.vertexSet());
    }

    return sortChanges(subsetGraph, comparator);
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
protected static void determineAndSolveConflicts(final PathBlockSet resultBlocks) {
    // determine conflicts
    final PathBlockSet deletedBlocks = new PathBlockSet();
    final DirectedGraph<Block, BlockConflict> blockConflictGraph = new SimpleDirectedGraph<>(BlockConflict::of);
    for (final Block block : resultBlocks.getBlocks()) {
        blockConflictGraph.addVertex(block);
    }
    for (final Block x : blockConflictGraph.vertexSet()) {
        createArcs(blockConflictGraph, resultBlocks, x);
    }
    // solve conflicts
    while (true) {
        final Optional<BlockConflict> mostUsefulConflictsFirst =
                blockConflictGraph.edgeSet().stream().max(Comparator.comparingInt(BlockConflict::getQuality));
        if (!mostUsefulConflictsFirst.isPresent()) {
            break;
        }
        final BlockConflict blockConflict = mostUsefulConflictsFirst.get();
        solveConflict(blockConflict, blockConflictGraph, resultBlocks, deletedBlocks);
    }
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
private Set<AttributeRef> findReachableSourceAttributes(AttributeRef targetAttribute, DirectedGraph<AttributeRef, DefaultEdge> dependencyGraph) {
    Set<AttributeRef> result = new HashSet<AttributeRef>();
    for (AttributeRef attribute : dependencyGraph.vertexSet()) {
        if (!attribute.isSource()) {
            continue;
        }
        if (result.contains(attribute)) {
            continue;
        }
        List path = DijkstraShortestPath.findPathBetween(dependencyGraph, attribute, targetAttribute);
        if (path != null) {
            result.add(attribute);
        }
    }
    return result;
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
public DirectedGraph<FunctionVertex, CallEdge> collapseGraph() {
    DirectedGraph<FunctionVertex, CallEdge> g = cloneGraph(graph);
    List<FunctionVertex> vToRemove = new ArrayList<>();

    for (int i = 0; i < 10; i++) {
        vToRemove.clear();
        /* remove all vertrtices with zero stack and no childs */
        for (FunctionVertex fn : g.vertexSet()) {
            Set<CallEdge> oe = g.outgoingEdgesOf(fn);
            if (oe.isEmpty() && fn.stack == 0) {
                vToRemove.add(fn);
            }
        }
        g.removeAllVertices(vToRemove);
    }

    for (int i = 0; i < 1000; i++) {
        traverseMaxStack(g);
    }
    
    return g;
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
private Map<String, Set<InfoVertex<T, C>>> createPackageVerticesMap(
		DirectedGraph<InfoVertex<T, C>, DependencyEdge> graph) {
	final Map<String, Set<InfoVertex<T, C>>> packageVerticesMap = new HashMap<String, Set<InfoVertex<T, C>>>();
	for (InfoVertex<T, C> vertex : graph.vertexSet()) {
		final MPackageInfo packageInfo = vertex.getPackageInfo();

		if (packageInfo != null) {
			Set<InfoVertex<T, C>> packageVertices = packageVerticesMap
					.get(packageInfo.getPackageName());
			if (packageVertices == null) {
				packageVertices = new HashSet<InfoVertex<T, C>>();
				packageVerticesMap.put(packageInfo.getPackageName(),
						packageVertices);
			}
			packageVertices.add(vertex);
		}
	}
	return packageVerticesMap;
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
protected SSA(DirectedGraph<V, E> graph, Dominators<V, E> dom) {
    if (!(graph instanceof CFG)) {
        throw new IllegalArgumentException();
    }
    this.cfg = (CFG) graph;
    this.dom = dom;
    this.domFrontier = dom.getDF();
    this.cdgTree = new SSAGraph<>();
    for (V v : graph.vertexSet()) {
        cdgTree.addVertex(v);
    }
    for (E e : graph.edgeSet()) {
        cdgTree.addEdge(graph.getEdgeSource(e), graph.getEdgeTarget(e));
    }
    this.cdgBlockTree = new SSABlockTree<>(this.cdgTree, dom.getStart());
    // gather variables
    discoverVariables();
    //this.count = new int[variables.size()];
    this.count = new HashMap<>(variables.size());
    this.stack = new HashMap<>(variables.size());
    // for each variable a
    for (int i : variables) {
        //count[i] = 0;
        count.put(i, 0);
        stack.put(i, new LinkedList<Integer>());
        stack.get(i).add(0); // push 0 onto Stack[a]
    }
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
public static <V, E> void write(DirectedGraph<V, E> g, String fileName) throws FileNotFoundException {
    try (PrintWriter out = new PrintWriter(fileName)) {
        out.print("digraph \"DirectedGraph\" { \n graph [label=\"");
        out.print(g.toString());
        out.print("\", labelloc=t, concentrate=true]; ");
        out.print("center=true;fontsize=12;node [fontsize=12];edge [fontsize=12]; \n");

        for (V node : g.vertexSet()) {
            out.print("   \"");
            out.print(getId(node));
            out.print("\" ");
            out.print("[label=\"");
            out.print(node.toString());
            out.print("\" shape=\"box\" color=\"blue\" ] \n");
        }

        for (V src : g.vertexSet()) {
            for (E e : g.outgoingEdgesOf(src)) {
                V tgt = g.getEdgeTarget(e);

                out.print(" \"");
                out.print(getId(src));
                out.print("\" -> \"");
                out.print(getId(tgt));
                out.print("\" ");
                out.print("[label=\"");
                out.print(e.toString());
                out.print("\"]\n");
            }
        }

        out.print("\n}");

        out.flush();
    }
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
public AttributesInSameCellGroups findAttributes(DirectedGraph<AttributeRef, ExtendedEdge> dependencyGraph) {
    AttributesInSameCellGroups attributesInSameCallGroups = new AttributesInSameCellGroups();
    Set<String> pathCache = new HashSet<String>();
    for (AttributeRef attributeRef : dependencyGraph.vertexSet()) {
        Set<AttributeRef> relatedAttributes = findRelatedAttributes(attributeRef, pathCache, dependencyGraph);
        attributesInSameCallGroups.addAttribute(attributeRef, relatedAttributes);
    }
    if (logger.isDebugEnabled()) logger.debug("Map for dependency graph " + dependencyGraph + "\n:" + attributesInSameCallGroups.toString());
    return attributesInSameCallGroups;
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
private Set<AttributeRef> findRelatedAttributes(AttributeRef attribute, Set<String> pathCache, DirectedGraph<AttributeRef, ExtendedEdge> dependencyGraph) {
    //All attributes corresponding to vertices of paths that pass throught the vertex of attribute
    Set<AttributeRef> result = new HashSet<AttributeRef>();
    for (AttributeRef otherAttribute : dependencyGraph.vertexSet()) {
        if (attribute.equals(otherAttribute)) {
            result.add(otherAttribute);
            continue;
        }
        String attributePair = buildAttributePair(attribute, otherAttribute);
        if (pathCache.contains(attributePair)) {
            result.add(otherAttribute);
            continue;
        }
        List<ExtendedEdge> outPath = DijkstraShortestPath.findPathBetween(dependencyGraph, attribute, otherAttribute);
        if (logger.isDebugEnabled()) logger.debug("Finding path between " + attribute + " and " + otherAttribute);
        if (outPath != null) {
            if (logger.isDebugEnabled()) logger.debug("Path found");
            addVerticesInPath(outPath, result, pathCache, dependencyGraph);
            continue;
        }
        List<ExtendedEdge> inPath = DijkstraShortestPath.findPathBetween(dependencyGraph, otherAttribute, attribute);
        if (logger.isDebugEnabled()) logger.debug("Finding path between " + otherAttribute + " and " + attribute);
        if (inPath != null) {
            if (logger.isDebugEnabled()) logger.debug("Path found");
            addVerticesInPath(inPath, result, pathCache, dependencyGraph);
        }
    }
    return result;
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
private Set<AttributeRef> findReachableAttribuesOnGraph(Set<AttributeRef> initialAttributes, DirectedGraph<AttributeRef, ExtendedEdge> dependencyGraph) {
    Set<AttributeRef> result = new HashSet<AttributeRef>(initialAttributes);
    for (AttributeRef attribute : dependencyGraph.vertexSet()) {
        if (result.contains(attribute)) {
            continue;
        }
        if (isReachable(attribute, initialAttributes, dependencyGraph)) {
            result.add(attribute);
        }
    }
    return result;
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
private void traverseMaxStack(DirectedGraph<FunctionVertex, CallEdge> g) {
    int maxStack, fnStack;
    for (FunctionVertex fn : g.vertexSet()) {
        Set<CallEdge> ces = g.outgoingEdgesOf(fn);
        if (ces.isEmpty()) {
            if (fn.stack >= 0) {
                fn.maxStack = fn.stack;
            } else {
                fn.maxStack = 0;
            }
            continue;
        }

        maxStack = -1;
        for (CallEdge ce : ces) {
            fnStack = g.getEdgeTarget(ce).maxStack;
            if (fnStack >= 0) {
                maxStack = Math.max(maxStack, fnStack);
            } else {
                maxStack = -1;
                break;
            }
        }
        if (maxStack >= 0) {
            if (isRecursive(fn)) {
            } else {
                fn.maxStack = maxStack + fn.stack;
            }
        } else if (isRecursive(fn)) {
            fn.maxStack = fn.stack;
        }
    }
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
private static DirectedGraph<FunctionVertex, CallEdge> cloneGraph(DirectedGraph<FunctionVertex, CallEdge> g) {
    DirectedGraph<FunctionVertex, CallEdge> result;
    result = new DefaultDirectedGraph<>(CallEdge.class);

    List<FunctionVertex> list = new ArrayList<>();

    for (FunctionVertex v : g.vertexSet()) {
        FunctionVertex v2 = new FunctionVertex();
        v2.clone(v);
        list.add(v2);
        result.addVertex(v2);
    }

    list.indexOf(g);
    FunctionVertex src;
    FunctionVertex dst;
    for (CallEdge e : g.edgeSet()) {
        src = g.getEdgeSource(e);
        dst = g.getEdgeTarget(e);

        /* get clonned vertex */
        src = list.get(list.indexOf(src));
        dst = list.get(list.indexOf(dst));

        result.addEdge(src, dst, new CallEdge(e.type));
    }

    return result;
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
public NetworkFlow(DirectedGraph<V, E> graph) {
	// init the flow graph
	this.graph = graph;
	this.vertices = graph.vertexSet();
	this.numOfEdges = graph.edgeSet().size();
	this.maximumFlow = new HashMap<E, Double>();
}
 

import org.jgrapht.DirectedGraph; //导入方法依赖的package包/类
public LinearProgrammingMaxFlow(DirectedGraph<V, E> graph) {

		this.graph = graph;
		this.vertices = graph.vertexSet();
		this.edgesIndex = new ArrayList<E>();
		this.numOfEdges = graph.edgeSet().size();
		this.maximumFlow = new HashMap<E, Double>();
	}