refactoring/impl/com/intellij/refactoring/util/classMembers/InterfaceMemberDependencyGraph.java

   1 package com.intellij.refactoring.util.classMembers;
   2
   3 import com.intellij.psi.*;
   4 import com.intellij.refactoring.RefactoringBundle;
   5 import com.intellij.refactoring.classMembers.MemberDependencyGraph;
   6 import com.intellij.util.containers.HashMap;
   7
   8 import java.util.HashSet;
   9 import java.util.Iterator;
  10 import java.util.Set;
  11
  12 public class InterfaceMemberDependencyGraph implements MemberDependencyGraph<PsiMember, MemberInfo> {
  13   protected HashSet<PsiMethod> myInterfaceDependencies = null;
  14   protected HashMap<PsiMethod,HashSet<PsiClass>> myMembersToInterfacesMap = new HashMap<PsiMethod, HashSet<PsiClass>>();
  15   protected HashSet<PsiClass> myImplementedInterfaces;
  16   protected HashMap<PsiClass,HashSet<PsiMethod>> myMethodsFromInterfaces;
  17   protected PsiClass myClass;
  18
  19   public InterfaceMemberDependencyGraph(PsiClass aClass) {
  20     myClass = aClass;
  21     myImplementedInterfaces = new HashSet<PsiClass>();
  22     myMethodsFromInterfaces = new com.intellij.util.containers.HashMap<PsiClass, HashSet<PsiMethod>>();
  23   }
  24
  25   public void memberChanged(MemberInfo memberInfo) {
  26     if (ClassMembersUtil.isImplementedInterface(memberInfo)) {
  27       final PsiClass aClass = (PsiClass) memberInfo.getMember();
  28       myInterfaceDependencies = null;
  29       myMembersToInterfacesMap = null;
  30       if(memberInfo.isChecked()) {
  31         myImplementedInterfaces.add(aClass);
  32       }
  33       else {
  34         myImplementedInterfaces.remove(aClass);
  35       }
  36     }
  37   }
  38
  39   public Set<? extends PsiMember> getDependent() {
  40     if(myInterfaceDependencies == null) {
  41       myInterfaceDependencies = new HashSet<PsiMethod>();
  42       myMembersToInterfacesMap = new com.intellij.util.containers.HashMap<PsiMethod, HashSet<PsiClass>>();
  43       for (final PsiClass implementedInterface : myImplementedInterfaces) {
  44         addInterfaceDeps(implementedInterface);
  45       }
  46     }
  47     return myInterfaceDependencies;
  48   }
  49
  50   public Set<? extends PsiMember> getDependenciesOf(PsiMember member) {
  51     final Set dependent = getDependent();
  52     if(dependent.contains(member)) return myMembersToInterfacesMap.get(member);
  53     return null;
  54   }
  55
  56   public String getElementTooltip(PsiMember member) {
  57     final Set<? extends PsiMember> dependencies = getDependenciesOf(member);
  58     if(dependencies == null || dependencies.size() == 0) return null;
  59     StringBuffer buffer = new StringBuffer();
  60     buffer.append(RefactoringBundle.message("interface.member.dependency.required.by.interfaces", dependencies.size()));
  61
  62     for (Iterator<? extends PsiMember> iterator = dependencies.iterator(); iterator.hasNext();) {
  63       PsiClass aClass = (PsiClass) iterator.next();
  64       buffer.append(aClass.getName());
  65       if(iterator.hasNext()) {
  66         buffer.append(", ");
  67       }
  68     }
  69     return buffer.toString();
  70   }
  71
  72   protected void addInterfaceDeps(PsiClass intf) {
  73     HashSet<PsiMethod> interfaceMethods = myMethodsFromInterfaces.get(intf);
  74
  75     if(interfaceMethods == null) {
  76       interfaceMethods = new HashSet<PsiMethod>();
  77       buildInterfaceMethods(interfaceMethods, intf);
  78       myMethodsFromInterfaces.put(intf, interfaceMethods);
  79     }
  80     for (PsiMethod method : interfaceMethods) {
  81       HashSet<PsiClass> interfaces = myMembersToInterfacesMap.get(method);
  82       if (interfaces == null) {
  83         interfaces = new HashSet<PsiClass>();
  84         myMembersToInterfacesMap.put(method, interfaces);
  85       }
  86       interfaces.add(intf);
  87     }
  88     myInterfaceDependencies.addAll(interfaceMethods);
  89   }
  90
  91   private void buildInterfaceMethods(HashSet<PsiMethod> interfaceMethods, PsiClass intf) {
  92     PsiMethod[] methods = intf.getMethods();
  93     for (PsiMethod method1 : methods) {
  94       PsiMethod method = myClass.findMethodBySignature(method1, true);
  95       if (method != null) {
  96         interfaceMethods.add(method);
  97       }
  98     }
  99
 100     PsiReferenceList implementsList = intf.getImplementsList();
 101     if (implementsList != null) {
 102       PsiClassType[] implemented = implementsList.getReferencedTypes();
 103       for (PsiClassType aImplemented : implemented) {
 104         PsiClass resolved = aImplemented.resolve();
 105         if (resolved != null) {
 106           buildInterfaceMethods(interfaceMethods, resolved);
 107         }
 108       }
 109     }
 110
 111     PsiReferenceList extendsList = intf.getExtendsList();
 112     if (extendsList != null) {
 113       PsiClassType[] extended = extendsList.getReferencedTypes();
 114       for (PsiClassType aExtended : extended) {
 115         PsiClass ref = aExtended.resolve();
 116         if (ref != null) {
 117           buildInterfaceMethods(interfaceMethods, ref);
 118         }
 119       }
 120     }
 121   }
 122
 123 }