lang-impl/src/com/intellij/codeInsight/completion/CompletionVariant.java

   1 package com.intellij.codeInsight.completion;
   2
   3 import com.intellij.codeInsight.TailType;
   4 import com.intellij.codeInsight.lookup.LookupItem;
   5 import com.intellij.patterns.ElementPattern;
   6 import com.intellij.psi.PsiElement;
   7 import com.intellij.psi.PsiFile;
   8 import com.intellij.psi.PsiReference;
   9 import com.intellij.psi.filters.ContextGetter;
  10 import com.intellij.psi.filters.ElementFilter;
  11 import com.intellij.psi.filters.position.PatternFilter;
  12 import com.intellij.util.ReflectionCache;
  13 import com.intellij.util.containers.HashMap;
  14 import org.jetbrains.annotations.NonNls;
  15
  16 import java.io.Serializable;
  17 import java.util.*;
  18
  19 /**
  20  * Created by IntelliJ IDEA.
  21  * User: ik
  22  * Date: 31.01.2003
  23  * Time: 17:38:14
  24  * To change this template use Options | File Templates.
  25  */
  26
  27 public class CompletionVariant {
  28   protected static final TailType DEFAULT_TAIL_TYPE = TailType.SPACE;
  29
  30   private final Set<Scope> myScopeClasses = new HashSet<Scope>();
  31   private ElementFilter myPosition;
  32   private final List<CompletionVariantItem> myCompletionsList = new ArrayList<CompletionVariantItem>();
  33   private final Set<Class> myScopeClassExceptions = new HashSet<Class>();
  34   private InsertHandler myInsertHandler = null;
  35   private final Map<Object, Serializable> myItemProperties = new HashMap<Object, Serializable>();
  36
  37   public CompletionVariant() {
  38   }
  39
  40   public CompletionVariant(Class scopeClass, ElementPattern position){
  41     this(scopeClass, new PatternFilter(position));
  42   }
  43   public CompletionVariant(Class scopeClass, ElementFilter position){
  44     includeScopeClass(scopeClass);
  45     myPosition = position;
  46   }
  47
  48   public CompletionVariant(ElementPattern<? extends PsiElement> position){
  49     this(new PatternFilter(position));
  50   }
  51   public CompletionVariant(ElementFilter position){
  52     myPosition = position;
  53   }
  54
  55   public boolean isScopeAcceptable(PsiElement scope){
  56     return isScopeClassAcceptable(scope.getClass());
  57   }
  58
  59   public boolean isScopeFinal(PsiElement scope){
  60     return isScopeClassFinal(scope.getClass());
  61   }
  62
  63   public InsertHandler getInsertHandler(){
  64     return myInsertHandler;
  65   }
  66
  67   public void setInsertHandler(InsertHandler handler){
  68     myInsertHandler = handler;
  69   }
  70
  71   public void setItemProperty(Object id, Serializable value){
  72     myItemProperties.put(id, value);
  73   }
  74
  75   public Map<Object, Serializable> getItemProperties() {
  76     return myItemProperties;
  77   }
  78
  79   public boolean isScopeClassFinal(Class scopeClass){
  80     for (final Object myScopeClass : myScopeClasses) {
  81       Scope scope = (Scope)myScopeClass;
  82       if (ReflectionCache.isAssignable(scope.myClass, scopeClass) && scope.myIsFinalScope) {
  83         return true;
  84       }
  85     }
  86     return false;
  87   }
  88
  89   public boolean isScopeClassAcceptable(Class scopeClass){
  90     boolean ret = false;
  91
  92     for (final Object myScopeClass : myScopeClasses) {
  93       final Class aClass = ((Scope)myScopeClass).myClass;
  94       if (ReflectionCache.isAssignable(aClass, scopeClass)) {
  95         ret = true;
  96         break;
  97       }
  98     }
  99
 100     if(ret){
 101       for (final Class aClass: myScopeClassExceptions) {
 102         if (ReflectionCache.isAssignable(aClass, scopeClass)) {
 103           ret = false;
 104           break;
 105         }
 106       }
 107     }
 108     return ret;
 109   }
 110
 111   public void excludeScopeClass(Class<?> aClass){
 112     myScopeClassExceptions.add(aClass);
 113   }
 114
 115   public void includeScopeClass(Class<?> aClass){
 116     myScopeClasses.add(new Scope(aClass, false));
 117   }
 118
 119   public void includeScopeClass(Class<?> aClass, boolean isFinalScope){
 120     myScopeClasses.add(new Scope(aClass, isFinalScope));
 121   }
 122
 123   public void addCompletionFilter(ElementFilter filter, TailType tailType){
 124     addCompletion(filter, tailType);
 125   }
 126
 127   public void addCompletionFilter(ElementFilter filter){
 128     addCompletionFilter(filter, TailType.NONE);
 129   }
 130
 131   public void addCompletion(@NonNls String keyword){
 132     addCompletion(keyword, DEFAULT_TAIL_TYPE);
 133   }
 134
 135   public void addCompletion(@NonNls String keyword, TailType tailType){
 136     addCompletion((Object)keyword, tailType);
 137   }
 138
 139   public void addCompletion(KeywordChooser chooser){
 140     addCompletion(chooser, DEFAULT_TAIL_TYPE);
 141   }
 142
 143   public void addCompletion(KeywordChooser chooser, TailType tailType){
 144     addCompletion((Object)chooser, tailType);
 145   }
 146
 147   public void addCompletion(ContextGetter chooser){
 148     addCompletion(chooser, DEFAULT_TAIL_TYPE);
 149   }
 150
 151   public void addCompletion(ContextGetter chooser, TailType tailType){
 152     addCompletion((Object)chooser, tailType);
 153   }
 154
 155   private void addCompletion(Object completion, TailType tail){
 156     myCompletionsList.add(new CompletionVariantItem(completion, tail));
 157   }
 158
 159   public void addCompletion(@NonNls String[] keywordList){
 160     addCompletion(keywordList, DEFAULT_TAIL_TYPE);
 161   }
 162
 163   public void addCompletion(String[] keywordList, TailType tailType){
 164     for (String aKeywordList : keywordList) {
 165       addCompletion(aKeywordList, tailType);
 166     }
 167   }
 168
 169   public boolean isVariantApplicable(PsiElement position, PsiElement scope){
 170     return isScopeAcceptable(scope) && myPosition.isAcceptable(position, scope);
 171   }
 172
 173   public void addReferenceCompletions(PsiReference reference, PsiElement position, Set<LookupItem> set, final PrefixMatcher matcher, final PsiFile file,
 174                                       final CompletionData completionData){
 175     for (final CompletionVariantItem ce : myCompletionsList) {
 176       if(ce.myCompletion instanceof ElementFilter){
 177         final ElementFilter filter = (ElementFilter)ce.myCompletion;
 178         if (LegacyCompletionContributor.DEBUG) {
 179           System.out.println("CompletionVariant.addReferenceCompletions");
 180           System.out.println("filter = " + filter);
 181         }
 182         completionData.completeReference(reference, position, set, ce.myTailType, matcher, file, filter, this);
 183       }
 184     }
 185   }
 186
 187   public void addKeywords(Set<LookupItem> set, PsiElement position, final PrefixMatcher matcher, final PsiFile file,
 188                           final CompletionData completionData){
 189
 190     for (final CompletionVariantItem ce : myCompletionsList) {
 191       completionData.addKeywords(set, position, matcher, file, this, ce.myCompletion, ce.myTailType);
 192     }
 193   }
 194
 195   public boolean hasReferenceFilter(){
 196     for (final CompletionVariantItem item: myCompletionsList) {
 197       if (item.myCompletion instanceof ElementFilter) {
 198         return true;
 199       }
 200     }
 201     return false;
 202   }
 203
 204   public boolean hasKeywordCompletions(){
 205     for (final CompletionVariantItem item : myCompletionsList) {
 206       if (!(item.myCompletion instanceof ElementFilter)) {
 207         return true;
 208       }
 209     }
 210     return false;
 211   }
 212
 213
 214   private static class Scope{
 215     Class myClass;
 216     boolean myIsFinalScope;
 217
 218     Scope(Class aClass, boolean isFinalScope){
 219       myClass = aClass;
 220       myIsFinalScope = isFinalScope;
 221     }
 222   }
 223
 224   protected static class CompletionVariantItem{
 225     public Object myCompletion;
 226     public TailType myTailType;
 227
 228     public CompletionVariantItem(Object completion, TailType tailtype){
 229       myCompletion = completion;
 230       myTailType = tailtype;
 231     }
 232
 233     public String toString(){
 234       return myCompletion.toString();
 235     }
 236   }
 237
 238   @SuppressWarnings({"HardCodedStringLiteral"})
 239   public String toString(){
 240     return "completion variant at " + myPosition.toString() + " completions: " + myCompletionsList;
 241   }
 242
 243   public void setCaseInsensitive(boolean caseInsensitive) {
 244     setItemProperty(LookupItem.CASE_INSENSITIVE, caseInsensitive);
 245   }
 246
 247 }