/*

* Copyright (c) 1996, 2020, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

/*

* (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved

* (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved

*

* The original version of this source code and documentation is copyrighted

* and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These

* materials are provided under terms of a License Agreement between Taligent

* and Sun. This technology is protected by multiple US and International

* patents. This notice and attribution to Taligent may not be removed.

* Taligent is a registered trademark of Taligent, Inc.

*

*/

package java.text;

import java.io.InvalidObjectException;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.text.DecimalFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.List;

import java.util.Locale;

/**

* <code>MessageFormat</code> provides a means to produce concatenated

* messages in a language-neutral way. Use this to construct messages

* displayed for end users.

*

* <p>

* <code>MessageFormat</code> takes a set of objects, formats them, then

* inserts the formatted strings into the pattern at the appropriate places.

*

* <p>

* <strong>Note:</strong>

* <code>MessageFormat</code> differs from the other <code>Format</code>

* classes in that you create a <code>MessageFormat</code> object with one

* of its constructors (not with a <code>getInstance</code> style factory

* method). The factory methods aren't necessary because <code>MessageFormat</code>

* 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.

*

* <h3><a name="patterns">Patterns and Their Interpretation</a></h3>

*

* <code>MessageFormat</code> uses patterns of the following form:

* <blockquote><pre>

* <i>MessageFormatPattern:</i>

* <i>String</i>

* <i>MessageFormatPattern</i> <i>FormatElement</i> <i>String</i>

*

* <i>FormatElement:</i>

* { <i>ArgumentIndex</i> }

* { <i>ArgumentIndex</i> , <i>FormatType</i> }

* { <i>ArgumentIndex</i> , <i>FormatType</i> , <i>FormatStyle</i> }

*

* <i>FormatType: one of </i>

* number date time choice

*

* <i>FormatStyle:</i>

* short

* medium

* long

* full

* integer

* currency

* percent

* <i>SubformatPattern</i>

* </pre></blockquote>

*

* <p>Within a <i>String</i>, a pair of single quotes can be used to

* quote any arbitrary characters except single quotes. For example,

* pattern string <code>"'{0}'"</code> represents string

* <code>"{0}"</code>, not a <i>FormatElement</i>. A single quote itself

* must be represented by doubled single quotes {@code ''} throughout a

* <i>String</i>. For example, pattern string <code>"'{''}'"</code> is

* interpreted as a sequence of <code>'{</code> (start of quoting and a

* left curly brace), <code>''</code> (a single quote), and

* <code>}'</code> (a right curly brace and end of quoting),

* <em>not</em> <code>'{'</code> and <code>'}'</code> (quoted left and

* right curly braces): representing string <code>"{'}"</code>,

* <em>not</em> <code>"{}"</code>.

*

* <p>A <i>SubformatPattern</i> is interpreted by its corresponding

* subformat, and subformat-dependent pattern rules apply. For example,

* pattern string <code>"{1,number,<u>$'#',##</u>}"</code>

* (<i>SubformatPattern</i> 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.

*

* <p>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}'"}.

*

* <p>Any curly braces within an unquoted pattern must be balanced. For

* example, <code>"ab {0} de"</code> and <code>"ab '}' de"</code> are

* valid patterns, but <code>"ab {0'}' de"</code>, <code>"ab } de"</code>

* and <code>"''{''"</code> are not.

*

* <dl><dt><b>Warning:</b><dd>The rules for using quotes within message

* format patterns unfortunately have shown to be somewhat confusing.

* In particular, it isn't always obvious to localizers whether single

* quotes need to be doubled or not. Make sure to inform localizers about

* the rules, and tell them (for example, by using comments in resource

* bundle source files) which strings will be processed by {@code MessageFormat}.

* Note that localizers may need to use single quotes in translated

* strings where the original version doesn't have them.

* </dl>

* <p>

* The <i>ArgumentIndex</i> 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.

* <p>

* The <i>FormatType</i> and <i>FormatStyle</i> 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 <i>SubformatPattern</i> must

* be a valid pattern string for the {@code Format} subclass used.

*

* <table border=1 summary="Shows how FormatType and FormatStyle values map to Format instances">

* <tr>

* <th id="ft" class="TableHeadingColor">FormatType

* <th id="fs" class="TableHeadingColor">FormatStyle

* <th id="sc" class="TableHeadingColor">Subformat Created

* <tr>

* <td headers="ft"><i>(none)</i>

* <td headers="fs"><i>(none)</i>

* <td headers="sc"><code>null</code>

* <tr>

* <td headers="ft" rowspan=5><code>number</code>

* <td headers="fs"><i>(none)</i>

* <td headers="sc">{@link NumberFormat#getInstance(Locale) NumberFormat.getInstance}{@code (getLocale())}

* <tr>

* <td headers="fs"><code>integer</code>

* <td headers="sc">{@link NumberFormat#getIntegerInstance(Locale) NumberFormat.getIntegerInstance}{@code (getLocale())}

* <tr>

* <td headers="fs"><code>currency</code>

* <td headers="sc">{@link NumberFormat#getCurrencyInstance(Locale) NumberFormat.getCurrencyInstance}{@code (getLocale())}

* <tr>

* <td headers="fs"><code>percent</code>

* <td headers="sc">{@link NumberFormat#getPercentInstance(Locale) NumberFormat.getPercentInstance}{@code (getLocale())}

* <tr>

* <td headers="fs"><i>SubformatPattern</i>

* <td headers="sc">{@code new} {@link DecimalFormat#DecimalFormat(String,DecimalFormatSymbols) DecimalFormat}{@code (subformatPattern,} {@link DecimalFormatSymbols#getInstance(Locale) DecimalFormatSymbols.getInstance}{@code (getLocale()))}

* <tr>

* <td headers="ft" rowspan=6><code>date</code>

* <td headers="fs"><i>(none)</i>

* <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())}

* <tr>

* <td headers="fs"><code>short</code>

* <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#SHORT}{@code , getLocale())}

* <tr>

* <td headers="fs"><code>medium</code>

* <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())}

* <tr>

* <td headers="fs"><code>long</code>

* <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#LONG}{@code , getLocale())}

* <tr>

* <td headers="fs"><code>full</code>

* <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#FULL}{@code , getLocale())}

* <tr>

* <td headers="fs"><i>SubformatPattern</i>

* <td headers="sc">{@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())}

* <tr>

* <td headers="ft" rowspan=6><code>time</code>

* <td headers="fs"><i>(none)</i>

* <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())}

* <tr>

* <td headers="fs"><code>short</code>

* <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#SHORT}{@code , getLocale())}

* <tr>

* <td headers="fs"><code>medium</code>

* <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())}

* <tr>

* <td headers="fs"><code>long</code>

* <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#LONG}{@code , getLocale())}

* <tr>

* <td headers="fs"><code>full</code>

* <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#FULL}{@code , getLocale())}

* <tr>

* <td headers="fs"><i>SubformatPattern</i>

* <td headers="sc">{@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())}

* <tr>

* <td headers="ft"><code>choice</code>

* <td headers="fs"><i>SubformatPattern</i>

* <td headers="sc">{@code new} {@link ChoiceFormat#ChoiceFormat(String) ChoiceFormat}{@code (subformatPattern)}

* </table>

*

* <h4>Usage Information</h4>

*

* <p>

* 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.

* <p>

* The first example uses the static method <code>MessageFormat.format</code>,

* which internally creates a <code>MessageFormat</code> for one-time use:

* <blockquote><pre>

* 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);

* </pre></blockquote>

* The output is:

* <blockquote><pre>

* At 12:30 PM on Jul 3, 2053, there was a disturbance in the Force on planet 7.

* </pre></blockquote>

*

* <p>

* The following example creates a <code>MessageFormat</code> instance that

* can be used repeatedly:

* <blockquote><pre>

* 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));

* </pre></blockquote>

* The output with different values for <code>fileCount</code>:

* <blockquote><pre>

* The disk "MyDisk" contains 0 file(s).

* The disk "MyDisk" contains 1 file(s).

* The disk "MyDisk" contains 1,273 file(s).

* </pre></blockquote>

*

* <p>

* For more sophisticated patterns, you can use a <code>ChoiceFormat</code>

* to produce correct forms for singular and plural:

* <blockquote><pre>

* 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));

* </pre></blockquote>

* The output with different values for <code>fileCount</code>:

* <blockquote><pre>

* The disk "MyDisk" contains no files.

* The disk "MyDisk" contains one file.

* The disk "MyDisk" contains 1,273 files.

* </pre></blockquote>

*

* <p>

* You can create the <code>ChoiceFormat</code> programmatically, as in the

* above example, or by using a pattern. See {@link ChoiceFormat}

* for more information.

* <blockquote><pre>{@code

* form.applyPattern(

* "There {0,choice,0#are no files|1#is one file|1<are {0,number,integer} files}.");

* }</pre></blockquote>

*

* <p>

* <strong>Note:</strong> As we see above, the string produced

* by a <code>ChoiceFormat</code> in <code>MessageFormat</code> is treated as special;

* occurrences of '{' are used to indicate subformats, and cause recursion.

* If you create both a <code>MessageFormat</code> and <code>ChoiceFormat</code>

* 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.

* <p>

* 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,

* <blockquote><pre>

* 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)}

* </pre></blockquote>

*

* <p>

* Likewise, parsing with a {@code MessageFormat} object using patterns containing

* multiple occurrences of the same argument would return the last match. For

* example,

* <blockquote><pre>

* 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")}

* </pre></blockquote>

*

* <h4><a name="synchronization">Synchronization</a></h4>

*

* <p>

* 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

* {@link java.util.Locale.Category#FORMAT FORMAT} 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

* <a href="#patterns">class description</a>.

*

* @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

* <a href="#patterns">class description</a>.

*

* @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

* <ul>

* <li>to the {@link #applyPattern applyPattern}

* and {@link #toPattern toPattern} methods if format elements specify

* a format type and therefore have the subformats created in the

* <code>applyPattern</code> method, as well as

* <li>to the <code>format</code> and

* {@link #formatToCharacterIterator formatToCharacterIterator} methods

* if format elements do not specify a format type and therefore have

* the subformats created in the formatting methods.

* </ul>

* Subformats that have already been created are not affected.

*

* @param locale the locale to be used when creating or comparing subformats

*/

