import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的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.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * Read this ldap record,{@code cn=Hierarchies, ou=OS-P} into this entity, {@link Hier}, before loading into this collection class,{@code org.jgrapht.graph.SimpleDirectedGraph}
 * using 3rd party lib, <a href="http://www.jgrapht.org/">JGraphT</a>.
 *
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.
 * @return handle to simple digraph containing role hierarchies.
 */
private synchronized SimpleDirectedGraph<String, Relationship> loadGraph( String contextId )
{
    Hier inHier = new Hier( Hier.Type.ROLE );
    inHier.setContextId( contextId );
    LOG.info( "loadGraph initializing ROLE context [{}]", inHier.getContextId() );
    List<Graphable> descendants = null;

    try
    {
        descendants = roleP.getAllDescendants( inHier.getContextId() );
    }
    catch ( SecurityException se )
    {
        LOG.info( "loadGraph caught SecurityException={}", se );
    }

    Hier hier = HierUtil.loadHier( contextId, descendants );
    SimpleDirectedGraph<String, Relationship> graph;

    graph = HierUtil.buildGraph( hier );
    roleCache.put( getKey( contextId ), graph );

    return graph;
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 *
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.
 * @return handle to simple digraph containing role hierarchies.
 */
private SimpleDirectedGraph<String, Relationship> getGraph( String contextId )
{
    String key = getKey( contextId );        
    LOG.debug("Getting graph for key " + contextId);
     
    SimpleDirectedGraph<String, Relationship> graph = ( SimpleDirectedGraph<String, Relationship> ) roleCache
             .get( key );
         
    if(graph == null){
        LOG.debug("Graph was null, creating... " + contextId);
        return loadGraph( contextId );
    }
    else{
        LOG.debug("Graph found in cache, returning...");
        return graph;
    }
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * This method converts from physical ldap entity format, {@link Hier} to logical {@code org.jgrapht.graph.SimpleDirectedGraph}.
 *
 * @param hier contains parent-child relationship in preparation to storing in ldap {@code ftRels} attribute of {@code ftHier} object class.
 * @return {@code org.jgrapht.graph.SimpleDirectedGraph} containing the vertices of {@code String}, and edges, as {@link Relationship}s that correspond to relational data.
 */
private static SimpleDirectedGraph<String, Relationship> toGraph( Hier hier )
{
    LOG.debug( "toGraph" );
    SimpleDirectedGraph<String, Relationship> graph =
        new SimpleDirectedGraph<>( Relationship.class );
    List<Relationship> edges = hier.getRelationships();
    if ( edges != null && edges.size() > 0 )
    {
        for ( Relationship edge : edges )
        {
            String child = edge.getChild();
            String parent = edge.getParent();

            try
            {
                graph.addVertex( child );
                graph.addVertex( parent );
                graph.addEdge( child, parent, edge );
            }
            catch (java.lang.IllegalArgumentException e)
            {
                String error = "toGraph child: " + child + " parent: " + parent + " caught IllegalArgumentException=" + e;
                LOG.error( error );
            }

            LOG.debug( "toGraph child={}, parent={}", child, parent );
        }
    }
    return graph;
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * Private utility to return the parents (direct ascendants) of a given child node.
 *
 * @param vertex contains node name and acts as cursor for current location.
 * @param graph  contains a reference to simple digraph {@code org.jgrapht.graph.SimpleDirectedGraph}.
 * @return Set of names that are parents of given child.
 */
static Set<String> getParents( String vertex, SimpleDirectedGraph<String, Relationship> graph )
{
    Set<String> parents = new HashSet<>();
    if ( graph == null )
    {
        // graph is null
        return null;
    }
    LOG.debug( "getParents [{}]", vertex);
    Set<Relationship> edges;
    try
    {
        edges = graph.outgoingEdgesOf( vertex );
    }
    catch ( java.lang.IllegalArgumentException iae )
    {
        // vertex is leaf.
        return null;
    }
    for ( Relationship edge : edges )
    {
        parents.add( edge.getParent() );
    }
    return parents;
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * Method instantiates a new digraph, {@code org.jgrapht.graph.SimpleDirectedGraph}, using data passed in via
 * {@link Hier} entity.
 *
 * @param hier contains the source data for digraph.
 * @return reference to {@code org.jgrapht.graph.SimpleDirectedGraph}.
 */
static SimpleDirectedGraph<String, Relationship> buildGraph( Hier hier )
{
    SimpleDirectedGraph<String, Relationship> graph;
    LOG.debug( "buildGraph is initializing" );
    if ( hier == null )
    {
        String error = "buildGraph detected null hier=";
        LOG.error( error );
        return null;
    }
    graph = toGraph( hier );
    LOG.debug( "buildGraph success to toGraph" );
    LOG.debug( "buildGraph is success" );
    return graph;
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.
 * @return handle to simple digraph containing perm ou hierarchies.
 */
private SimpleDirectedGraph<String, Relationship> getGraph( String contextId )
{
    String key = getKey( contextId );        
    LOG.debug("Getting graph for key " + contextId);
     
    SimpleDirectedGraph<String, Relationship> graph = ( SimpleDirectedGraph<String, Relationship> ) psoCache
             .get( key );
         
    if(graph == null){
        LOG.debug("Graph was null, creating... " + contextId);
        return loadGraph( contextId );
    }
    else{
        LOG.debug("Graph found in cache, returning...");
        return graph;
    }
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 *
 * @return handle to simple digraph containing user ou hierarchies.
 */
private SimpleDirectedGraph<String, Relationship> getGraph( String contextId )
{
    String key = getKey( contextId );        
    LOG.debug("Getting graph for key " + contextId);
     
    SimpleDirectedGraph<String, Relationship> graph = ( SimpleDirectedGraph<String, Relationship> ) usoCache
             .get( key );
         
    if(graph == null){
        LOG.debug("Graph was null, creating... " + contextId);
        return loadGraph( contextId );
    }
    else{
        LOG.debug("Graph found in cache, returning...");
        return graph;
    }
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * Read this ldap record,{@code cn=Hierarchies, ou=OS-P} into this entity, {@link Hier}, before loading into this collection class,{@code org.jgrapht.graph.SimpleDirectedGraph}
 * using 3rd party lib, <a href="http://www.jgrapht.org/">JGraphT</a>.
 *
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.
 * @return handle to simple digraph containing adminRole hierarchies.
 */
private static synchronized SimpleDirectedGraph<String, Relationship> loadGraph( String contextId )
{
    Hier inHier = new Hier( Hier.Type.ROLE );
    inHier.setContextId( contextId );
    LOG.info( "loadGraph initializing ADMIN ROLE context [{}]", inHier.getContextId() );
    List<Graphable> descendants = null;

    try
    {
        descendants = adminRoleP.getAllDescendants( inHier.getContextId() );
    }
    catch ( SecurityException se )
    {
        LOG.info( "loadGraph caught SecurityException={}", se );
    }

    Hier hier = HierUtil.loadHier( contextId, descendants );
    SimpleDirectedGraph<String, Relationship> graph;

    graph = HierUtil.buildGraph( hier );
    adminRoleCache.put( getKey( contextId ), graph );

    return graph;
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * Read this ldap record,{@code cn=Hierarchies, ou=OS-P} into this entity, {@link Hier}, before loading into this collection class,{@code org.jgrapht.graph.SimpleDirectedGraph}
 * using 3rd party lib, <a href="http://www.jgrapht.org/">JGraphT</a>.
 *
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.
 * @return handle to simple digraph containing adminRole hierarchies.
 */
private static SimpleDirectedGraph<String, Relationship> getGraph( String contextId )
{
    String key = getKey( contextId );        
    LOG.debug("Getting graph for key " + contextId);
     
    SimpleDirectedGraph<String, Relationship> graph = ( SimpleDirectedGraph<String, Relationship> ) adminRoleCache
             .get( key );
         
    if(graph == null){
        LOG.debug("Graph was null, creating... " + contextId);
        return loadGraph( contextId );
    }
    else{
        LOG.debug("Graph found in cache, returning...");
        return graph;
    }
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
private Iterable<SpeciesDescription> getSpeciesInHierarchicalOrder(final ModelDescription model) {
	final DirectedGraph<SpeciesDescription, Object> hierarchy = new SimpleDirectedGraph<>(Object.class);
	final DescriptionVisitor visitor = new DescriptionVisitor<SpeciesDescription>() {

		@Override
		public boolean visit(final SpeciesDescription desc) {
			if (desc instanceof ModelDescription)
				return true;
			final SpeciesDescription sd = desc.getParent();
			if (sd == null || sd == desc)
				return false;
			hierarchy.addVertex(desc);
			if (!sd.isBuiltIn()) {
				hierarchy.addVertex(sd);
				hierarchy.addEdge(sd, desc);
			}
			return true;
		}
	};
	model.visitAllSpecies(visitor);
	return () -> new TopologicalOrderIterator<>(hierarchy);
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
public List<String> sort(List<Class<?>> classes) throws OrderSortCycleException {
    List<String> result = new ArrayList<>();
    SimpleDirectedGraph<String, DefaultEdge> graph = new SimpleDirectedGraph<>(DefaultEdge.class);
    
    for (OrderConstraint orderConstraint : getConstraints(classes)) {
        graph.addVertex(orderConstraint.getFirst());
        graph.addVertex(orderConstraint.getSecond());
        
        graph.addEdge(orderConstraint.getFirst(), orderConstraint.getSecond());
    }
    
    CycleDetector<String, DefaultEdge> cycleDetector = new CycleDetector<>(graph);
    if(!cycleDetector.detectCycles()) {
                    for (TopologicalOrderIterator<String, DefaultEdge> iterator = new TopologicalOrderIterator<>(graph); iterator.hasNext();) {
            result.add(iterator.next());
        }
    } else {
        String cycles = Joiner.on(", ").join(cycleDetector.findCycles());
        
        throw new OrderSortCycleException("The given order constraints contain (at least one) cycle. Cycles can only "
                + "be caused by static references because we have single inherintance only in Java (involved classes: '" + cycles + "').");
    }

    return result;
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * Check if there are any cycles in the dependencies of the modules.
 */
public void checkDependencyCycles(List<String> errors) {
	if (!dependenciesResolved) {
		throw new Error("Call resolveDependencies() first");
	}

	SimpleDirectedGraph<ModuleModel, Edge> g = buildModuleDependencyGraph();

	CycleDetector<ModuleModel, Edge> detector = new CycleDetector<>(g);
	Set<ModuleModel> cycleModules = detector.findCycles();

	if (!cycleModules.isEmpty()) {
		errors.add("Found cycle in module dependency graph. Involved modules: "
				+ cycleModules);
	}
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * Create a simple directed graph.
 * 
 * @see http://en.wikipedia.org/wiki/Topological_sorting
 */
@SuppressWarnings("boxing")
public static DirectedGraph<Integer, DefaultEdge> directedGraph()
{
	final DirectedGraph<Integer, DefaultEdge> g = new SimpleDirectedGraph<>(
			DefaultEdge.class);

	final Set<Integer> vertices = CollectionUtil.toSet(7, 5, 3, 11, 8, 2, 9, 10);
	for (final Integer v : vertices)
	{
		g.addVertex(v);
	}

	g.addEdge(7, 8);
	g.addEdge(7, 11);
	g.addEdge(5, 11);
	g.addEdge(3, 8);
	g.addEdge(3, 10);
	g.addEdge(11, 2);
	g.addEdge(11, 9);
	g.addEdge(11, 10);
	g.addEdge(8, 9);

	return g;
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
private void checkChildrenSets(Set<String> oidsToCheck) {
    SimpleDirectedGraph<String,DefaultEdge> tc = (SimpleDirectedGraph) orgGraph.clone();
    TransitiveClosure.INSTANCE.closeSimpleDirectedGraph(tc);
    for (String subroot : oidsToCheck) {
        LOGGER.info("Checking descendants of {}", subroot);
        Set<String> expectedChildren = new HashSet<>();
        for (DefaultEdge edge : tc.incomingEdgesOf(subroot)) {
            expectedChildren.add(tc.getEdgeSource(edge));
        }
        expectedChildren.add(subroot);
        LOGGER.trace("Expected children: {}", expectedChildren);
        Set<String> actualChildren = getActualChildrenOf(subroot);
        LOGGER.trace("Actual children: {}", actualChildren);

        Set<String> expectedMinusActual = new HashSet<>(expectedChildren);
        expectedMinusActual.removeAll(actualChildren);
        if (!expectedMinusActual.isEmpty()) {
            System.out.println("Expected-Actual = " + expectedMinusActual);
        }
        Set<String> actualMinusExpected = new HashSet<>(actualChildren);
        actualMinusExpected.removeAll(expectedChildren);
        if (!actualMinusExpected.isEmpty()) {
            System.out.println("Actual-Expected = " + actualMinusExpected);
        }
        assertEquals("Incorrect children for " + subroot, expectedChildren, actualChildren);
    }
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
public Collection<ConfClass> getConfigurations(ConfClass confObject, Properties props) {
	Class<? extends Object> confClass = confObject.getClass();
	HashMap<String, Field> parameters = new HashMap<>();
	DirectedGraph<Field, DefaultEdge> dependencyGraph = new SimpleDirectedGraph<>(DefaultEdge.class);
	HashMap<Field, DependsOn> rawDependencies = new HashMap<>();

	for (Field f : confClass.getFields()) {
		dependencyGraph.addVertex(f);

		parameters.put(f.getName(), f);
		if (f.isAnnotationPresent(DependsOn.class)) {
			DependsOn depOn = f.getAnnotation(DependsOn.class);
			rawDependencies.put(f, depOn);
		}
	}

	for (Entry<Field, DependsOn> entry : rawDependencies.entrySet()) {
		String otherParam = entry.getValue().parameter();
		if (!parameters.containsKey(otherParam)) {
			throw new RuntimeException("Parameter dependency '" + otherParam + "' referenced from '"
					+ entry.getKey() + "' not found!");
		}
		Field otherField = parameters.get(otherParam);
		// read this edge as "otherField" before "entry.getKey()"
		dependencyGraph.addEdge(otherField, entry.getKey());

	}
	List<Field> consistentOrdering = getParameterOrdering(dependencyGraph);

	Collection<ConfClass> configurations = enumerateConfigurations(confObject, consistentOrdering, parameters,
			props);
	
	return configurations;
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
@Override
public void preClose() {
	DirectedGraph<String, String> graph = new SimpleDirectedGraph<>(String.class);
	addVerticesToGraph(graph);
	addEdgesToGraph(graph);
	
	depthFirstSearchAndWriteOutResults(graph);
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * Creates a new Graph.
 *
 * @param edgeFact
 *            The edgefactory to use for this graph.
 */
public JGraphTGraphAdapter(final JGraphTEdgeFactory<V> edgeFact) {
    internalGraph = new SimpleDirectedGraph<V, DefaultEdge>(
            DefaultEdge.class);
    this.edgeFact = edgeFact;
    sources = new TreeSet<>();
    sinks = new TreeSet<>();
    vertexIdentifiers = new ArrayList<>();
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * This method is synchronized and adds an edge and its associated vertices to simple directed graph stored in static memory of this process.
 *
 * @param graph synchronized parameter contains a reference to simple digraph {@code org.jgrapht.graph.SimpleDirectedGraph}.
 * @param relation contains parent-child relationship targeted for addition.
 * @return {@code org.jgrapht.graph.SimpleDirectedGraph} containing the vertices of {@code String}, and edges, as {@link Relationship}s that correspond to relational data.
 */
private static void addEdge( SimpleDirectedGraph<String, Relationship> graph, Relationship relation )
{
    LOG.debug( "addEdge" );
    synchronized ( graph )
    {
        graph.addVertex( relation.getChild().toUpperCase() );
        graph.addVertex( relation.getParent().toUpperCase() );
        graph.addEdge( relation.getChild().toUpperCase(), relation.getParent().toUpperCase(), relation );
    }
}
 

import org.jgrapht.graph.SimpleDirectedGraph; //导入依赖的package包/类
/**
 * This method is synchronized and removes an edge from a simple directed graph stored in static memory of this process.
 *
 * @param graph synchronized parameter contains a reference to simple digraph {@code org.jgrapht.graph.SimpleDirectedGraph}.
 * @param relation contains parent-child relationship targeted for removal.
 * @return {@code org.jgrapht.graph.SimpleDirectedGraph} containing the vertices of {@code String}, and edges, as {@link Relationship}s that correspond to relational data.
 */
private static void removeEdge( SimpleDirectedGraph<String, Relationship> graph, Relationship relation )
{
    LOG.debug( "removeEdge" );
    synchronized ( graph )
    {
        graph.removeEdge( relation );
    }
}