package com.intellij.lang.javascript.flex.build;
import com.intellij.openapi.compiler.CompileContext;
import com.intellij.openapi.compiler.CompilerMessageCategory;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class CompilerMessagesBuffer {
private static class CompilerMessage {
private final CompilerMessageCategory category;
private final String message;
private final String url;
private final int line;
private final int column;
private CompilerMessage(final CompilerMessageCategory category,
final String message,
final String url,
final int line,
final int column) {
this.category = category;
this.message = message;
this.url = url;
this.line = line;
this.column = column;
}
}
private final List<CompilerMessage> messages;
private final CompileContext compileContext;
private boolean bufferingEnabled;
private static final String OUT_OF_MEMORY = "java.lang.OutOfMemoryError";
/**
* @param bufferingEnabled is <code>false</code> then this buffer doen't buffer anything but just passes all messages to CompilerContext
*/
public CompilerMessagesBuffer(final @Nullable CompileContext compileContext, final boolean bufferingEnabled) {
this.compileContext = compileContext;
this.bufferingEnabled = bufferingEnabled;
messages = bufferingEnabled ? Collections.synchronizedList(new ArrayList<CompilerMessage>()) : null;
}
public void addMessage(final CompilerMessageCategory category, final String message, final String url, final int line, final int column) {
if (bufferingEnabled) {
messages.add(new CompilerMessage(category, message, url, line, column));
}
else if (compileContext != null) {
compileContext.addMessage(category, message, url, line, column);
}
}
public void flush() {
if (bufferingEnabled && compileContext != null) {
synchronized (messages) {
for (final CompilerMessage message : messages) {
compileContext.addMessage(message.category, message.message, message.url, message.line, message.column);
}
}
}
}
/**
* This method may be called only if buffering is enabled.
*/
public boolean containsErrors() {
if (!bufferingEnabled) {
throw new IllegalStateException();
}
synchronized (messages) {
for (final CompilerMessage message : messages) {
if (message.category == CompilerMessageCategory.ERROR) {
return true;
}
}
}
return false;
}
/**
* This method may be called only if buffering is enabled.
*/
public boolean containsOutOfMemoryError() {
if (!bufferingEnabled) {
throw new IllegalStateException();
}
synchronized (messages) {
for (final CompilerMessage message : messages) {
if (message.message.indexOf(OUT_OF_MEMORY) != -1) {
return true;
}
}
}
return false;
}
public void removeErrorsAndStackTrace() {
if (bufferingEnabled) {
synchronized (messages) {
final Iterator<CompilerMessage> iterator = messages.iterator();
while (iterator.hasNext()) {
CompilerMessage message = iterator.next();
if (message.category == CompilerMessageCategory.ERROR) {
iterator.remove();
}
else if (isStackTrace(message.message)) {
iterator.remove();
}
}
}
}
}
private static boolean isStackTrace(final String message) {
return message.startsWith("\tat ") || message.startsWith(OUT_OF_MEMORY);
}
}