MessageFormat provides a means to produce concatenated
+ * messages in a language-neutral way. Use this to construct messages
+ * displayed for end users.
+ *
+ *
+ * MessageFormat takes a set of objects, formats them, then
+ * inserts the formatted strings into the pattern at the appropriate places.
+ *
+ *
+ * Note:
+ * MessageFormat differs from the other Format
+ * classes in that you create a MessageFormat object with one
+ * of its constructors (not with a getInstance style factory
+ * method). The factory methods aren't necessary because MessageFormat
+ * itself doesn't implement locale specific behavior. Any locale specific
+ * behavior is defined by the pattern that you provide as well as the
+ * subformats used for inserted arguments.
+ *
+ *
MessageFormat uses patterns of the following form:
+ *
+ * MessageFormatPattern:
+ * String
+ * MessageFormatPattern FormatElement String
+ *
+ * FormatElement:
+ * { ArgumentIndex }
+ * { ArgumentIndex , FormatType }
+ * { ArgumentIndex , FormatType , FormatStyle }
+ *
+ * FormatType: one of
+ * number date time choice
+ *
+ * FormatStyle:
+ * short
+ * medium
+ * long
+ * full
+ * integer
+ * currency
+ * percent
+ * SubformatPattern
+ * Within a String, a pair of single quotes can be used to
+ * quote any arbitrary characters except single quotes. For example,
+ * pattern string "'{0}'" represents string
+ * "{0}", not a FormatElement. A single quote itself
+ * must be represented by doubled single quotes {@code ''} throughout a
+ * String. For example, pattern string "'{''}'" is
+ * interpreted as a sequence of '{ (start of quoting and a
+ * left curly brace), '' (a single quote), and
+ * }' (a right curly brace and end of quoting),
+ * not '{' and '}' (quoted left and
+ * right curly braces): representing string "{'}",
+ * not "{}".
+ *
+ *
A SubformatPattern is interpreted by its corresponding
+ * subformat, and subformat-dependent pattern rules apply. For example,
+ * pattern string "{1,number,$'#',##}"
+ * (SubformatPattern with underline) will produce a number format
+ * with the pound-sign quoted, with a result such as: {@code
+ * "$#31,45"}. Refer to each {@code Format} subclass documentation for
+ * details.
+ *
+ *
Any unmatched quote is treated as closed at the end of the given + * pattern. For example, pattern string {@code "'{0}"} is treated as + * pattern {@code "'{0}'"}. + * + *
Any curly braces within an unquoted pattern must be balanced. For
+ * example, "ab {0} de" and "ab '}' de" are
+ * valid patterns, but "ab {0'}' de", "ab } de"
+ * and "''{''" are not.
+ *
+ *
+ *
+ * The ArgumentIndex value is a non-negative integer written + * using the digits {@code '0'} through {@code '9'}, and represents an index into the + * {@code arguments} array passed to the {@code format} methods + * or the result array returned by the {@code parse} methods. + *
+ * The FormatType and FormatStyle values are used to create + * a {@code Format} instance for the format element. The following + * table shows how the values map to {@code Format} instances. Combinations not + * shown in the table are illegal. A SubformatPattern must + * be a valid pattern string for the {@code Format} subclass used. + *
+ *
| FormatType + * | FormatStyle + * | Subformat Created + * |
|---|---|---|
| (none) + * | (none) + * | null
+ * |
number
+ * | (none) + * | {@link NumberFormat#getInstance(Locale) NumberFormat.getInstance}{@code (getLocale())} + * |
integer
+ * | {@link NumberFormat#getIntegerInstance(Locale) NumberFormat.getIntegerInstance}{@code (getLocale())} + * | |
currency
+ * | {@link NumberFormat#getCurrencyInstance(Locale) NumberFormat.getCurrencyInstance}{@code (getLocale())} + * | |
percent
+ * | {@link NumberFormat#getPercentInstance(Locale) NumberFormat.getPercentInstance}{@code (getLocale())} + * | |
| SubformatPattern + * | {@code new} {@link DecimalFormat#DecimalFormat(String,DecimalFormatSymbols) DecimalFormat}{@code (subformatPattern,} {@link DecimalFormatSymbols#getInstance(Locale) DecimalFormatSymbols.getInstance}{@code (getLocale()))} + * | |
date
+ * | (none) + * | {@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} + * |
short
+ * | {@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#SHORT}{@code , getLocale())} + * | |
medium
+ * | {@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} + * | |
long
+ * | {@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#LONG}{@code , getLocale())} + * | |
full
+ * | {@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#FULL}{@code , getLocale())} + * | |
| SubformatPattern + * | {@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())} + * | |
time
+ * | (none) + * | {@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} + * |
short
+ * | {@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#SHORT}{@code , getLocale())} + * | |
medium
+ * | {@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} + * | |
long
+ * | {@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#LONG}{@code , getLocale())} + * | |
full
+ * | {@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#FULL}{@code , getLocale())} + * | |
| SubformatPattern + * | {@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())} + * | |
choice
+ * | SubformatPattern + * | {@code new} {@link ChoiceFormat#ChoiceFormat(String) ChoiceFormat}{@code (subformatPattern)} + * |
+ * + *
+ * Here are some examples of usage. + * In real internationalized programs, the message format pattern and other + * static strings will, of course, be obtained from resource bundles. + * Other parameters will be dynamically determined at runtime. + *
+ * The first example uses the static method MessageFormat.format,
+ * which internally creates a MessageFormat for one-time use:
+ *
+ * int planet = 7;
+ * String event = "a disturbance in the Force";
+ *
+ * String result = MessageFormat.format(
+ * "At {1,time} on {1,date}, there was {2} on planet {0,number,integer}.",
+ * planet, new Date(), event);
+ * + * + *+ * At 12:30 PM on Jul 3, 2053, there was a disturbance in the Force on planet 7. + *
+ * The following example creates a MessageFormat instance that
+ * can be used repeatedly:
+ *
+ * int fileCount = 1273;
+ * String diskName = "MyDisk";
+ * Object[] testArgs = {new Long(fileCount), diskName};
+ *
+ * MessageFormat form = new MessageFormat(
+ * "The disk \"{1}\" contains {0} file(s).");
+ *
+ * System.out.println(form.format(testArgs));
+ * fileCount:
+ * + * + *+ * The disk "MyDisk" contains 0 file(s). + * The disk "MyDisk" contains 1 file(s). + * The disk "MyDisk" contains 1,273 file(s). + *
+ * For more sophisticated patterns, you can use a ChoiceFormat
+ * to produce correct forms for singular and plural:
+ *
+ * MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0}.");
+ * double[] filelimits = {0,1,2};
+ * String[] filepart = {"no files","one file","{0,number} files"};
+ * ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
+ * form.setFormatByArgumentIndex(0, fileform);
+ *
+ * int fileCount = 1273;
+ * String diskName = "MyDisk";
+ * Object[] testArgs = {new Long(fileCount), diskName};
+ *
+ * System.out.println(form.format(testArgs));
+ * fileCount:
+ * + * + *+ * The disk "MyDisk" contains no files. + * The disk "MyDisk" contains one file. + * The disk "MyDisk" contains 1,273 files. + *
+ * You can create the ChoiceFormat programmatically, as in the
+ * above example, or by using a pattern. See {@link ChoiceFormat}
+ * for more information.
+ *
+ * form.applyPattern(
+ * "There {0,choice,0#are no files|1#is one file|1<are {0,number,integer} files}.");
+ *
+ * Note: As we see above, the string produced
+ * by a ChoiceFormat in MessageFormat is treated as special;
+ * occurrences of '{' are used to indicate subformats, and cause recursion.
+ * If you create both a MessageFormat and ChoiceFormat
+ * programmatically (instead of using the string patterns), then be careful not to
+ * produce a format that recurses on itself, which will cause an infinite loop.
+ *
+ * When a single argument is parsed more than once in the string, the last match + * will be the final result of the parsing. For example, + *
+ * MessageFormat mf = new MessageFormat("{0,number,#.##}, {0,number,#.#}");
+ * Object[] objs = {new Double(3.1415)};
+ * String result = mf.format( objs );
+ * // result now equals "3.14, 3.1"
+ * objs = null;
+ * objs = mf.parse(result, new ParsePosition(0));
+ * // objs now equals {new Double(3.1)}
+ * + * Likewise, parsing with a {@code MessageFormat} object using patterns containing + * multiple occurrences of the same argument would return the last match. For + * example, + *
+ * MessageFormat mf = new MessageFormat("{0}, {0}, {0}");
+ * String forParsing = "x, y, z";
+ * Object[] objs = mf.parse(forParsing, new ParsePosition(0));
+ * // result now equals {new String("z")}
+ * + * Message formats are not synchronized. + * It is recommended to create separate format instances for each thread. + * If multiple threads access a format concurrently, it must be synchronized + * externally. + * + * @see java.util.Locale + * @see Format + * @see NumberFormat + * @see DecimalFormat + * @see DecimalFormatSymbols + * @see ChoiceFormat + * @see DateFormat + * @see SimpleDateFormat + * + * @author Mark Davis + */ + +public class MessageFormat extends Format { + + private static final long serialVersionUID = 6479157306784022952L; + + /** + * Constructs a MessageFormat for the default locale and the + * specified pattern. + * The constructor first sets the locale, then parses the pattern and + * creates a list of subformats for the format elements contained in it. + * Patterns and their interpretation are specified in the + * class description. + * + * @param pattern the pattern for this message format + * @exception IllegalArgumentException if the pattern is invalid + */ + public MessageFormat(String pattern) { + this.locale = Locale.getDefault(Locale.Category.FORMAT); + applyPattern(pattern); + } + + /** + * Constructs a MessageFormat for the specified locale and + * pattern. + * The constructor first sets the locale, then parses the pattern and + * creates a list of subformats for the format elements contained in it. + * Patterns and their interpretation are specified in the + * class description. + * + * @param pattern the pattern for this message format + * @param locale the locale for this message format + * @exception IllegalArgumentException if the pattern is invalid + * @since 1.4 + */ + public MessageFormat(String pattern, Locale locale) { + this.locale = locale; + applyPattern(pattern); + } + + /** + * Sets the locale to be used when creating or comparing subformats. + * This affects subsequent calls + *
applyPattern method, as well as
+ * format and
+ * {@link #formatToCharacterIterator formatToCharacterIterator} methods
+ * if format elements do not specify a format type and therefore have
+ * the subformats created in the formatting methods.
+ * format methods or returned from parse
+ * methods. The indices of elements in newFormats
+ * correspond to the argument indices used in the previously set
+ * pattern string.
+ * The order of formats in newFormats thus corresponds to
+ * the order of elements in the arguments array passed
+ * to the format methods or the result array returned
+ * by the parse methods.
+ *
+ * If an argument index is used for more than one format element
+ * in the pattern string, then the corresponding new format is used
+ * for all such format elements. If an argument index is not used
+ * for any format element in the pattern string, then the
+ * corresponding new format is ignored. If fewer formats are provided
+ * than needed, then only the formats for argument indices less
+ * than newFormats.length are replaced.
+ *
+ * @param newFormats the new formats to use
+ * @exception NullPointerException if newFormats is null
+ * @since 1.4
+ */
+ public void setFormatsByArgumentIndex(Format[] newFormats) {
+ for (int i = 0; i <= maxOffset; i++) {
+ int j = argumentNumbers[i];
+ if (j < newFormats.length) {
+ formats[i] = newFormats[j];
+ }
+ }
+ }
+
+ /**
+ * Sets the formats to use for the format elements in the
+ * previously set pattern string.
+ * The order of formats in newFormats corresponds to
+ * the order of format elements in the pattern string.
+ *
+ * If more formats are provided than needed by the pattern string,
+ * the remaining ones are ignored. If fewer formats are provided
+ * than needed, then only the first newFormats.length
+ * formats are replaced.
+ *
+ * Since the order of format elements in a pattern string often
+ * changes during localization, it is generally better to use the
+ * {@link #setFormatsByArgumentIndex setFormatsByArgumentIndex}
+ * method, which assumes an order of formats corresponding to the
+ * order of elements in the arguments array passed to
+ * the format methods or the result array returned by
+ * the parse methods.
+ *
+ * @param newFormats the new formats to use
+ * @exception NullPointerException if newFormats is null
+ */
+ public void setFormats(Format[] newFormats) {
+ int runsToCopy = newFormats.length;
+ if (runsToCopy > maxOffset + 1) {
+ runsToCopy = maxOffset + 1;
+ }
+ for (int i = 0; i < runsToCopy; i++) {
+ formats[i] = newFormats[i];
+ }
+ }
+
+ /**
+ * Sets the format to use for the format elements within the
+ * previously set pattern string that use the given argument
+ * index.
+ * The argument index is part of the format element definition and
+ * represents an index into the arguments array passed
+ * to the format methods or the result array returned
+ * by the parse methods.
+ *
+ * If the argument index is used for more than one format element + * in the pattern string, then the new format is used for all such + * format elements. If the argument index is not used for any format + * element in the pattern string, then the new format is ignored. + * + * @param argumentIndex the argument index for which to use the new format + * @param newFormat the new format to use + * @since 1.4 + */ + public void setFormatByArgumentIndex(int argumentIndex, Format newFormat) { + for (int j = 0; j <= maxOffset; j++) { + if (argumentNumbers[j] == argumentIndex) { + formats[j] = newFormat; + } + } + } + + /** + * Sets the format to use for the format element with the given + * format element index within the previously set pattern string. + * The format element index is the zero-based number of the format + * element counting from the start of the pattern string. + *
+ * Since the order of format elements in a pattern string often
+ * changes during localization, it is generally better to use the
+ * {@link #setFormatByArgumentIndex setFormatByArgumentIndex}
+ * method, which accesses format elements based on the argument
+ * index they specify.
+ *
+ * @param formatElementIndex the index of a format element within the pattern
+ * @param newFormat the format to use for the specified format element
+ * @exception ArrayIndexOutOfBoundsException if {@code formatElementIndex} is equal to or
+ * larger than the number of format elements in the pattern string
+ */
+ public void setFormat(int formatElementIndex, Format newFormat) {
+ formats[formatElementIndex] = newFormat;
+ }
+
+ /**
+ * Gets the formats used for the values passed into
+ * format methods or returned from parse
+ * methods. The indices of elements in the returned array
+ * correspond to the argument indices used in the previously set
+ * pattern string.
+ * The order of formats in the returned array thus corresponds to
+ * the order of elements in the arguments array passed
+ * to the format methods or the result array returned
+ * by the parse methods.
+ *
+ * If an argument index is used for more than one format element + * in the pattern string, then the format used for the last such + * format element is returned in the array. If an argument index + * is not used for any format element in the pattern string, then + * null is returned in the array. + * + * @return the formats used for the arguments within the pattern + * @since 1.4 + */ + public Format[] getFormatsByArgumentIndex() { + int maximumArgumentNumber = -1; + for (int i = 0; i <= maxOffset; i++) { + if (argumentNumbers[i] > maximumArgumentNumber) { + maximumArgumentNumber = argumentNumbers[i]; + } + } + Format[] resultArray = new Format[maximumArgumentNumber + 1]; + for (int i = 0; i <= maxOffset; i++) { + resultArray[argumentNumbers[i]] = formats[i]; + } + return resultArray; + } + + /** + * Gets the formats used for the format elements in the + * previously set pattern string. + * The order of formats in the returned array corresponds to + * the order of format elements in the pattern string. + *
+ * Since the order of format elements in a pattern string often
+ * changes during localization, it's generally better to use the
+ * {@link #getFormatsByArgumentIndex getFormatsByArgumentIndex}
+ * method, which assumes an order of formats corresponding to the
+ * order of elements in the arguments array passed to
+ * the format methods or the result array returned by
+ * the parse methods.
+ *
+ * @return the formats used for the format elements in the pattern
+ */
+ public Format[] getFormats() {
+ Format[] resultArray = new Format[maxOffset + 1];
+ System.arraycopy(formats, 0, resultArray, 0, maxOffset + 1);
+ return resultArray;
+ }
+
+ /**
+ * Formats an array of objects and appends the MessageFormat's
+ * pattern, with format elements replaced by the formatted objects, to the
+ * provided StringBuffer.
+ *
+ * The text substituted for the individual format elements is derived from
+ * the current subformat of the format element and the
+ * arguments element at the format element's argument index
+ * as indicated by the first matching line of the following table. An
+ * argument is unavailable if arguments is
+ * null or has fewer than argumentIndex+1 elements.
+ *
+ *
| Subformat + * | Argument + * | Formatted Text + * |
|---|---|---|
| any + * | unavailable + * | "{" + argumentIndex + "}"
+ * |
| any + * | null
+ * | "null"
+ * |
instanceof ChoiceFormat
+ * | any + * | subformat.format(argument).indexOf('{') >= 0 ?
+ * |
!= null
+ * | any + * | subformat.format(argument)
+ * |
null
+ * | instanceof Number
+ * | NumberFormat.getInstance(getLocale()).format(argument)
+ * |
null
+ * | instanceof Date
+ * | DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, getLocale()).format(argument)
+ * |
null
+ * | instanceof String
+ * | argument
+ * |
null
+ * | any + * | argument.toString()
+ * |
+ * If pos is non-null, and refers to
+ * Field.ARGUMENT, the location of the first formatted
+ * string will be returned.
+ *
+ * @param arguments an array of objects to be formatted and substituted.
+ * @param result where text is appended.
+ * @param pos On input: an alignment field, if desired.
+ * On output: the offsets of the alignment field.
+ * @exception IllegalArgumentException if an argument in the
+ * arguments array is not of the type
+ * expected by the format element(s) that use it.
+ */
+ public final StringBuffer format(Object[] arguments, StringBuffer result,
+ FieldPosition pos)
+ {
+ return subformat(arguments, result, pos, null);
+ }
+
+ /**
+ * Creates a MessageFormat with the given pattern and uses it
+ * to format the given arguments. This is equivalent to
+ *
+ * (new {@link #MessageFormat(String) MessageFormat}(pattern)).{@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}(arguments, new StringBuffer(), null).toString()
+ *
+ *
+ * @exception IllegalArgumentException if the pattern is invalid,
+ * or if an argument in the arguments array
+ * is not of the type expected by the format element(s)
+ * that use it.
+ */
+ public static String format(String pattern, Object ... arguments) {
+ MessageFormat temp = new MessageFormat(pattern);
+ return temp.format(arguments);
+ }
+
+ // Overrides
+ /**
+ * Formats an array of objects and appends the MessageFormat's
+ * pattern, with format elements replaced by the formatted objects, to the
+ * provided StringBuffer.
+ * This is equivalent to
+ *
+ * {@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}((Object[]) arguments, result, pos)
+ *
+ *
+ * @param arguments an array of objects to be formatted and substituted.
+ * @param result where text is appended.
+ * @param pos On input: an alignment field, if desired.
+ * On output: the offsets of the alignment field.
+ * @exception IllegalArgumentException if an argument in the
+ * arguments array is not of the type
+ * expected by the format element(s) that use it.
+ */
+ public final StringBuffer format(Object arguments, StringBuffer result,
+ FieldPosition pos)
+ {
+ return subformat((Object[]) arguments, result, pos, null);
+ }
+
+ /**
+ * Formats an array of objects and inserts them into the
+ * MessageFormat's pattern, producing an
+ * AttributedCharacterIterator.
+ * You can use the returned AttributedCharacterIterator
+ * to build the resulting String, as well as to determine information
+ * about the resulting String.
+ *
+ * The text of the returned AttributedCharacterIterator is
+ * the same that would be returned by
+ *
+ * {@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}(arguments, new StringBuffer(), null).toString()
+ *
+ *
+ * In addition, the AttributedCharacterIterator contains at
+ * least attributes indicating where text was generated from an
+ * argument in the arguments array. The keys of these attributes are of
+ * type MessageFormat.Field, their values are
+ * Integer objects indicating the index in the arguments
+ * array of the argument from which the text was generated.
+ *
+ * The attributes/value from the underlying Format
+ * instances that MessageFormat uses will also be
+ * placed in the resulting AttributedCharacterIterator.
+ * This allows you to not only find where an argument is placed in the
+ * resulting String, but also which fields it contains in turn.
+ *
+ * @param arguments an array of objects to be formatted and substituted.
+ * @return AttributedCharacterIterator describing the formatted value.
+ * @exception NullPointerException if arguments is null.
+ * @exception IllegalArgumentException if an argument in the
+ * arguments array is not of the type
+ * expected by the format element(s) that use it.
+ * @since 1.4
+ */
+ public AttributedCharacterIterator formatToCharacterIterator(Object arguments) {
+ StringBuffer result = new StringBuffer();
+ ArrayList iterators = new ArrayList();
+
+ if (arguments == null) {
+ throw new NullPointerException(
+ "formatToCharacterIterator must be passed non-null object");
+ }
+ subformat((Object[]) arguments, result, null, iterators);
+ if (iterators.size() == 0) {
+ return createAttributedCharacterIterator("");
+ }
+ return createAttributedCharacterIterator(
+ (AttributedCharacterIterator[])iterators.toArray(
+ new AttributedCharacterIterator[iterators.size()]));
+ }
+
+ /**
+ * Parses the string.
+ *
+ *
Caveats: The parse may fail in a number of circumstances. + * For example: + *
+ * See the {@link #parse(String, ParsePosition)} method for more information
+ * on message parsing.
+ *
+ * @param source A String whose beginning should be parsed.
+ * @return An Object array parsed from the string.
+ * @exception ParseException if the beginning of the specified string
+ * cannot be parsed.
+ */
+ public Object[] parse(String source) throws ParseException {
+ ParsePosition pos = new ParsePosition(0);
+ Object[] result = parse(source, pos);
+ if (pos.index == 0) // unchanged, returned object is null
+ throw new ParseException("MessageFormat parse error!", pos.errorIndex);
+
+ return result;
+ }
+
+ /**
+ * Parses text from a string to produce an object array.
+ *
+ * The method attempts to parse text starting at the index given by
+ * pos.
+ * If parsing succeeds, then the index of pos is updated
+ * to the index after the last character used (parsing does not necessarily
+ * use all characters up to the end of the string), and the parsed
+ * object array is returned. The updated pos can be used to
+ * indicate the starting point for the next call to this method.
+ * If an error occurs, then the index of pos is not
+ * changed, the error index of pos is set to the index of
+ * the character where the error occurred, and null is returned.
+ *
+ * See the {@link #parse(String, ParsePosition)} method for more information
+ * on message parsing.
+ *
+ * @param source A String, part of which should be parsed.
+ * @param pos A ParsePosition object with index and error
+ * index information as described above.
+ * @return An Object array parsed from the string. In case of
+ * error, returns null.
+ * @exception NullPointerException if pos is null.
+ */
+ public Object parseObject(String source, ParsePosition pos) {
+ return parse(source, pos);
+ }
+
+ /**
+ * Creates and returns a copy of this object.
+ *
+ * @return a clone of this instance.
+ */
+ public Object clone() {
+ MessageFormat other = (MessageFormat) super.clone();
+
+ // clone arrays. Can't do with utility because of bug in Cloneable
+ other.formats = (Format[]) formats.clone(); // shallow clone
+ for (int i = 0; i < formats.length; ++i) {
+ if (formats[i] != null)
+ other.formats[i] = (Format)formats[i].clone();
+ }
+ // for primitives or immutables, shallow clone is enough
+ other.offsets = (int[]) offsets.clone();
+ other.argumentNumbers = (int[]) argumentNumbers.clone();
+
+ return other;
+ }
+
+ /**
+ * Equality comparison between two message format objects
+ */
+ public boolean equals(Object obj) {
+ if (this == obj) // quick check
+ return true;
+ if (obj == null || getClass() != obj.getClass())
+ return false;
+ MessageFormat other = (MessageFormat) obj;
+ return (maxOffset == other.maxOffset
+ && pattern.equals(other.pattern)
+ && ((locale != null && locale.equals(other.locale))
+ || (locale == null && other.locale == null))
+ && Arrays.equals(offsets,other.offsets)
+ && Arrays.equals(argumentNumbers,other.argumentNumbers)
+ && Arrays.equals(formats,other.formats));
+ }
+
+ /**
+ * Generates a hash code for the message format object.
+ */
+ public int hashCode() {
+ return pattern.hashCode(); // enough for reasonable distribution
+ }
+
+
+ /**
+ * Defines constants that are used as attribute keys in the
+ * AttributedCharacterIterator returned
+ * from MessageFormat.formatToCharacterIterator.
+ *
+ * @since 1.4
+ */
+ public static class Field extends Format.Field {
+
+ // Proclaim serial compatibility with 1.4 FCS
+ private static final long serialVersionUID = 7899943957617360810L;
+
+ /**
+ * Creates a Field with the specified name.
+ *
+ * @param name Name of the attribute
+ */
+ protected Field(String name) {
+ super(name);
+ }
+
+ /**
+ * Resolves instances being deserialized to the predefined constants.
+ *
+ * @throws InvalidObjectException if the constant could not be
+ * resolved.
+ * @return resolved MessageFormat.Field constant
+ */
+ protected Object readResolve() throws InvalidObjectException {
+ if (this.getClass() != MessageFormat.Field.class) {
+ throw new InvalidObjectException("subclass didn't correctly implement readResolve");
+ }
+
+ return ARGUMENT;
+ }
+
+ //
+ // The constants
+ //
+
+ /**
+ * Constant identifying a portion of a message that was generated
+ * from an argument passed into formatToCharacterIterator.
+ * The value associated with the key will be an Integer
+ * indicating the index in the arguments array of the
+ * argument from which the text was generated.
+ */
+ public final static Field ARGUMENT =
+ new Field("message argument field");
+ }
+
+ // ===========================privates============================
+
+ /**
+ * The locale to use for formatting numbers and dates.
+ * @serial
+ */
+ private Locale locale;
+
+ /**
+ * The string that the formatted values are to be plugged into. In other words, this
+ * is the pattern supplied on construction with all of the {} expressions taken out.
+ * @serial
+ */
+ private String pattern = "";
+
+ /** The initially expected number of subformats in the format */
+ private static final int INITIAL_FORMATS = 10;
+
+ /**
+ * An array of formatters, which are used to format the arguments.
+ * @serial
+ */
+ private Format[] formats = new Format[INITIAL_FORMATS];
+
+ /**
+ * The positions where the results of formatting each argument are to be inserted
+ * into the pattern.
+ * @serial
+ */
+ private int[] offsets = new int[INITIAL_FORMATS];
+
+ /**
+ * The argument numbers corresponding to each formatter. (The formatters are stored
+ * in the order they occur in the pattern, not in the order in which the arguments
+ * are specified.)
+ * @serial
+ */
+ private int[] argumentNumbers = new int[INITIAL_FORMATS];
+
+ /**
+ * One less than the number of entries in offsets. Can also be thought of
+ * as the index of the highest-numbered element in offsets that is being used.
+ * All of these arrays should have the same number of elements being used as offsets
+ * does, and so this variable suffices to tell us how many entries are in all of them.
+ * @serial
+ */
+ private int maxOffset = -1;
+
+ /**
+ * Internal routine used by format. If characterIterators is
+ * non-null, AttributedCharacterIterator will be created from the
+ * subformats as necessary. If characterIterators is null
+ * and fp is non-null and identifies
+ * Field.MESSAGE_ARGUMENT, the location of
+ * the first replaced argument will be set in it.
+ *
+ * @exception IllegalArgumentException if an argument in the
+ * arguments array is not of the type
+ * expected by the format element(s) that use it.
+ */
+ private StringBuffer subformat(Object[] arguments, StringBuffer result,
+ FieldPosition fp, List characterIterators) {
+ // note: this implementation assumes a fast substring & index.
+ // if this is not true, would be better to append chars one by one.
+ int lastOffset = 0;
+ int last = result.length();
+ for (int i = 0; i <= maxOffset; ++i) {
+ result.append(pattern.substring(lastOffset, offsets[i]));
+ lastOffset = offsets[i];
+ int argumentNumber = argumentNumbers[i];
+ if (arguments == null || argumentNumber >= arguments.length) {
+ result.append('{').append(argumentNumber).append('}');
+ continue;
+ }
+ // int argRecursion = ((recursionProtection >> (argumentNumber*2)) & 0x3);
+ if (false) { // if (argRecursion == 3){
+ // prevent loop!!!
+ result.append('\uFFFD');
+ } else {
+ Object obj = arguments[argumentNumber];
+ String arg = null;
+ Format subFormatter = null;
+ if (obj == null) {
+ arg = "null";
+ } else if (formats[i] != null) {
+ subFormatter = formats[i];
+ if (subFormatter instanceof ChoiceFormat) {
+ arg = formats[i].format(obj);
+ if (arg.indexOf('{') >= 0) {
+ subFormatter = new MessageFormat(arg, locale);
+ obj = arguments;
+ arg = null;
+ }
+ }
+ } else if (obj instanceof Number) {
+ // format number if can
+ subFormatter = NumberFormat.getInstance(locale);
+ } else if (obj instanceof Date) {
+ // format a Date if can
+ subFormatter = DateFormat.getDateTimeInstance(
+ DateFormat.SHORT, DateFormat.SHORT, locale);//fix
+ } else if (obj instanceof String) {
+ arg = (String) obj;
+
+ } else {
+ arg = obj.toString();
+ if (arg == null) arg = "null";
+ }
+
+ // At this point we are in two states, either subFormatter
+ // is non-null indicating we should format obj using it,
+ // or arg is non-null and we should use it as the value.
+
+ if (characterIterators != null) {
+ // If characterIterators is non-null, it indicates we need
+ // to get the CharacterIterator from the child formatter.
+ if (last != result.length()) {
+ characterIterators.add(
+ createAttributedCharacterIterator(result.substring
+ (last)));
+ last = result.length();
+ }
+ if (subFormatter != null) {
+ AttributedCharacterIterator subIterator =
+ subFormatter.formatToCharacterIterator(obj);
+
+ append(result, subIterator);
+ if (last != result.length()) {
+ characterIterators.add(
+ createAttributedCharacterIterator(
+ subIterator, Field.ARGUMENT,
+ Integer.valueOf(argumentNumber)));
+ last = result.length();
+ }
+ arg = null;
+ }
+ if (arg != null && arg.length() > 0) {
+ result.append(arg);
+ characterIterators.add(
+ createAttributedCharacterIterator(
+ arg, Field.ARGUMENT,
+ Integer.valueOf(argumentNumber)));
+ last = result.length();
+ }
+ }
+ else {
+ if (subFormatter != null) {
+ arg = subFormatter.format(obj);
+ }
+ last = result.length();
+ result.append(arg);
+ if (i == 0 && fp != null && Field.ARGUMENT.equals(
+ fp.getFieldAttribute())) {
+ fp.setBeginIndex(last);
+ fp.setEndIndex(result.length());
+ }
+ last = result.length();
+ }
+ }
+ }
+ result.append(pattern.substring(lastOffset, pattern.length()));
+ if (characterIterators != null && last != result.length()) {
+ characterIterators.add(createAttributedCharacterIterator(
+ result.substring(last)));
+ }
+ return result;
+ }
+
+ /**
+ * Convenience method to append all the characters in
+ * iterator to the StringBuffer result.
+ */
+ private void append(StringBuffer result, CharacterIterator iterator) {
+ if (iterator.first() != CharacterIterator.DONE) {
+ char aChar;
+
+ result.append(iterator.first());
+ while ((aChar = iterator.next()) != CharacterIterator.DONE) {
+ result.append(aChar);
+ }
+ }
+ }
+
+ // Indices for segments
+ private static final int SEG_RAW = 0;
+ private static final int SEG_INDEX = 1;
+ private static final int SEG_TYPE = 2;
+ private static final int SEG_MODIFIER = 3; // modifier or subformat
+
+ // Indices for type keywords
+ private static final int TYPE_NULL = 0;
+ private static final int TYPE_NUMBER = 1;
+ private static final int TYPE_DATE = 2;
+ private static final int TYPE_TIME = 3;
+ private static final int TYPE_CHOICE = 4;
+
+ private static final String[] TYPE_KEYWORDS = {
+ "",
+ "number",
+ "date",
+ "time",
+ "choice"
+ };
+
+ // Indices for number modifiers
+ private static final int MODIFIER_DEFAULT = 0; // common in number and date-time
+ private static final int MODIFIER_CURRENCY = 1;
+ private static final int MODIFIER_PERCENT = 2;
+ private static final int MODIFIER_INTEGER = 3;
+
+ private static final String[] NUMBER_MODIFIER_KEYWORDS = {
+ "",
+ "currency",
+ "percent",
+ "integer"
+ };
+
+ // Indices for date-time modifiers
+ private static final int MODIFIER_SHORT = 1;
+ private static final int MODIFIER_MEDIUM = 2;
+ private static final int MODIFIER_LONG = 3;
+ private static final int MODIFIER_FULL = 4;
+
+ private static final String[] DATE_TIME_MODIFIER_KEYWORDS = {
+ "",
+ "short",
+ "medium",
+ "long",
+ "full"
+ };
+
+ // Date-time style values corresponding to the date-time modifiers.
+ private static final int[] DATE_TIME_MODIFIERS = {
+ DateFormat.DEFAULT,
+ DateFormat.SHORT,
+ DateFormat.MEDIUM,
+ DateFormat.LONG,
+ DateFormat.FULL,
+ };
+
+ private void makeFormat(int position, int offsetNumber,
+ StringBuilder[] textSegments)
+ {
+ String[] segments = new String[textSegments.length];
+ for (int i = 0; i < textSegments.length; i++) {
+ StringBuilder oneseg = textSegments[i];
+ segments[i] = (oneseg != null) ? oneseg.toString() : "";
+ }
+
+ // get the argument number
+ int argumentNumber;
+ try {
+ argumentNumber = Integer.parseInt(segments[SEG_INDEX]); // always unlocalized!
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException("can't parse argument number: "
+ + segments[SEG_INDEX], e);
+ }
+ if (argumentNumber < 0) {
+ throw new IllegalArgumentException("negative argument number: "
+ + argumentNumber);
+ }
+
+ // resize format information arrays if necessary
+ if (offsetNumber >= formats.length) {
+ int newLength = formats.length * 2;
+ Format[] newFormats = new Format[newLength];
+ int[] newOffsets = new int[newLength];
+ int[] newArgumentNumbers = new int[newLength];
+ System.arraycopy(formats, 0, newFormats, 0, maxOffset + 1);
+ System.arraycopy(offsets, 0, newOffsets, 0, maxOffset + 1);
+ System.arraycopy(argumentNumbers, 0, newArgumentNumbers, 0, maxOffset + 1);
+ formats = newFormats;
+ offsets = newOffsets;
+ argumentNumbers = newArgumentNumbers;
+ }
+ int oldMaxOffset = maxOffset;
+ maxOffset = offsetNumber;
+ offsets[offsetNumber] = segments[SEG_RAW].length();
+ argumentNumbers[offsetNumber] = argumentNumber;
+
+ // now get the format
+ Format newFormat = null;
+ if (segments[SEG_TYPE].length() != 0) {
+ int type = findKeyword(segments[SEG_TYPE], TYPE_KEYWORDS);
+ switch (type) {
+ case TYPE_NULL:
+ // Type "" is allowed. e.g., "{0,}", "{0,,}", and "{0,,#}"
+ // are treated as "{0}".
+ break;
+
+ case TYPE_NUMBER:
+ switch (findKeyword(segments[SEG_MODIFIER], NUMBER_MODIFIER_KEYWORDS)) {
+ case MODIFIER_DEFAULT:
+ newFormat = NumberFormat.getInstance(locale);
+ break;
+ case MODIFIER_CURRENCY:
+ newFormat = NumberFormat.getCurrencyInstance(locale);
+ break;
+ case MODIFIER_PERCENT:
+ newFormat = NumberFormat.getPercentInstance(locale);
+ break;
+ case MODIFIER_INTEGER:
+ newFormat = NumberFormat.getIntegerInstance(locale);
+ break;
+ default: // DecimalFormat pattern
+ try {
+ newFormat = new DecimalFormat(segments[SEG_MODIFIER],
+ DecimalFormatSymbols.getInstance(locale));
+ } catch (IllegalArgumentException e) {
+ maxOffset = oldMaxOffset;
+ throw e;
+ }
+ break;
+ }
+ break;
+
+ case TYPE_DATE:
+ case TYPE_TIME:
+ int mod = findKeyword(segments[SEG_MODIFIER], DATE_TIME_MODIFIER_KEYWORDS);
+ if (mod >= 0 && mod < DATE_TIME_MODIFIER_KEYWORDS.length) {
+ if (type == TYPE_DATE) {
+ newFormat = DateFormat.getDateInstance(DATE_TIME_MODIFIERS[mod],
+ locale);
+ } else {
+ newFormat = DateFormat.getTimeInstance(DATE_TIME_MODIFIERS[mod],
+ locale);
+ }
+ } else {
+ // SimpleDateFormat pattern
+ try {
+ newFormat = new SimpleDateFormat(segments[SEG_MODIFIER], locale);
+ } catch (IllegalArgumentException e) {
+ maxOffset = oldMaxOffset;
+ throw e;
+ }
+ }
+ break;
+
+ case TYPE_CHOICE:
+ try {
+ // ChoiceFormat pattern
+ newFormat = new ChoiceFormat(segments[SEG_MODIFIER]);
+ } catch (Exception e) {
+ maxOffset = oldMaxOffset;
+ throw new IllegalArgumentException("Choice Pattern incorrect: "
+ + segments[SEG_MODIFIER], e);
+ }
+ break;
+
+ default:
+ maxOffset = oldMaxOffset;
+ throw new IllegalArgumentException("unknown format type: " +
+ segments[SEG_TYPE]);
+ }
+ }
+ formats[offsetNumber] = newFormat;
+ }
+
+ private static final int findKeyword(String s, String[] list) {
+ for (int i = 0; i < list.length; ++i) {
+ if (s.equals(list[i]))
+ return i;
+ }
+
+ // Try trimmed lowercase.
+ String ls = s.trim().toLowerCase(Locale.ROOT);
+ if (ls != s) {
+ for (int i = 0; i < list.length; ++i) {
+ if (ls.equals(list[i]))
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ private static final void copyAndFixQuotes(String source, int start, int end,
+ StringBuilder target) {
+ boolean quoted = false;
+
+ for (int i = start; i < end; ++i) {
+ char ch = source.charAt(i);
+ if (ch == '{') {
+ if (!quoted) {
+ target.append('\'');
+ quoted = true;
+ }
+ target.append(ch);
+ } else if (ch == '\'') {
+ target.append("''");
+ } else {
+ if (quoted) {
+ target.append('\'');
+ quoted = false;
+ }
+ target.append(ch);
+ }
+ }
+ if (quoted) {
+ target.append('\'');
+ }
+ }
+
+ /**
+ * After reading an object from the input stream, do a simple verification
+ * to maintain class invariants.
+ * @throws InvalidObjectException if the objects read from the stream is invalid.
+ */
+ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+ in.defaultReadObject();
+ boolean isValid = maxOffset >= -1
+ && formats.length > maxOffset
+ && offsets.length > maxOffset
+ && argumentNumbers.length > maxOffset;
+ if (isValid) {
+ int lastOffset = pattern.length() + 1;
+ for (int i = maxOffset; i >= 0; --i) {
+ if ((offsets[i] < 0) || (offsets[i] > lastOffset)) {
+ isValid = false;
+ break;
+ } else {
+ lastOffset = offsets[i];
+ }
+ }
+ }
+ if (!isValid) {
+ throw new InvalidObjectException("Could not reconstruct MessageFormat from corrupt stream.");
+ }
+ }
+}