java.util.FormattableFlags Java Examples

/**
 * Returns a string representation of the user supplied formattable, accounting for any possible
 * runtime exceptions.
 *
 * @param value the value to be formatted.
 * @return a best-effort string representation of the given value, even if exceptions were thrown.
 */
private static void safeFormatTo(Formattable value, StringBuilder out, FormatOptions options) {
  // Only care about 3 specific flags for Formattable.
  int formatFlags = options.getFlags() & (FLAG_LEFT_ALIGN | FLAG_UPPER_CASE | FLAG_SHOW_ALT_FORM);
  if (formatFlags != 0) {
    // TODO: Maybe re-order the options flags to make this step easier or use a lookup table.
    // Note that reordering flags would require a rethink of how they are parsed.
    formatFlags = ((formatFlags & FLAG_LEFT_ALIGN) != 0 ? FormattableFlags.LEFT_JUSTIFY : 0)
        | ((formatFlags & FLAG_UPPER_CASE) != 0 ? FormattableFlags.UPPERCASE : 0)
        | ((formatFlags & FLAG_SHOW_ALT_FORM) != 0 ? FormattableFlags.ALTERNATE : 0);
  }
  // We may need to undo an arbitrary amount of appending if there is an error.
  int originalLength = out.length();
  Formatter formatter = new Formatter(out, FORMAT_LOCALE);
  try {
    value.formatTo(formatter, formatFlags, options.getWidth(), options.getPrecision());
  } catch (RuntimeException e) {
    out.setLength(originalLength);
    // We only use a StringBuilder to create the Formatter instance.
    try {
      formatter.out().append(getErrorString(value, e));
    } catch (IOException impossible) { }
  }
}
 

@Override
public void writeTo(final Formatter f, final Object aValueToWrite, final Appendable aOut) throws IOException {
    if (aValueToWrite == null) {
        if ((flags & FormattableFlags.UPPERCASE) > 0) {
            aOut.append("NULL");
        } else {
            aOut.append("null");
        }
    } else if (aValueToWrite instanceof Boolean) {
        if ((flags & FormattableFlags.UPPERCASE) > 0) {
            aOut.append(String.valueOf(((Boolean) aValueToWrite).booleanValue()).toUpperCase());
        } else {
            aOut.append(String.valueOf(((Boolean) aValueToWrite).booleanValue()));
        }
    } else {
        if ((flags & FormattableFlags.UPPERCASE) > 0) {
            aOut.append("true");
        } else {
            aOut.append("true");
        }
    }
}
 

@Override
public void writeTo(final Formatter f, final Object aValueToWrite, final Appendable aOut) throws IOException {
    if (aValueToWrite == null) {
        if ((flags & FormattableFlags.UPPERCASE) > 0) {
            aOut.append("NULL");
        } else {
            aOut.append("null");
        }
    } else if (aValueToWrite instanceof Formattable) {
        final Formattable formattable = (Formattable) aValueToWrite;

        formattable.formatTo(f, flags, width, precision);
    } else {
        if ((flags & FormattableFlags.UPPERCASE) > 0) {
            aOut.append(aValueToWrite.toString().toUpperCase());
        } else {
            aOut.append(aValueToWrite.toString());
        }
    }
}
 

@Override
public void formatTo(Formatter formatter, int flags, int width, int precision) {
    final boolean alt = (flags & FormattableFlags.ALTERNATE) == FormattableFlags.ALTERNATE;
    final boolean upper = (flags & FormattableFlags.UPPERCASE) == FormattableFlags.UPPERCASE;
    final boolean leftJustified = (flags & FormattableFlags.LEFT_JUSTIFY) == FormattableFlags.LEFT_JUSTIFY;

    String out;
    if (!alt) {
        out = getAsMention();
    } else if (upper) {
        out = getAsTag().toUpperCase();
    } else {
        out = getAsTag();
    }

    MiscUtil.appendTo(formatter, width, precision, leftJustified, out);
}
 

@Override
public void formatTo(Formatter formatter, int flags, int width, int precision)
{
    boolean alt = (flags & FormattableFlags.ALTERNATE) == FormattableFlags.ALTERNATE;
    boolean upper = (flags & FormattableFlags.UPPERCASE) == FormattableFlags.UPPERCASE;
    boolean leftJustified = (flags & FormattableFlags.LEFT_JUSTIFY) == FormattableFlags.LEFT_JUSTIFY;

    String out;
    if (!alt)
        out = getAsMention();
    else if (upper)
        out = getAsTag().toUpperCase();
    else
        out = getAsTag();

    MiscUtil.appendTo(formatter, width, precision, leftJustified, out);
}
 

