Java EdgeFactory类代码示例

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
static KuhnMunkresMinimalWeightBipartitePerfectMatching<V, WeightedEdge>
    match(final double[][] costMatrix, final int partitionCardinality) {

    List<? extends V> first     = firstPartition.subList(0, partitionCardinality);
    List<? extends V> second    = secondPartition.subList(0, partitionCardinality);

    WeightedGraph<V, WeightedEdge> target =
      new SimpleWeightedGraph<V, WeightedEdge>(new EdgeFactory<V, WeightedEdge>() {
        @Override
        public WeightedEdge createEdge(V sourceVertex, V targetVertex) {
          return WeightedEdge.make(sourceVertex, targetVertex);
        }
      });

    WeightedGraphGeneratorAdapter<V, WeightedEdge, V> generator =
      new SimpleWeightedBipartiteGraphMatrixGenerator<V, WeightedEdge>()
          .first  (first)
          .second (second)
          .weights(costMatrix);

    generator.generateGraph(target, null, null);

    return new KuhnMunkresMinimalWeightBipartitePerfectMatching<V, WeightedEdge>(target, first, second);

}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
@Test
public void testAddEdgeWithMissingVertices() {
	Graph<String, String> graph = new DefaultDirectedGraph<>(new EdgeFactory<String, String>() {
		public String createEdge(String sourceVertex, String targetVertex) {
			return sourceVertex + targetVertex;
		};
	});
	graph = new AddVerticesAutomatically<>(graph);
	graph.addEdge("A", "B");
	graph.addEdge("A", "C", "DEF");
	assertTrue(graph.containsVertex("A"));
	assertTrue(graph.containsVertex("B"));
	assertTrue(graph.containsVertex("C"));
	assertTrue(graph.containsEdge("AB"));
	assertTrue(graph.containsEdge("DEF"));
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
@Test
public void testCutCyclesCompleteGraph() throws IOException {
	CompleteGraphGenerator<String, String> generator = new CompleteGraphGenerator<>(5);
	DirectedGraph<String, String> graph = new DefaultDirectedGraph<>(new EdgeFactory<String, String>() {
		@Override
		public String createEdge(String sourceVertex, String targetVertex) {
			return sourceVertex + targetVertex;
		}
	});
	generator.generateGraph(graph, new VertexFactory<String>() {
		
		private int count = 0;
		
		@Override
		public String createVertex() {
			count ++;
			return "V" + count;
		}
	}, new HashMap<String, String>());
	DirectedGraph<String, String> target = new DefaultDirectedGraph<>(new UnsupportedEdgeFactory<String, String>());
	target = new MinimumEdgesCycleCut<String, String>(graph, target).cutCycles();
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
/**
 * Construct a TestGraph with kmerSize
 * @param kmerSize
 */
public BaseGraph(final int kmerSize, final EdgeFactory<V,E> edgeFactory) {
    super(edgeFactory);

    if ( kmerSize < 1 ) throw new IllegalArgumentException("kmerSize must be >= 1 but got " + kmerSize);
    this.kmerSize = kmerSize;
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
private TrafficLocationGraph()
{
	EdgeFactory<Integer, LocationEdge> ef = new EdgeFactory<Integer, TrafficLocationGraph.LocationEdge>() {
		
		@Override
		public LocationEdge createEdge(Integer sourceVertex, Integer targetVertex) {
			// TODO Auto-generated method stub
			return new LocationEdge(sourceVertex, targetVertex);
		}
	};
	graph = new DefaultDirectedGraph<Integer, LocationEdge>(ef);
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
/**
   * Computes the metric closure with a given set of vertices over a graph.
   * @param originalGraph The Graph over which the metric closure should be computed.
   * @param destinations A set of vertices which should exist in the metric closure.
   * @return A Graph that uses MetricClosureEdgeAnnotations that store the paths in the original graph to allow later reconstruction.
   */
public static <T, E> DirectedWeightedPseudograph<T, MetricClosureEdge<T>> createMetricClosure(DirectedWeightedPseudograph<T, E> originalGraph, Set<T> destinations) {
	DirectedWeightedPseudograph<T, MetricClosureEdge<T>> metricClosure = new DirectedWeightedPseudograph<>(new EdgeFactory<T, MetricClosureEdge<T>>() {
		@Override
		public MetricClosureEdge<T> createEdge(T sourceVertex, T targetVertex) {
			return new MetricClosureEdge<>(new ArrayList<T>());
		}
	});
	
	for (E edge : originalGraph.edgeSet()) {
		T start = originalGraph.getEdgeSource(edge);
		T end = originalGraph.getEdgeTarget(edge);
		
		metricClosure.addVertex(start);
		metricClosure.addVertex(end);
		MetricClosureEdge<T> newEdge = metricClosure.addEdge(start, end);
		double edgeWeight = originalGraph.getEdgeWeight(edge);
		metricClosure.setEdgeWeight(newEdge, edgeWeight);
	}
	
	Set<T> removedVertices = new HashSet<T>(originalGraph.vertexSet());
	removedVertices.removeAll(destinations);
	
	for (T removedVertex : removedVertices) {
		eliminateVertex(metricClosure, removedVertex);
	}
	
	return metricClosure;
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
public TestDigraph(EdgeFactory<DiNode, DiEdge> arg0) {
	super(arg0, true, true);
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
private DirectedGraph<AbstractProject<?,?>, String> constructDirectedGraph(AbstractProject<?,?> root, Set<String> exclusions) {
    final DirectedGraph<AbstractProject<?,?>, String> graph = new DefaultDirectedGraph<AbstractProject<?,?>, String>(
            new EdgeFactory<AbstractProject<?,?>, String>() {
                public String createEdge(AbstractProject<?,?> source, AbstractProject<?,?> target) {
                    return String.format("'%s' --> '%s'", source.getName(), target.getName());
                }
            });

    final StringBuilder prettyPrinter = new StringBuilder(); // Used for printing the pipeline graph as an adjacency list matrix.
    final Stack<AbstractProject<?,?>> stack = new Stack<AbstractProject<?,?>>();
    graph.addVertex(root);
    stack.push(root);
    while (!stack.isEmpty()) {
        final AbstractProject<?,?> p = stack.pop();
        prettyPrinter.append(p.getName());
        prettyPrinter.append(": {");
        int index = 0;
        final List<AbstractProject> children = p.getDownstreamProjects();
        for (AbstractProject<?,?> child : children) {
            if (!child.isDisabled() && !exclusions.contains(child.getName())) {
                graph.addVertex(child);
                graph.addEdge(p, child);
                stack.push(child);
                if (index > 0) {
                    prettyPrinter.append(", ");
                }
                prettyPrinter.append(child.getName());
                index++;
            }
        }
        prettyPrinter.append(String.format("}%n"));
    }

    if (verbose) {
        LOGGER.log(Level.INFO, String.format("The build pipeline graph rooted at '%s':%n%s", root.getName(), prettyPrinter.toString()));
    }

    return graph;
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
@Override
public EdgeFactory<Node, Triple> getEdgeFactory() {
    return edgeFactory;
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
@Override
public EdgeFactory<RDFNode, Statement> getEdgeFactory() {
    return edgeFactory;
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
public StandardGraph(EdgeFactory<V, E> edgeFactory)
{
	super(edgeFactory);
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
public EdgeFactory<State, Transition> getEdgeFactory() {
    return delegate.getEdgeFactory();
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
GeneNetwork(EdgeFactory edgeFactory) {
    super(edgeFactory);
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
protected SimpleGraph(EdgeFactory<String, String> ef, boolean allowMultipleEdges, boolean allowLoops) {
	super(ef, allowMultipleEdges, allowLoops);
	// TODO Auto-generated constructor stub
}
 

import org.jgrapht.EdgeFactory; //导入依赖的package包/类
@Override
public EdgeFactory<Vertex, Edge> getEdgeFactory() {
	// TODO Auto-generated method stub
	return null;
}