Java Graph類代碼示例

import org.jgrapht.Graph; //導入依賴的package包/類
@SuppressWarnings("unchecked")
private FormulaWithAdornments findFormulaWithAdornments(UndirectedGraph<FormulaGraphVertex, DefaultEdge> formulaGraph,
        List<VariablePair> variablePairs, List<FormulaVariable> anonymousVariables, IFormula formula) {
    Set<FormulaGraphVertex> vertices = new HashSet<FormulaGraphVertex>(formulaGraph.vertexSet());
    for (VariablePair variablePair : variablePairs) {
        vertices.remove(variablePair.getVertex());
    }
    UndirectedSubgraph<FormulaGraphVertex, DefaultEdge> subgraph = new UndirectedSubgraph<FormulaGraphVertex, DefaultEdge>(formulaGraph, vertices, formulaGraph.edgeSet());
    ConnectivityInspector<FormulaGraphVertex, DefaultEdge> inspector = new ConnectivityInspector<FormulaGraphVertex, DefaultEdge>(subgraph);
    List<Set<FormulaGraphVertex>> connectedVertices = inspector.connectedSets();
    if (connectedVertices.size() != 2) {
        return null;
    }
    UndirectedSubgraph<FormulaGraphVertex, DefaultEdge> connectedSubgraphOne = new UndirectedSubgraph<FormulaGraphVertex, DefaultEdge>(formulaGraph, connectedVertices.get(0), formulaGraph.edgeSet());
    UndirectedSubgraph<FormulaGraphVertex, DefaultEdge> connectedSubgraphTwo = new UndirectedSubgraph<FormulaGraphVertex, DefaultEdge>(formulaGraph, connectedVertices.get(1), formulaGraph.edgeSet());
    VertexEquivalenceComparator vertexComparator = new VertexEquivalenceComparator(variablePairs, anonymousVariables);
    UniformEquivalenceComparator<DefaultEdge, Graph<FormulaGraphVertex, DefaultEdge>> edgeComparator = new UniformEquivalenceComparator<DefaultEdge, Graph<FormulaGraphVertex, DefaultEdge>>();
    GraphIsomorphismInspector<Graph<FormulaGraphVertex, DefaultEdge>> isomorphismInspector = AdaptiveIsomorphismInspectorFactory.createIsomorphismInspector(connectedSubgraphOne, connectedSubgraphTwo, vertexComparator, edgeComparator);
    boolean areIsomorphic = isomorphismInspector.isIsomorphic();
    if (logger.isDebugEnabled()) logger.debug("Graph One: \n" + connectedSubgraphOne + "\nGraph Two: \n" + connectedSubgraphTwo + "\nAre isomorphic: " + areIsomorphic);
    if (!areIsomorphic) {
        return null;
    }
    return formulaWithAdornmentsGenerator.generate(formula, connectedSubgraphOne, connectedSubgraphTwo, variablePairs);
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
private Graph<AutomatVertex, DefaultEdge> generateCompleteGraph(int size) {
    LOG.info("--- generateCompleteGraph ---");

    //Create the CompleteGraphGenerator object
    final Graph<AutomatVertex, DefaultEdge> completeGraph = new SimpleGraph<>(DefaultEdge.class);
    final CompleteGraphGenerator<AutomatVertex, DefaultEdge> completeGenerator = new CompleteGraphGenerator<>(size);

    //Create the VertexFactory so the generator can create vertices
    final VertexFactory<AutomatVertex> vFactory = new ClassBasedVertexFactory<>(AutomatVertex.class);

    LOG.info("Generating complete graph");

    //Use the CompleteGraphGenerator object to make completeGraph a
    //complete graph with [size] number of vertices
    completeGenerator.generateGraph(completeGraph, vFactory, null);
    return completeGraph;
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
/**
 * Shows how to create an FNSS Topology, convert it to a JGraphT Graph and
 * then compute shortest paths
 */
public static void exampleGraph() {
	// create a simple FNSS topology
	Topology topology = new Topology();
	topology.addEdge("1", "2", new Edge());
	topology.addEdge("2", "3", new Edge());
	
	// convert to JGraphT
	Graph<String, Edge> graph = JGraphTConverter.getGraph(topology);
	
	// Find shortest paths
	String source = "3";
	String destination = "1";
	List<Edge> sp = DijkstraShortestPath.findPathBetween(graph, source, destination);
	
	// Print results
	System.out.println("Shortest path from " + source + " to " + destination + ":");
	for (Edge e : sp) {
		System.out.println(graph.getEdgeSource(e) + " -> " + graph.getEdgeTarget(e));
	}
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
/**
 * Convert an FNSS Topology to a JGraphT graph.
 * 
 * @param topology FNSS Topology object
 * @return A JGraphT graph
 */
public static Graph<String, Edge> getGraph(Topology topology) {
	Graph<String, Edge> graph = null;
	if (topology.isDirected()) {
		graph = new DefaultDirectedGraph<String, Edge>(Edge.class);
	} else {
		graph = new SimpleGraph<String, Edge>(Edge.class);
	}
	for(String node : topology.getAllNodes()) {
		graph.addVertex(node);
	}
	for(Pair<String, String> endpoints : topology.getAllEdges()) {
		Edge edge = topology.getEdge(endpoints);
		graph.addEdge(endpoints.getU(), endpoints.getV(), edge);
	}
	return graph;
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
public static <V, E, T extends Graph<V, E>> T difference(T result, Graph<V, E> baseSet, Graph<V, E> removalSet) {

        baseSet.edgeSet().forEach(e -> {
            boolean skip = removalSet.containsEdge(e);
            if(!skip) {
                V srcVertex = baseSet.getEdgeSource(e);
                V tgtVertex = baseSet.getEdgeTarget(e);
                result.addVertex(srcVertex);
                result.addVertex(tgtVertex);
                result.addEdge(srcVertex, tgtVertex, e);
            }
        });

//    	Graphs.addGraph(result, baseSet);
//
//        //Graphs.unio
//        result.removeAllEdges(removalSet.edgeSet());
//        baseSet.vertexSet().forEach(v -> {
//            if(baseSet.edgesOf(v).isEmpty()) {
//                result.removeVertex(v);
//            }
//        });
//
        return result;
    }
 

import org.jgrapht.Graph; //導入依賴的package包/類
public static <V, E, G extends Graph<V, E>> G transformItems(G result, G set, Function<V, V> nodeTransform, BiFunction<E, Function<V, V>, E> edgeTransform) {
    set.vertexSet().stream()
        .map(item -> MoreObjects.firstNonNull(nodeTransform.apply(item), item))
        .forEach(result::addVertex);

    set.edgeSet().stream().forEach(e -> {
        V src = set.getEdgeSource(e);
        V tgt = set.getEdgeTarget(e);

        V tmpSrc = nodeTransform.apply(src);
        V tmpTgt = nodeTransform.apply(tgt);

        V isoSrc = tmpSrc != null ? tmpSrc : src;
        V isoTgt = tmpTgt != null ? tmpTgt : tgt;

        E isoEdge = edgeTransform.apply(e, nodeTransform);

        result.addEdge(isoSrc, isoTgt, isoEdge);
    });

    return result;
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
/**
 * @param parentGraph
 * @return SubGraphs sets, with graph items indices
 */
public List<Collection<Integer>> getAndUpdateSubGraphs(Graph<GraphItem, JGraphEdge> parentGraph) {
  ConnectivityInspector<GraphItem, JGraphEdge> connectivityInspector = new ConnectivityInspector<>((UndirectedGraph)parentGraph);
  return getSubGraphsIndicesFrom(connectivityInspector.connectedSets());
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
private void compareContent(final Graph<Node, Edge> givenGraph, final Graph<Node, Edge> expectedGraph,
        final AssertionErrorCollector errorCollector) {

    final Set<String> expectedNodeTypes = expectedGraph.vertexSet().stream().map(Node::getType).collect(toSet());

    final Set<String> currentNodeTypes = givenGraph.vertexSet().stream().map(Node::getType).collect(toSet());

    verifyNodeLabels(currentNodeTypes, expectedNodeTypes, errorCollector,
            "Nodes with %s labels were expected to be present, but not found");

    checkPresenceOfExpectedNodes(givenGraph, expectedGraph, errorCollector);
    checkPresenceOfExpectedReferences(givenGraph, expectedGraph, errorCollector);
    checkAbsenseOfNotExpectedNodes(givenGraph, expectedGraph, errorCollector);
    checkAbsenseOfNotExpectedReferences(givenGraph, expectedGraph, errorCollector);

    if (isStrict) {
        verifyNodeLabels(expectedNodeTypes, currentNodeTypes, errorCollector,
                "Nodes with %s labels were not expected, but are present");
    }
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
private void checkPresenceOfExpectedNodes(final Graph<Node, Edge> givenGraph, final Graph<Node, Edge> expectedGraph,
        final AssertionErrorCollector errorCollector) {
    for (final Node expectedNode : expectedGraph.vertexSet()) {

        final List<String> attributesToExclude = expectedNode.getLabels().stream().map(toExclude::getColumns).flatMap(List::stream)
                .distinct().collect(toList());

        final List<Node> availableNodesOfExpectedType = givenGraph.vertexSet().stream()
                .filter(n -> n.getType().equals(expectedNode.getType())).collect(toList());

        final List<Node> foundNodes = availableNodesOfExpectedType.stream().filter(n -> n.isSame(expectedNode, attributesToExclude))
                .collect(toList());

        if (foundNodes.isEmpty()) {
            errorCollector.collect(expectedNode.asString() + " was expected, but is not present");
        } else if (foundNodes.size() > 1) {
            errorCollector.collect("Ambiguouty detected for node " + expectedNode.asString() + " for given attribute filter");
        }
    }
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
private void checkPresenceOfExpectedReferences(final Graph<Node, Edge> givenGraph, final Graph<Node, Edge> expectedGraph,
        final AssertionErrorCollector errorCollector) {
    for (final Edge expectedEdge : expectedGraph.edgeSet()) {

        final List<String> attributesToExclude = expectedEdge.getLabels().stream().map(toExclude::getColumns).flatMap(List::stream)
                .distinct().collect(toList());

        final List<Edge> availableEdgesOfExpectedType = givenGraph.edgeSet().stream()
                .filter(e -> e.getType().equals(expectedEdge.getType())).collect(toList());

        final List<Edge> foundEdges = availableEdgesOfExpectedType.stream().filter(e -> e.isSame(expectedEdge, attributesToExclude))
                .collect(toList());

        if (foundEdges.isEmpty()) {
            errorCollector.collect(expectedEdge.asString() + " was expected, but is not present");
        } else if (foundEdges.size() > 1) {
            errorCollector.collect("Ambiguouty detected for edge " + expectedEdge.asString() + " for given attribute filter");
        }
    }
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
@Override
public CleanupStrategyExecutor<Connection, Graph<Node, Edge>> usedTablesOnlyStrategy() {
    return (final Connection connection, final List<Graph<Node, Edge>> initialGraphs, final String... nodeTypesToRetain) -> {
        if (initialGraphs.isEmpty()) {
            return;
        }

        try {
            for (final Graph<Node, Edge> graph : initialGraphs) {
                Neo4JOperations.DELETE_ALL.execute(connection, computeGraphToBeDeleted(graph, nodeTypesToRetain));
            }

            connection.commit();
        } catch (final SQLException e) {
            throw new DbFeatureException(UNABLE_TO_CLEAN_DATABASE, e);
        }
    };
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
@Override
public CleanupStrategyExecutor<Connection, Graph<Node, Edge>> usedRowsOnlyStrategy() {
    return (final Connection connection, final List<Graph<Node, Edge>> initialGraphs, final String... nodeTypesToRetain) -> {
        if (initialGraphs.isEmpty()) {
            return;
        }

        try {
            for (final Graph<Node, Edge> graph : initialGraphs) {
                Neo4JOperations.DELETE.execute(connection, computeGraphToBeDeleted(graph, nodeTypesToRetain));
            }

            connection.commit();
        } catch (final SQLException e) {
            throw new DbFeatureException(UNABLE_TO_CLEAN_DATABASE, e);
        }
    };
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
@Test
public void testLoadDataSetsUsingAvailableFilePaths() {
    // GIVEN

    // WHEN
    final List<Graph<Node, Edge>> dataSetList = featureExecutor.loadDataSets(Arrays.asList("test-data.xml", "test-data.xml"));

    // THEN
    assertNotNull(dataSetList);
    assertThat(dataSetList.size(), equalTo(2));

    final Graph<Node, Edge> graph1 = dataSetList.get(0);
    assertNotNull(graph1);
    assertThat(graph1.vertexSet().size(), equalTo(6));
    assertThat(graph1.edgeSet().size(), equalTo(4));

    final Graph<Node, Edge> graph2 = dataSetList.get(1);
    assertNotNull(graph2);
    assertThat(graph2.vertexSet().size(), equalTo(6));
    assertThat(graph2.edgeSet().size(), equalTo(4));

    assertThat(graph1, equalTo(graph1));
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
@Test
public void testXmlLoaderLoadUsingProperResource() throws Exception {
    // WHEN
    final DataSetLoader<Graph<Node, Edge>> loader = LOADER_PROVIDER.xmlLoader();

    // THEN
    assertThat(loader, notNullValue());

    // WHEN
    final Graph<Node, Edge> graph = loader.load(getFile("test-data.xml"));

    // THEN
    assertThat(graph, notNullValue());

    // TODO: finalize me
}
 

import org.jgrapht.Graph; //導入依賴的package包/類
@Test
public void testExecute() throws Exception {
    // GIVEN
    final Node n1 = graphElementFactory.createNode("n1", Arrays.asList("A"),
            ImmutableMap.<String, Object>builder().put("id", 1l).build());
    final Node n2 = graphElementFactory.createNode("n2", Arrays.asList("A"),
            ImmutableMap.<String, Object>builder().put("id", 2l).build());
    final Edge e1 = graphElementFactory.createEdge(n1, n2, "e1", Arrays.asList("E"),
            ImmutableMap.<String, Object>builder().put("id", 3l).build());

    final Graph<Node, Edge> graph = new DefaultDirectedGraph<>(new ClassBasedEdgeFactory<>(Edge.class));
    graph.addVertex(n1);
    graph.addVertex(n2);
    graph.addEdge(e1.getSourceNode(), e1.getTargetNode(), e1);

    // WHEN
    operation.execute(connection, graph);

    // THEN
    final ArgumentCaptor<String> queryCaptor = ArgumentCaptor.forClass(String.class);
    verify(operation).executeQuery(eq(connection), queryCaptor.capture());
    final String query = queryCaptor.getValue();
    assertThat(query, containsString("CREATE (n1:A {id:1}),(n2:A {id:2}),(n1)-[e1:E {id:3}]->(n2)"));
}