1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/*
* Copyright 2000-2014 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.codeInspection.bytecodeAnalysis;
import com.intellij.ide.util.PropertiesComponent;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.PathManager;
import com.intellij.openapi.util.ThrowableComputable;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.util.io.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.*;
import java.io.DataOutputStream;
import java.util.Arrays;
import static com.intellij.codeInspection.bytecodeAnalysis.ProjectBytecodeAnalysis.LOG;
/**
* @author lambdamix
*/
public class BytecodeAnalysisConverterImpl extends BytecodeAnalysisConverter {
private static final int LOGIC_VERSION = 1;
private static final String ENUMERATORS_VERSION_KEY = "BytecodeAnalysisConverter.Enumerators";
private File myVersionFile;
private PersistentStringEnumerator myNamesEnumerator;
private PersistentEnumeratorDelegate<int[]> myCompoundKeyEnumerator;
private int version;
@Override
public void initComponent() {
// suffix as an indicator of version
final File keysDir = new File(PathManager.getIndexRoot(), "bytecodekeys");
final File namesFile = new File(keysDir, "names" + LOGIC_VERSION);
final File compoundKeysFile = new File(keysDir, "compound" + LOGIC_VERSION);
myVersionFile = new File(keysDir, "version" + LOGIC_VERSION);
version = PropertiesComponent.getInstance().getOrInitInt(ENUMERATORS_VERSION_KEY, 0);
if (ApplicationManager.getApplication().isUnitTestMode()) {
version = _readVersion();
}
if (!namesFile.exists() || !compoundKeysFile.exists() || !myVersionFile.exists()) {
LOG.info("No enumerators detected, re-initialization of enumerators.");
IOUtil.deleteAllFilesStartingWith(keysDir);
version++;
}
try {
IOUtil.openCleanOrResetBroken(new ThrowableComputable<Void, IOException>() {
@Override
public Void compute() throws IOException {
myNamesEnumerator = new PersistentStringEnumerator(namesFile, true);
myCompoundKeyEnumerator = new IntArrayPersistentEnumerator(compoundKeysFile, new IntArrayKeyDescriptor());
return null;
}
}, new Runnable() {
@Override
public void run() {
LOG.info("Error during initialization of enumerators in bytecode analysis. Re-initializing.");
IOUtil.deleteAllFilesStartingWith(keysDir);
version++;
}
});
}
catch (IOException e) {
LOG.error("Re-initialization of enumerators in bytecode analysis failed.", e);
}
PropertiesComponent.getInstance().setValue(ENUMERATORS_VERSION_KEY, String.valueOf(version));
_saveVersion();
}
@Override
public void disposeComponent() {
try {
myNamesEnumerator.close();
myCompoundKeyEnumerator.close();
}
catch (IOException e) {
LOG.debug(e);
}
}
public int _readVersion() {
try {
final DataInputStream is = new DataInputStream(new FileInputStream(myVersionFile));
try {
return is.readInt();
}
finally {
is.close();
}
}
catch (FileNotFoundException ignored) {
}
catch (IOException ignored) {
}
return 0;
}
private void _saveVersion() {
try {
FileUtil.createIfDoesntExist(myVersionFile);
final DataOutputStream os = new DataOutputStream(new FileOutputStream(myVersionFile));
try {
os.writeInt(version);
}
finally {
os.close();
}
}
catch (IOException ignored) {
}
}
public int getVersion() {
return version;
}
@Override
protected int enumerateString(@NotNull String s) throws IOException {
return myNamesEnumerator.enumerate(s);
}
@Override
protected int enumerateCompoundKey(@NotNull int[] key) throws IOException {
return myCompoundKeyEnumerator.enumerate(key);
}
private static class IntArrayKeyDescriptor implements KeyDescriptor<int[]>, DifferentSerializableBytesImplyNonEqualityPolicy {
@Override
public void save(@NotNull DataOutput out, int[] value) throws IOException {
DataInputOutputUtil.writeINT(out, value.length);
for (int i : value) {
DataInputOutputUtil.writeINT(out, i);
}
}
@Override
public int[] read(@NotNull DataInput in) throws IOException {
int[] value = new int[DataInputOutputUtil.readINT(in)];
for (int i = 0; i < value.length; i++) {
value[i] = DataInputOutputUtil.readINT(in);
}
return value;
}
@Override
public int getHashCode(int[] value) {
return Arrays.hashCode(value);
}
@Override
public boolean isEqual(int[] val1, int[] val2) {
return Arrays.equals(val1, val2);
}
}
private static class IntArrayPersistentEnumerator extends PersistentEnumeratorDelegate<int[]> {
private final CachingEnumerator<int[]> myCache;
public IntArrayPersistentEnumerator(File compoundKeysFile, IntArrayKeyDescriptor descriptor) throws IOException {
super(compoundKeysFile, descriptor, 1024 * 4);
myCache = new CachingEnumerator<int[]>(new DataEnumerator<int[]>() {
@Override
public int enumerate(@Nullable int[] value) throws IOException {
return IntArrayPersistentEnumerator.super.enumerate(value);
}
@Nullable
@Override
public int[] valueOf(int idx) throws IOException {
return IntArrayPersistentEnumerator.super.valueOf(idx);
}
}, descriptor);
}
@Override
public int enumerate(@Nullable int[] value) throws IOException {
return myCache.enumerate(value);
}
@Nullable
@Override
public int[] valueOf(int idx) throws IOException {
return myCache.valueOf(idx);
}
}
}
|
