lang-impl/src/com/intellij/refactoring/classMembers/UsesMemberDependencyGraph.java

   1 /*
   2  * Created by IntelliJ IDEA.
   3  * User: dsl
   4  * Date: 08.07.2002
   5  * Time: 18:22:48
   6  * To change template for new class use
   7  * Code Style | Class Templates options (Tools | IDE Options).
   8  */
   9 package com.intellij.refactoring.classMembers;
  10
  11 import com.intellij.lang.LanguageDependentMembersRefactoringSupport;
  12 import com.intellij.openapi.diagnostic.Logger;
  13 import com.intellij.openapi.util.text.StringUtil;
  14 import com.intellij.psi.NavigatablePsiElement;
  15 import com.intellij.psi.PsiElement;
  16 import com.intellij.refactoring.RefactoringBundle;
  17 import com.intellij.util.containers.HashMap;
  18
  19 import java.util.ArrayList;
  20 import java.util.HashSet;
  21 import java.util.Set;
  22
  23 public class UsesMemberDependencyGraph<T extends NavigatablePsiElement, C extends PsiElement, M extends MemberInfoBase<T>> implements MemberDependencyGraph<T, M> {
  24   private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.util.classMembers.UsesMemberDependencyGraph");
  25   protected HashSet<T> mySelectedNormal;
  26   protected HashSet<T> mySelectedAbstract;
  27   protected HashSet<T> myDependencies = null;
  28   protected HashMap<T, HashSet<T>> myDependenciesToDependentMap = null;
  29   private final boolean myRecursive;
  30   private final MemberDependenciesStorage<T, C> myMemberDependenciesStorage;
  31
  32   public UsesMemberDependencyGraph(C aClass, C superClass, boolean recursive) {
  33     myRecursive = recursive;
  34     mySelectedNormal = new HashSet<T>();
  35     mySelectedAbstract = new HashSet<T>();
  36     myMemberDependenciesStorage = new MemberDependenciesStorage<T, C>(aClass, superClass);
  37   }
  38
  39
  40   public Set<? extends T> getDependent() {
  41     if (myDependencies == null) {
  42       myDependencies = new HashSet<T>();
  43       myDependenciesToDependentMap = new HashMap<T, HashSet<T>>();
  44       buildDeps(null, mySelectedNormal);
  45     }
  46     return myDependencies;
  47   }
  48
  49   public Set<? extends T> getDependenciesOf(T member) {
  50     final Set dependent = getDependent();
  51     if(!dependent.contains(member)) return null;
  52     return myDependenciesToDependentMap.get(member);
  53   }
  54
  55   public String getElementTooltip(T element) {
  56     final Set<? extends T> dependencies = getDependenciesOf(element);
  57     if(dependencies == null || dependencies.size() == 0) return null;
  58
  59     ArrayList<String> strings = new ArrayList<String>();
  60     for (T dep : dependencies) {
  61       strings.add(dep.getName());
  62     }
  63
  64     if(strings.isEmpty()) return null;
  65     return RefactoringBundle.message("used.by.0", StringUtil.join(strings, ", "));
  66   }
  67
  68
  69   private void buildDeps(T sourceElement, Set<T> members) {
  70     if (myRecursive) {
  71       buildDepsRecursively(sourceElement, members);
  72     }
  73     else {
  74       for (final T member : members) {
  75         for (final T dependency : myMemberDependenciesStorage.getMemberDependencies(member)) {
  76           addDependency(dependency, member);
  77         }
  78       }
  79     }
  80   }
  81
  82   private void buildDepsRecursively(final T sourceElement, final Set<T> members) {
  83     for (T member : members) {
  84       if (!myDependencies.contains(member)) {
  85         addDependency(member, sourceElement);
  86         if (!mySelectedAbstract.contains(member)) {
  87           buildDepsRecursively(member, myMemberDependenciesStorage.getMemberDependencies(member));
  88         }
  89       }
  90     }
  91   }
  92
  93   private void addDependency(final T member, final T sourceElement) {
  94     if (LOG.isDebugEnabled()) {
  95       LOG.debug(member.toString());
  96     }
  97     myDependencies.add(member);
  98     if (sourceElement != null) {
  99       HashSet<T> relations = myDependenciesToDependentMap.get(member);
 100       if (relations == null) {
 101         relations = new HashSet<T>();
 102         myDependenciesToDependentMap.put(member, relations);
 103       }
 104       relations.add(sourceElement);
 105     }
 106   }
 107
 108   public void memberChanged(M memberInfo) {
 109     final ClassMembersRefactoringSupport support =
 110       LanguageDependentMembersRefactoringSupport.INSTANCE.forLanguage(memberInfo.getMember().getLanguage());
 111     if (support != null && support.isProperMember(memberInfo)) {
 112       myDependencies = null;
 113       myDependenciesToDependentMap = null;
 114       T member = memberInfo.getMember();
 115       if (!memberInfo.isChecked()) {
 116         mySelectedNormal.remove(member);
 117         mySelectedAbstract.remove(member);
 118       } else {
 119         if (memberInfo.isToAbstract()) {
 120           mySelectedNormal.remove(member);
 121           mySelectedAbstract.add(member);
 122         } else {
 123           mySelectedNormal.add(member);
 124           mySelectedAbstract.remove(member);
 125         }
 126       }
 127     }
 128   }
 129 }