com.google.gwt.dev.javac.CompilationErrorsIndexImpl Maven / Gradle / Ivy
/*
* Copyright 2014 Google Inc.
*
* 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.google.gwt.dev.javac;
import com.google.gwt.thirdparty.guava.common.base.Objects;
import com.google.gwt.thirdparty.guava.common.collect.HashMultimap;
import com.google.gwt.thirdparty.guava.common.collect.Maps;
import com.google.gwt.thirdparty.guava.common.collect.SetMultimap;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* A mutable and serializable CompilationErrorsIndex.
*
* JDT compilation errors for a current compile can be accumulated here, saved into libraries, and
* reloaded later from libraries to enable accurate and detailed compilation error cause traces.
*/
public class CompilationErrorsIndexImpl implements CompilationErrorsIndex, Serializable {
private static SetMultimap readStringListMap(ObjectInputStream objectInputStream)
throws IOException {
HashMultimap stringListMap = HashMultimap. create();
int keyCount = objectInputStream.readInt();
for (int i = 0; i < keyCount; i++) {
String key = objectInputStream.readUTF();
int listLength = objectInputStream.readInt();
for (int j = 0; j < listLength; j++) {
stringListMap.put(key, objectInputStream.readUTF());
}
}
return stringListMap;
}
private static Map readStringMap(ObjectInputStream objectInputStream)
throws IOException {
Map stringMap = Maps.newHashMap();
int fileNameMappingCount = objectInputStream.readInt();
for (int i = 0; i < fileNameMappingCount; i++) {
String typeSourceName = objectInputStream.readUTF();
String fileName = objectInputStream.readUTF();
stringMap.put(typeSourceName, fileName);
}
return stringMap;
}
private static void writeStringListMap(ObjectOutputStream objectOutputStream,
Map> stringMap) throws IOException {
objectOutputStream.writeInt(stringMap.size());
for (Entry> entry : stringMap.entrySet()) {
objectOutputStream.writeUTF(entry.getKey());
Collection strings = entry.getValue();
objectOutputStream.writeInt(strings.size());
for (String string : strings) {
objectOutputStream.writeUTF(string);
}
}
}
private static void writeStringMap(ObjectOutputStream objectOutputStream,
Map stringMap) throws IOException {
objectOutputStream.writeInt(stringMap.size());
for (Entry entry : stringMap.entrySet()) {
objectOutputStream.writeUTF(entry.getKey());
objectOutputStream.writeUTF(entry.getValue());
}
}
private SetMultimap compilationErrorsByTypeSourceName =
HashMultimap. create();
private Map fileNamesByTypeSourceName = Maps.newHashMap();
private SetMultimap referencesByTypeSourceName =
HashMultimap. create();
@Override
public void add(String typeSourceName, String fileName, List typeReferences,
List compilationErrors) {
fileNamesByTypeSourceName.put(typeSourceName, fileName);
compilationErrorsByTypeSourceName.putAll(typeSourceName, compilationErrors);
referencesByTypeSourceName.putAll(typeSourceName, typeReferences);
}
@Override
public boolean equals(Object object) {
if (object instanceof CompilationErrorsIndexImpl) {
CompilationErrorsIndexImpl that = (CompilationErrorsIndexImpl) object;
return
Objects.equal(this.fileNamesByTypeSourceName, that.fileNamesByTypeSourceName) && Objects
.equal(this.compilationErrorsByTypeSourceName, that.compilationErrorsByTypeSourceName)
&& Objects.equal(this.referencesByTypeSourceName, that.referencesByTypeSourceName);
}
return false;
}
@Override
public Set getCompileErrors(String typeSourceName) {
return compilationErrorsByTypeSourceName.get(typeSourceName);
}
@Override
public String getFileName(String typeSourceName) {
return fileNamesByTypeSourceName.get(typeSourceName);
}
@Override
public Set getTypeReferences(String typeSourceName) {
return referencesByTypeSourceName.get(typeSourceName);
}
@Override
public boolean hasCompileErrors(String typeSourceName) {
return compilationErrorsByTypeSourceName.containsKey(typeSourceName);
}
@Override
public int hashCode() {
return Objects.hashCode(fileNamesByTypeSourceName, compilationErrorsByTypeSourceName,
referencesByTypeSourceName);
}
@Override
public boolean hasTypeReferences(String typeSourceName) {
return referencesByTypeSourceName.containsKey(typeSourceName);
}
public void merge(CompilationErrorsIndexImpl that) {
for (String typeSourceName : that.fileNamesByTypeSourceName.keySet()) {
if (!this.fileNamesByTypeSourceName.containsKey(typeSourceName)) {
this.fileNamesByTypeSourceName.put(typeSourceName,
that.fileNamesByTypeSourceName.get(typeSourceName));
this.compilationErrorsByTypeSourceName.putAll(typeSourceName,
that.compilationErrorsByTypeSourceName.get(typeSourceName));
this.referencesByTypeSourceName.putAll(typeSourceName,
that.referencesByTypeSourceName.get(typeSourceName));
}
}
}
private void readObject(ObjectInputStream objectInputStream) throws IOException {
fileNamesByTypeSourceName = readStringMap(objectInputStream);
compilationErrorsByTypeSourceName = readStringListMap(objectInputStream);
referencesByTypeSourceName = readStringListMap(objectInputStream);
}
private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {
writeStringMap(objectOutputStream, fileNamesByTypeSourceName);
writeStringListMap(objectOutputStream, compilationErrorsByTypeSourceName.asMap());
writeStringListMap(objectOutputStream, referencesByTypeSourceName.asMap());
}
}