@Override
default void formatTo(Formatter formatter, int flags, int width, int precision) {
    boolean alternate = (flags & FormattableFlags.ALTERNATE) != 0;
    String representation = alternate ? this.toString() : this.getName();
    boolean uppercase = (flags & FormattableFlags.UPPERCASE) != 0;
    boolean leftAlign = (flags & FormattableFlags.LEFT_JUSTIFY) != 0;
    boolean doPad = representation.length() < width;
    String padString = null;

    if (doPad) {
        char[] spaces = new char[width - representation.length()];
        Arrays.fill(spaces, ' ');
        padString = new String(spaces);
    }

    try {
        if (doPad && !leftAlign) {
            formatter.out().append(padString);
        }

        formatter.out().append(uppercase ? representation.toUpperCase() : representation);

        if (doPad && leftAlign) {
            formatter.out().append(padString);
        }
    } catch (IOException e) {
        ExceptionLogger.getConsumer().accept(e);
    }
}
 

@Override
default void formatTo(Formatter formatter, int flags, int width, int precision) {
    boolean alternate = (flags & FormattableFlags.ALTERNATE) != 0;
    String representation = alternate ? this.toString() : this.getName();
    boolean uppercase = (flags & FormattableFlags.UPPERCASE) != 0;
    boolean leftAlign = (flags & FormattableFlags.LEFT_JUSTIFY) != 0;
    boolean doPad = representation.length() < width;
    String padString = null;

    if (doPad) {
        char[] spaces = new char[width - representation.length()];
        Arrays.fill(spaces, ' ');
        padString = new String(spaces);
    }

    try {
        if (doPad && !leftAlign) {
            formatter.out().append(padString);
        }

        formatter.out().append(uppercase ? representation.toUpperCase() : representation);

        if (doPad && leftAlign) {
            formatter.out().append(padString);
        }
    } catch (IOException e) {
        ExceptionLogger.getConsumer().accept(e);
    }
}
 

@Override
default void formatTo(Formatter formatter, int flags, int width, int precision)
{
    boolean leftJustified = (flags & FormattableFlags.LEFT_JUSTIFY) == FormattableFlags.LEFT_JUSTIFY;
    boolean upper = (flags & FormattableFlags.UPPERCASE) == FormattableFlags.UPPERCASE;
    String out = upper ? getAsMention().toUpperCase(formatter.locale()) : getAsMention();

    MiscUtil.appendTo(formatter, width, precision, leftJustified, out);
}
 

@Override
default void formatTo(Formatter formatter, int flags, int width, int precision)
{
    boolean leftJustified = (flags & FormattableFlags.LEFT_JUSTIFY) == FormattableFlags.LEFT_JUSTIFY;
    boolean upper = (flags & FormattableFlags.UPPERCASE) == FormattableFlags.UPPERCASE;
    boolean alt = (flags & FormattableFlags.ALTERNATE) == FormattableFlags.ALTERNATE;
    String out;

    if (alt)
        out = "#" + (upper ? getName().toUpperCase(formatter.locale()) : getName());
    else
        out = getAsMention();

    MiscUtil.appendTo(formatter, width, precision, leftJustified, out);
}
 

@Override
public void formatTo(Formatter formatter, int flags, int width, int precision)
{
    boolean upper = (flags & FormattableFlags.UPPERCASE) == FormattableFlags.UPPERCASE;
    boolean leftJustified = (flags & FormattableFlags.LEFT_JUSTIFY) == FormattableFlags.LEFT_JUSTIFY;

    String out = content;

    if (upper)
        out = out.toUpperCase(formatter.locale());

    appendFormat(formatter, width, precision, leftJustified, out);
}
 

/**
 * Returns a {@link Formattable} object that can be used with {@link String#format(String, Object...)}.
 * <p>
 * When used as the argument for a {@literal %s} format string element, the {@literal bytes} value
 * will be formatted using the current {@link ByteSizeStrings} values, or if the alternative
 * flag is set (using the {@literal %#s} format string) it will use the {@link ByteSizeStrings#metric()}
 * formatter. Finally, the precision of the formatted value can be adjusted using format string
 * argumenbts like {@literal %.6s}.
 *
 * @see http://docs.oracle.com/javase/7/docs/api/java/util/Formatter.html#syntax
 */
