import org.jgrapht.alg.StrongConnectivityInspector; //导入依赖的package包/类
/**
 * Returns the components of the graph that are cycles.
 * Taken from the implementation of {@link CycleDetector#findCycles()}. (EPL)
 */
private static <T, E> ListIterable<Set<T>> getCycleComponents(final DirectedGraph<T, E> graph) {
    StrongConnectivityInspector<T, E> inspector =
            new StrongConnectivityInspector<T, E>(graph);

    return ListAdapter.adapt(inspector.stronglyConnectedSets()).select(new Predicate<Set<T>>() {
        @Override
        public boolean accept(Set<T> each) {
            if (each.size() > 1) {
                // multi-vertex strongly-connected component is a cycle
                return true;
            }

            // vertex with an edge to itself is a cycle
            T vertex = each.iterator().next();
            return graph.containsEdge(vertex, vertex);
        }
    });
}
 

import org.jgrapht.alg.StrongConnectivityInspector; //导入依赖的package包/类
/**
 * Returns the average two-term reliability (A2TR) of the network. A2TR is computed
 * as the ratio between the number of node-pair for which a path can be found
 * and the same number when the network is connected (<i>Nx(N-1)</i>, where
 * <i>N</i> is the number of nodes in the network). The value is in range [0, 1].
 *
 * @return Average two-term reliability
 */
public double getAverageTwoTermReliability()
{
	if (E == 0) return 0;

	DirectedGraph<Node, Link> graph = getGraph_JGraphT();
	StrongConnectivityInspector<Node, Link> ci = new StrongConnectivityInspector<Node, Link>(graph);
	List<Set<Node>> connectedComponents = ci.stronglyConnectedSets();

	double sum = 0;
	Iterator<Set<Node>> it = connectedComponents.iterator();
	while (it.hasNext())
	{
		int componentSize = it.next().size();
		sum += componentSize * (componentSize - 1);
	}

	return sum / (N * (N - 1));
}
 

import org.jgrapht.alg.StrongConnectivityInspector; //导入依赖的package包/类
/**
 * Constructs a list of NFA graphs each representing a strongly connected
 * component in the graph given as parameter.
 * 
 * @param m
 *            The NFA graph to find the strongly connected components in.
 * @return A list containing all the strongly connected components.
 * @throws InterruptedException 
 */
public static LinkedList<NFAGraph> getStronglyConnectedComponents(NFAGraph m) throws InterruptedException {
	StrongConnectivityInspector<NFAVertexND, NFAEdge> sci = new StrongConnectivityInspector<NFAVertexND, NFAEdge>(m);
	List<DirectedSubgraph<NFAVertexND, NFAEdge>> sccs = sci.stronglyConnectedSubgraphs();
	LinkedList<NFAGraph> sccNFAs = new LinkedList<NFAGraph>();

	for (DirectedSubgraph<NFAVertexND, NFAEdge> scc : sccs) {
		if (isInterrupted()) {
			throw new InterruptedException();
		}

		/* scc's consisting of no edges are irrelevant for our purpose */
		if (scc.edgeSet().size() > 0) {

			NFAGraph currentNFAG = new NFAGraph();
			for (NFAVertexND v : scc.vertexSet()) {
				if (isInterrupted()) {
					throw new InterruptedException();
				}
				currentNFAG.addVertex(v);
			}
			for (NFAEdge e : scc.edgeSet()) {
				if (isInterrupted()) {
					throw new InterruptedException();
				}
				currentNFAG.addEdge(e);
			}

			sccNFAs.add(currentNFAG);
		}

	}
	return sccNFAs;
}
 

