com.google.errorprone.annotations.FormatString Java Examples

@FormatMethod
private void problem(
    Severity severity,
    int lineNumber,
    String filePath,
    @FormatString String detailMessage,
    Object... args) {
  String message = args.length == 0 ? detailMessage : String.format(detailMessage, args);
  problemsBySeverity.put(
      severity,
      String.format(
          "%s:%s:%s: %s",
          severity.getMessagePrefix(),
          filePath.substring(filePath.lastIndexOf('/') + 1),
          lineNumber,
          message));
}
 

/**
 * Sets the progress message. The string is lazily evaluated.
 *
 * @param progressMessage The message to display
 * @param subject0 Passed to {@link String#format}
 * @param subject1 Passed to {@link String#format}
 * @param subject2 Passed to {@link String#format}
 * @param subject3 Passed to {@link String#format}
 */
@FormatMethod
public Builder setProgressMessage(
    @FormatString String progressMessage,
    Object subject0,
    Object subject1,
    Object subject2,
    Object subject3) {
  return setProgressMessage(
      new LazyString() {
        @Override
        public String toString() {
          return String.format(progressMessage, subject0, subject1, subject2, subject3);
        }
      });
}
 

@FormatMethod
private void stepLog(
    Level level, @Nullable Throwable cause, @FormatString String fmt, Object... args) {
  String msg = String.format(fmt, args);
  String toLog = String.format("%s (#%d %s)", msg, id, desc());
  logger.at(level).withCause(cause).log(toLog);
}
 

/** Checks a condition or throw {@link EvalException}. */
@FormatMethod
public static void check(boolean condition, @FormatString String format, Object... args)
    throws EvalException {
  if (!condition) {
    throw Starlark.errorf(format, args);
  }
}
 

/**
 * Check a condition and throw {@link ValidationException} if false
 *
 * @throws ValidationException if {@code condition} is false
 */
@FormatMethod
public static void checkCondition(boolean condition, @FormatString String format, Object... args)
    throws ValidationException {
  if (!condition) {
    // Don't try to format if there is no args. This allows strings like '%Fooooo'¡
    if (args.length == 0) {
      throw new ValidationException(format);
    }
    throw new ValidationException(String.format(format, args));
  }
}
 

@FormatMethod
protected static void logCompose(
    final int depth, String methodName, @FormatString String format, Object... args) {

  // Compute indentation.
  char[] indentChars = new char[depth * 2];
  Arrays.fill(indentChars, ' ');
  String indent = new String(indentChars);

  // Log message.
  LogUtils.v(TAG, "%s%s() %s", indent, methodName, String.format(format, args));
}
 

@FormatMethod
private void logOrThrow(@FormatString String format, Object... parameters) {
  if (isDebug()) {
    throwError(format, parameters);
  } else {
    logError(format, parameters);
  }
}
 

@FormatMethod
public void trace(Throwable throwable, @FormatString String message, Object... args) {
    if (!isTraceEnabled()) {
        return;
    }
    kLogger.trace(format(message, args), throwable);
}
 

@FormatMethod
public void trace(@FormatString String message, Object... args) {
    if (!isTraceEnabled()) {
        return;
    }
    kLogger.trace(format(message, args));
}
 

@FormatMethod
public void debug(Throwable throwable, @FormatString String message, Object... args) {
    if (!isDebugEnabled()) {
        return;
    }
    kLogger.debug(format(message, args), throwable);
}
 

@FormatMethod
public void debug(@FormatString String message, Object... args) {
    if (!isDebugEnabled()) {
        return;
    }
    kLogger.debug(format(message, args));
}
 

@FormatMethod
private void logOrThrow(@FormatString String format, Object... parameters) {
  if (isDebug()) {
    throwError(format, parameters);
  } else {
    logError(format, parameters);
  }
}
 

/**
 * Helper method to print a debugging message, if the given {@link EventHandler} is not {@code
 * null}.
 */
@FormatMethod
private static void debugMessage(
    @Nullable EventHandler eventHandler, @FormatString String template, Object... args) {
  if (eventHandler == null) {
    return;
  }

  eventHandler.handle(Event.info("ToolchainResolution: " + String.format(template, args)));
}
 

