2cfdcc0427d90c1223e0a608c137d938646cb95a
[idea/community.git] / jps / jps-builders / src / org / jetbrains / jps / backwardRefs / index / JavaCompilerIndices.java
1 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
2 package org.jetbrains.jps.backwardRefs.index;
3
4 import com.intellij.openapi.util.io.DataInputOutputUtilRt;
5 import com.intellij.util.indexing.DataIndexer;
6 import com.intellij.util.indexing.IndexExtension;
7 import com.intellij.util.indexing.IndexId;
8 import com.intellij.util.io.DataExternalizer;
9 import com.intellij.util.io.DataInputOutputUtil;
10 import com.intellij.util.io.KeyDescriptor;
11 import com.intellij.util.io.VoidDataExternalizer;
12 import org.jetbrains.annotations.NotNull;
13 import org.jetbrains.jps.backwardRefs.CompilerRef;
14 import org.jetbrains.jps.backwardRefs.CompilerRefDescriptor;
15 import org.jetbrains.jps.backwardRefs.SignatureData;
16
17 import java.io.DataInput;
18 import java.io.DataOutput;
19 import java.io.IOException;
20 import java.util.Arrays;
21 import java.util.Collection;
22 import java.util.List;
23
24 public class JavaCompilerIndices {
25   //TODO manage version separately
26   public static final int VERSION = 7;
27
28   public static final IndexId<CompilerRef, Integer> BACK_USAGES = IndexId.create("back.refs");
29   public static final IndexId<CompilerRef, Collection<CompilerRef>> BACK_HIERARCHY = IndexId.create("back.hierarchy");
30   public static final IndexId<CompilerRef, Void> BACK_CLASS_DEF = IndexId.create("back.class.def");
31   public static final IndexId<SignatureData, Collection<CompilerRef>> BACK_MEMBER_SIGN = IndexId.create("back.member.sign");
32   public static final IndexId<CompilerRef, Collection<CompilerRef>> BACK_CAST = IndexId.create("back.cast");
33   public static final IndexId<CompilerRef, Void> IMPLICIT_TO_STRING = IndexId.create("implicit.to.string");
34
35   public static List<IndexExtension<?, ?, CompiledFileData>> getIndices() {
36     return Arrays.asList(createBackwardClassDefinitionExtension(),
37                          createBackwardUsagesExtension(),
38                          createBackwardHierarchyExtension(),
39                          createBackwardSignatureExtension(),
40                          createBackwardCastExtension(),
41                          createImplicitToStringExtension());
42   }
43
44   private static IndexExtension<CompilerRef, Void, CompiledFileData> createImplicitToStringExtension() {
45     return new IndexExtension<CompilerRef, Void, CompiledFileData>() {
46       @NotNull
47       @Override
48       public IndexId<CompilerRef, Void> getName() {
49         return IMPLICIT_TO_STRING;
50       }
51
52       @NotNull
53       @Override
54       public DataIndexer<CompilerRef, Void, CompiledFileData> getIndexer() {
55         return CompiledFileData::getImplicitToString;
56       }
57
58       @NotNull
59       @Override
60       public KeyDescriptor<CompilerRef> getKeyDescriptor() {
61         return CompilerRefDescriptor.INSTANCE;
62       }
63
64       @NotNull
65       @Override
66       public DataExternalizer<Void> getValueExternalizer() {
67         return VoidDataExternalizer.INSTANCE;
68       }
69
70       @Override
71       public int getVersion() {
72         return VERSION;
73       }
74     };
75   }
76
77   private static IndexExtension<CompilerRef, Collection<CompilerRef>, CompiledFileData> createBackwardCastExtension() {
78     return new IndexExtension<CompilerRef, Collection<CompilerRef>, CompiledFileData>() {
79       @NotNull
80       @Override
81       public IndexId<CompilerRef, Collection<CompilerRef>> getName() {
82         return BACK_CAST;
83       }
84
85       @NotNull
86       @Override
87       public DataIndexer<CompilerRef, Collection<CompilerRef>, CompiledFileData> getIndexer() {
88         return CompiledFileData::getCasts;
89       }
90
91       @NotNull
92       @Override
93       public KeyDescriptor<CompilerRef> getKeyDescriptor() {
94         return CompilerRefDescriptor.INSTANCE;
95       }
96
97       @NotNull
98       @Override
99       public DataExternalizer<Collection<CompilerRef>> getValueExternalizer() {
100         return createCompilerRefSeqExternalizer();
101       }
102
103       @Override
104       public int getVersion() {
105         return VERSION;
106       }
107     };
108   }
109
110   private static IndexExtension<CompilerRef, Integer, CompiledFileData> createBackwardUsagesExtension() {
111     return new IndexExtension<CompilerRef, Integer, CompiledFileData>() {
112       @Override
113       public int getVersion() {
114         return VERSION;
115       }
116
117       @Override
118       @NotNull
119       public IndexId<CompilerRef, Integer> getName() {
120         return BACK_USAGES;
121       }
122
123       @Override
124       @NotNull
125       public DataIndexer<CompilerRef, Integer, CompiledFileData> getIndexer() {
126         return CompiledFileData::getReferences;
127       }
128
129       @Override
130       @NotNull
131       public KeyDescriptor<CompilerRef> getKeyDescriptor() {
132         return CompilerRefDescriptor.INSTANCE;
133       }
134
135       @Override
136       @NotNull
137       public DataExternalizer<Integer> getValueExternalizer() {
138         return new UnsignedByteExternalizer();
139       }
140     };
141   }
142
143   private static class UnsignedByteExternalizer implements DataExternalizer<Integer> {
144     @Override
145     public void save(@NotNull DataOutput out, Integer value) throws IOException {
146       int v = value;
147       if (v > 255) {
148         v = 255;
149       }
150       out.writeByte(v);
151     }
152
153     @Override
154     public Integer read(@NotNull DataInput in) throws IOException {
155       return in.readByte() & 0xFF;
156     }
157   }
158
159   private static IndexExtension<CompilerRef, Collection<CompilerRef>, CompiledFileData> createBackwardHierarchyExtension() {
160     return new IndexExtension<CompilerRef, Collection<CompilerRef>, CompiledFileData>() {
161       @Override
162       public int getVersion() {
163         return VERSION;
164       }
165
166       @Override
167       @NotNull
168       public IndexId<CompilerRef, Collection<CompilerRef>> getName() {
169         return BACK_HIERARCHY;
170       }
171
172       @Override
173       @NotNull
174       public DataIndexer<CompilerRef, Collection<CompilerRef>, CompiledFileData> getIndexer() {
175         return CompiledFileData::getBackwardHierarchy;
176       }
177
178       @Override
179       @NotNull
180       public KeyDescriptor<CompilerRef> getKeyDescriptor() {
181         return CompilerRefDescriptor.INSTANCE;
182       }
183
184       @Override
185       @NotNull
186       public DataExternalizer<Collection<CompilerRef>> getValueExternalizer() {
187         return createCompilerRefSeqExternalizer();
188       }
189     };
190   }
191
192   private static IndexExtension<CompilerRef, Void, CompiledFileData> createBackwardClassDefinitionExtension() {
193     return new IndexExtension<CompilerRef, Void, CompiledFileData>() {
194       @Override
195       public int getVersion() {
196         return VERSION;
197       }
198
199       @Override
200       @NotNull
201       public IndexId<CompilerRef, Void> getName() {
202         return BACK_CLASS_DEF;
203       }
204
205       @Override
206       @NotNull
207       public DataIndexer<CompilerRef, Void, CompiledFileData> getIndexer() {
208         return CompiledFileData::getDefinitions;
209       }
210
211       @Override
212       @NotNull
213       public KeyDescriptor<CompilerRef> getKeyDescriptor() {
214         return CompilerRefDescriptor.INSTANCE;
215       }
216
217       @Override
218       @NotNull
219       public DataExternalizer<Void> getValueExternalizer() {
220         return VoidDataExternalizer.INSTANCE;
221       }
222     };
223   }
224
225   private static IndexExtension<SignatureData, Collection<CompilerRef>, CompiledFileData> createBackwardSignatureExtension() {
226     return new IndexExtension<SignatureData, Collection<CompilerRef>, CompiledFileData>() {
227       @NotNull
228       @Override
229       public IndexId<SignatureData, Collection<CompilerRef>> getName() {
230         return BACK_MEMBER_SIGN;
231       }
232
233       @NotNull
234       @Override
235       public DataIndexer<SignatureData, Collection<CompilerRef>, CompiledFileData> getIndexer() {
236         return CompiledFileData::getSignatureData;
237       }
238
239       @NotNull
240       @Override
241       public KeyDescriptor<SignatureData> getKeyDescriptor() {
242         return createSignatureDataDescriptor();
243       }
244
245       @NotNull
246       @Override
247       public DataExternalizer<Collection<CompilerRef>> getValueExternalizer() {
248         return createCompilerRefSeqExternalizer();
249       }
250
251       @Override
252       public int getVersion() {
253         return VERSION;
254       }
255     };
256   }
257
258   @NotNull
259   private static DataExternalizer<Collection<CompilerRef>> createCompilerRefSeqExternalizer() {
260     return new DataExternalizer<Collection<CompilerRef>>() {
261       @Override
262       public void save(@NotNull final DataOutput out, Collection<CompilerRef> value) throws IOException {
263         DataInputOutputUtilRt.writeSeq(out, value, lightRef -> CompilerRefDescriptor.INSTANCE.save(out, lightRef));
264       }
265
266       @Override
267       public Collection<CompilerRef> read(@NotNull final DataInput in) throws IOException {
268         return DataInputOutputUtilRt.readSeq(in, () -> CompilerRefDescriptor.INSTANCE.read(in));
269       }
270     };
271   }
272
273   private static KeyDescriptor<SignatureData> createSignatureDataDescriptor() {
274     return new KeyDescriptor<SignatureData>() {
275       @Override
276       public int getHashCode(SignatureData value) {
277         return value.hashCode();
278       }
279
280       @Override
281       public boolean isEqual(SignatureData val1, SignatureData val2) {
282         return val1.equals(val2);
283       }
284
285       @Override
286       public void save(@NotNull DataOutput out, SignatureData value) throws IOException {
287         DataInputOutputUtil.writeINT(out, value.getRawReturnType());
288         out.writeByte(value.getIteratorKind());
289         out.writeBoolean(value.isStatic());
290       }
291
292       @Override
293       public SignatureData read(@NotNull DataInput in) throws IOException {
294         return new SignatureData(DataInputOutputUtil.readINT(in), in.readByte(), in.readBoolean());
295       }
296     };
297   }
298 }