public Formattable formatted(final long bytes) {
    return new Formattable() {
        @Override
        public void formatTo(Formatter formatter, int flags, int width, int precision) {
            boolean alternate = (flags & FormattableFlags.ALTERNATE) == FormattableFlags.ALTERNATE;
            ByteSizeStrings strings = alternate ? ByteSizeStrings.metric() : ByteSizeStrings.this;
            if (precision != -1) {
                formatter.format("%s", strings.makeSizeString(bytes, precision));
            } else {
                formatter.format("%s", strings.makeSizeString(bytes));
            }
        }
    };
}
 

public void formatTo(Formatter formatter, int flags, int width,
        int precision) throws IllegalFormatException {
    if ((flags & FormattableFlags.UPPERCASE) != 0) {
        formatter.format("CUSTOMIZED FORMAT FUNCTION" + " WIDTH: "
                + width + " PRECISION: " + precision);
    } else {
        formatter.format("customized format function" + " width: "
                + width + " precision: " + precision);
    }
}
 

/**
 * Formats the given character sequence to the given formatter. This method takes in account
 * the {@link FormattableFlags#UPPERCASE} and {@link FormattableFlags#LEFT_JUSTIFY} flags.
 *
 * @param formatter  the formatter in which to format the value.
 * @param flags      the formatting flags.
 * @param width      minimal number of characters to write, padding with {@code ' '} if necessary.
 * @param precision  number of characters to keep before truncation, or -1 if no limit.
 * @param value      the text to format.
 */
public static void formatTo(final Formatter formatter, final int flags, int width, int precision, String value) {
    /*
     * Converting to upper cases may change the string length in some locales.
     * So we need to perform this conversion before to check the length.
     */
    boolean isUpperCase = (flags & FormattableFlags.UPPERCASE) != 0;
    if (isUpperCase && (width > 0 || precision >= 0)) {
        value = value.toUpperCase(formatter.locale());
        isUpperCase = false;                            // Because conversion has already been done.
    }
    /*
     * If the string is longer than the specified "precision", truncate
     * and add "…" for letting user know that there is missing characters.
     * This loop counts the number of Unicode code points rather than characters.
     */
    int length = value.length();
    if (precision >= 0) {
        for (int i=0,n=0; i<length; i += n) {
            if (--precision < 0) {
                /*
                 * Found the amount of characters to keep. The 'n' variable can be
                 * zero only if precision == 0, in which case the string is empty.
                 */
                if (n == 0) {
                    value = "";
                } else {
                    length = (i -= n) + 1;
                    final StringBuilder buffer = new StringBuilder(length);
                    value = buffer.append(value, 0, i).append('…').toString();
                }
                break;
            }
            n = Character.charCount(value.codePointAt(i));
        }
    }
    /*
     * If the string is shorter than the minimal width, add spaces on the left or right side.
     * We double check with `width > length` since it is faster than codePointCount(…).
     */
    final String format;
    final Object[] args;
    if (width > length && (width -= value.codePointCount(0, length)) > 0) {
        format = "%s%s";
        args = new Object[] {value, value};
        args[(flags & FormattableFlags.LEFT_JUSTIFY) != 0 ? 1 : 0] = CharSequences.spaces(width);
    } else {
        format = isUpperCase ? "%S" : "%s";
        args = new Object[] {value};
    }
    formatter.format(format, args);
}
 

public void test_ConstantFieldValues() {
    assertEquals(1, FormattableFlags.LEFT_JUSTIFY);
    assertEquals(2, FormattableFlags.UPPERCASE);
    assertEquals(4, FormattableFlags.ALTERNATE);
}
 