import org.jgrapht.alg.StrongConnectivityInspector; //导入依赖的package包/类
public DependencyStratification generate(List<Dependency> dependencies, EGTask task) {
    Map<Dependency, Set<AttributeRef>> affectedAttributes = findAllAffectedAttributes(dependencies, task);
    if (logger.isDebugEnabled()) logger.debug("Affected attributes: " + SpeedyUtility.printMap(affectedAttributes));
    Map<Dependency, Set<AttributeRef>> queriedAttributes = findAllQueriedAttributes(dependencies, task);
    if (logger.isDebugEnabled()) logger.debug("Queried attributes: " + SpeedyUtility.printMap(queriedAttributes));
    DirectedGraph<Dependency, DefaultEdge> dependencyGraph = initDependencyGraph(dependencies, affectedAttributes, queriedAttributes);
    if (logger.isDebugEnabled()) logger.debug("Dependency graph: \n" + dependencyGraph);
    StrongConnectivityInspector<Dependency, DefaultEdge> connectivityInstector = new StrongConnectivityInspector<Dependency, DefaultEdge>(dependencyGraph);
    List<Set<Dependency>> strata = connectivityInstector.stronglyConnectedSets();
    Collections.sort(strata, new StratumComparator(dependencyGraph));
    return new DependencyStratification(strata);
}
 

import org.jgrapht.alg.StrongConnectivityInspector; //导入依赖的package包/类
private List<MappingConfiguration> getTopologicallyOrderedMappingConfigurations(
		JsonixContext context,
		final List<ModuleConfiguration> moduleConfigurations) {
	final DirectedGraph<MappingConfiguration, Object> mappingConfigurationDependencyGraph = buildMappingConfigurationDependencyGraph(
			context, moduleConfigurations);

	final StrongConnectivityInspector<MappingConfiguration, Object> strongConnectivityInspector = new StrongConnectivityInspector<MappingConfiguration, Object>(
			mappingConfigurationDependencyGraph);

	final List<Set<MappingConfiguration>> stronglyConnectedSets = strongConnectivityInspector
			.stronglyConnectedSets();

	for (Set<MappingConfiguration> stronglyConnectedSet : stronglyConnectedSets) {
		if (stronglyConnectedSet.size() > 1) {
			throw new IllegalArgumentException(MessageFormat.format(
					"Mappings have the following dependency cycle: {0}",
					stronglyConnectedSet.toString()));
		}
	}

	final List<MappingConfiguration> mappingConfigurations = new ArrayList<MappingConfiguration>(
			mappingConfigurationDependencyGraph.vertexSet().size());
	for (Iterator<MappingConfiguration> mappingConfigurationsInTopologicalOrderIterator = new TopologicalOrderIterator<MappingConfiguration, Object>(
			mappingConfigurationDependencyGraph); mappingConfigurationsInTopologicalOrderIterator
			.hasNext();) {
		mappingConfigurations
				.add(mappingConfigurationsInTopologicalOrderIterator.next());
	}
	return mappingConfigurations;
}
 

import org.jgrapht.alg.StrongConnectivityInspector; //导入依赖的package包/类
private Set<Long> getTheLargestGraphComponent(
		StrongConnectivityInspector<Long, PlannerEdge> strongConnectivityInspector) {
	List<Set<Long>> components = strongConnectivityInspector.stronglyConnectedSets();
	Collections.sort(components, new Comparator<Set<Long>>() {

		@Override
		public int compare(Set<Long> o1, Set<Long> o2) {
			return o2.size() - o1.size();
		}

	});

	return components.get(0);
}
 

import org.jgrapht.alg.StrongConnectivityInspector; //导入依赖的package包/类
private Graph<Node, Edge> connectivity(Graph graph) {

		DirectedGraph<Long, PlannerEdge> plannerGraph = prepareGraphForFindComponents(graph);

		StrongConnectivityInspector<Long, PlannerEdge> strongConnectivityInspector = new StrongConnectivityInspector<>(
				plannerGraph);

		if (strongConnectivityInspector.isStronglyConnected()) {
			return graph;
		}

		LOGGER.debug("The Highway map has more then one strong component, it will be selected the largest components");

		Set<Long> strongestComponents = getTheLargestGraphComponent(strongConnectivityInspector);

		return createGraphBasedOnTheLargestComponent(graph, strongestComponents);
	}
 

import org.jgrapht.alg.StrongConnectivityInspector; //导入依赖的package包/类
@Override
public boolean isIrreducible() {
	
	StrongConnectivityInspector<Integer, DefaultEdge> tmpSCI = new StrongConnectivityInspector<>(this.internalGraph);
	
	return tmpSCI.isStronglyConnected();
}