0b6ea2ecc3e0682336600f1d6e127cd14c9918fc
[idea/community.git] / java / compiler / impl / src / com / intellij / compiler / impl / newApi / NewCompilerCache.java
1 /*
2  * Copyright 2000-2010 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.impl.newApi;
17
18 import com.intellij.openapi.diagnostic.Logger;
19 import com.intellij.util.Processor;
20 import com.intellij.util.io.KeyDescriptor;
21 import com.intellij.util.io.PersistentHashMap;
22
23 import java.io.DataInput;
24 import java.io.DataOutput;
25 import java.io.File;
26 import java.io.IOException;
27
28 /**
29  * @author nik
30  */
31 public class NewCompilerCache<Key, State> {
32   private static final Logger LOG = Logger.getInstance("#com.intellij.compiler.impl.newApi.NewCompilerCache");
33   private PersistentHashMap<KeyAndTargetData<Key>, State> myPersistentMap;
34   private File myCacheFile;
35   private final NewCompiler<Key, State> myCompiler;
36
37   public NewCompilerCache(NewCompiler<Key, State> compiler, final File compilerCacheDir) throws IOException {
38     myCompiler = compiler;
39     myCacheFile = new File(compilerCacheDir, "timestamps");
40     createMap();
41   }
42
43   private void createMap() throws IOException {
44     myPersistentMap = new PersistentHashMap<KeyAndTargetData<Key>, State>(myCacheFile, new SourceItemDataDescriptor(myCompiler.getItemKeyDescriptor()),
45                                                                   myCompiler.getItemStateExternalizer());
46   }
47
48   private KeyAndTargetData<Key> getKeyAndTargetData(Key key, int target) {
49     KeyAndTargetData<Key> data = new KeyAndTargetData<Key>();
50     data.myTarget = target;
51     data.myKey = key;
52     return data;
53   }
54
55   public void wipe() throws IOException {
56     try {
57       myPersistentMap.close();
58     }
59     catch (IOException ignored) {
60     }
61     PersistentHashMap.deleteFilesStartingWith(myCacheFile);
62     createMap();
63   }
64
65   public void close() {
66     try {
67       myPersistentMap.close();
68     }
69     catch (IOException e) {
70       LOG.info(e);
71     }
72   }
73
74   public void remove(int targetId, Key key) throws IOException {
75     myPersistentMap.remove(getKeyAndTargetData(key, targetId));
76   }
77
78   public State getState(int targetId, Key key) throws IOException {
79     return myPersistentMap.get(getKeyAndTargetData(key, targetId));
80   }
81
82   public void processSources(final int targetId, final Processor<Key> processor) throws IOException {
83     myPersistentMap.processKeys(new Processor<KeyAndTargetData<Key>>() {
84       @Override
85       public boolean process(KeyAndTargetData<Key> data) {
86         return targetId == data.myTarget ? processor.process(data.myKey) : true;
87       }
88     });
89   }
90
91   public void putOutput(int targetId, Key key, State outputItem) throws IOException {
92     myPersistentMap.put(getKeyAndTargetData(key, targetId), outputItem);
93   }
94
95
96   private static class KeyAndTargetData<Key> {
97     public int myTarget;
98     public Key myKey;
99   }
100
101   private class SourceItemDataDescriptor implements KeyDescriptor<KeyAndTargetData<Key>> {
102     private final KeyDescriptor<Key> myKeyDescriptor;
103
104     public SourceItemDataDescriptor(KeyDescriptor<Key> keyDescriptor) {
105       myKeyDescriptor = keyDescriptor;
106     }
107
108     @Override
109     public boolean isEqual(KeyAndTargetData<Key> val1, KeyAndTargetData<Key> val2) {
110       return val1.myTarget == val2.myTarget;
111     }
112
113     @Override
114     public int getHashCode(KeyAndTargetData<Key> value) {
115       return value.myTarget + 239 * myKeyDescriptor.getHashCode(value.myKey);
116     }
117
118     @Override
119     public void save(DataOutput out, KeyAndTargetData<Key> value) throws IOException {
120       out.writeInt(value.myTarget);
121       myKeyDescriptor.save(out, value.myKey);
122     }
123
124
125     @Override
126     public KeyAndTargetData<Key> read(DataInput in) throws IOException {
127       int target = in.readInt();
128       final Key item = myKeyDescriptor.read(in);
129       return getKeyAndTargetData(item, target);
130     }
131   }
132 }