public void setLocale(Locale locale) {

this.locale = locale;

}

/**

* Gets the locale that's used when creating or comparing subformats.

*

* @return the locale used when creating or comparing subformats

*/

public Locale getLocale() {

return locale;

}

/**

* Sets the pattern used by this message format.

* The method parses the pattern and creates a list of subformats

* for the format elements contained in it.

* Patterns and their interpretation are specified in the

* <a href="#patterns">class description</a>.

*

* @param pattern the pattern for this message format

* @exception IllegalArgumentException if the pattern is invalid

*/

@SuppressWarnings("fallthrough") // fallthrough in switch is expected, suppress it

public void applyPattern(String pattern) {

StringBuilder[] segments = new StringBuilder[4];

// Allocate only segments[SEG_RAW] here. The rest are

// allocated on demand.

segments[SEG_RAW] = new StringBuilder();

int part = SEG_RAW;

int formatNumber = 0;

boolean inQuote = false;

int braceStack = 0;

maxOffset = -1;

for (int i = 0; i < pattern.length(); ++i) {

char ch = pattern.charAt(i);

if (part == SEG_RAW) {

if (ch == '\'') {

if (i + 1 < pattern.length()

&& pattern.charAt(i+1) == '\'') {

segments[part].append(ch); // handle doubles

++i;

} else {

inQuote = !inQuote;

}

} else if (ch == '{' && !inQuote) {

part = SEG_INDEX;

if (segments[SEG_INDEX] == null) {

segments[SEG_INDEX] = new StringBuilder();

}

} else {

segments[part].append(ch);

}

} else {

if (inQuote) { // just copy quotes in parts

segments[part].append(ch);

if (ch == '\'') {

inQuote = false;

}

} else {

switch (ch) {

case ',':

if (part < SEG_MODIFIER) {

if (segments[++part] == null) {

segments[part] = new StringBuilder();

}

} else {

segments[part].append(ch);

}

break;

case '{':

++braceStack;

segments[part].append(ch);

break;

case '}':

if (braceStack == 0) {

part = SEG_RAW;

makeFormat(i, formatNumber, segments);

formatNumber++;

// throw away other segments

segments[SEG_INDEX] = null;

segments[SEG_TYPE] = null;

segments[SEG_MODIFIER] = null;

} else {

--braceStack;

segments[part].append(ch);

}

break;

case ' ':

// Skip any leading space chars for SEG_TYPE.

if (part != SEG_TYPE || segments[SEG_TYPE].length() > 0) {

segments[part].append(ch);

}

break;

case '\'':

inQuote = true;

// fall through, so we keep quotes in other parts

default:

segments[part].append(ch);

break;

}

}

}

}

if (braceStack == 0 && part != 0) {

maxOffset = -1;

throw new IllegalArgumentException("Unmatched braces in the pattern.");

}

this.pattern = segments[0].toString();

}

