Java DirectedPseudograph.vertexSet方法代码示例

import org.jgrapht.graph.DirectedPseudograph; //导入方法依赖的package包/类
private Set<Edge> neighbors(DirectedPseudograph<Resource, Edge> candidate,
        DirectedPseudograph<Resource, Edge> fullGraph) {
    Set<Edge> result = new HashSet<>();
    for (Resource node : candidate.vertexSet())
        for (Edge e : fullGraph.outgoingEdgesOf(node)) {
            if (candidate.containsEdge(e))
                continue;
            result.add(e);
        }
    return result;
}
 

import org.jgrapht.graph.DirectedPseudograph; //导入方法依赖的package包/类
public GGraph(DirectedPseudograph<GVertex, GEdge> gGraph) {
    this.gGraph = gGraph;
    vertexMap = new HashMap<>();
    for(GVertex gVertex : gGraph.vertexSet()) {
        vertexMap.put(gVertex.getName(),gVertex);
    }
}
 

import org.jgrapht.graph.DirectedPseudograph; //导入方法依赖的package包/类
private Pair<DirectedPseudograph<Resource, Edge>, Double>
    findGraph(URI referent,
              DirectedPseudograph<Resource, Edge> fullGraph, DirectedPseudograph<Resource, Edge> bestGraph,
              double bestGraphCost, DirectedPseudograph<Resource, Edge> candidate, long startTime,
              final Map<String, Integer>mappedOrder)
        throws ReferringExpressionException {
    double candidateCost = cost(candidate);
    if (bestGraph != null && bestGraphCost <= candidateCost)
        return Pair.of(bestGraph, bestGraphCost);

    List<Resource> distractors = new ArrayList<Resource>(fullGraph.vertexSet().size());
    for (Resource v : fullGraph.vertexSet()) {
        if (System.currentTimeMillis() - startTime > maxTime)
            throw new ReferringExpressionException("Time-out");
        if (v != referent && matchGraphs(referent, candidate, v, fullGraph, startTime))
            distractors.add(v);
    }

    if (distractors.isEmpty())
        return Pair.of(candidate, candidateCost);

    Collection<Edge>neighbors = neighbors(candidate, fullGraph);
    if(mappedOrder != null){
        List<Edge>toSort = new ArrayList<Edge>(neighbors);

        Collections.sort(toSort, new Comparator<Edge>() {
                public int compare(Edge e1, Edge e2) {
                    Integer m1 = mappedOrder.get(e1.getURI().getLocalName());
                    Integer m2 = mappedOrder.get(e2.getURI().getLocalName());
                    if (m1 != null && m2 != null)
                        return m1.compareTo(m2);
                    if (m1 != null)
                        return -1;
                    if (m2 != null)
                        return 1;
                    return e1.getURI().toString().compareTo(e2.getURI().toString());
                }
            });
        neighbors = toSort;
    }
    for (Edge e : neighbors) {
        if (System.currentTimeMillis() - startTime > maxTime)
            throw new ReferringExpressionException("Time-out");

        @SuppressWarnings("unchecked")
        DirectedPseudograph<Resource, Edge> newCandidate = (DirectedPseudograph<Resource, Edge>) candidate.clone();
        Resource source = fullGraph.getEdgeSource(e);
        Resource target = fullGraph.getEdgeTarget(e);
        if (!newCandidate.vertexSet().contains(source))
            // odd, this shouldn't always be the case?
            newCandidate.addVertex(source);
        if (!newCandidate.vertexSet().contains(target))
            newCandidate.addVertex(target);
        newCandidate.addEdge(fullGraph.getEdgeSource(e), fullGraph.getEdgeTarget(e), e);
        Pair<DirectedPseudograph<Resource, Edge>, Double> p =
            findGraph(referent, fullGraph, bestGraph,
                      bestGraphCost, newCandidate, startTime, mappedOrder);
        if (bestGraph == null || p.getRight() <= bestGraphCost) {
            bestGraph = p.getLeft();
            bestGraphCost = p.getRight();
        }
    }

    return Pair.of(bestGraph, bestGraphCost);
}
 

import org.jgrapht.graph.DirectedPseudograph; //导入方法依赖的package包/类
private boolean matchHelper(Map<Resource, Resource> bijection, // pi
        Set<Resource> neighbors, // Y
        DirectedPseudograph<Resource, Edge> fullGraph, // G
        DirectedPseudograph<Resource, Edge> candidate, // H
        long startTime) throws ReferringExpressionException {

    if (bijection.keySet().size() == candidate.vertexSet().size()) {
        return true;
    }
    if (neighbors.isEmpty()){
        return false;
    }

    if (System.currentTimeMillis() - startTime > maxTime)
        throw new ReferringExpressionException("Time-out");

    for (Resource toMap : neighbors) { // y
        if (bijection.containsKey(toMap))
            continue;
        // find valid matches Z
        for (Resource extension : fullGraph.vertexSet()) { // z
            if (bijection.values().contains(extension) || bijection.keySet().contains(extension))
                continue;
            if (!containedPropertiesInSubgraph(toMap, candidate, extension, fullGraph))
                continue;
            Set<Resource> toCheck = neighbors(candidate, toMap);
            toCheck.retainAll(bijection.keySet());
            boolean good = true;
            for (Resource other : toCheck) { // h
                // (toMap -> other) y->h
                Set<Edge> outgoing = candidate.getAllEdges(toMap, other);
                if (!fullGraph.getAllEdges(extension, bijection.get(other)).containsAll(outgoing)) {
                    good = false;
                    break;
                }
                // (other -> toMap) y->h
                Set<Edge> incoming = candidate.getAllEdges(other, toMap);
                if (!fullGraph.getAllEdges(bijection.get(other), extension).containsAll(incoming)) {
                    good = false;
                    break;
                }
            }
            if (!good)
                continue;
            Map<Resource, Resource> bijectionRec = new HashMap<>();
            bijectionRec.putAll(bijection);
            bijectionRec.put(toMap, extension);
            Set<Resource> neighborsRec = new HashSet<Resource>(neighbors);
            neighborsRec.remove(toMap); // not in Figure 8
            if (matchHelper(bijectionRec, neighborsRec, fullGraph, candidate, startTime))
                return true;
        }

    }
    return false;
}