Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.base.jmod - Base Module
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module.
JDK 11 Base module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.base.jmod.
JDK 11 Base module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Base module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/text/MessageFormat.java
/* * Copyright (c) 1996, 2017, 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 id="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 class="plain"> * <caption style="display:none">Shows how FormatType and FormatStyle values map to Format instances</caption> * <thead> * <tr> * <th scope="col" class="TableHeadingColor">FormatType * <th scope="col" class="TableHeadingColor">FormatStyle * <th scope="col" class="TableHeadingColor">Subformat Created * </thead> * <tbody> * <tr> * <th scope="row" style="text-weight: normal"><i>(none)</i> * <th scope="row" style="text-weight: normal"><i>(none)</i> * <td>{@code null} * <tr> * <th scope="row" style="text-weight: normal" rowspan=5>{@code number} * <th scope="row" style="text-weight: normal"><i>(none)</i> * <td>{@link NumberFormat#getInstance(Locale) NumberFormat.getInstance}{@code (getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code integer} * <td>{@link NumberFormat#getIntegerInstance(Locale) NumberFormat.getIntegerInstance}{@code (getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code currency} * <td>{@link NumberFormat#getCurrencyInstance(Locale) NumberFormat.getCurrencyInstance}{@code (getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code percent} * <td>{@link NumberFormat#getPercentInstance(Locale) NumberFormat.getPercentInstance}{@code (getLocale())} * <tr> * <th scope="row" style="text-weight: normal"><i>SubformatPattern</i> * <td>{@code new} {@link DecimalFormat#DecimalFormat(String,DecimalFormatSymbols) DecimalFormat}{@code (subformatPattern,} {@link DecimalFormatSymbols#getInstance(Locale) DecimalFormatSymbols.getInstance}{@code (getLocale()))} * <tr> * <th scope="row" style="text-weight: normal" rowspan=6>{@code date} * <th scope="row" style="text-weight: normal"><i>(none)</i> * <td>{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code short} * <td>{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#SHORT}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code medium} * <td>{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code long} * <td>{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#LONG}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code full} * <td>{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}{@code (}{@link DateFormat#FULL}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal"><i>SubformatPattern</i> * <td>{@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())} * <tr> * <th scope="row" style="text-weight: normal" rowspan=6>{@code time} * <th scope="row" style="text-weight: normal"><i>(none)</i> * <td>{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code short} * <td>{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#SHORT}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code medium} * <td>{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code long} * <td>{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#LONG}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code full} * <td>{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}{@code (}{@link DateFormat#FULL}{@code , getLocale())} * <tr> * <th scope="row" style="text-weight: normal"><i>SubformatPattern</i> * <td>{@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())} * <tr> * <th scope="row" style="text-weight: normal">{@code choice} * <th scope="row" style="text-weight: normal"><i>SubformatPattern</i> * <td>{@code new} {@link ChoiceFormat#ChoiceFormat(String) ChoiceFormat}{@code (subformatPattern)} * </tbody> * </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 id="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 * @since 1.1 */ 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 * @exception NullPointerException if {@code pattern} is * {@code null} */ 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 * @exception NullPointerException if {@code pattern} is * {@code null} * @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 * @exception NullPointerException if {@code pattern} is * {@code null} */ @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) { if (formatElementIndex > maxOffset) { throw new ArrayIndexOutOfBoundsException(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 class="plain"> * <caption style="display:none">Examples of subformat,argument,and formatted text</caption> * <thead> * <tr> * <th scope="col">Subformat * <th scope="col">Argument * <th scope="col">Formatted Text * </thead> * <tbody> * <tr> * <th scope="row" style="text-weight-normal" rowspan=2><i>any</i> * <th scope="row" style="text-weight-normal"><i>unavailable</i> * <td><code>"{" + argumentIndex + "}"</code> * <tr> * <th scope="row" style="text-weight-normal"><code>null</code> * <td><code>"null"</code> * <tr> * <th scope="row" style="text-weight-normal"><code>instanceof ChoiceFormat</code> * <th scope="row" style="text-weight-normal"><i>any</i> * <td><code>subformat.format(argument).indexOf('{') >= 0 ?<br> * (new MessageFormat(subformat.format(argument), getLocale())).format(argument) : * subformat.format(argument)</code> * <tr> * <th scope="row" style="text-weight-normal"><code>!= null</code> * <th scope="row" style="text-weight-normal"><i>any</i> * <td><code>subformat.format(argument)</code> * <tr> * <th scope="row" style="text-weight-normal" rowspan=4><code>null</code> * <th scope="row" style="text-weight-normal"><code>instanceof Number</code> * <td><code>NumberFormat.getInstance(getLocale()).format(argument)</code> * <tr> * <th scope="row" style="text-weight-normal"><code>instanceof Date</code> * <td><code>DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, getLocale()).format(argument)</code> * <tr> * <th scope="row" style="text-weight-normal"><code>instanceof String</code> * <td><code>argument</code> * <tr> * <th scope="row" style="text-weight-normal"><i>any</i> * <td><code>argument.toString()</code> * </tbody> * </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 keeps track on the position of the first replaced argument in the output string. * @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. * @exception NullPointerException if {@code result} is {@code null} */ 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. * @exception NullPointerException if {@code pattern} is {@code null} */ 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 keeps track on the position of the first replaced argument * in the output string. * @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. * @exception NullPointerException if {@code result} is {@code null} */ 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 * @exception NullPointerException if {@code pos} is {@code null} * for a non-null {@code source} string. */ 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. * @throws NullPointerException if {@code pos} is null. */ public Object parseObject(String source, ParsePosition pos) { return parse(source, pos); } /** * Creates and returns a copy of this object. * * @return a clone of this instance. */ public Object clone() { MessageFormat other = (MessageFormat) super.clone(); // clone arrays. Can't do with utility because of bug in Cloneable other.formats = 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 static final 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} is * {@code non-null}, AttributedCharacterIterator will be created from the * subformats as necessary. If {@code characterIterators} is {@code null} * and {@code fp} is {@code non-null} and identifies * {@code Field.ARGUMENT} as the field attribute, 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, 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, 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."); } } }
⏎ java/text/MessageFormat.java
Or download all of them as a single archive file:
File name: java.base-11.0.1-src.zip File size: 8740354 bytes Release date: 2018-11-04 Download
2020-05-29, 245746👍, 0💬
Popular Posts:
JDK 17 java.base.jmod is the JMOD file for JDK 17 Base module. JDK 17 Base module compiled class fil...
How to run "javac" command from JDK tools.jar file? "javac" is the Java compiler command that allows...
Java Advanced Imaging (JAI) is a Java platform extension API that provides a set of object-oriented ...
What Is log4j-1.2.15.jar? I got the JAR file from apache-log4j-1.2.15.zip. log4j-1.2.15.jar is the v...
How to download and install ojdbc6.jar for Oracle 11g R2? ojdbc6.jar for Oracle 11g R2 is a Java 6, ...