Java DirectedGraph类代码示例

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
@Test
public void testBfs() throws Exception {

	DirectedGraph<URI, URI> graph = new DirectedSparseGraph<>();
	graph.addVertex( YURI );
	graph.addVertex( YUGO );
	graph.addEdge( YPY, YURI, YUGO, EdgeType.DIRECTED );

	Collection<URI> roots = Arrays.asList( YURI );
	GraphToTreeConverter.Search search = GraphToTreeConverter.Search.BFS;
	Forest<URI, URI> result = GraphToTreeConverter.convert( graph, roots, search );
	assertEquals( 1, result.getTrees().size() );

	Tree<URI, URI> tree = result.getTrees().iterator().next();
	assertEquals( YURI, tree.getRoot() );
	assertEquals( YUGO, tree.getChildren( YURI ).iterator().next() );
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
@Test
public void testDfs() throws Exception {

	DirectedGraph<URI, URI> graph = new DirectedSparseGraph<>();
	graph.addVertex( YURI );
	graph.addVertex( YUGO );
	graph.addEdge( YPY, YURI, YUGO, EdgeType.DIRECTED );

	Collection<URI> roots = Arrays.asList( YURI );
	GraphToTreeConverter.Search search = GraphToTreeConverter.Search.DFS;
	Forest<URI, URI> result = GraphToTreeConverter.convert( graph, roots, search );
	assertEquals( 1, result.getTrees().size() );

	Tree<URI, URI> tree = result.getTrees().iterator().next();
	assertEquals( YURI, tree.getRoot() );
	assertEquals( YUGO, tree.getChildren( YURI ).iterator().next() );
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
@Test
public void testPrint() throws Exception {

	DirectedGraph<URI, URI> graph = new DirectedSparseGraph<>();
	graph.addVertex( YURI );
	graph.addVertex( YUGO );
	graph.addEdge( YPY, YURI, YUGO, EdgeType.DIRECTED );

	Collection<URI> roots = Arrays.asList( YURI );
	GraphToTreeConverter.Search search = GraphToTreeConverter.Search.DFS;
	Forest<URI, URI> result = GraphToTreeConverter.convert( graph, roots, search );

	Logger log = Logger.getLogger( GraphToTreeConverter.class );
	StringWriter stringy = new StringWriter();
	WriterAppender app = new WriterAppender( new SimpleLayout(), stringy );
	log.setLevel( Level.DEBUG );
	log.addAppender( app );
	GraphToTreeConverter.printForest( result );
	String output = stringy.toString().replaceAll( "\\s", "" );
	assertEquals( "DEBUG-http://semoss.va.gov/database/T44889381-85ce-43e3-893d-6267fd480660/YuriDEBUG-http://semoss.va.gov/database/T44889381-85ce-43e3-893d-6267fd480660/Yugo", output );
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
/**
 * Constructor for LayoutPopup.
 *
 * @param name String
 * @param ps IPlaySheet
 */
public LayoutPopup( String name, GraphPlaySheet ps, Collection<SEMOSSVertex> verts ) {
	super( name );

	DirectedGraph<SEMOSSVertex, SEMOSSEdge> viz = ps.getVisibleGraph();
	boolean forestok = ( viz instanceof Forest || !verts.isEmpty() );

	for ( Class<? extends Layout> layout : LAYOUTS ) {
		LayoutMenuItem mi = new LayoutMenuItem( layout, ps, verts );
		add( mi );

		if ( TREELAYOUTS.contains( layout ) ) {
			mi.setEnabled( forestok );
		}
	}
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
/**
 * Method actionPerformed. Dictates what actions to take when an Action Event
 * is performed.
 *
 * @param arg0 ActionEvent - The event that triggers the actions in the
 * method.
 */
@Override
public void actionPerformed( ActionEvent arg0 ) {
	logger.debug( "Export button has been pressed" );

	DirectedGraph<SEMOSSVertex, SEMOSSEdge> graph = gps.getVisibleGraph();

	ValueFactory vf = new ValueFactoryImpl();
	List<Value[]> vals = new ArrayList<>();

	for ( SEMOSSEdge edge : graph.getEdges() ) {
		SEMOSSVertex src = graph.getSource( edge );
		SEMOSSVertex dst = graph.getDest( edge );

		Value subj = vf.createLiteral( src.getLabel() );
		Value obj = vf.createLiteral( dst.getLabel() );
		vals.add( new Value[] { subj, obj } );
	}

	GridRAWPlaySheet.convertUrisToLabels( vals, gps.getEngine() );

	GridRAWPlaySheet newGps = new GridRAWPlaySheet();
	newGps.setTitle( "EXPORT: " + gps.getTitle() );
	newGps.create( vals, Arrays.asList( "Source", "Destination" ), gps.getEngine() );
	gps.addSibling( "Graph Edge List", newGps );
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
/**
 * Gets nodes that have both in- and out- edges and are of the given type
 *
 * @param graph the graph to inspect
 * @param type the node type that has the edges
 * @param endpoint
 * @return
 */
public static MultiMap<SEMOSSVertex, CondenserTuple>
		findNodesToCondense( DirectedGraph<SEMOSSVertex, SEMOSSEdge> graph,
				URI type, URI endpoint ) {
	MultiMap<SEMOSSVertex, CondenserTuple> removers = new MultiMap<>();
	for ( SEMOSSVertex middle : graph.getVertices() ) {
		if ( type.equals( middle.getType() ) ) {
			SEMOSSEdge upstream = getEdge( endpoint, middle, graph, true );
			SEMOSSEdge downstream = getEdge( endpoint, middle, graph, false );

			// FIXME: we might have multiple pairs of
			// endpoints through our middle, so loop
			//while ( !( null == upstream || null == downstream ) ) {
			if ( !( null == upstream || null == downstream ) ) {
				removers.add( middle, new CondenserTuple( upstream, downstream ) );
			}

			// upstream = getVertex( endpoint, middle, graph, true );
			//downstream = getVertex( endpoint, middle, graph, false );
			//}
		}
	}

	return removers;
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
public String select( DirectedGraph<QueryNode, QueryEdge> graph,
		List<QueryOrder> ordering ) {

	List<QueryGraphElement> todo = new ArrayList<>();
	todo.addAll( graph.getVertices() );
	todo.addAll( graph.getEdges() );

	Set<QueryOrder> linkedOrderSet = new LinkedHashSet<>( ordering );
	for ( QueryGraphElement v : todo ) {
		for ( URI prop : v.getAllValues().keySet() ) {
			QueryOrder qo = new QueryOrder( v, prop );
			if ( !linkedOrderSet.contains( qo ) ) {
				linkedOrderSet.add( qo );
			}
		}
	}

	List<QueryOrder> fullOrdering = new ArrayList<>( linkedOrderSet );
	return buildSelect( fullOrdering ) + buildWhere( graph, fullOrdering );
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
public static DirectedGraph<GraphNode, GraphEdge> build(
    GraphModel graphModel, EdgeMatcher<String> matcher) {

  DirectedGraph<GraphNode, GraphEdge> result =
          new DirectedSparseMultigraph<GraphNode, GraphEdge>();

  Set<GraphNode> includedNodes = graphModel.getNodesSet();

  for (GraphEdge edge : graphModel.getEdges()) {
    // Filter on nodes first
    if (!includedNodes.contains(edge.getHead()))
      continue;

    if (!includedNodes.contains(edge.getTail()))
      continue;

    if (matcher.edgeForward(edge)) {
      result.addEdge(edge, edge.getHead(), edge.getTail());
    }
    else if (matcher.edgeReverse(edge)) {
      result.addEdge(edge, edge.getTail(), edge.getHead());
    }
  }
  return result;
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
private void addEdges(
        DirectedGraph<GraphNode, GraphEdge> result,
        Set<GraphNode> includedNodes) {

  EdgeMatcher<String> matcher = edgeMatcher.getInfo();
  for (GraphEdge edge : graphModel.getEdges()) {
    // Filter on nodes first
    if (!includedNodes.contains(edge.getHead()))
      continue;

    if (!includedNodes.contains(edge.getTail()))
      continue;

    if (matcher.edgeForward(edge)) {
      addForwardEdge(result, edge);
    }
    else if (matcher.edgeReverse(edge)) {
      addReverseEdge(result, edge);
    }
  }
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
@Override
protected Layout<GraphNode,GraphEdge> buildJungLayout(
        DirectedGraph<GraphNode, GraphEdge> jungGraph,
        Dimension layoutSize) {
  SpringLayout<GraphNode, GraphEdge> result =
          new SpringLayout<GraphNode, GraphEdge>(jungGraph);
  result.setSize(layoutSize);
  if (force.isSet()) {
    result.setForceMultiplier(force.getValue());
  }
  if (range.isSet()) {
    result.setRepulsionRange(range.getValue());
  }
  if (stretch.isSet()) {
    result.setStretch(stretch.getValue());
  }
  return result;
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
public static <V> DirectedGraph<V, WeightedEdge> toDirected(Graph<V, WeightedEdge> graph) {	
	DirectedGraph<V, WeightedEdge> directedGraph = new DirectedSparseGraph<V, WeightedEdge>();

	// Add all vertices first
	Collection<V> vertices = graph.getVertices();
	for(V vertex : vertices) {
		directedGraph.addVertex(vertex);
	}
	
	// Add directed edges
	for(WeightedEdge edge : graph.getEdges()) {	
		Pair<V> endpoints = graph.getEndpoints(edge);
		directedGraph.addEdge(new WeightedEdge(edge.getWeight()), endpoints.getFirst(), endpoints.getSecond());
		directedGraph.addEdge(new WeightedEdge(edge.getWeight()), endpoints.getSecond(), endpoints.getFirst());
	}
	return directedGraph;
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
private void buildGraphInternal(final DirectedGraph<Object, JobGraphLink> graph,
        final AnalysisJobBuilder analysisJobBuilder, final List<Table> sourceTables,
        final JobGraphElementFactory linkFactory) {

    // note: currently SourceColumnFinder cannot cross links from
    // OutputDataStreams to the main/parent AnalysisJobBuilder, so we create
    // a new SourceColumnFinder for each AnalysisJobBuilder instead of
    // reusing the instance.
    final SourceColumnFinder sourceColumnFinder = new SourceColumnFinder();
    sourceColumnFinder.addSources(analysisJobBuilder);

    for (final Table table : sourceTables) {
        addNodes(graph, sourceColumnFinder, linkFactory, table, -1);
    }

    final Collection<ComponentBuilder> componentBuilders = analysisJobBuilder.getComponentBuilders();
    for (final ComponentBuilder componentBuilder : componentBuilders) {
        addNodes(graph, sourceColumnFinder, linkFactory, componentBuilder, -1);
    }

    removeUnnecesaryEdges(graph, sourceColumnFinder);
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
/*******************************************************
 * Creates a new instance of this class
 * 
 * @param invokingFile
 *            The file that invokes methods whose declarations will be
 *            searched
 * @param macroGraph
 *            The macro graph to be filled
 * @param microGraph
 *            The micro graph to be filled
 * @throws IllegalArgumentException
 *             If any of the parameters is null
 *******************************************************/
public MacroMicroSearchRequestor(ICompilationUnit invokingFile, DirectedGraph<ICompilationUnit, EdgeWrapper> macroGraph,
		DirectedGraph<ICompilationUnit, EdgeWrapper> microGraph)
{
	if (invokingFile == null || macroGraph == null || microGraph == null)
	{
		throw new IllegalArgumentException();
	}

	
	mInvokingFile = invokingFile;
	mMacroGraph = macroGraph;
	mMicroGraph = microGraph;

	// Add the invoking file vertices
	mMacroGraph.addVertex(mInvokingFile);
	mMicroGraph.addVertex(mInvokingFile);
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public List<Set<V>> transform(DirectedGraph<V, E> graph) {
    WeakComponentClusterer<V, E> clust = new WeakComponentClusterer<V, E>();
    Set<Set<V>> components = clust.transform(graph);
    ArrayList<Set<V>> res = new ArrayList<Set<V>>();        
    for (Set<V> comp : components) {
        List<Set<V>> r = rank(graph, comp);
        for (int i = 0; i < r.size(); i++) {
            Set<V> s = r.get(i);
            if (res.size() <= i) {
                res.add(s);
            }
            else {
                res.get(i).addAll(s);
            }
        }
    }
    
    return res;
}
 

import edu.uci.ics.jung.graph.DirectedGraph; //导入依赖的package包/类
/**
 * Constructs a new instance of the algorithm solver for a given graph, source, and sink.
 * Source and sink vertices must be elements of the specified graph, and must be 
 * distinct.
 * @param directedGraph the flow graph
 * @param source the source vertex
 * @param sink the sink vertex
 * @param edgeCapacityKey the UserDatum key that stores the capacity for each edge.
 * @param edgeFlowKey the UserDatum key where the solver will place the value of the flow for each edge
 */
public EdmondsKarpMaxFlow(DirectedGraph directedGraph, Vertex source, Vertex sink, String edgeCapacityKey, String edgeFlowKey) 
{
    if (source.getGraph() != directedGraph || sink.getGraph() != directedGraph)
        throw new IllegalArgumentException("source and sink vertices must be elements of the specified graph");
    
    if (source.equals(sink))
        throw new IllegalArgumentException("source and sink vertices must be distinct");
    
    mOriginalGraph = directedGraph;
    mFlowGraph = (DirectedGraph) directedGraph.copy();
    mSource = (Vertex) source.getEqualVertex(mFlowGraph);
    mTarget = (Vertex) sink.getEqualVertex(mFlowGraph);
    mEdgeFlowKey = edgeFlowKey;
    mEdgeCapacityKey = edgeCapacityKey;
    mMaxFlow = 0;
    mSinkPartitionNodes = new HashSet();
    mSourcePartitionNodes = new HashSet();
    mMinCutEdges = new HashSet();
}