FormatSpecifier parseFormatSpecifier() {
    final FormatSpecifier spec = new FormatSpecifier();
    char c = pattern.charAt(parsePosition);
    int width = -1;
    int precision = -1;
    int flags = 0;
    boolean hasWidth = false;
    handler: while (true) {
        if (Character.isDigit(c)) {
            final int startPosition = parsePosition;
            while (Character.isDigit(c)) {
                parsePosition++;
                c = pattern.charAt(parsePosition);
            }
            if (c == '$') {
                spec.valueIndex = Integer.parseInt(pattern.substring(startPosition, parsePosition)) - 1;
            } else if (!hasWidth) {
                width = Integer.parseInt(pattern.substring(startPosition, parsePosition));
                hasWidth = true;
            } else if (precision == -1) {
                precision = Integer.parseInt(pattern.substring(startPosition, parsePosition));
            } else {
                throw new IllegalStateException(pattern);
            }
        }
        switch (c) {
            case '.':
                hasWidth = true;
                break;
            case 'b':
                spec.conversion = new BooleanConversion(width, precision, flags);
                parsePosition++;
                break handler;
            case 'B':
                spec.conversion = new BooleanConversion(width, precision, flags | FormattableFlags.UPPERCASE);
                parsePosition++;
                break handler;
            case 'h':
                throw new IllegalArgumentException(pattern);
            case 'H':
                throw new IllegalArgumentException(pattern);
            case 's':
                spec.conversion = new StringConversion(width, precision, flags);
                parsePosition++;
                break handler;
            case 'S':
                spec.conversion = new StringConversion(width, precision, flags | FormattableFlags.UPPERCASE);
                parsePosition++;
                break handler;
            case '%':
                spec.conversion = new PercentConversion(width, precision, flags);
                parsePosition++;
                break handler;
            case 'n':
                spec.conversion = new LinefeedConversion(width, precision, flags);
                parsePosition++;
                break handler;
            case 'c':
            case 'C':
            case 'd':
            case 'o':
            case 'x':
            case 'X':
            case 'e':
            case 'E':
            case 'f':
            case 'g':
            case 'G':
            case 'a':
            case 'A':
                throw new IllegalArgumentException(pattern);
            case 't':
            case 'T':
                throw new IllegalArgumentException(pattern);
        }
        parsePosition++;
        c = pattern.charAt(parsePosition);
    }

    if (spec.valueIndex == -1) {
        spec.valueIndex = valueIndex;
    }
    return spec;
}
 

/**
 * Formats the name or identifier of this object using the provider formatter.
 * This method is invoked when an {@code IdentifiedObject} object is formatted
 * using the {@code "%s"} conversion specifier of {@link java.util.Formatter}.
 * Users don't need to invoke this method explicitly.
 *
 * <p>If the alternate flags is present (as in {@code "%#s"}), then this method
 * will format the identifier (if present) instead than the object name.</p>
 *
 * @param  formatter  the formatter in which to format this identified object.
 * @param  flags      whether to apply left alignment, use upper-case letters and/or use alternate form.
 * @param  width      minimal number of characters to write, padding with {@code ' '} if necessary.
 * @param  precision  maximal number of characters to write, or -1 if no limit.
 *
 * @see IdentifiedObjects#getName(IdentifiedObject, Citation)
 * @see IdentifiedObjects#getIdentifierOrName(IdentifiedObject)
 *
 * @since 1.1
 */
@Override
public void formatTo(final java.util.Formatter formatter, final int flags, final int width, final int precision) {
    final String value;
    if ((flags & FormattableFlags.ALTERNATE) != 0) {
        value = IdentifiedObjects.getIdentifierOrName(this);
    } else {
        value = IdentifiedObjects.getName(this, null);
    }
    Strings.formatTo(formatter, flags, width, precision, value);
}
 

/**
 * Formats this range using the provider formatter. This method is invoked when a
 * {@code Range} object is formatted using the {@code "%s"} conversion specifier of
 * {@link Formatter}. Users don't need to invoke this method explicitly.
 *
 * <p>If the alternate flags is present (as in {@code "%#s"}), then the range will
 * be formatted using the {@linkplain RangeFormat#isAlternateForm() alternate form}
 * for exclusive bounds.</p>
 *
 * @param  formatter  the formatter in which to format this range.
 * @param  flags      {@link FormattableFlags#LEFT_JUSTIFY} for left alignment, or 0 for right alignment.
 * @param  width      minimal number of characters to write, padding with {@code ' '} if necessary.
 * @param  precision  maximal number of characters to write, or -1 if no limit.
 */
@Override
public void formatTo(final Formatter formatter, final int flags, final int width, int precision) {
    final String value;
    if (precision == 0) {
        value = "";
    } else {
        final RangeFormat format = new RangeFormat(formatter.locale(), elementType);
        format.setAlternateForm((flags & FormattableFlags.ALTERNATE) != 0);
        value = format.format(this, new StringBuffer(), null).toString();
    }
    Strings.formatTo(formatter, flags, width, precision, value);
}