1 /*

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

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 /*

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

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

    29  *

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

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

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

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

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

    35  *   Taligent is a registered trademark of Taligent, Inc.

    36  *

    37  */

    38 

    39 package java.text;

    40 

    41 import java.io.InvalidObjectException;

    42 import java.io.IOException;

    43 import java.io.ObjectInputStream;

    44 import java.text.DecimalFormat;

    45 import java.util.ArrayList;

    46 import java.util.Arrays;

    47 import java.util.Date;

    48 import java.util.List;

    49 import java.util.Locale;

    50 

    51 

    52 /**

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

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

    55  * displayed for end users.

    56  *

    57  * <p>

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

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

    60  *

    61  * <p>

    62  * <strong>Note:</strong>

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

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

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

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

    67  * itself doesn't implement locale specific behavior. Any locale specific

    68  * behavior is defined by the pattern that you provide as well as the

    69  * subformats used for inserted arguments.

    70  *

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

    72  *

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

    74  * <blockquote><pre>

    75  * <i>MessageFormatPattern:</i>

    76  *         <i>String</i>

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

    78  *

    79  * <i>FormatElement:</i>

    80  *         { <i>ArgumentIndex</i> }

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

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

    83  *

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

    85  *         number date time choice

    86  *

    87  * <i>FormatStyle:</i>

    88  *         short

    89  *         medium

    90  *         long

    91  *         full

    92  *         integer

    93  *         currency

    94  *         percent

    95  *         <i>SubformatPattern</i>

    96  * </pre></blockquote>

    97  *

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

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

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

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

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

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

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

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

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

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

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

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

   110  *

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

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

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

   114  * (<i>SubformatPattern</i> with underline) will produce a number format

   115  * with the pound-sign quoted, with a result such as: {@code

   116  * "$#31,45"}. Refer to each {@code Format} subclass documentation for

   117  * details.

   118  *

   119  * <p>Any unmatched quote is treated as closed at the end of the given

   120  * pattern. For example, pattern string {@code "'{0}"} is treated as

   121  * pattern {@code "'{0}'"}.

   122  *

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

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

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

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

   127  *

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

   129  * format patterns unfortunately have shown to be somewhat confusing.

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

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

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

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

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

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

   136  * </dl>

   137  * <p>

   138  * The <i>ArgumentIndex</i> value is a non-negative integer written

   139  * using the digits {@code '0'} through {@code '9'}, and represents an index into the

   140  * {@code arguments} array passed to the {@code format} methods

   141  * or the result array returned by the {@code parse} methods.

   142  * <p>

   143  * The <i>FormatType</i> and <i>FormatStyle</i> values are used to create

   144  * a {@code Format} instance for the format element. The following

   145  * table shows how the values map to {@code Format} instances. Combinations not

   146  * shown in the table are illegal. A <i>SubformatPattern</i> must

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

   148  *

   149  * <table class="plain">

   150  * <caption style="display:none">Shows how FormatType and FormatStyle values map to Format instances</caption>

   151  * <thead>

   152  *    <tr>

   153  *       <th scope="col" class="TableHeadingColor">FormatType

   154  *       <th scope="col" class="TableHeadingColor">FormatStyle

   155  *       <th scope="col" class="TableHeadingColor">Subformat Created

   156  * </thead>

   157  * <tbody>

   158  *    <tr>

   159  *       <th scope="row" style="text-weight: normal"><i>(none)</i>

   160  *       <th scope="row" style="text-weight: normal"><i>(none)</i>

   161  *       <td>{@code null}

   162  *    <tr>

   163  *       <th scope="row" style="text-weight: normal" rowspan=5>{@code number}

   164  *       <th scope="row" style="text-weight: normal"><i>(none)</i>

   165  *       <td>{@link NumberFormat#getInstance(Locale) NumberFormat.getInstance}{@code (getLocale())}

   166  *    <tr>

   167  *       <th scope="row" style="text-weight: normal">{@code integer}

   168  *       <td>{@link NumberFormat#getIntegerInstance(Locale) NumberFormat.getIntegerInstance}{@code (getLocale())}

   169  *    <tr>

   170  *       <th scope="row" style="text-weight: normal">{@code currency}

   171  *       <td>{@link NumberFormat#getCurrencyInstance(Locale) NumberFormat.getCurrencyInstance}{@code (getLocale())}

   172  *    <tr>

   173  *       <th scope="row" style="text-weight: normal">{@code percent}

   174  *       <td>{@link NumberFormat#getPercentInstance(Locale) NumberFormat.getPercentInstance}{@code (getLocale())}

   175  *    <tr>

   176  *       <th scope="row" style="text-weight: normal"><i>SubformatPattern</i>

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

   178  *    <tr>

   179  *       <th scope="row" style="text-weight: normal" rowspan=6>{@code date}

   180  *       <th scope="row" style="text-weight: normal"><i>(none)</i>

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

   182  *    <tr>

   183  *       <th scope="row" style="text-weight: normal">{@code short}

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

   185  *    <tr>

   186  *       <th scope="row" style="text-weight: normal">{@code medium}

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

   188  *    <tr>

   189  *       <th scope="row" style="text-weight: normal">{@code long}

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

   191  *    <tr>

   192  *       <th scope="row" style="text-weight: normal">{@code full}

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

   194  *    <tr>

   195  *       <th scope="row" style="text-weight: normal"><i>SubformatPattern</i>

   196  *       <td>{@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())}

   197  *    <tr>

   198  *       <th scope="row" style="text-weight: normal" rowspan=6>{@code time}

   199  *       <th scope="row" style="text-weight: normal"><i>(none)</i>

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

   201  *    <tr>

   202  *       <th scope="row" style="text-weight: normal">{@code short}

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

   204  *    <tr>

   205  *       <th scope="row" style="text-weight: normal">{@code medium}

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

   207  *    <tr>

   208  *       <th scope="row" style="text-weight: normal">{@code long}

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

   210  *    <tr>

   211  *       <th scope="row" style="text-weight: normal">{@code full}

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

   213  *    <tr>

   214  *       <th scope="row" style="text-weight: normal"><i>SubformatPattern</i>

   215  *       <td>{@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())}

   216  *    <tr>

   217  *       <th scope="row" style="text-weight: normal">{@code choice}

   218  *       <th scope="row" style="text-weight: normal"><i>SubformatPattern</i>

   219  *       <td>{@code new} {@link ChoiceFormat#ChoiceFormat(String) ChoiceFormat}{@code (subformatPattern)}

   220  * </tbody>

   221  * </table>

   222  *

   223  * <h4>Usage Information</h4>

   224  *

   225  * <p>

   226  * Here are some examples of usage.

   227  * In real internationalized programs, the message format pattern and other

   228  * static strings will, of course, be obtained from resource bundles.

   229  * Other parameters will be dynamically determined at runtime.

   230  * <p>

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

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

   233  * <blockquote><pre>

   234  * int planet = 7;

   235  * String event = "a disturbance in the Force";

   236  *

   237  * String result = MessageFormat.format(

   238  *     "At {1,time} on {1,date}, there was {2} on planet {0,number,integer}.",

   239  *     planet, new Date(), event);

   240  * </pre></blockquote>

   241  * The output is:

   242  * <blockquote><pre>

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

   244  * </pre></blockquote>

   245  *

   246  * <p>

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

   248  * can be used repeatedly:

   249  * <blockquote><pre>

   250  * int fileCount = 1273;

   251  * String diskName = "MyDisk";

   252  * Object[] testArgs = {new Long(fileCount), diskName};

   253  *

   254  * MessageFormat form = new MessageFormat(

   255  *     "The disk \"{1}\" contains {0} file(s).");

   256  *

   257  * System.out.println(form.format(testArgs));

   258  * </pre></blockquote>

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

   260  * <blockquote><pre>

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

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

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

   264  * </pre></blockquote>

   265  *

   266  * <p>

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

   268  * to produce correct forms for singular and plural:

   269  * <blockquote><pre>

   270  * MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0}.");

   271  * double[] filelimits = {0,1,2};

   272  * String[] filepart = {"no files","one file","{0,number} files"};

   273  * ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);

   274  * form.setFormatByArgumentIndex(0, fileform);

   275  *

   276  * int fileCount = 1273;

   277  * String diskName = "MyDisk";

   278  * Object[] testArgs = {new Long(fileCount), diskName};

   279  *

   280  * System.out.println(form.format(testArgs));

   281  * </pre></blockquote>

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

   283  * <blockquote><pre>

   284  * The disk "MyDisk" contains no files.

   285  * The disk "MyDisk" contains one file.

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

   287  * </pre></blockquote>

   288  *

   289  * <p>

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

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

   292  * for more information.

   293  * <blockquote><pre>{@code

   294  * form.applyPattern(

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

   296  * }</pre></blockquote>

   297  *

   298  * <p>

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

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

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

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

   303  * programmatically (instead of using the string patterns), then be careful not to

   304  * produce a format that recurses on itself, which will cause an infinite loop.

   305  * <p>

   306  * When a single argument is parsed more than once in the string, the last match

   307  * will be the final result of the parsing.  For example,

   308  * <blockquote><pre>

   309  * MessageFormat mf = new MessageFormat("{0,number,#.##}, {0,number,#.#}");

   310  * Object[] objs = {new Double(3.1415)};

   311  * String result = mf.format( objs );

   312  * // result now equals "3.14, 3.1"

   313  * objs = null;

   314  * objs = mf.parse(result, new ParsePosition(0));

   315  * // objs now equals {new Double(3.1)}

   316  * </pre></blockquote>

   317  *

   318  * <p>

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

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

   321  * example,

   322  * <blockquote><pre>

   323  * MessageFormat mf = new MessageFormat("{0}, {0}, {0}");

   324  * String forParsing = "x, y, z";

   325  * Object[] objs = mf.parse(forParsing, new ParsePosition(0));

   326  * // result now equals {new String("z")}

   327  * </pre></blockquote>

   328  *

   329  * <h4><a id="synchronization">Synchronization</a></h4>

   330  *

   331  * <p>

   332  * Message formats are not synchronized.

   333  * It is recommended to create separate format instances for each thread.

   334  * If multiple threads access a format concurrently, it must be synchronized

   335  * externally.

   336  *

   337  * @see          java.util.Locale

   338  * @see          Format

   339  * @see          NumberFormat

   340  * @see          DecimalFormat

   341  * @see          DecimalFormatSymbols

   342  * @see          ChoiceFormat

   343  * @see          DateFormat

   344  * @see          SimpleDateFormat

   345  *

   346  * @author       Mark Davis

   347  * @since 1.1

   348  */

   349 

   350 public class MessageFormat extends Format {

   351 

   352     private static final long serialVersionUID = 6479157306784022952L;

   353 

   354     /**

   355      * Constructs a MessageFormat for the default

   356      * {@link java.util.Locale.Category#FORMAT FORMAT} locale and the

   357      * specified pattern.

   358      * The constructor first sets the locale, then parses the pattern and

   359      * creates a list of subformats for the format elements contained in it.

   360      * Patterns and their interpretation are specified in the

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

   362      *

   363      * @param pattern the pattern for this message format

   364      * @exception IllegalArgumentException if the pattern is invalid

   365      * @exception NullPointerException if {@code pattern} is

   366      *            {@code null}

   367      */

   368     public MessageFormat(String pattern) {

   369         this.locale = Locale.getDefault(Locale.Category.FORMAT);

   370         applyPattern(pattern);

   371     }

   372 

   373     /**

   374      * Constructs a MessageFormat for the specified locale and

   375      * pattern.

   376      * The constructor first sets the locale, then parses the pattern and

   377      * creates a list of subformats for the format elements contained in it.

   378      * Patterns and their interpretation are specified in the

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

   380      *

   381      * @param pattern the pattern for this message format

   382      * @param locale the locale for this message format

   383      * @exception IllegalArgumentException if the pattern is invalid

   384      * @exception NullPointerException if {@code pattern} is

   385      *            {@code null}

   386      * @since 1.4

   387      */

   388     public MessageFormat(String pattern, Locale locale) {

   389         this.locale = locale;

   390         applyPattern(pattern);

   391     }

   392 

   393     /**

   394      * Sets the locale to be used when creating or comparing subformats.

   395      * This affects subsequent calls

   396      * <ul>

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

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

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

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

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

   402      *     {@link #formatToCharacterIterator formatToCharacterIterator} methods

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

   404      *     the subformats created in the formatting methods.

   405      * </ul>

   406      * Subformats that have already been created are not affected.

   407      *

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

   409      */

   410     public void setLocale(Locale locale) {

   411         this.locale = locale;

   412     }

   413 

   414     /**

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

   416      *

   417      * @return the locale used when creating or comparing subformats

   418      */

   419     public Locale getLocale() {

   420         return locale;

   421     }

   422 

   423 

   424     /**

   425      * Sets the pattern used by this message format.

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

   427      * for the format elements contained in it.

   428      * Patterns and their interpretation are specified in the

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

   430      *

   431      * @param pattern the pattern for this message format

   432      * @exception IllegalArgumentException if the pattern is invalid

   433      * @exception NullPointerException if {@code pattern} is

   434      *            {@code null}

   435      */

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

   437     public void applyPattern(String pattern) {

   438             StringBuilder[] segments = new StringBuilder[4];

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

   440             // allocated on demand.

   441             segments[SEG_RAW] = new StringBuilder();

   442 

   443             int part = SEG_RAW;

   444             int formatNumber = 0;

   445             boolean inQuote = false;

   446             int braceStack = 0;

   447             maxOffset = -1;

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

   449                 char ch = pattern.charAt(i);

   450                 if (part == SEG_RAW) {

   451                     if (ch == '\'') {

   452                         if (i + 1 < pattern.length()

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

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

   455                             ++i;

   456                         } else {

   457                             inQuote = !inQuote;

   458                         }

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

   460                         part = SEG_INDEX;

   461                         if (segments[SEG_INDEX] == null) {

   462                             segments[SEG_INDEX] = new StringBuilder();

   463                         }

   464                     } else {

   465                         segments[part].append(ch);

   466                     }

   467                 } else  {

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

   469                         segments[part].append(ch);

   470                         if (ch == '\'') {

   471                             inQuote = false;

   472                         }

   473                     } else {

   474                         switch (ch) {

   475                         case ',':

   476                             if (part < SEG_MODIFIER) {

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

   478                                     segments[part] = new StringBuilder();

   479                                 }

   480                             } else {

   481                                 segments[part].append(ch);

   482                             }

   483                             break;

   484                         case '{':

   485                             ++braceStack;

   486                             segments[part].append(ch);

   487                             break;

   488                         case '}':

   489                             if (braceStack == 0) {

   490                                 part = SEG_RAW;

   491                                 makeFormat(i, formatNumber, segments);

   492                                 formatNumber++;

   493                                 // throw away other segments

   494                                 segments[SEG_INDEX] = null;

   495                                 segments[SEG_TYPE] = null;

   496                                 segments[SEG_MODIFIER] = null;

   497                             } else {

   498                                 --braceStack;

   499                                 segments[part].append(ch);

   500                             }

   501                             break;

   502                         case ' ':

   503                             // Skip any leading space chars for SEG_TYPE.

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

   505                                 segments[part].append(ch);

   506                             }

   507                             break;

   508                         case '\'':

   509                             inQuote = true;

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

   511                         default:

   512                             segments[part].append(ch);

   513                             break;

   514                         }

   515                     }

   516                 }

   517             }

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

   519                 maxOffset = -1;

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

   521             }

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

   523     }

   524 

   525 

   526     /**

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

   528      * The string is constructed from internal information and therefore

   529      * does not necessarily equal the previously applied pattern.

   530      *

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

   532      */

   533     public String toPattern() {

   534         // later, make this more extensible

   535         int lastOffset = 0;

   536         StringBuilder result = new StringBuilder();

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

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

   539             lastOffset = offsets[i];

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

   541             Format fmt = formats[i];

   542             if (fmt == null) {

   543                 // do nothing, string format

   544             } else if (fmt instanceof NumberFormat) {

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

   546                     result.append(",number");

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

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

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

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

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

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

   553                 } else {

   554                     if (fmt instanceof DecimalFormat) {

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

   556                     } else if (fmt instanceof ChoiceFormat) {

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

   558                     } else {

   559                         // UNKNOWN

   560                     }

   561                 }

   562             } else if (fmt instanceof DateFormat) {

   563                 int index;

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

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

   566                                                                locale);

   567                     if (fmt.equals(df)) {

   568                         result.append(",date");

   569                         break;

   570                     }

   571                     df = DateFormat.getTimeInstance(DATE_TIME_MODIFIERS[index],

   572                                                     locale);

   573                     if (fmt.equals(df)) {

   574                         result.append(",time");

   575                         break;

   576                     }

   577                 }

   578                 if (index >= DATE_TIME_MODIFIERS.length) {

   579                     if (fmt instanceof SimpleDateFormat) {

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

   581                     } else {

   582                         // UNKNOWN

   583                     }

   584                 } else if (index != MODIFIER_DEFAULT) {

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

   586                 }

   587             } else {

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

   589             }

   590             result.append('}');

   591         }

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

   593         return result.toString();

   594     }

   595 

   596     /**

   597      * Sets the formats to use for the values passed into

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

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

   600      * correspond to the argument indices used in the previously set

   601      * pattern string.

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

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

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

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

   606      * <p>

   607      * If an argument index is used for more than one format element

   608      * in the pattern string, then the corresponding new format is used

   609      * for all such format elements. If an argument index is not used

   610      * for any format element in the pattern string, then the

   611      * corresponding new format is ignored. If fewer formats are provided

   612      * than needed, then only the formats for argument indices less

   613      * than <code>newFormats.length</code> are replaced.

   614      *

   615      * @param newFormats the new formats to use

   616      * @exception NullPointerException if <code>newFormats</code> is null

   617      * @since 1.4

   618      */

   619     public void setFormatsByArgumentIndex(Format[] newFormats) {

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

   621             int j = argumentNumbers[i];

   622             if (j < newFormats.length) {

   623                 formats[i] = newFormats[j];

   624             }

   625         }

   626     }

   627 

   628     /**

   629      * Sets the formats to use for the format elements in the

   630      * previously set pattern string.

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

   632      * the order of format elements in the pattern string.

   633      * <p>

   634      * If more formats are provided than needed by the pattern string,

   635      * the remaining ones are ignored. If fewer formats are provided

   636      * than needed, then only the first <code>newFormats.length</code>

   637      * formats are replaced.

   638      * <p>

   639      * Since the order of format elements in a pattern string often

   640      * changes during localization, it is generally better to use the

   641      * {@link #setFormatsByArgumentIndex setFormatsByArgumentIndex}

   642      * method, which assumes an order of formats corresponding to the

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

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

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

   646      *

   647      * @param newFormats the new formats to use

   648      * @exception NullPointerException if <code>newFormats</code> is null

   649      */

   650     public void setFormats(Format[] newFormats) {

   651         int runsToCopy = newFormats.length;

   652         if (runsToCopy > maxOffset + 1) {

   653             runsToCopy = maxOffset + 1;

   654         }

   655         for (int i = 0; i < runsToCopy; i++) {

   656             formats[i] = newFormats[i];

   657         }

   658     }

   659 

   660     /**

   661      * Sets the format to use for the format elements within the

   662      * previously set pattern string that use the given argument

   663      * index.

   664      * The argument index is part of the format element definition and

   665      * represents an index into the <code>arguments</code> array passed

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

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

   668      * <p>

   669      * If the argument index is used for more than one format element

   670      * in the pattern string, then the new format is used for all such

   671      * format elements. If the argument index is not used for any format

   672      * element in the pattern string, then the new format is ignored.

   673      *

   674      * @param argumentIndex the argument index for which to use the new format

   675      * @param newFormat the new format to use

   676      * @since 1.4

   677      */

   678     public void setFormatByArgumentIndex(int argumentIndex, Format newFormat) {

   679         for (int j = 0; j <= maxOffset; j++) {

   680             if (argumentNumbers[j] == argumentIndex) {

   681                 formats[j] = newFormat;

   682             }

   683         }

   684     }

   685 

   686     /**

   687      * Sets the format to use for the format element with the given

   688      * format element index within the previously set pattern string.

   689      * The format element index is the zero-based number of the format

   690      * element counting from the start of the pattern string.

   691      * <p>

   692      * Since the order of format elements in a pattern string often

   693      * changes during localization, it is generally better to use the

   694      * {@link #setFormatByArgumentIndex setFormatByArgumentIndex}

   695      * method, which accesses format elements based on the argument

   696      * index they specify.

   697      *

   698      * @param formatElementIndex the index of a format element within the pattern

   699      * @param newFormat the format to use for the specified format element

   700      * @exception ArrayIndexOutOfBoundsException if {@code formatElementIndex} is equal to or

   701      *            larger than the number of format elements in the pattern string

   702      */

   703     public void setFormat(int formatElementIndex, Format newFormat) {

   704         formats[formatElementIndex] = newFormat;

   705     }

   706 

   707     /**

   708      * Gets the formats used for the values passed into

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

   710      * methods. The indices of elements in the returned array

   711      * correspond to the argument indices used in the previously set

   712      * pattern string.

   713      * The order of formats in the returned array thus corresponds to

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

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

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

   717      * <p>

   718      * If an argument index is used for more than one format element

   719      * in the pattern string, then the format used for the last such

   720      * format element is returned in the array. If an argument index

   721      * is not used for any format element in the pattern string, then

   722      * null is returned in the array.

   723      *

   724      * @return the formats used for the arguments within the pattern

   725      * @since 1.4

   726      */

   727     public Format[] getFormatsByArgumentIndex() {

   728         int maximumArgumentNumber = -1;

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

   730             if (argumentNumbers[i] > maximumArgumentNumber) {

   731                 maximumArgumentNumber = argumentNumbers[i];

   732             }

   733         }

   734         Format[] resultArray = new Format[maximumArgumentNumber + 1];

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

   736             resultArray[argumentNumbers[i]] = formats[i];

   737         }

   738         return resultArray;

   739     }

   740 

   741     /**

   742      * Gets the formats used for the format elements in the

   743      * previously set pattern string.

   744      * The order of formats in the returned array corresponds to

   745      * the order of format elements in the pattern string.

   746      * <p>

   747      * Since the order of format elements in a pattern string often

   748      * changes during localization, it's generally better to use the

   749      * {@link #getFormatsByArgumentIndex getFormatsByArgumentIndex}

   750      * method, which assumes an order of formats corresponding to the

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

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

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

   754      *

   755      * @return the formats used for the format elements in the pattern

   756      */

   757     public Format[] getFormats() {

   758         Format[] resultArray = new Format[maxOffset + 1];

   759         System.arraycopy(formats, 0, resultArray, 0, maxOffset + 1);

   760         return resultArray;

   761     }

   762 

   763     /**

   764      * Formats an array of objects and appends the <code>MessageFormat</code>'s

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

   766      * provided <code>StringBuffer</code>.

   767      * <p>

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

   769      * the current subformat of the format element and the

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

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

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

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

   774      *

   775      * <table class="plain">

   776      * <caption style="display:none">Examples of subformat,argument,and formatted text</caption>

   777      * <thead>

   778      *    <tr>

   779      *       <th scope="col">Subformat

   780      *       <th scope="col">Argument

   781      *       <th scope="col">Formatted Text

   782      * </thead>

   783      * <tbody>

   784      *    <tr>

   785      *       <th scope="row" style="text-weight-normal" rowspan=2><i>any</i>

   786      *       <th scope="row" style="text-weight-normal"><i>unavailable</i>

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

   788      *    <tr>

   789      *       <th scope="row" style="text-weight-normal"><code>null</code>

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

   791      *    <tr>

   792      *       <th scope="row" style="text-weight-normal"><code>instanceof ChoiceFormat</code>

   793      *       <th scope="row" style="text-weight-normal"><i>any</i>

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

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

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

   797      *    <tr>

   798      *       <th scope="row" style="text-weight-normal"><code>!= null</code>

   799      *       <th scope="row" style="text-weight-normal"><i>any</i>

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

   801      *    <tr>

   802      *       <th scope="row" style="text-weight-normal" rowspan=4><code>null</code>

   803      *       <th scope="row" style="text-weight-normal"><code>instanceof Number</code>

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

   805      *    <tr>

   806      *       <th scope="row" style="text-weight-normal"><code>instanceof Date</code>

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

   808      *    <tr>

   809      *       <th scope="row" style="text-weight-normal"><code>instanceof String</code>

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

   811      *    <tr>

   812      *       <th scope="row" style="text-weight-normal"><i>any</i>

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

   814      * </tbody>

   815      * </table>

   816      * <p>

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

   818      * <code>Field.ARGUMENT</code>, the location of the first formatted

   819      * string will be returned.

   820      *

   821      * @param arguments an array of objects to be formatted and substituted.

   822      * @param result where text is appended.

   823      * @param pos On input: an alignment field, if desired.

   824      *            On output: the offsets of the alignment field.

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

   826      * text appended

   827      * @exception IllegalArgumentException if an argument in the

   828      *            <code>arguments</code> array is not of the type

   829      *            expected by the format element(s) that use it.

   830      * @exception NullPointerException if {@code result} is {@code null}

   831      */

   832     public final StringBuffer format(Object[] arguments, StringBuffer result,

   833                                      FieldPosition pos)

   834     {

   835         return subformat(arguments, result, pos, null);

   836     }

   837 

   838     /**

   839      * Creates a MessageFormat with the given pattern and uses it

   840      * to format the given arguments. This is equivalent to

   841      * <blockquote>

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

   843      * </blockquote>

   844      *

   845      * @param pattern   the pattern string

   846      * @param arguments object(s) to format

   847      * @return the formatted string

   848      * @exception IllegalArgumentException if the pattern is invalid,

   849      *            or if an argument in the <code>arguments</code> array

   850      *            is not of the type expected by the format element(s)

   851      *            that use it.

   852      * @exception NullPointerException if {@code pattern} is {@code null}

   853      */

   854     public static String format(String pattern, Object ... arguments) {

   855         MessageFormat temp = new MessageFormat(pattern);

   856         return temp.format(arguments);

   857     }

   858 

   859     // Overrides

   860     /**

   861      * Formats an array of objects and appends the <code>MessageFormat</code>'s

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

   863      * provided <code>StringBuffer</code>.

   864      * This is equivalent to

   865      * <blockquote>

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

   867      * </blockquote>

   868      *

   869      * @param arguments an array of objects to be formatted and substituted.

   870      * @param result where text is appended.

   871      * @param pos On input: an alignment field, if desired.

   872      *            On output: the offsets of the alignment field.

   873      * @exception IllegalArgumentException if an argument in the

   874      *            <code>arguments</code> array is not of the type

   875      *            expected by the format element(s) that use it.

   876      * @exception NullPointerException if {@code result} is {@code null}

   877      */

   878     public final StringBuffer format(Object arguments, StringBuffer result,

   879                                      FieldPosition pos)

   880     {

   881         return subformat((Object[]) arguments, result, pos, null);

   882     }

   883 

   884     /**

   885      * Formats an array of objects and inserts them into the

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

   887      * <code>AttributedCharacterIterator</code>.

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

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

   890      * about the resulting String.

   891      * <p>

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

   893      * the same that would be returned by

   894      * <blockquote>

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

   896      * </blockquote>

   897      * <p>

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

   899      * least attributes indicating where text was generated from an

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

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

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

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

   904      * <p>

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

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

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

   908      * This allows you to not only find where an argument is placed in the

   909      * resulting String, but also which fields it contains in turn.

   910      *

   911      * @param arguments an array of objects to be formatted and substituted.

   912      * @return AttributedCharacterIterator describing the formatted value.

   913      * @exception NullPointerException if <code>arguments</code> is null.

   914      * @exception IllegalArgumentException if an argument in the

   915      *            <code>arguments</code> array is not of the type

   916      *            expected by the format element(s) that use it.

   917      * @since 1.4

   918      */

   919     public AttributedCharacterIterator formatToCharacterIterator(Object arguments) {

   920         StringBuffer result = new StringBuffer();

   921         ArrayList<AttributedCharacterIterator> iterators = new ArrayList<>();

   922 

   923         if (arguments == null) {

   924             throw new NullPointerException(

   925                    "formatToCharacterIterator must be passed non-null object");

   926         }

   927         subformat((Object[]) arguments, result, null, iterators);

   928         if (iterators.size() == 0) {

   929             return createAttributedCharacterIterator("");

   930         }

   931         return createAttributedCharacterIterator(

   932                      iterators.toArray(

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

   934     }

   935 

   936     /**

   937      * Parses the string.

   938      *

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

   940      * For example:

   941      * <ul>

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

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

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

   945      * <li>Does not yet handle recursion (where

   946      *     the substituted strings contain {n} references.)

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

   948      *     if some part of the parse is ambiguous.

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

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

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

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

   953      *     then the later parse wins.

   954      * </ul>

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

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

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

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

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

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

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

   962      *

   963      * @param source the string to parse

   964      * @param pos    the parse position

   965      * @return an array of parsed objects

   966      * @exception NullPointerException if {@code pos} is {@code null}

   967      *            for a non-null {@code source} string.

   968      */

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

   970         if (source == null) {

   971             Object[] empty = {};

   972             return empty;

   973         }

   974 

   975         int maximumArgumentNumber = -1;

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

   977             if (argumentNumbers[i] > maximumArgumentNumber) {

   978                 maximumArgumentNumber = argumentNumbers[i];

   979             }

   980         }

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

   982 

   983         int patternOffset = 0;

   984         int sourceOffset = pos.index;

   985         ParsePosition tempStatus = new ParsePosition(0);

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

   987             // match up to format

   988             int len = offsets[i] - patternOffset;

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

   990                                                   source, sourceOffset, len)) {

   991                 sourceOffset += len;

   992                 patternOffset += len;

   993             } else {

   994                 pos.errorIndex = sourceOffset;

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

   996             }

   997 

   998             // now use format

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

  1000                 // if at end, use longest possible match

  1001                 // otherwise uses first match to intervening string

  1002                 // does NOT recursively try all possibilities

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

  1004 

  1005                 int next;

  1006                 if (patternOffset >= tempLength) {

  1007                     next = source.length();

  1008                 }else{

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

  1010                                           sourceOffset);

  1011                 }

  1012 

  1013                 if (next < 0) {

  1014                     pos.errorIndex = sourceOffset;

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

  1016                 } else {

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

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

  1019                         resultArray[argumentNumbers[i]]

  1020                             = source.substring(sourceOffset,next);

  1021                     sourceOffset = next;

  1022                 }

  1023             } else {

  1024                 tempStatus.index = sourceOffset;

  1025                 resultArray[argumentNumbers[i]]

  1026                     = formats[i].parseObject(source,tempStatus);

  1027                 if (tempStatus.index == sourceOffset) {

  1028                     pos.errorIndex = sourceOffset;

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

  1030                 }

  1031                 sourceOffset = tempStatus.index; // update

  1032             }

  1033         }

  1034         int len = pattern.length() - patternOffset;

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

  1036                                               source, sourceOffset, len)) {

  1037             pos.index = sourceOffset + len;

  1038         } else {

  1039             pos.errorIndex = sourceOffset;

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

  1041         }

  1042         return resultArray;

  1043     }

  1044 

  1045     /**

  1046      * Parses text from the beginning of the given string to produce an object

  1047      * array.

  1048      * The method may not use the entire text of the given string.

  1049      * <p>

  1050      * See the {@link #parse(String, ParsePosition)} method for more information

  1051      * on message parsing.

  1052      *

  1053      * @param source A <code>String</code> whose beginning should be parsed.

  1054      * @return An <code>Object</code> array parsed from the string.

  1055      * @exception ParseException if the beginning of the specified string

  1056      *            cannot be parsed.

  1057      */

  1058     public Object[] parse(String source) throws ParseException {

  1059         ParsePosition pos  = new ParsePosition(0);

  1060         Object[] result = parse(source, pos);

  1061         if (pos.index == 0)  // unchanged, returned object is null

  1062             throw new ParseException("MessageFormat parse error!", pos.errorIndex);

  1063 

  1064         return result;

  1065     }

  1066 

  1067     /**

  1068      * Parses text from a string to produce an object array.

  1069      * <p>

  1070      * The method attempts to parse text starting at the index given by

  1071      * <code>pos</code>.

  1072      * If parsing succeeds, then the index of <code>pos</code> is updated

  1073      * to the index after the last character used (parsing does not necessarily

  1074      * use all characters up to the end of the string), and the parsed

  1075      * object array is returned. The updated <code>pos</code> can be used to

  1076      * indicate the starting point for the next call to this method.

  1077      * If an error occurs, then the index of <code>pos</code> is not

  1078      * changed, the error index of <code>pos</code> is set to the index of

  1079      * the character where the error occurred, and null is returned.

  1080      * <p>

  1081      * See the {@link #parse(String, ParsePosition)} method for more information

  1082      * on message parsing.

  1083      *

  1084      * @param source A <code>String</code>, part of which should be parsed.

  1085      * @param pos A <code>ParsePosition</code> object with index and error

  1086      *            index information as described above.

  1087      * @return An <code>Object</code> array parsed from the string. In case of

  1088      *         error, returns null.

  1089      * @throws NullPointerException if {@code pos} is null.

  1090      */

  1091     public Object parseObject(String source, ParsePosition pos) {

  1092         return parse(source, pos);

  1093     }

  1094 

  1095     /**

  1096      * Creates and returns a copy of this object.

  1097      *

  1098      * @return a clone of this instance.

  1099      */

  1100     public Object clone() {

  1101         MessageFormat other = (MessageFormat) super.clone();

  1102 

  1103         // clone arrays. Can't do with utility because of bug in Cloneable

  1104         other.formats = formats.clone(); // shallow clone

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

  1106             if (formats[i] != null)

  1107                 other.formats[i] = (Format)formats[i].clone();

  1108         }

  1109         // for primitives or immutables, shallow clone is enough

  1110         other.offsets = offsets.clone();

  1111         other.argumentNumbers = argumentNumbers.clone();

  1112 

  1113         return other;

  1114     }

  1115 

  1116     /**

  1117      * Equality comparison between two message format objects

  1118      */

  1119     public boolean equals(Object obj) {

  1120         if (this == obj)                      // quick check

  1121             return true;

  1122         if (obj == null || getClass() != obj.getClass())

  1123             return false;

  1124         MessageFormat other = (MessageFormat) obj;

  1125         return (maxOffset == other.maxOffset

  1126                 && pattern.equals(other.pattern)

  1127                 && ((locale != null && locale.equals(other.locale))

  1128                  || (locale == null && other.locale == null))

  1129                 && Arrays.equals(offsets,other.offsets)

  1130                 && Arrays.equals(argumentNumbers,other.argumentNumbers)

  1131                 && Arrays.equals(formats,other.formats));

  1132     }

  1133 

  1134     /**