EditorConfig documentation test
[idea/community.git] / java / java-impl / src / com / intellij / cyclicDependencies / CyclicDependenciesBuilder.java
index 608ec526b3eea566f77cee12105ff688a7341fa8..8f546070ad139aadf32d5ac69a475d3cb063ea8d 100644 (file)
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2000-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package com.intellij.cyclicDependencies;
 
 import com.intellij.analysis.AnalysisScope;
@@ -11,38 +26,36 @@ import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.packageDependencies.DependenciesBuilder;
 import com.intellij.packageDependencies.ForwardDependenciesBuilder;
 import com.intellij.psi.*;
-import com.intellij.util.graph.CachingSemiGraph;
-import com.intellij.util.graph.Graph;
-import com.intellij.util.graph.GraphGenerator;
+import com.intellij.util.graph.*;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
 
-/**
- * User: anna
- * Date: Jan 30, 2005
- */
 public class CyclicDependenciesBuilder{
+  @NotNull
   private final Project myProject;
   private final AnalysisScope myScope;
-  private final Map<String, PsiPackage> myPackages = new HashMap<String, PsiPackage>();
+  private final Map<String, PsiPackage> myPackages = new HashMap<>();
   private Graph<PsiPackage> myGraph;
-  private final Map<PsiPackage, Map<PsiPackage, Set<PsiFile>>> myFilesInDependentPackages = new HashMap<PsiPackage, Map<PsiPackage, Set<PsiFile>>>();
-  private final Map<PsiPackage, Map<PsiPackage, Set<PsiFile>>> myBackwardFilesInDependentPackages = new HashMap<PsiPackage, Map<PsiPackage, Set<PsiFile>>>();
-  private final Map<PsiPackage, Set<PsiPackage>> myPackageDependencies = new HashMap<PsiPackage, Set<PsiPackage>>();
-  private HashMap<PsiPackage, Set<List<PsiPackage>>> myCyclicDependencies = new HashMap<PsiPackage, Set<List<PsiPackage>>>();
-  private int myFileCount = 0;
+  private final Map<PsiPackage, Map<PsiPackage, Set<PsiFile>>> myFilesInDependentPackages = new HashMap<>();
+  private final Map<PsiPackage, Map<PsiPackage, Set<PsiFile>>> myBackwardFilesInDependentPackages = new HashMap<>();
+  private final Map<PsiPackage, Set<PsiPackage>> myPackageDependencies = new HashMap<>();
+  private HashMap<PsiPackage, Set<List<PsiPackage>>> myCyclicDependencies = new HashMap<>();
+  private int myFileCount;
   private final ForwardDependenciesBuilder myForwardBuilder;
 
   private String myRootNodeNameInUsageView;
 
-  public CyclicDependenciesBuilder(final Project project, final AnalysisScope scope) {
+  public CyclicDependenciesBuilder(@NotNull Project project, final AnalysisScope scope) {
     myProject = project;
     myScope = scope;
     myForwardBuilder = new ForwardDependenciesBuilder(myProject, myScope){
+      @Override
       public String getRootNodeNameInUsageView() {
         return CyclicDependenciesBuilder.this.getRootNodeNameInUsageView();
       }
 
+      @Override
       public String getInitialUsagesPosition() {
         return AnalysisScopeBundle.message("cyclic.dependencies.usage.view.initial.text");
       }
@@ -57,6 +70,7 @@ public class CyclicDependenciesBuilder{
     myRootNodeNameInUsageView = rootNodeNameInUsageView;
   }
 
+  @NotNull
   public Project getProject() {
     return myProject;
   }
@@ -91,7 +105,7 @@ public class CyclicDependenciesBuilder{
           for (PsiPackage pack : packs) {
             Set<PsiPackage> pack2Packages = myPackageDependencies.get(pack);
             if (pack2Packages == null) {
-              pack2Packages = new HashSet<PsiPackage>();
+              pack2Packages = new HashSet<>();
               myPackageDependencies.put(pack, pack2Packages);
             }
             for (PsiFile psiFile : psiFiles) {
@@ -139,12 +153,12 @@ public class CyclicDependenciesBuilder{
                                                        final Map<PsiPackage, Map<PsiPackage, Set<PsiFile>>> filesInDependentPackages) {
     Map<PsiPackage, Set<PsiFile>> dependentPackages2Files = filesInDependentPackages.get(pack);
     if (dependentPackages2Files == null) {
-      dependentPackages2Files = new HashMap<PsiPackage, Set<PsiFile>>();
+      dependentPackages2Files = new HashMap<>();
       filesInDependentPackages.put(pack, dependentPackages2Files);
     }
     Set<PsiFile> depFiles = dependentPackages2Files.get(depPackage);
     if (depFiles == null) {
-      depFiles = new HashSet<PsiFile>();
+      depFiles = new HashSet<>();
       dependentPackages2Files.put(depPackage, depFiles);
     }
     depFiles.add(file);
@@ -154,26 +168,26 @@ public class CyclicDependenciesBuilder{
   private void constractWholeDependenciesMap(final PsiJavaFile psiJavaFile, final PsiFile psiFile) {
     Set<PsiFile> wholeDependencies = myForwardBuilder.getDependencies().get(psiJavaFile);
     if (wholeDependencies == null) {
-      wholeDependencies = new HashSet<PsiFile>();
+      wholeDependencies = new HashSet<>();
       myForwardBuilder.getDependencies().put(psiJavaFile, wholeDependencies);
     }
     wholeDependencies.add(psiFile);
   }
 
   public Set<PsiFile> getDependentFilesInPackage(PsiPackage pack, PsiPackage depPack) {
-    Set<PsiFile> psiFiles = new HashSet<PsiFile>();
+    Set<PsiFile> psiFiles = new HashSet<>();
     final Map<PsiPackage, Set<PsiFile>> map = myFilesInDependentPackages.get(pack);
     if (map != null){
       psiFiles = map.get(depPack);
     }
     if (psiFiles == null) {
-      psiFiles = new HashSet<PsiFile>();
+      psiFiles = new HashSet<>();
     }
     return psiFiles;
   }
 
   public Set<PsiFile> getDependentFilesInPackage(PsiPackage firstPack, PsiPackage middlePack, PsiPackage lastPack) {
-    Set<PsiFile> result = new HashSet<PsiFile>();
+    Set<PsiFile> result = new HashSet<>();
     final Map<PsiPackage, Set<PsiFile>> forwardMap = myFilesInDependentPackages.get(firstPack);
     if (forwardMap != null && forwardMap.get(middlePack) != null){
       result.addAll(forwardMap.get(middlePack));
@@ -190,19 +204,18 @@ public class CyclicDependenciesBuilder{
     return myCyclicDependencies;
   }
 
-  public HashMap<PsiPackage, Set<List<PsiPackage>>> getCycles(Collection<PsiPackage> packages) {
+  public HashMap<PsiPackage, Set<List<PsiPackage>>> getCycles(Collection<? extends PsiPackage> packages) {
     if (myGraph == null){
       myGraph = buildGraph();
     }
-    final HashMap<PsiPackage, Set<List<PsiPackage>>> result = new HashMap<PsiPackage, Set<List<PsiPackage>>>();
-    for (Iterator<PsiPackage> iterator = packages.iterator(); iterator.hasNext();) {
-      PsiPackage psiPackage = iterator.next();
-        Set<List<PsiPackage>> paths2Pack = result.get(psiPackage);
-        if (paths2Pack == null) {
-          paths2Pack = new HashSet<List<PsiPackage>>();
-          result.put(psiPackage, paths2Pack);
-        }
-        paths2Pack.addAll(CyclicGraphUtil.getNodeCycles(myGraph, psiPackage));
+    final HashMap<PsiPackage, Set<List<PsiPackage>>> result = new HashMap<>();
+    for (PsiPackage psiPackage : packages) {
+      Set<List<PsiPackage>> paths2Pack = result.get(psiPackage);
+      if (paths2Pack == null) {
+        paths2Pack = new HashSet<>();
+        result.put(psiPackage, paths2Pack);
+      }
+      paths2Pack.addAll(GraphAlgorithms.getInstance().findCycles(myGraph, psiPackage));
     }
     return result;
   }
@@ -225,26 +238,28 @@ public class CyclicDependenciesBuilder{
     return myPackages;
   }
 
-
   private Graph<PsiPackage> buildGraph() {
-    final Graph<PsiPackage> graph = GraphGenerator.create(CachingSemiGraph.create(new GraphGenerator.SemiGraph<PsiPackage>() {
+    return GraphGenerator.generate(CachingSemiGraph.cache(new InboundSemiGraph<PsiPackage>() {
+      @Override
+      @NotNull
       public Collection<PsiPackage> getNodes() {
         return getAllScopePackages().values();
       }
 
+      @NotNull
+      @Override
       public Iterator<PsiPackage> getIn(PsiPackage psiPack) {
         final Set<PsiPackage> psiPackages = myPackageDependencies.get(psiPack);
         if (psiPackages == null) {     //for packs without java classes
-          return new HashSet<PsiPackage>().iterator();
+          return Collections.emptyIterator();
         }
         return psiPackages.iterator();
       }
     }));
-    return graph;
   }
 
   public Set<PsiPackage> getPackageHierarhy(String packageName) {
-    final Set<PsiPackage> result = new HashSet<PsiPackage>();
+    final Set<PsiPackage> result = new HashSet<>();
     PsiPackage psiPackage = findPackage(packageName);
     if (psiPackage != null) {
       result.add(psiPackage);
@@ -267,5 +282,4 @@ public class CyclicDependenciesBuilder{
     final PsiPackage psiPackage = getAllScopePackages().get(packName);
     return psiPackage;
   }
-
-}
+}
\ No newline at end of file