java/compiler/impl/src/com/intellij/compiler/make/Cache.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.compiler.make;
  17
  18 import com.intellij.compiler.SymbolTable;
  19 import com.intellij.compiler.classParsing.*;
  20 import com.intellij.openapi.diagnostic.Logger;
  21 import com.intellij.openapi.util.io.FileUtil;
  22 import com.intellij.util.ArrayUtil;
  23 import com.intellij.util.cls.ClsFormatException;
  24 import com.intellij.util.io.DataExternalizer;
  25 import com.intellij.util.io.EnumeratorIntegerDescriptor;
  26 import com.intellij.util.io.PersistentHashMap;
  27 import org.jetbrains.annotations.NonNls;
  28 import org.jetbrains.annotations.Nullable;
  29
  30 import java.io.DataInput;
  31 import java.io.DataOutput;
  32 import java.io.File;
  33 import java.io.IOException;
  34 import java.util.*;
  35
  36 /**
  37  * @author Eugene Zhuravlev
  38  * Date: Aug 8, 2003
  39  * Time: 7:03:56 PM
  40  */
  41 public class Cache {
  42   private static final Logger LOG = Logger.getInstance("#com.intellij.compiler.make.Cache");
  43   public static final int UNKNOWN = -1;
  44
  45   private final PersistentHashMap<Integer, ClassInfo> myQNameToClassInfoMap;
  46
  47   private final BackwardDependenciesStorage myDependencies;
  48   private final CompilerDependencyStorage<Integer> myQNameToReferencedClassesMap;
  49   private final CompilerDependencyStorage<Integer> myQNameToSubclassesMap;
  50   private final PersistentHashMap<Integer, Boolean> myRemoteQNames;
  51   private final String myStorePath;
  52
  53   public Cache(@NonNls final String storePath, final int cacheSize) throws IOException {
  54     myStorePath = storePath;
  55     new File(storePath).mkdirs();
  56     myQNameToClassInfoMap = new CachedPersistentHashMap<Integer, ClassInfo>(getOrCreateFile("classes"), EnumeratorIntegerDescriptor.INSTANCE, new DataExternalizer<ClassInfo>() {
  57       public void save(DataOutput out, ClassInfo value) throws IOException {
  58         value.save(out);
  59       }
  60       public ClassInfo read(DataInput in) throws IOException {
  61         return new ClassInfo(in);
  62       }
  63     }, cacheSize * 2) {
  64       protected boolean isValueDirty(ClassInfo classInfo) {
  65         return classInfo.isDirty();
  66       }
  67     };
  68
  69     myDependencies = new BackwardDependenciesStorage(getOrCreateFile("bdeps"), cacheSize);
  70     myQNameToReferencedClassesMap = new CompilerDependencyStorage<Integer>(getOrCreateFile("fdeps"), EnumeratorIntegerDescriptor.INSTANCE, cacheSize);
  71     myQNameToSubclassesMap = new CompilerDependencyStorage<Integer>(getOrCreateFile("subclasses"), EnumeratorIntegerDescriptor.INSTANCE, cacheSize);
  72
  73     myRemoteQNames = new PersistentHashMap<Integer, Boolean>(getOrCreateFile("remote"), EnumeratorIntegerDescriptor.INSTANCE, new DataExternalizer<Boolean>() {
  74       public void save(DataOutput out, Boolean value) throws IOException {
  75         out.writeBoolean(value.booleanValue());
  76       }
  77
  78       public Boolean read(DataInput in) throws IOException {
  79         return in.readBoolean();
  80       }
  81     }, cacheSize);
  82   }
  83
  84   private File getOrCreateFile(final String fileName) throws IOException {
  85     final File file = new File(myStorePath, fileName);
  86     FileUtil.createIfDoesntExist(file);
  87     return file;
  88   }
  89
  90   public void dispose() throws CacheCorruptedException {
  91     CacheCorruptedException ex = null;
  92     try {
  93       myQNameToClassInfoMap.close();
  94     }
  95     catch (IOException e) {
  96       LOG.info(e);
  97       ex = new CacheCorruptedException(e);
  98     }
  99     try {
 100       myRemoteQNames.close();
 101     }
 102     catch (IOException e) {
 103       LOG.info(e);
 104       if (ex != null) {
 105         ex = new CacheCorruptedException(e);
 106       }
 107     }
 108
 109     myQNameToReferencedClassesMap.dispose();
 110     myDependencies.dispose();
 111     myQNameToSubclassesMap.dispose();
 112
 113     if (ex != null) {
 114       throw ex;
 115     }
 116
 117   }
 118
 119   public int[] getAllClassNames() throws CacheCorruptedException {
 120     try {
 121       final Collection<Integer> allKeys = myQNameToClassInfoMap.getAllKeysWithExistingMapping();
 122       final int[] array = ArrayUtil.newIntArray(allKeys.size());
 123       int idx = 0;
 124       for (Integer id : allKeys) {
 125         array[idx++] = id.intValue();
 126       }
 127       return array;
 128     }
 129     catch (IOException e) {
 130       throw new CacheCorruptedException(e);
 131     }
 132   }
 133
 134   public int importClassInfo(ClassFileReader reader, SymbolTable symbolTable) throws ClsFormatException, CacheCorruptedException {
 135     try {
 136       final ClassInfo classInfo = new ClassInfo(reader, symbolTable);
 137       myQNameToClassInfoMap.put(classInfo.getQualifiedName(), classInfo);
 138       return classInfo.getQualifiedName();
 139     }
 140     catch (IOException e) {
 141       throw new CacheCorruptedException(e);
 142     }
 143   }
 144
 145   public void importClassInfo(Cache fromCache, final int qName) throws CacheCorruptedException {
 146     try {
 147       final ClassInfo classInfo = fromCache.myQNameToClassInfoMap.get(qName);
 148       if (classInfo != null) {
 149         final ClassInfo clone = classInfo.clone();
 150         clone.clearReferences();
 151         myQNameToClassInfoMap.put(qName, clone);
 152       }
 153     }
 154     catch (Throwable e) {
 155       throw new CacheCorruptedException(e);
 156     }
 157   }
 158
 159   public AnnotationConstantValue[] getRuntimeVisibleAnnotations(int classId) throws CacheCorruptedException {
 160     try {
 161       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 162       return classInfo != null? classInfo.getRuntimeVisibleAnnotations() : AnnotationConstantValue.EMPTY_ARRAY;
 163     }
 164     catch (Throwable e) {
 165       throw new CacheCorruptedException(e);
 166     }
 167   }
 168
 169   public AnnotationConstantValue[] getRuntimeInvisibleAnnotations(int classId) throws CacheCorruptedException {
 170     try {
 171       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 172       return classInfo != null? classInfo.getRuntimeInvisibleAnnotations() : AnnotationConstantValue.EMPTY_ARRAY;
 173     }
 174     catch (Throwable e) {
 175       throw new CacheCorruptedException(e);
 176     }
 177   }
 178
 179   public int[] getSubclasses(int classId) throws CacheCorruptedException {
 180     try {
 181       return myQNameToSubclassesMap.getValues(classId);
 182     }
 183     catch (Throwable e) {
 184       throw new CacheCorruptedException(e);
 185     }
 186   }
 187
 188   public void addSubclass(int classId, int subclassQName) throws CacheCorruptedException {
 189     try {
 190       myQNameToSubclassesMap.addValue(classId, subclassQName);
 191     }
 192     catch (Throwable e) {
 193       throw new CacheCorruptedException(e);
 194     }
 195   }
 196
 197   public void removeSubclass(int classId, int subclassQName) throws CacheCorruptedException {
 198     try {
 199       myQNameToSubclassesMap.removeValue(classId, subclassQName);
 200     }
 201     catch (Throwable e) {
 202       throw new CacheCorruptedException(e);
 203     }
 204   }
 205
 206   public int[] getReferencedClasses(int classId) throws CacheCorruptedException {
 207     try {
 208       return myQNameToReferencedClassesMap.getValues(classId);
 209     }
 210     catch (Throwable e) {
 211       throw new CacheCorruptedException(e);
 212     }
 213   }
 214
 215   public void clearReferencedClasses(int qName) throws CacheCorruptedException {
 216     try {
 217       myQNameToReferencedClassesMap.remove(qName);
 218     }
 219     catch (Throwable e) {
 220       throw new CacheCorruptedException(e);
 221     }
 222   }
 223
 224   public Collection<ReferenceInfo> getReferences(int classId) throws CacheCorruptedException {
 225     try {
 226       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 227       return classInfo != null? Arrays.asList(classInfo.getReferences()) : Collections.<ReferenceInfo>emptyList();
 228     }
 229     catch (Throwable e) {
 230       throw new CacheCorruptedException(e);
 231     }
 232   }
 233
 234   public String getSourceFileName(int classId) throws CacheCorruptedException {
 235     try {
 236       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 237       return classInfo != null? classInfo.getSourceFileName() : "";
 238     }
 239     catch (Throwable e) {
 240       throw new CacheCorruptedException(e);
 241     }
 242   }
 243
 244   public boolean isRemote(int classId) throws CacheCorruptedException {
 245     try {
 246       return myRemoteQNames.containsMapping(classId);
 247     }
 248     catch (Throwable e) {
 249       throw new CacheCorruptedException(e);
 250     }
 251   }
 252
 253   public void setRemote(int classId, boolean remote) throws CacheCorruptedException {
 254     try {
 255       if (remote) {
 256         myRemoteQNames.put(classId, Boolean.TRUE);
 257       }
 258       else {
 259         myRemoteQNames.remove(classId);
 260       }
 261     }
 262     catch (Throwable e) {
 263       throw new CacheCorruptedException(e);
 264     }
 265   }
 266
 267   public int getSuperQualifiedName(int classId) throws CacheCorruptedException {
 268     try {
 269       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 270       return classInfo != null? classInfo.getSuperQualifiedName() : UNKNOWN;
 271     }
 272     catch (Throwable e) {
 273       throw new CacheCorruptedException(e);
 274     }
 275   }
 276
 277   public String getPath(int classId) throws CacheCorruptedException {
 278     try {
 279       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 280       return classInfo != null? classInfo.getPath() : "";
 281     }
 282     catch (Throwable e) {
 283       throw new CacheCorruptedException(e);
 284     }
 285   }
 286
 287   public void setPath(int classId, String path) throws CacheCorruptedException {
 288     try {
 289       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 290       if (classInfo != null) {
 291         classInfo.setPath(path);
 292       }
 293     }
 294     catch (Throwable e) {
 295       throw new CacheCorruptedException(e);
 296     }
 297   }
 298
 299   public int getGenericSignature(int classId) throws CacheCorruptedException {
 300     try {
 301       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 302       return classInfo != null? classInfo.getGenericSignature() : UNKNOWN;
 303     }
 304     catch (Throwable e) {
 305       throw new CacheCorruptedException(e);
 306     }
 307   }
 308
 309   public boolean containsClass(int qName) throws CacheCorruptedException {
 310     try {
 311       return myQNameToClassInfoMap.containsMapping(qName);
 312     }
 313     catch (IOException e) {
 314       throw new CacheCorruptedException(e);
 315     }
 316   }
 317
 318   public int[] getSuperInterfaces(int classId) throws CacheCorruptedException {
 319     try {
 320       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 321       return classInfo != null? classInfo.getSuperInterfaces() : ArrayUtil.EMPTY_INT_ARRAY;
 322     }
 323     catch (Throwable e) {
 324       throw new CacheCorruptedException(e);
 325     }
 326   }
 327
 328   public int getFlags(int classId) throws CacheCorruptedException {
 329     try {
 330       final ClassInfo classInfo = myQNameToClassInfoMap.get(classId);
 331       return classInfo != null? classInfo.getFlags() : UNKNOWN;
 332     }
 333     catch (Throwable e) {
 334       throw new CacheCorruptedException(e);
 335     }
 336   }
 337
 338   public FieldInfo[] getFields(int qName) throws CacheCorruptedException{
 339     try {
 340       final ClassInfo classInfo = myQNameToClassInfoMap.get(qName);
 341       return classInfo != null? classInfo.getFields() : FieldInfo.EMPTY_ARRAY;
 342     }
 343     catch (Throwable e) {
 344       throw new CacheCorruptedException(e);
 345     }
 346   }
 347
 348   @Nullable
 349   public FieldInfo findField(final int classDeclarationId, final int name, final int descriptor) throws CacheCorruptedException{
 350     try {
 351       for (FieldInfo fieldInfo : getFields(classDeclarationId)) {
 352         if (fieldInfo.getName() == name && fieldInfo.getDescriptor() == descriptor) {
 353           return fieldInfo;
 354         }
 355       }
 356       return null;
 357     }
 358     catch (Throwable e) {
 359       throw new CacheCorruptedException(e);
 360     }
 361   }
 362
 363   @Nullable
 364   public FieldInfo findFieldByName(final int classDeclarationId, final int name) throws CacheCorruptedException{
 365     try {
 366       for (FieldInfo fieldInfo : getFields(classDeclarationId)) {
 367         if (fieldInfo.getName() == name) {
 368           return fieldInfo;
 369         }
 370       }
 371       return null;
 372     }
 373     catch (Throwable e) {
 374       throw new CacheCorruptedException(e);
 375     }
 376   }
 377
 378   public MethodInfo[] getMethods(int classQName) throws CacheCorruptedException{
 379     try {
 380       final ClassInfo classInfo = myQNameToClassInfoMap.get(classQName);
 381       return classInfo != null? classInfo.getMethods() : MethodInfo.EMPTY_ARRAY;
 382     }
 383     catch (Throwable e) {
 384       throw new CacheCorruptedException(e);
 385     }
 386   }
 387
 388   @Nullable
 389   public MethodInfo findMethod(final int classQName, final int name, final int descriptor) throws CacheCorruptedException{
 390     try {
 391       for (MethodInfo methodInfo : getMethods(classQName)) {
 392         if (methodInfo.getName() == name && methodInfo.getDescriptor() == descriptor) {
 393           return methodInfo;
 394         }
 395       }
 396       return null;
 397     }
 398     catch (Throwable e) {
 399       throw new CacheCorruptedException(e);
 400     }
 401   }
 402
 403   public List<MethodInfo> findMethodsByName(final int classDeclarationId, final int name) throws CacheCorruptedException{
 404     try {
 405       final List<MethodInfo> methods = new ArrayList<MethodInfo>();
 406       for (MethodInfo methodInfo : getMethods(classDeclarationId)) {
 407         if (methodInfo.getName() == name) {
 408           methods.add(methodInfo);
 409         }
 410       }
 411       return methods;
 412     }
 413     catch (Throwable e) {
 414       throw new CacheCorruptedException(e);
 415     }
 416   }
 417
 418   @Nullable
 419   public MethodInfo findMethodsBySignature(final int classDeclarationId, final String signature, SymbolTable symbolTable) throws CacheCorruptedException{
 420     try {
 421       for (MethodInfo methodInfo : getMethods(classDeclarationId)) {
 422         if (signature.equals(CacheUtils.getMethodSignature(symbolTable.getSymbol(methodInfo.getName()), symbolTable.getSymbol(methodInfo.getDescriptor())))) {
 423           return methodInfo;
 424         }
 425       }
 426       return null;
 427     }
 428     catch (Throwable e) {
 429       throw new CacheCorruptedException(e);
 430     }
 431   }
 432
 433   public void addClassReferencer(int qName, int referencerQName) throws CacheCorruptedException {
 434     try {
 435       if (qName == referencerQName) {
 436         return; // do not log self-dependencies
 437       }
 438       if (myQNameToClassInfoMap.containsMapping(qName)) {
 439         myDependencies.addClassReferencer(qName, referencerQName);
 440         myQNameToReferencedClassesMap.addValue(referencerQName, qName);
 441       }
 442     }
 443     catch (Throwable e) {
 444       throw new CacheCorruptedException(e);
 445     }
 446   }
 447
 448   public void removeClassReferencer(int qName, int referencerQName) throws CacheCorruptedException {
 449     try {
 450       myDependencies.removeReferencer(qName, referencerQName);
 451     }
 452     catch (Throwable e) {
 453       throw new CacheCorruptedException(e);
 454     }
 455   }
 456
 457   public void addFieldReferencer(int qName, int fieldName, int referencerQName) throws CacheCorruptedException {
 458     try {
 459       if (qName != referencerQName && myQNameToClassInfoMap.containsMapping(qName)) {
 460         myDependencies.addFieldReferencer(qName, referencerQName, fieldName);
 461         myQNameToReferencedClassesMap.addValue(referencerQName, qName);
 462       }
 463     }
 464     catch (Throwable e) {
 465       throw new CacheCorruptedException(e);
 466     }
 467   }
 468
 469   public void addMethodReferencer(int qName, int methodName, int methodDescriptor, int referencerQName) throws CacheCorruptedException {
 470     try {
 471       if (qName != referencerQName && myQNameToClassInfoMap.containsMapping(qName)) {
 472         myDependencies.addMethodReferencer(qName, referencerQName, methodName, methodDescriptor);
 473         myQNameToReferencedClassesMap.addValue(referencerQName, qName);
 474       }
 475     }
 476     catch (Throwable e) {
 477       throw new CacheCorruptedException(e);
 478     }
 479   }
 480
 481   /** @NotNull */
 482   public Dependency[] getBackDependencies(final int classQName) throws CacheCorruptedException{
 483     return myDependencies.getDependencies(classQName);
 484   }
 485
 486   public void wipe() {
 487     myDependencies.dispose();
 488     myQNameToReferencedClassesMap.dispose();
 489     myQNameToSubclassesMap.dispose();
 490     try {
 491       myQNameToClassInfoMap.close();
 492     }
 493     catch (IOException e) {
 494       LOG.info(e);
 495     }
 496     try {
 497       myRemoteQNames.close();
 498     }
 499     catch (IOException e) {
 500       LOG.info(e);
 501     }
 502     final File[] files = new File(myStorePath).listFiles();
 503     if (files != null) {
 504       for (File file : files) {
 505         if (!file.isDirectory()) {
 506           FileUtil.delete(file);
 507         }
 508       }
 509     }
 510   }
 511
 512   public void removeClass(final int qName) throws CacheCorruptedException {
 513     try {
 514       final ClassInfo classInfo = myQNameToClassInfoMap.get(qName);
 515       if (classInfo == null) {
 516         return;
 517       }
 518       myDependencies.remove(qName);
 519       myQNameToClassInfoMap.remove(qName);
 520       myQNameToReferencedClassesMap.remove(qName);
 521       myQNameToSubclassesMap.remove(qName);
 522       myRemoteQNames.remove(qName);
 523     }
 524     catch (Throwable e) {
 525       throw new CacheCorruptedException(e);
 526     }
 527   }
 528 }