| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * (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) { |
| // Android-added: prevent setting unused formatters. |
| if (formatElementIndex > maxOffset) { |
| // Note: maxOffset is maximum index, not the length. |
| throw new ArrayIndexOutOfBoundsException( |
| "maxOffset=" + maxOffset + "; formatElementIndex=" + formatElementIndex); |
| } |
| 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."); |
| } |
| } |
| } |
