java/java-impl/src/com/intellij/codeInsight/lookup/LookupItemUtil.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.codeInsight.lookup;
  17
  18 import com.intellij.codeInsight.TailType;
  19 import com.intellij.codeInsight.completion.CompletionUtil;
  20 import com.intellij.codeInsight.completion.JavaPsiClassReferenceElement;
  21 import com.intellij.codeInsight.completion.PrefixMatcher;
  22 import com.intellij.codeInsight.completion.JavaMethodCallElement;
  23 import com.intellij.codeInsight.completion.impl.CamelHumpMatcher;
  24 import com.intellij.codeInsight.template.Template;
  25 import com.intellij.openapi.diagnostic.Logger;
  26 import com.intellij.openapi.util.text.StringUtil;
  27 import com.intellij.psi.*;
  28 import com.intellij.psi.meta.PsiMetaData;
  29 import com.intellij.psi.util.PsiUtilBase;
  30 import com.intellij.util.containers.ContainerUtil;
  31 import org.jetbrains.annotations.NotNull;
  32 import org.jetbrains.annotations.Nullable;
  33
  34 import java.util.ArrayList;
  35 import java.util.Collection;
  36 import java.util.List;
  37 import java.util.Set;
  38
  39 /**
  40  * Created by IntelliJ IDEA.
  41  * User: ik
  42  * Date: 06.02.2003
  43  * Time: 16:05:20
  44  * To change this template use Options | File Templates.
  45  */
  46 public class LookupItemUtil{
  47   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.lookup.LookupItemUtil");
  48
  49   private LookupItemUtil() {
  50   }
  51
  52   @Nullable
  53   public static LookupElement addLookupItem(Collection<LookupElement> set, @NotNull Object object) {
  54     return addLookupItem(set, object, new CamelHumpMatcher(""));
  55   }
  56
  57   @Nullable
  58   public static LookupElement addLookupItem(Collection<LookupElement> set, @NotNull Object object, PrefixMatcher matcher) {
  59     if (object instanceof PsiType) {
  60       PsiType psiType = (PsiType)object;
  61       for (final LookupElement lookupItem : set) {
  62         Object o = lookupItem.getObject();
  63         if (o.equals(psiType)) {
  64           return lookupItem;
  65         }
  66       }
  67     }
  68
  69     for (LookupElement lookupItem : set) {
  70       if(lookupItem.getObject().equals(lookupItem)) return null;
  71     }
  72     LookupElement item = objectToLookupItem(object);
  73     if (matcher.prefixMatches(item)) {
  74       return set.add(item) ? item : null;
  75     }
  76     return null;
  77   }
  78
  79   public static List<LookupElement> addLookupItems(Set<LookupElement> set, Object[] objects, PrefixMatcher matcher) {
  80     final ArrayList<LookupElement> list = new ArrayList<LookupElement>(objects.length);
  81     for (Object object : objects) {
  82       LOG.assertTrue(object != null, "Lookup item can't be null!");
  83       ContainerUtil.addIfNotNull(addLookupItem(set, object, matcher), list);
  84     }
  85     return list;
  86   }
  87
  88   /**
  89    * @deprecated
  90    * @see LookupElementBuilder
  91   */
  92   public static LookupElement objectToLookupItem(Object object) {
  93     if (object instanceof LookupElement) return (LookupElement)object;
  94     if (object instanceof PsiClass) {
  95       return new JavaPsiClassReferenceElement((PsiClass)object).setTailType(TailType.NONE);
  96     }
  97     if (object instanceof PsiMethod) {
  98       return new JavaMethodCallElement((PsiMethod)object);
  99     }
 100
 101     String s = null;
 102     LookupItem item = new LookupItem(object, "");
 103     if (object instanceof PsiElement){
 104       s = PsiUtilBase.getName((PsiElement) object);
 105     }
 106     if (object instanceof PsiEnumConstant) {
 107       item.addLookupStrings(((PsiEnumConstant)object).getName());
 108     }
 109     TailType tailType = TailType.NONE;
 110     if (object instanceof PsiPackage) {
 111       tailType = TailType.DOT;
 112       s = StringUtil.notNullize(s);
 113     }
 114     else if (object instanceof PsiKeyword) {
 115       return new KeywordLookupItem((PsiKeyword)object).setTailType(tailType);
 116     }
 117     else if (object instanceof PsiExpression) {
 118       return new ExpressionLookupItem((PsiExpression) object).setTailType(tailType);
 119     }
 120     else if (object instanceof PsiType) {
 121       return PsiTypeLookupItem.createLookupItem((PsiType)object);
 122     }
 123     else if (object instanceof PsiMetaData) {
 124       s = ((PsiMetaData)object).getName();
 125     }
 126     else if (object instanceof String) {
 127       s = (String)object;
 128     }
 129     else if (object instanceof Template) {
 130       s = ((Template) object).getKey();
 131     }
 132     else if (object instanceof PresentableLookupValue) {
 133       s = ((PresentableLookupValue)object).getPresentation();
 134     }
 135
 136     if (object instanceof LookupValueWithUIHint && ((LookupValueWithUIHint) object).isBold() || object instanceof PsiKeyword) {
 137       item.setBold();
 138     }
 139
 140     if (s == null) {
 141       LOG.assertTrue(false, "Null string for object: " + object + " of class " + (object != null ?object.getClass():null));
 142     }
 143     if (object instanceof LookupValueWithTail) {
 144       item.setAttribute(LookupItem.TAIL_TEXT_ATTR, " " + ((LookupValueWithTail)object).getTailText());
 145     }
 146     item.setLookupString(s);
 147
 148     item.setAttribute(CompletionUtil.TAIL_TYPE_ATTR, tailType);
 149     return item;
 150   }
 151
 152 }