/**
 * Sets the progress message. The string is lazily evaluated.
 *
 * @param progressMessage The message to display
 * @param subject Passed to {@link String#format}
 */
@FormatMethod
public Builder setProgressMessage(@FormatString String progressMessage, Object subject) {
  return setProgressMessage(
      new LazyString() {
        @Override
        public String toString() {
          return String.format(progressMessage, subject);
        }
      });
}
 

/**
 * Sets the progress message. The string is lazily evaluated.
 *
 * @param progressMessage The message to display
 * @param subject0 Passed to {@link String#format}
 * @param subject1 Passed to {@link String#format}
 */
@FormatMethod
public Builder setProgressMessage(
    @FormatString String progressMessage, Object subject0, Object subject1) {
  return setProgressMessage(
      new LazyString() {
        @Override
        public String toString() {
          return String.format(progressMessage, subject0, subject1);
        }
      });
}
 

@FormatMethod
private static String format(final @FormatString String message, final Object... arguments ) {
    final String messageToUse = message == null ? StringConstants.EMPTY_STRING : message;
    if (arguments == null || arguments.length == 0) {
        return messageToUse;
    }
    return String.format(messageToUse, arguments);
}
 

/**
 * Sets the progress message. The string is lazily evaluated.
 *
 * @param progressMessage The message to display
 * @param subject0 Passed to {@link String#format}
 * @param subject1 Passed to {@link String#format}
 * @param subject2 Passed to {@link String#format}
 */
@FormatMethod
public Builder setProgressMessage(
    @FormatString String progressMessage, Object subject0, Object subject1, Object subject2) {
  return setProgressMessage(
      new LazyString() {
        @Override
        public String toString() {
          return String.format(progressMessage, subject0, subject1, subject2);
        }
      });
}
 

/** Calls {@link String#format} at command line expansion time. */
@FormatMethod
public Builder addFormatted(@FormatString String formatStr, Object... args) {
  Preconditions.checkNotNull(formatStr);
  FormatArg.push(arguments, formatStr, args);
  return this;
}
 

@FormatMethod
public MoeProblem(Throwable cause, @FormatString String explanationFmt, Object... args) {
  super(cause); // TODO(cgruber) do we need to lazily format? Could we not just format at constr?
  this.explanationFmt = explanationFmt;
  this.args = args;
}
 

@FormatMethod
public MoeProblem(@FormatString String explanationFmt, Object... args) {
  this.explanationFmt = explanationFmt;
  this.args = args;
}
 

@FormatMethod
protected void failWithMessage(@FormatString String message, Object... args) {
  failWithoutActual(
      Fact.simpleFact(
          "Not true that " + internalCustomName() + " " + String.format(message, args)));
}
 

@FormatMethod
public CodebaseCreationError(@FormatString String message, Object... args) {
  super(String.format(message, args));
}
 

@FormatMethod
public CodebaseCreationError(Throwable cause, @FormatString String message, Object... args) {
  super(String.format(message, args), cause);
}
 

@FormatMethod
private void stepLog(Level level, @FormatString String fmt, Object... args) {
  stepLog(level, /*cause=*/ null, fmt, args);
}
 

@FormatMethod
SerializationProcessingFailedException(
    Element element, @FormatString String fmt, Object... args) {
  super(String.format(fmt, args));
  this.element = element;
}
 

@FormatMethod
private void validate(boolean condition, @FormatString String message, Object... args) {
  if (!condition) {
    throw InvalidBundleException.builder().withUserMessage(message, args).build();
  }
}
 

@FormatMethod
private static void logError(String functionName, @FormatString String format, Object... args) {
  LogUtils.e(TAG, functionName + "() " + String.format(format, args));
}
 

@FormatMethod
protected void throwError(@FormatString String format, Object... parameters) {
  throw new IllegalStateException(String.format(format, parameters));
}
 

@FormatMethod
protected void throwError(@FormatString String format, Object... parameters) {
  throw new IllegalStateException(String.format(format, parameters));
}
 

@FormatMethod
public void error(
    int lineNumber, String filePath, @FormatString String detailMessage, Object... args) {
  problem(Severity.ERROR, lineNumber, filePath, detailMessage, args);
}