/*
* Copyright (c) 1996, 2013, 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('{') >= 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]+"}"))
resultArray[
argumentNumbers[
i]]
=
source.
substring(
sourceOffset,
next);
sourceOffset =
next;
}
} else {
tempStatus.
index =
sourceOffset;
resultArray[
argumentNumbers[
i]]
=
formats[
i].
parseObject(
source,
tempStatus);
if (
tempStatus.
index ==
sourceOffset) {
pos.
errorIndex =
sourceOffset;
return null; // leave index as is to signal error
}
sourceOffset =
tempStatus.
index; // update
}
}
int
len =
pattern.
length() -
patternOffset;
if (
len == 0 ||
pattern.
regionMatches(
patternOffset,
source,
sourceOffset,
len)) {
pos.
index =
sourceOffset +
len;
} else {
pos.
errorIndex =
sourceOffset;
return null; // leave index as is to signal error
}
return
resultArray;
}
/**
* Parses text from the beginning of the given string to produce an object
* array.
* The method may not use the entire text of the given string.
* <p>
* See the {@link #parse(String, ParsePosition)} method for more information
* on message parsing.
*
* @param source A <code>String</code> whose beginning should be parsed.
* @return An <code>Object</code> 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.
* <p>
* The method attempts to parse text starting at the index given by
* <code>pos</code>.
* If parsing succeeds, then the index of <code>pos</code> 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 <code>pos</code> can be used to
* indicate the starting point for the next call to this method.
* If an error occurs, then the index of <code>pos</code> is not
* changed, the error index of <code>pos</code> is set to the index of
* the character where the error occurred, and null is returned.
* <p>
* See the {@link #parse(String, ParsePosition)} method for more information
* on message parsing.
*
* @param source A <code>String</code>, part of which should be parsed.
* @param pos A <code>ParsePosition</code> object with index and error
* index information as described above.
* @return An <code>Object</code> array parsed from the string. In case of
* error, returns null.
* @exception NullPointerException if <code>pos</code> 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 =
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 =
offsets.
clone();
other.
argumentNumbers =
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
* <code>AttributedCharacterIterator</code> returned
* from <code>MessageFormat.formatToCharacterIterator</code>.
*
* @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 <code>formatToCharacterIterator</code>.
* The value associated with the key will be an <code>Integer</code>
* indicating the index in the <code>arguments</code> 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 <code>offsets</code>. Can also be thought of
* as the index of the highest-numbered element in <code>offsets</code> that is being used.
* All of these arrays should have the same number of elements being used as <code>offsets</code>
* 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 <code>characterIterators</code> is
* non-null, AttributedCharacterIterator will be created from the
* subformats as necessary. If <code>characterIterators</code> is null
* and <code>fp</code> is non-null and identifies
* <code>Field.MESSAGE_ARGUMENT</code>, the location of
* the first replaced argument will be set in it.
*
* @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.
*/
private
StringBuffer subformat(
Object[]
arguments,
StringBuffer result,
FieldPosition fp,
List<
AttributedCharacterIterator>
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
* <code>iterator</code> to the StringBuffer <code>result</code>.
*/
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.");
}
}
}