/**

* Returns a pattern representing the current state of the message format.

* The string is constructed from internal information and therefore

* does not necessarily equal the previously applied pattern.

*

* @return a pattern representing the current state of the message format

*/

public String toPattern() {

// later, make this more extensible

int lastOffset = 0;

StringBuilder result = new StringBuilder();

for (int i = 0; i <= maxOffset; ++i) {

copyAndFixQuotes(pattern, lastOffset, offsets[i], result);

lastOffset = offsets[i];

result.append('{').append(argumentNumbers[i]);

Format fmt = formats[i];

if (fmt == null) {

// do nothing, string format

} else if (fmt instanceof NumberFormat) {

if (fmt.equals(NumberFormat.getInstance(locale))) {

result.append(",number");

} else if (fmt.equals(NumberFormat.getCurrencyInstance(locale))) {

result.append(",number,currency");

} else if (fmt.equals(NumberFormat.getPercentInstance(locale))) {

result.append(",number,percent");

} else if (fmt.equals(NumberFormat.getIntegerInstance(locale))) {

result.append(",number,integer");

} else {

if (fmt instanceof DecimalFormat) {

result.append(",number,").append(((DecimalFormat)fmt).toPattern());

} else if (fmt instanceof ChoiceFormat) {

result.append(",choice,").append(((ChoiceFormat)fmt).toPattern());

} else {

// UNKNOWN

}

}

} else if (fmt instanceof DateFormat) {

int index;

for (index = MODIFIER_DEFAULT; index < DATE_TIME_MODIFIERS.length; index++) {

DateFormat df = DateFormat.getDateInstance(DATE_TIME_MODIFIERS[index],

locale);

if (fmt.equals(df)) {

result.append(",date");

break;

}

df = DateFormat.getTimeInstance(DATE_TIME_MODIFIERS[index],

locale);

if (fmt.equals(df)) {

result.append(",time");

break;

}

}

if (index >= DATE_TIME_MODIFIERS.length) {

if (fmt instanceof SimpleDateFormat) {

result.append(",date,").append(((SimpleDateFormat)fmt).toPattern());

} else {

// UNKNOWN

}

} else if (index != MODIFIER_DEFAULT) {

result.append(',').append(DATE_TIME_MODIFIER_KEYWORDS[index]);

}

} else {

//result.append(", unknown");

}

result.append('}');

}

copyAndFixQuotes(pattern, lastOffset, pattern.length(), result);

return result.toString();

}

