Java BuildMessage.Kind方法代码示例

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
public void outputLineAvailable(String line) {
  if (!StringUtil.isEmpty(line)) {
    if (line.startsWith(ExternalJavacManager.STDOUT_LINE_PREFIX)) {
      //noinspection UseOfSystemOutOrSystemErr
      System.out.println(line);
    }
    else if (line.startsWith(ExternalJavacManager.STDERR_LINE_PREFIX)) {
      //noinspection UseOfSystemOutOrSystemErr
      System.err.println(line);
    }
    else if (line.contains("java.lang.OutOfMemoryError")) {
      myContext.processMessage(new CompilerMessage(BUILDER_NAME, BuildMessage.Kind.ERROR, "OutOfMemoryError: insufficient memory"));
      myErrorCount++;
    }
    else {
      final BuildMessage.Kind kind = getKindByMessageText(line);
      if (kind == BuildMessage.Kind.ERROR) {
        myErrorCount++;
      }
      else if (kind == BuildMessage.Kind.WARNING) {
        myWarningCount++;
      }
      myContext.processMessage(new CompilerMessage(BUILDER_NAME, kind, line));
    }
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
public static void addMessages(@NotNull CompileContext context,
                               @NotNull Map<AndroidCompilerMessageKind, List<String>> messages,
                               @NotNull String builderName,
                               @NotNull String entryName) {
  for (Map.Entry<AndroidCompilerMessageKind, List<String>> entry : messages.entrySet()) {
    for (String message : entry.getValue()) {
      String filePath = null;
      int line = -1;
      final Matcher matcher = AndroidCommonUtils.COMPILER_MESSAGE_PATTERN.matcher(message);

      if (matcher.matches()) {
        filePath = matcher.group(1);
        line = Integer.parseInt(matcher.group(2));
      }
      final BuildMessage.Kind category = toBuildMessageKind(entry.getKey());
      if (category != null) {
        context.processMessage(
          new CompilerMessage(builderName, category, '[' + entryName + "] " + message, filePath, -1L, -1L, -1L, line, -1L));
      }
    }
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
private static void addMessages(@NotNull CompileContext context,
                                @NotNull Map<AndroidCompilerMessageKind, List<String>> messages,
                                @NotNull String sourcePath,
                                @NotNull String builderName) {
  for (Map.Entry<AndroidCompilerMessageKind, List<String>> entry : messages.entrySet()) {
    final AndroidCompilerMessageKind kind = entry.getKey();
    final BuildMessage.Kind buildMessageKind = AndroidJpsUtil.toBuildMessageKind(kind);

    if (buildMessageKind == null) {
      continue;
    }

    for (String message : entry.getValue()) {
      context.processMessage(new CompilerMessage(builderName, buildMessageKind, message, sourcePath));
    }
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
public void outputLineAvailable(String line) {
  if (!StringUtil.isEmpty(line)) {
    if (line.contains("java.lang.OutOfMemoryError")) {
      myContext.processMessage(new CompilerMessage(BUILDER_NAME, BuildMessage.Kind.ERROR, "OutOfMemoryError: insufficient memory"));
      myErrorCount++;
    }
    else {
      final BuildMessage.Kind kind = getKindByMessageText(line);
      if (kind == BuildMessage.Kind.ERROR) {
        myErrorCount++;
      }
      else if (kind == BuildMessage.Kind.WARNING) {
        myWarningCount++;
      }
      myContext.processMessage(new CompilerMessage(BUILDER_NAME, kind, line));
    }
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
private static BuildMessage.Kind getKindByMessageText(String line) {
  final String lowercasedLine = line.toLowerCase(Locale.US);
  if (lowercasedLine.contains("error") || lowercasedLine.contains("requires target release")) {
    return BuildMessage.Kind.ERROR;
  }
  return BuildMessage.Kind.INFO;
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
@Override
protected void lineAvailable(String line) {
  if (!StringUtil.isEmpty(line)) {
    BuildMessage.Kind kind = BuildMessage.Kind.INFO;
    if (line.contains("error")) {
      kind = BuildMessage.Kind.ERROR;
      myErrorsReported = true;
    }
    else if (line.contains("warning")) {
      kind = BuildMessage.Kind.WARNING;
    }
    myContext.processMessage(new CompilerMessage(myCompilerName, kind, line));
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
/**
 * Adapter method to create IDEA CompilerMessages from an Android build Message.
 *
 * If the Android build message has multiple source locations, this will create multiple CompilerMesssages with the same kind and
 * messageText, but different source positions.
 */
@NotNull
public static List<CompilerMessage> createCompilerMessages(@NotNull Message message) {
  final BuildMessage.Kind kind;
  switch (message.getKind()) {
    case INFO:
      kind = BuildMessage.Kind.INFO;
      break;
    case WARNING:
      kind = BuildMessage.Kind.WARNING;
      break;
    case ERROR:
      kind = BuildMessage.Kind.ERROR;
      break;
    default:
      kind = BuildMessage.Kind.PROGRESS;
  }
  List<CompilerMessage> compilerMessages = new ArrayList<CompilerMessage>();
  for (SourceFilePosition filePosition : message.getSourceFilePositions()) {
    File sourceFile = filePosition.getFile().getSourceFile();
    String sourceFilePath = sourceFile != null ? sourceFile.getAbsolutePath() : null;
    SourcePosition pos = filePosition.getPosition();
    compilerMessages.add(
      new CompilerMessage(COMPILER_NAME, kind, message.getText().trim(), sourceFilePath, pos.getStartOffset(), pos.getEndOffset(),
                          pos.getEndOffset(), pos.getEndLine(), pos.getEndColumn()));
  }
  return Collections.unmodifiableList(compilerMessages);
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
@Nullable
public static BuildMessage.Kind toBuildMessageKind(@NotNull AndroidCompilerMessageKind kind) {
  switch (kind) {
    case ERROR:
      return BuildMessage.Kind.ERROR;
    case INFORMATION:
      return BuildMessage.Kind.INFO;
    case WARNING:
      return BuildMessage.Kind.WARNING;
    default:
      LOG.error("unknown AndroidCompilerMessageKind object " + kind);
      return null;
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
private static BuildMessage.Kind toBuildMessageKind(IMergerLog.Severity severity) {
  if (severity == null) {
    return BuildMessage.Kind.INFO;
  }
  switch (severity) {
    case INFO:
      return BuildMessage.Kind.INFO;
    case WARNING:
      return BuildMessage.Kind.WARNING;
    case ERROR:
      return BuildMessage.Kind.ERROR;
    default:
      return BuildMessage.Kind.INFO;
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
@Override
public void processMessage(BuildMessage msg) {
  BuildMessage.Kind kind = msg.getKind();
  String text = msg.getMessageText();
  switch (kind) {
    case ERROR:
      String compilerName = msg instanceof CompilerMessage ? ((CompilerMessage)msg).getCompilerName() : "";
      myBuildInfoPrinter.printCompilationErrors(JpsGantProjectBuilder.this, compilerName, text);
      error("Compilation failed");
      break;
    case WARNING:
      warning(text);
      break;
    case INFO:
      if (!text.isEmpty()) {
        info(text);
      }
      break;
    case PROGRESS:
      if (msg instanceof BuildingTargetProgressMessage) {
        String targetsString = StringUtil.join(((BuildingTargetProgressMessage)msg).getTargets(),
                                               new NotNullFunction<BuildTarget<?>, String>() {
                                                 @NotNull
                                                 @Override
                                                 public String fun(BuildTarget<?> dom) {
                                                   return dom.getPresentableName();
                                                 }
                                               }, ",");
        switch (((BuildingTargetProgressMessage)msg).getEventType()) {
          case STARTED:
            myBuildInfoPrinter.printBlockOpenedMessage(JpsGantProjectBuilder.this, targetsString);
            break;
          case FINISHED:
            myBuildInfoPrinter.printBlockClosedMessage(JpsGantProjectBuilder.this, targetsString);
            break;
        }
      }
      break;
  }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
private static CompilerMessageCategory getMessageCategory(CompilerMessage compilerMessage) {
  BuildMessage.Kind category = compilerMessage.getKind();

  if (BuildMessage.Kind.ERROR.equals(category)) return CompilerMessageCategory.ERROR;
  if (BuildMessage.Kind.INFO.equals(category)) return CompilerMessageCategory.INFORMATION;
  if (BuildMessage.Kind.WARNING.equals(category)) return CompilerMessageCategory.WARNING;

  return CompilerMessageCategory.ERROR;
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
private void reportProblems(ProblemProvider problemProvider, CallGraph callGraph) {
    for (Problem problem : problemProvider.getProblems()) {
        BuildMessage.Kind kind;
        switch (problem.getSeverity()) {
            case ERROR:
                kind = BuildMessage.Kind.ERROR;
                break;
            case WARNING:
                kind = BuildMessage.Kind.WARNING;
                break;
            default:
                continue;
        }

        DefaultProblemTextConsumer textConsumer = new DefaultProblemTextConsumer();
        problem.render(textConsumer);
        String baseText = textConsumer.getText();

        List<ProblemToReport> problemsToReport = resolveProblemLocation(problem, callGraph);

        if (problemsToReport.isEmpty()) {
            context.processMessage(new CompilerMessage("TeaVM", kind, problem.getText(), null,
                    -1, -1, -1, -1, -1));
        }
        for (ProblemToReport problemToReport : problemsToReport) {
            String text = baseText + buildCallStack(problemToReport.locations);
            context.processMessage(new CompilerMessage("TeaVM", kind, text, problemToReport.path,
                    problemToReport.startOffset, problemToReport.endOffset, problemToReport.startOffset,
                    problemToReport.line, 0));
        }
    }
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
public static BuilderMessage createCompileMessage(final BuildMessage.Kind kind,
                                                                             String text,
                                                                             String path,
                                                                             long beginOffset, long endOffset, long offset, long line,
                                                                             long column, float done) {

  final BuilderMessage.CompileMessage.Builder builder = BuilderMessage.CompileMessage.newBuilder();
  switch (kind) {
    case ERROR:
      builder.setKind(BuilderMessage.CompileMessage.Kind.ERROR);
      break;
    case WARNING:
      builder.setKind(BuilderMessage.CompileMessage.Kind.WARNING);
      break;
    case INFO:
      builder.setKind(BuilderMessage.CompileMessage.Kind.INFO);
      break;
    default:
      builder.setKind(BuilderMessage.CompileMessage.Kind.PROGRESS);
  }
  if (text != null) {
    builder.setText(text);
  }
  if (path != null) {
    builder.setSourceFilePath(path);
  }
  if (beginOffset >= 0L) {
    builder.setProblemBeginOffset(beginOffset);
  }
  if (endOffset >= 0L) {
    builder.setProblemEndOffset(endOffset);
  }
  if (offset >= 0L) {
    builder.setProblemLocationOffset(offset);
  }
  if (line >= 0L) {
    builder.setLine(line);
  }
  if (column >= 0L) {
    builder.setColumn(column);
  }
  if (done >= 0.0f) {
    builder.setDone(done);
  }
  return BuilderMessage.newBuilder().setType(BuilderMessage.Type.COMPILE_MESSAGE).setCompileMessage(builder.build()).build();
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
@NotNull
public List<BuildMessage> getMessages(@NotNull BuildMessage.Kind kind) {
  if (kind == BuildMessage.Kind.ERROR) return myErrorMessages;
  else if (kind == BuildMessage.Kind.WARNING) return myWarnMessages;
  else return myInfoMessages;
}
 

import org.jetbrains.jps.incremental.messages.BuildMessage; //导入方法依赖的package包/类
@Override
public void processMessage(BuildMessage msg) {
  BuildMessage.Kind kind = msg.getKind();
  String text = msg.getMessageText();
  switch (kind) {
    case ERROR:
      String compilerName;
      String messageText;
      if (msg instanceof CompilerMessage) {
        CompilerMessage compilerMessage = (CompilerMessage)msg;
        compilerName = compilerMessage.getCompilerName();
        String sourcePath = compilerMessage.getSourcePath();
        if (sourcePath != null) {
          messageText = sourcePath + (compilerMessage.getLine() != -1 ? ":" + compilerMessage.getLine() : "") + ":\n" + text;
        }
        else {
          messageText = text;
        }
      }
      else {
        compilerName = "";
        messageText = text;
      }
      myFailed = true;
      myBuildInfoPrinter.printCompilationErrors(JpsGantProjectBuilder.this, compilerName, messageText);
      break;
    case WARNING:
      warning(text);
      break;
    case INFO:
      if (msg instanceof BuilderStatisticsMessage) {
        BuilderStatisticsMessage message = (BuilderStatisticsMessage)msg;
        String buildKind = myBuildIncrementally ? " (incremental)" : "";
        myBuildInfoPrinter.printStatisticsMessage(JpsGantProjectBuilder.this, "Compilation time '" + message.getBuilderName() + "'" + buildKind + ", ms",
                                                  String.valueOf(message.getElapsedTimeMs()));
        int sources = message.getNumberOfProcessedSources();
        myBuildInfoPrinter.printStatisticsMessage(JpsGantProjectBuilder.this, "Processed files by '" + message.getBuilderName() + "'" + buildKind,
                                                  String.valueOf(sources));
        if (!myBuildIncrementally && sources > 0) {
          myBuildInfoPrinter.printStatisticsMessage(JpsGantProjectBuilder.this, "Compilation time per file for '" + message.getBuilderName() + "', ms",
                                                    String.format(Locale.US, "%.2f", (double)message.getElapsedTimeMs() / sources));
        }
      }
      else if (!text.isEmpty()) {
        info(text);
      }
      break;
    case PROGRESS:
      if (msg instanceof BuildingTargetProgressMessage) {
        String targetsString = StringUtil.join(((BuildingTargetProgressMessage)msg).getTargets(),
                                               new NotNullFunction<BuildTarget<?>, String>() {
                                                 @NotNull
                                                 @Override
                                                 public String fun(BuildTarget<?> dom) {
                                                   return dom.getPresentableName();
                                                 }
                                               }, ",");
        switch (((BuildingTargetProgressMessage)msg).getEventType()) {
          case STARTED:
            myBuildInfoPrinter.printBlockOpenedMessage(JpsGantProjectBuilder.this, targetsString);
            break;
          case FINISHED:
            myBuildInfoPrinter.printBlockClosedMessage(JpsGantProjectBuilder.this, targetsString);
            break;
        }
      }
      break;
  }
}