codeInsight/impl/com/intellij/codeInsight/template/macro/DescendantClassesEnumMacro.java

   1 package com.intellij.codeInsight.template.macro;
   2
   3 import com.intellij.codeInsight.CodeInsightBundle;
   4 import com.intellij.codeInsight.lookup.LookupItem;
   5 import com.intellij.codeInsight.lookup.LookupItemUtil;
   6 import com.intellij.codeInsight.template.*;
   7 import com.intellij.psi.PsiClass;
   8 import com.intellij.psi.PsiManager;
   9 import com.intellij.psi.PsiModifier;
  10 import com.intellij.psi.PsiModifierList;
  11 import com.intellij.psi.search.GlobalSearchScope;
  12 import com.intellij.psi.search.PsiElementProcessor;
  13 import com.intellij.psi.search.PsiSearchHelper;
  14
  15 import java.util.ArrayList;
  16 import java.util.LinkedHashSet;
  17 import java.util.List;
  18 import java.util.Set;
  19
  20 public class DescendantClassesEnumMacro implements Macro {
  21   public String getName() {
  22     return "descendantClassesEnum";
  23   }
  24
  25   public String getDescription() {
  26     return CodeInsightBundle.message("macro.descendant.classes.enum");
  27   }
  28
  29   public String getDefaultValue() {
  30     return "";
  31   }
  32
  33   public Result calculateResult(Expression[] params, ExpressionContext context) {
  34     final List<PsiClass> classes = findDescendants(context, params);
  35     if (classes == null || classes.size() == 0) return null;
  36     Result[] results = calculateResults(classes);
  37
  38     return results[0];
  39   }
  40
  41   private static Result[] calculateResults(final List<PsiClass> classes) {
  42     Result[] results = new Result[classes.size()];
  43     int i = 0;
  44
  45     for (final PsiClass aClass : classes) {
  46       results[i++] = new PsiElementResult(aClass);
  47     }
  48     return results;
  49   }
  50
  51   private static List<PsiClass> findDescendants(ExpressionContext context, Expression[] params) {
  52     if (params == null || params.length == 0) return null;
  53     PsiManager instance = PsiManager.getInstance(context.getProject());
  54
  55     final String paramResult = params[0].calculateResult(context).toString();
  56     if (paramResult == null) return null;
  57
  58     final boolean isAllowAbstract = isAllowAbstract(context, params);
  59     final PsiClass myBaseClass = instance.findClass(paramResult, GlobalSearchScope.allScope(context.getProject()));
  60
  61     if (myBaseClass != null) {
  62       PsiSearchHelper helper = instance.getSearchHelper();
  63
  64       final List<PsiClass> classes = new ArrayList<PsiClass>();
  65
  66       helper.processInheritors(new PsiElementProcessor<PsiClass>() {
  67         public boolean execute(PsiClass element) {
  68           if (isAllowAbstract || !isAbstractOrInterface(element)) {
  69             classes.add(element);
  70           }
  71           return true;
  72         }
  73
  74       }, myBaseClass, myBaseClass.getUseScope(), true);
  75
  76       return classes;
  77     }
  78
  79     return null;
  80   }
  81
  82   public Result calculateQuickResult(Expression[] params, ExpressionContext context) {
  83     final List<PsiClass> classes = findDescendants(context, params);
  84     if (classes == null || classes.size() == 0) return null;
  85     Result[] results = calculateResults(classes);
  86
  87     return results[0];
  88   }
  89
  90   public LookupItem[] calculateLookupItems(Expression[] params, ExpressionContext context) {
  91     final List<PsiClass> classes = findDescendants(context, params);
  92     if (classes == null || classes.size() == 0) return null;
  93
  94     Set<LookupItem> set = new LinkedHashSet<LookupItem>();
  95     boolean isShortName = params.length > 1 && !Boolean.valueOf(params[1].calculateResult(context).toString());
  96
  97     for (PsiClass object : classes) {
  98       final String name = isShortName ? object.getName() : object.getQualifiedName();
  99       if (name != null && name.length() > 0) LookupItemUtil.addLookupItem(set, name, "");
 100     }
 101
 102     return set.toArray(new LookupItem[set.size()]);
 103   }
 104
 105   private static boolean isAbstractOrInterface(final PsiClass psiClass) {
 106     final PsiModifierList modifierList = psiClass.getModifierList();
 107
 108     return psiClass.isInterface() || (modifierList != null && modifierList.hasModifierProperty(PsiModifier.ABSTRACT));
 109   }
 110
 111   private static boolean isAllowAbstract(final ExpressionContext context, final Expression[] params) {
 112       return params.length > 2 ? Boolean.valueOf(params[2].calculateResult(context).toString()) : true;
 113   }
 114 }