java/java-impl/src/com/intellij/psi/impl/CompositeShortNamesCache.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.psi.impl;
  17
  18 import com.intellij.psi.PsiClass;
  19 import com.intellij.psi.PsiField;
  20 import com.intellij.psi.PsiFile;
  21 import com.intellij.psi.PsiMethod;
  22 import com.intellij.psi.search.GlobalSearchScope;
  23 import com.intellij.psi.search.PsiShortNamesCache;
  24 import com.intellij.util.ArrayUtil;
  25 import com.intellij.util.containers.HashSet;
  26 import gnu.trove.THashSet;
  27 import org.jetbrains.annotations.NonNls;
  28 import org.jetbrains.annotations.NotNull;
  29
  30 import java.util.ArrayList;
  31 import java.util.Arrays;
  32 import java.util.List;
  33 import java.util.Set;
  34
  35 public class CompositeShortNamesCache extends PsiShortNamesCache {
  36   private final List<PsiShortNamesCache> myCaches = new ArrayList<PsiShortNamesCache>();
  37   private PsiShortNamesCache[] myCacheArray = new PsiShortNamesCache[0];
  38
  39   public void addCache(PsiShortNamesCache cache) {
  40     myCaches.add(cache);
  41     myCacheArray = myCaches.toArray(new PsiShortNamesCache[myCaches.size()]);
  42   }
  43
  44   public void runStartupActivity() {
  45     for (PsiShortNamesCache cache : myCaches) {
  46       cache.runStartupActivity();
  47     }
  48   }
  49
  50   @NotNull
  51   public PsiFile[] getFilesByName(@NotNull String name) {
  52     Merger<PsiFile> merger = null;
  53     for (PsiShortNamesCache cache : myCacheArray) {
  54       PsiFile[] classes = cache.getFilesByName(name);
  55       if (classes.length != 0) {
  56         if (merger == null) merger = new Merger<PsiFile>();
  57         merger.add(classes);
  58       }
  59     }
  60     PsiFile[] result = merger == null ? null : merger.getResult();
  61     return result != null ? result : PsiFile.EMPTY_ARRAY;
  62   }
  63
  64   @NotNull
  65   public String[] getAllFileNames() {
  66     Merger<String> merger = new Merger<String>();
  67     for (PsiShortNamesCache cache : myCacheArray) {
  68       merger.add(cache.getAllFileNames());
  69     }
  70     String[] result = merger.getResult();
  71     return result != null ? result : ArrayUtil.EMPTY_STRING_ARRAY;
  72   }
  73
  74   @NotNull
  75   public PsiClass[] getClassesByName(@NotNull String name, @NotNull GlobalSearchScope scope) {
  76     Merger<PsiClass> merger = null;
  77     for (PsiShortNamesCache cache : myCacheArray) {
  78       PsiClass[] classes = cache.getClassesByName(name, scope);
  79       if (classes.length != 0) {
  80         if (merger == null) merger = new Merger<PsiClass>();
  81         merger.add(classes);
  82       }
  83     }
  84     PsiClass[] result = merger == null ? null : merger.getResult();
  85     return result != null ? result : PsiClass.EMPTY_ARRAY;
  86   }
  87
  88   @NotNull
  89   public String[] getAllClassNames() {
  90     Merger<String> merger = new Merger<String>();
  91     for (PsiShortNamesCache cache : myCacheArray) {
  92       merger.add(cache.getAllClassNames());
  93     }
  94     String[] result = merger.getResult();
  95     return result != null ? result : ArrayUtil.EMPTY_STRING_ARRAY;
  96   }
  97
  98   public void getAllClassNames(@NotNull HashSet<String> dest) {
  99     for (PsiShortNamesCache cache : myCacheArray) {
 100       cache.getAllClassNames(dest);
 101     }
 102   }
 103
 104   @NotNull
 105   public PsiMethod[] getMethodsByName(@NotNull String name, @NotNull GlobalSearchScope scope) {
 106     Merger<PsiMethod> merger = null;
 107     for (PsiShortNamesCache cache : myCacheArray) {
 108       PsiMethod[] classes = cache.getMethodsByName(name, scope);
 109       if (classes.length != 0) {
 110         if (merger == null) merger = new Merger<PsiMethod>();
 111         merger.add(classes);
 112       }
 113     }
 114     PsiMethod[] result = merger == null ? null : merger.getResult();
 115     return result != null ? result : PsiMethod.EMPTY_ARRAY;
 116   }
 117
 118   @NotNull
 119   public PsiMethod[] getMethodsByNameIfNotMoreThan(@NonNls @NotNull final String name, @NotNull final GlobalSearchScope scope, final int maxCount) {
 120     Merger<PsiMethod> merger = null;
 121     for (PsiShortNamesCache cache : myCacheArray) {
 122       PsiMethod[] classes = cache.getMethodsByNameIfNotMoreThan(name, scope, maxCount);
 123       if (classes.length != 0) {
 124         if (merger == null) merger = new Merger<PsiMethod>();
 125         merger.add(classes);
 126       }
 127     }
 128     PsiMethod[] result = merger == null ? null : merger.getResult();
 129     return result != null ? result : PsiMethod.EMPTY_ARRAY;
 130   }
 131
 132   @NotNull
 133   public String[] getAllMethodNames() {
 134     Merger<String> merger = new Merger<String>();
 135     for (PsiShortNamesCache cache : myCacheArray) {
 136       merger.add(cache.getAllMethodNames());
 137     }
 138     String[] result = merger.getResult();
 139     return result != null ? result : ArrayUtil.EMPTY_STRING_ARRAY;
 140   }
 141
 142   public void getAllMethodNames(@NotNull HashSet<String> set) {
 143     for (PsiShortNamesCache cache : myCacheArray) {
 144       cache.getAllMethodNames(set);
 145     }
 146   }
 147
 148   @NotNull
 149   public PsiField[] getFieldsByName(@NotNull String name, @NotNull GlobalSearchScope scope) {
 150     Merger<PsiField> merger = null;
 151     for (PsiShortNamesCache cache : myCacheArray) {
 152       PsiField[] classes = cache.getFieldsByName(name, scope);
 153       if (classes.length != 0) {
 154         if (merger == null) merger = new Merger<PsiField>();
 155         merger.add(classes);
 156       }
 157     }
 158     PsiField[] result = merger == null ? null : merger.getResult();
 159     return result != null ? result : PsiField.EMPTY_ARRAY;
 160   }
 161
 162   @NotNull
 163   public String[] getAllFieldNames() {
 164     Merger<String> merger = new Merger<String>();
 165     for (PsiShortNamesCache cache : myCacheArray) {
 166       merger.add(cache.getAllFieldNames());
 167     }
 168     String[] result = merger.getResult();
 169     return result != null ? result : ArrayUtil.EMPTY_STRING_ARRAY;
 170   }
 171
 172   public void getAllFieldNames(@NotNull HashSet<String> set) {
 173     for (PsiShortNamesCache cache : myCacheArray) {
 174       cache.getAllFieldNames(set);
 175     }
 176   }
 177
 178   private static class Merger<T> {
 179     private T[] mySingleItem = null;
 180     private Set<T> myAllItems = null;
 181
 182     public void add(T[] items) {
 183       if (items == null || items.length == 0) return;
 184       if (mySingleItem == null) {
 185         mySingleItem = items;
 186         return;
 187       }
 188       if (myAllItems == null) {
 189         myAllItems = new THashSet<T>(Arrays.asList(mySingleItem));
 190       }
 191       myAllItems.addAll(Arrays.asList(items));
 192     }
 193
 194     public T[] getResult() {
 195       if (myAllItems == null) return mySingleItem;
 196       return myAllItems.toArray(mySingleItem);
 197     }
 198   }
 199
 200   @SuppressWarnings({"HardCodedStringLiteral"})
 201   @Override
 202   public String toString() {
 203     return "Composite cache: " + myCaches;
 204   }
 205 }