/**

* Sets the formats to use for the values passed into

* <code>format</code> methods or returned from <code>parse</code>

* methods. The indices of elements in <code>newFormats</code>

* correspond to the argument indices used in the previously set

* pattern string.

* The order of formats in <code>newFormats</code> thus corresponds to

* the order of elements in the <code>arguments</code> array passed

* to the <code>format</code> methods or the result array returned

* by the <code>parse</code> methods.

* <p>

* 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 <code>newFormats.length</code> are replaced.

*

* @param newFormats the new formats to use

* @exception NullPointerException if <code>newFormats</code> 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 <code>newFormats</code> corresponds to

* the order of format elements in the pattern string.

* <p>

* 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 <code>newFormats.length</code>

* formats are replaced.

* <p>

* 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 <code>arguments</code> array passed to

* the <code>format</code> methods or the result array returned by

* the <code>parse</code> methods.

*

* @param newFormats the new formats to use

* @exception NullPointerException if <code>newFormats</code> 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 <code>arguments</code> array passed

* to the <code>format</code> methods or the result array returned

* by the <code>parse</code> methods.

* <p>

* 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.

* <p>

* 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

* <code>format</code> methods or returned from <code>parse</code>

* 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 <code>arguments</code> array passed

* to the <code>format</code> methods or the result array returned

* by the <code>parse</code> methods.

* <p>

* 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.

* <p>

* 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 <code>arguments</code> array passed to

* the <code>format</code> methods or the result array returned by

* the <code>parse</code> 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 <code>MessageFormat</code>'s

* pattern, with format elements replaced by the formatted objects, to the

* provided <code>StringBuffer</code>.

* <p>

* The text substituted for the individual format elements is derived from

* the current subformat of the format element and the

* <code>arguments</code> element at the format element's argument index

* as indicated by the first matching line of the following table. An

* argument is <i>unavailable</i> if <code>arguments</code> is

* <code>null</code> or has fewer than argumentIndex+1 elements.

*

* <table border=1 summary="Examples of subformat,argument,and formatted text">

* <tr>

* <th>Subformat

* <th>Argument

* <th>Formatted Text

* <tr>

* <td><i>any</i>

* <td><i>unavailable</i>

* <td><code>"{" + argumentIndex + "}"</code>

* <tr>

* <td><i>any</i>

* <td><code>null</code>

* <td><code>"null"</code>

* <tr>

* <td><code>instanceof ChoiceFormat</code>

* <td><i>any</i>

* <td><code>subformat.format(argument).indexOf('{') &gt;= 0 ?<br>

* (new MessageFormat(subformat.format(argument), getLocale())).format(argument) :

* subformat.format(argument)</code>

* <tr>

* <td><code>!= null</code>

* <td><i>any</i>

* <td><code>subformat.format(argument)</code>

* <tr>

* <td><code>null</code>

* <td><code>instanceof Number</code>

* <td><code>NumberFormat.getInstance(getLocale()).format(argument)</code>

* <tr>

* <td><code>null</code>

* <td><code>instanceof Date</code>

* <td><code>DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, getLocale()).format(argument)</code>

* <tr>

* <td><code>null</code>

* <td><code>instanceof String</code>

* <td><code>argument</code>

* <tr>

* <td><code>null</code>

* <td><i>any</i>

* <td><code>argument.toString()</code>

* </table>

* <p>

* If <code>pos</code> is non-null, and refers to

* <code>Field.ARGUMENT</code>, 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.

* @return the string buffer passed in as {@code result}, with formatted

* text appended

* @exception IllegalArgumentException if an argument in the

* <code>arguments</code> 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

* <blockquote>

* <code>(new {@link #MessageFormat(String) MessageFormat}(pattern)).{@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}(arguments, new StringBuffer(), null).toString()</code>

* </blockquote>

*

* @param pattern the pattern string

* @param arguments object(s) to format

* @return the formatted string

* @exception IllegalArgumentException if the pattern is invalid,

* or if an argument in the <code>arguments</code> 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 <code>MessageFormat</code>'s

* pattern, with format elements replaced by the formatted objects, to the

* provided <code>StringBuffer</code>.

* This is equivalent to

* <blockquote>

* <code>{@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}((Object[]) arguments, result, pos)</code>

* </blockquote>

*

* @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

* <code>arguments</code> 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

* <code>MessageFormat</code>'s pattern, producing an

* <code>AttributedCharacterIterator</code>.

* You can use the returned <code>AttributedCharacterIterator</code>

* to build the resulting String, as well as to determine information

* about the resulting String.

* <p>

* The text of the returned <code>AttributedCharacterIterator</code> is

* the same that would be returned by

* <blockquote>

* <code>{@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}(arguments, new StringBuffer(), null).toString()</code>

* </blockquote>

* <p>

* In addition, the <code>AttributedCharacterIterator</code> contains at

* least attributes indicating where text was generated from an

* argument in the <code>arguments</code> array. The keys of these attributes are of

* type <code>MessageFormat.Field</code>, their values are

* <code>Integer</code> objects indicating the index in the <code>arguments</code>

* array of the argument from which the text was generated.

* <p>

* The attributes/value from the underlying <code>Format</code>

* instances that <code>MessageFormat</code> uses will also be

* placed in the resulting <code>AttributedCharacterIterator</code>.

* 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 <code>arguments</code> is null.

* @exception IllegalArgumentException if an argument in the

* <code>arguments</code> 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<AttributedCharacterIterator> 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(

iterators.toArray(

new AttributedCharacterIterator[iterators.size()]));

}

/**

* Parses the string.

*

* <p>Caveats: The parse may fail in a number of circumstances.

* For example:

* <ul>

* <li>If one of the arguments does not occur in the pattern.

* <li>If the format of an argument loses information, such as

* with a choice format where a large number formats to "many".

* <li>Does not yet handle recursion (where

* the substituted strings contain {n} references.)

* <li>Will not always find a match (or the correct match)

* if some part of the parse is ambiguous.

* For example, if the pattern "{1},{2}" is used with the

* string arguments {"a,b", "c"}, it will format as "a,b,c".

* When the result is parsed, it will return {"a", "b,c"}.

* <li>If a single argument is parsed more than once in the string,

* then the later parse wins.

* </ul>

* When the parse fails, use ParsePosition.getErrorIndex() to find out

* where in the string the parsing failed. The returned error

* index is the starting offset of the sub-patterns that the string

* is comparing with. For example, if the parsing string "AAA {0} BBB"

* is comparing against the pattern "AAD {0} BBB", the error index is

* 0. When an error occurs, the call to this method will return null.

* If the source is null, return an empty array.

*

* @param source the string to parse

* @param pos the parse position

* @return an array of parsed objects

*/

