java/java-impl/src/com/intellij/refactoring/psi/MethodInheritanceUtils.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.refactoring.psi;
  17
  18 import com.intellij.psi.PsiClass;
  19 import com.intellij.psi.PsiCompiledElement;
  20 import com.intellij.psi.PsiMethod;
  21 import com.intellij.psi.search.searches.OverridingMethodsSearch;
  22
  23 import java.util.*;
  24
  25 public class MethodInheritanceUtils {
  26     private MethodInheritanceUtils() {
  27         super();
  28     }
  29
  30     public static Set<PsiMethod> calculateSiblingMethods(PsiMethod method) {
  31         final Set<PsiMethod> siblingMethods = new HashSet<PsiMethod>();
  32         final Stack<PsiMethod> pendingMethods = new Stack<PsiMethod>();
  33         pendingMethods.add(method);
  34         while(!pendingMethods.isEmpty())
  35         {
  36             final PsiMethod methodToAnalyze = pendingMethods.pop();
  37             siblingMethods.add(methodToAnalyze);
  38             final Iterable<PsiMethod> overridingMethods = OverridingMethodsSearch.search(methodToAnalyze, methodToAnalyze.getUseScope(), false);
  39             for (PsiMethod overridingMethod : overridingMethods) {
  40                 if (!siblingMethods.contains(overridingMethod) &&
  41                         !pendingMethods.contains(overridingMethod)) {
  42                     pendingMethods.add(overridingMethod);
  43                 }
  44             }
  45             final PsiMethod[] superMethods = methodToAnalyze.findSuperMethods();
  46             for (PsiMethod superMethod : superMethods) {
  47                 if (!siblingMethods.contains(superMethod) &&
  48                         !pendingMethods.contains(superMethod)) {
  49                     pendingMethods.add(superMethod);
  50                 }
  51             }
  52         }
  53         return siblingMethods;
  54     }
  55
  56     public static boolean hasSiblingMethods(PsiMethod method) {
  57
  58
  59         final Iterable<PsiMethod> overridingMethods =
  60                 SearchUtils.findOverridingMethods(method);
  61         if(overridingMethods.iterator().hasNext())
  62         {
  63             return true;
  64         }
  65         final PsiMethod[] superMethods = method.findSuperMethods();
  66         return superMethods.length!=0;
  67
  68     }
  69
  70     public static PsiClass[] findAvailableSuperClassesForMethod(PsiMethod method){
  71         final List<PsiClass> sourceClasses = new ArrayList<PsiClass>();
  72         findAvailableSuperClasses(method, sourceClasses);
  73         return sourceClasses.toArray(new PsiClass[sourceClasses.size()]);
  74     }
  75
  76     private static void findAvailableSuperClasses(PsiMethod method, List<PsiClass> sourceClasses){
  77         final PsiMethod[] superMethods = method.findSuperMethods(true);
  78         for(PsiMethod superMethod : superMethods){
  79             final PsiClass containingClass = superMethod.getContainingClass();
  80             if(!(containingClass instanceof PsiCompiledElement)){
  81                 sourceClasses.add(containingClass);
  82                 findAvailableSuperClasses(superMethod, sourceClasses);
  83             }
  84         }
  85     }
  86
  87     public static PsiClass[] findAvailableSubClassesForMethod(PsiMethod method){
  88         final Iterable<PsiMethod> query = SearchUtils.findOverridingMethods(method);
  89         final List<PsiClass> sourceClasses = new ArrayList<PsiClass>();
  90         for(PsiMethod superMethod : query){
  91             final PsiClass containingClass = superMethod.getContainingClass();
  92             if(!(containingClass instanceof PsiCompiledElement)){
  93                 sourceClasses.add(containingClass);
  94             }
  95         }
  96         return sourceClasses.toArray(new PsiClass[sourceClasses.size()]);
  97     }
  98
  99     public static PsiClass[] getNonLibrarySuperClasses(PsiClass sourceClass){
 100
 101         final List<PsiClass> out = new ArrayList<PsiClass>();
 102         findNonLibrarySupers(sourceClass, out);
 103         return out.toArray(new PsiClass[out.size()]);
 104     }
 105
 106     private static void findNonLibrarySupers(PsiClass sourceClass, List<PsiClass> out){
 107         final PsiClass[] supers = sourceClass.getSupers();
 108         for(PsiClass psiClass : supers){
 109             if(!(psiClass instanceof PsiCompiledElement) && !out.contains(psiClass))
 110             {
 111                 out.add(psiClass);
 112                 findNonLibrarySupers(psiClass, out);
 113             }
 114         }
 115     }
 116
 117     public static PsiClass[] getNonLibrarySubClasses(PsiClass sourceClass){
 118         final List<PsiClass> out = new ArrayList<PsiClass>();
 119         final Iterable<PsiClass> query = SearchUtils.findClassInheritors(sourceClass, true);
 120         for(PsiClass psiClass : query){
 121             if(!(psiClass instanceof PsiCompiledElement))
 122             {
 123                 out.add(psiClass);
 124             }
 125         }
 126         return out.toArray(new PsiClass[out.size()]);
 127     }
 128
 129
 130 }