public Object[] parse(String source, ParsePosition pos) {

if (source == null) {

Object[] empty = {};

return empty;

}

int maximumArgumentNumber = -1;

for (int i = 0; i <= maxOffset; i++) {

if (argumentNumbers[i] > maximumArgumentNumber) {

maximumArgumentNumber = argumentNumbers[i];

}

}

Object[] resultArray = new Object[maximumArgumentNumber + 1];

int patternOffset = 0;

int sourceOffset = pos.index;

ParsePosition tempStatus = new ParsePosition(0);

for (int i = 0; i <= maxOffset; ++i) {

// match up to format

int len = offsets[i] - patternOffset;

if (len == 0 || pattern.regionMatches(patternOffset,

source, sourceOffset, len)) {

sourceOffset += len;

patternOffset += len;

} else {

pos.errorIndex = sourceOffset;

return null; // leave index as is to signal error

}

// now use format

if (formats[i] == null) { // string format

// if at end, use longest possible match

// otherwise uses first match to intervening string

// does NOT recursively try all possibilities

int tempLength = (i != maxOffset) ? offsets[i+1] : pattern.length();

int next;

if (patternOffset >= tempLength) {

next = source.length();

}else{

next = source.indexOf(pattern.substring(patternOffset, tempLength),

sourceOffset);

}

if (next < 0) {

pos.errorIndex = sourceOffset;

return null; // leave index as is to signal error

} else {

String strValue= source.substring(sourceOffset,next);

if (!strValue.equals("{"+argumentNumbers[i]+"}"))