/*
    * Copyright (c) 2001-2017, Zoltan Farkas All Rights Reserved.
    *
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    *
    * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
   *
   * Additionally licensed with:
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.spf4j.text;
  //CHECKSTYLE:OFF
  /*
   * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
   * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
   */
  
   /*
   * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
   * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
   *
   *   The original version of this source code and documentation is copyrighted
   * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
   * materials are provided under terms of a License Agreement between Taligent
   * and Sun. This technology is protected by multiple US and International
   * patents. This notice and attribution to Taligent may not be removed.
   *   Taligent is a registered trademark of Taligent, Inc.
   *
   */
  import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  import java.io.InvalidObjectException;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.UncheckedIOException;
  import java.text.AttributedCharacterIterator;
  import java.text.CharacterIterator;
  import java.text.ChoiceFormat;
  import java.text.DateFormat;
  import java.text.DecimalFormat;
  import java.text.DecimalFormatSymbols;
  import java.text.FieldPosition;
  import java.text.Format;
  import java.text.NumberFormat;
  import java.text.ParseException;
  import java.text.ParsePosition;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Date;
  import java.util.List;
  import java.util.Locale;
  import javax.annotation.Nonnull;
  import javax.annotation.Nullable;
  import javax.annotation.concurrent.NotThreadSafe;
  import org.spf4j.base.CharSequences;
  
  /**
   * Performance mutation of the JDK message formatter.
   * Lots things of things have been done:
   * 1) reduced the amount of garbage generated during formatting.
   * 2) made some method invocations static.
   * 3) made this more flexible and usable against StringBuilder not only StringBuffer...
   * 4) thrown exceptions provide more detail on what went wrong.
   * 5) cleaned up lots of static analisys reported issues.
   *
   * <code>MessageFormat</code> provides a means to produce concatenated messages in a language-neutral way. Use this to
   * construct messages displayed for end users.
   *
   * this implementation is based on java.text.MessageFormat with the goal to be a faster and more flexible implementation
   *
   * <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 sub-formats
  * used for inserted arguments.
  *
  * <h3><a name="patterns">Patterns and Their Interpretation</a></h3>
  *
  * <code>MessageFormat</code> uses patterns of the following form:
  * <blockquote><pre>
  * <i>MessageFormatPattern:</i>
  *         <i>String</i>
  *         <i>MessageFormatPattern</i> <i>FormatElement</i> <i>String</i>
  *
  * <i>FormatElement:</i>
  *         { <i>ArgumentIndex</i> }
  *         { <i>ArgumentIndex</i> , <i>FormatType</i> }
  *         { <i>ArgumentIndex</i> , <i>FormatType</i> , <i>FormatStyle</i> }
  *
  * <i>FormatType: one of </i>
  *         number date time choice
  *
  * <i>FormatStyle:</i>
  *         short
  *         medium
  *         long
  *         full
  *         integer
  *         currency
  *         percent
  *         <i>SubformatPattern</i>
  * </pre></blockquote>
  *
  * <p>
  * Within a <i>String</i>, a pair of single quotes can be used to quote any arbitrary characters except single quotes.
  * For example, pattern string <code>"'{0}'"</code> represents string <code>"{0}"</code>, not a <i>FormatElement</i>. A
  * single quote itself must be represented by doubled single quotes {@code ''} throughout a
  * <i>String</i>. For example, pattern string <code>"'{''}'"</code> is interpreted as a sequence of <code>'{</code>
  * (start of quoting and a left curly brace), <code>''</code> (a single quote), and <code>}'</code> (a right curly brace
  * and end of quoting),
  * <em>not</em> <code>'{'</code> and <code>'}'</code> (quoted left and right curly braces): representing string
  * <code>"{'}"</code>,
  * <em>not</em> <code>"{}"</code>.
  *
  * <p>
  * A <i>SubformatPattern</i> is interpreted by its corresponding sub-format, and sub-format-dependent pattern rules
  * apply. For example, pattern string <code>"{1,number,<u>$'#',##</u>}"</code> (<i>SubformatPattern</i> with underline)
  * will produce a number format with the pound-sign quoted, with a result such as: {@code
  * "$#31,45"}. Refer to each {@code Format} subclass documentation for details.
  *
  * <p>
  * Any unmatched quote is treated as closed at the end of the given pattern. For example, pattern string {@code "'{0}"}
  * is treated as pattern {@code "'{0}'"}.
  *
  * <p>
  * Any curly braces within an unquoted pattern must be balanced. For example, <code>"ab {0} de"</code> and
  * <code>"ab '}' de"</code> are valid patterns, but <code>"ab {0'}' de"</code>, <code>"ab } de"</code> and
  * <code>"''{''"</code> are not.
  *
  * <dl><dt><b>Warning:</b><dd>The rules for using quotes within message format patterns unfortunately have shown to be
  * somewhat confusing. In particular, it isn't always obvious to localizers whether single quotes need to be doubled or
  * not. Make sure to inform localizers about the rules, and tell them (for example, by using comments in resource bundle
  * source files) which strings will be processed by {@code MessageFormat}. Note that localizers may need to use single
  * quotes in translated strings where the original version doesn't have them.
  * </dl>
  * <p>
  * The <i>ArgumentIndex</i> value is a non-negative integer written using the digits {@code '0'} through {@code '9'},
  * and represents an index into the {@code arguments} array passed to the {@code format} methods or the result array
  * returned by the {@code parse} methods.
  * <p>
  * The <i>FormatType</i> and <i>FormatStyle</i> values are used to create a {@code Format} instance for the format
  * element. The following table shows how the values map to {@code Format} instances. Combinations not shown in the
  * table are illegal. A <i>SubformatPattern</i> must be a valid pattern string for the {@code Format} subclass used.
  *
  * <table border=1 summary="Shows how FormatType and FormatStyle values map to Format instances">
  * <tr>
  * <th id="ft" class="TableHeadingColor">FormatType
  * <th id="fs" class="TableHeadingColor">FormatStyle
  * <th id="sc" class="TableHeadingColor">Subformat Created
  * <tr>
  * <td headers="ft"><i>(none)</i>
  * <td headers="fs"><i>(none)</i>
  * <td headers="sc"><code>null</code>
  * <tr>
  * <td headers="ft" rowspan=5><code>number</code>
  * <td headers="fs"><i>(none)</i>
  * <td headers="sc">{@link NumberFormat#getInstance(Locale) NumberFormat.getInstance}{@code (getLocale())}
  * <tr>
  * <td headers="fs"><code>integer</code>
  * <td headers="sc">{@link NumberFormat#getIntegerInstance(Locale) NumberFormat.getIntegerInstance}{@code (getLocale())}
  * <tr>
  * <td headers="fs"><code>currency</code>
  * <td headers="sc">{@link NumberFormat#getCurrencyInstance(Locale) NumberFormat.getCurrencyInstance}
  * {@code (getLocale())}
  * <tr>
  * <td headers="fs"><code>percent</code>
  * <td headers="sc">{@link NumberFormat#getPercentInstance(Locale) NumberFormat.getPercentInstance}{@code (getLocale())}
  * <tr>
  * <td headers="fs"><i>SubformatPattern</i>
  * <td headers="sc">{@code new}
  * {@link DecimalFormat#DecimalFormat(String,DecimalFormatSymbols) DecimalFormat}{@code (subformatPattern,}
  * {@link DecimalFormatSymbols#getInstance(Locale) DecimalFormatSymbols.getInstance}{@code (getLocale()))}
  * <tr>
  * <td headers="ft" rowspan=6><code>date</code>
  * <td headers="fs"><i>(none)</i>
  * <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}
  * {@code (}{@link DateFormat#DEFAULT}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><code>short</code>
  * <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}
  * {@code (}{@link DateFormat#SHORT}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><code>medium</code>
  * <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}
  * {@code (}{@link DateFormat#DEFAULT}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><code>long</code>
  * <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}
  * {@code (}{@link DateFormat#LONG}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><code>full</code>
  * <td headers="sc">{@link DateFormat#getDateInstance(int,Locale) DateFormat.getDateInstance}
  * {@code (}{@link DateFormat#FULL}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><i>SubformatPattern</i>
  * <td headers="sc">{@code new}
  * {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())}
  * <tr>
  * <td headers="ft" rowspan=6><code>time</code>
  * <td headers="fs"><i>(none)</i>
  * <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}
  * {@code (}{@link DateFormat#DEFAULT}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><code>short</code>
  * <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}
  * {@code (}{@link DateFormat#SHORT}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><code>medium</code>
  * <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}
  * {@code (}{@link DateFormat#DEFAULT}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><code>long</code>
  * <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}
  * {@code (}{@link DateFormat#LONG}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><code>full</code>
  * <td headers="sc">{@link DateFormat#getTimeInstance(int,Locale) DateFormat.getTimeInstance}
  * {@code (}{@link DateFormat#FULL}{@code , getLocale())}
  * <tr>
  * <td headers="fs"><i>SubformatPattern</i>
  * <td headers="sc">{@code new}
  * {@link SimpleDateFormat#SimpleDateFormat(String,Locale) SimpleDateFormat}{@code (subformatPattern, getLocale())}
  * <tr>
  * <td headers="ft"><code>choice</code>
  * <td headers="fs"><i>SubformatPattern</i>
  * <td headers="sc">{@code new} {@link ChoiceFormat#ChoiceFormat(String) ChoiceFormat}{@code (subformatPattern)}
  * </table>
  *
  * <h4>Usage Information</h4>
  *
  * <p>
  * Here are some examples of usage. In real internationalized programs, the message format pattern and other static
  * strings will, of course, be obtained from resource bundles. Other parameters will be dynamically determined at
  * runtime.
  * <p>
  * The first example uses the static method <code>MessageFormat.format</code>, which internally creates a
  * <code>MessageFormat</code> for one-time use:
  * <blockquote><pre>
  * int planet = 7;
  * String event = "a disturbance in the Force";
  *
  * String result = MessageFormat.format(
  *     "At {1,time} on {1,date}, there was {2} on planet {0,number,integer}.",
  *     planet, new Date(), event);
  * </pre></blockquote>
  * The output is:
  * <blockquote><pre>
  * At 12:30 PM on Jul 3, 2053, there was a disturbance in the Force on planet 7.
  * </pre></blockquote>
  *
  * <p>
  * The following example creates a <code>MessageFormat</code> instance that can be used repeatedly:
  * <blockquote><pre>
  * int fileCount = 1273;
  * String diskName = "MyDisk";
  * Object[] testArgs = {new Long(fileCount), diskName};
  *
  * MessageFormat form = new MessageFormat(
  *     "The disk \"{1}\" contains {0} file(s).");
  *
  * System.out.println(form.format(testArgs));
  * </pre></blockquote>
  * The output with different values for <code>fileCount</code>:
  * <blockquote><pre>
  * The disk "MyDisk" contains 0 file(s).
  * The disk "MyDisk" contains 1 file(s).
  * The disk "MyDisk" contains 1,273 file(s).
  * </pre></blockquote>
  *
  * <p>
  * For more sophisticated patterns, you can use a <code>ChoiceFormat</code> to produce correct forms for singular and
  * plural:
  * <blockquote><pre>
  * MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0}.");
  * double[] filelimits = {0,1,2};
  * String[] filepart = {"no files","one file","{0,number} files"};
  * ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
  * form.setFormatByArgumentIndex(0, fileform);
  *
  * int fileCount = 1273;
  * String diskName = "MyDisk";
  * Object[] testArgs = {new Long(fileCount), diskName};
  *
  * System.out.println(form.format(testArgs));
  * </pre></blockquote>
  * The output with different values for <code>fileCount</code>:
  * <blockquote><pre>
  * The disk "MyDisk" contains no files.
  * The disk "MyDisk" contains one file.
  * The disk "MyDisk" contains 1,273 files.
  * </pre></blockquote>
  *
  * <p>
  * You can create the <code>ChoiceFormat</code> programmatically, as in the above example, or by using a pattern. See
  * {@link ChoiceFormat} for more information.
  * <blockquote><pre>{@code
  * form.applyPattern(
  *    "There {0,choice,0#are no files|1#is one file|1<are {0,number,integer} files}.");
  * }</pre></blockquote>
  *
  * <p>
  * <strong>Note:</strong> As we see above, the string produced by a <code>ChoiceFormat</code> in
  * <code>MessageFormat</code> is treated as special; occurrences of '{' are used to indicate subformats, and cause
  * recursion. If you create both a <code>MessageFormat</code> and <code>ChoiceFormat</code> programmatically (instead of
  * using the string patterns), then be careful not to produce a format that recurses on itself, which will cause an
  * infinite loop.
  * <p>
  * When a single argument is parsed more than once in the string, the last match will be the final result of the
  * parsing. For example,
  * <blockquote><pre>
  * MessageFormat mf = new MessageFormat("{0,number,#.##}, {0,number,#.#}");
  * Object[] objs = {new Double(3.1415)};
  * String result = mf.format( objs );
  * // result now equals "3.14, 3.1"
  * objs = null;
  * objs = mf.parse(result, new ParsePosition(0));
  * // objs now equals {new Double(3.1)}
  * </pre></blockquote>
  *
  * <p>
  * Likewise, parsing with a {@code MessageFormat} object using patterns containing multiple occurrences of the same
  * argument would return the last match. For example,
  * <blockquote><pre>
  * MessageFormat mf = new MessageFormat("{0}, {0}, {0}");
  * String forParsing = "x, y, z";
  * Object[] objs = mf.parse(forParsing, new ParsePosition(0));
  * // result now equals {new String("z")}
  * </pre></blockquote>
  *
  * <h4><a name="synchronization">Synchronization</a></h4>
  *
  * <p>
  * Message formats are not synchronized. It is recommended to create separate format instances for each thread. If
  * multiple threads access a format concurrently, it must be synchronized externally.
  *
  * @see java.util.Locale
  * @see Format
  * @see NumberFormat
  * @see DecimalFormat
  * @see DecimalFormatSymbols
  * @see ChoiceFormat
  * @see DateFormat
  * @see SimpleDateFormat
  *
  * @author Mark Davis
  */
 @SuppressFBWarnings("IMC_IMMATURE_CLASS_WRONG_FIELD_ORDER")
 @NotThreadSafe
 public final class MessageFormat extends Format {
 
   private static final long serialVersionUID = 1L;
 
   // 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"
   };
 
   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,};
 
 
 
   // ===========================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 transient CharSequence pattern;
 
   /**
    * An array of formatters, which are used to format the arguments.
    *
    * @serial
    */
   private FormatInfo[] 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;
 
 
   private int hash = 0;
 
 
   /**
    * Constructs a FastMessageFormat for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale and the
    * specified pattern. The constructor first sets the locale, then parses the pattern and creates a list of subformats
    * for the format elements contained in it. Patterns and their interpretation are specified in the
    * <a href="#patterns">class description</a>.
    *
    * @param pattern the pattern for this message format
    * @exception IllegalArgumentException if the pattern is invalid
    */
   public MessageFormat(String pattern) {
     this.locale = Locale.getDefault(Locale.Category.FORMAT);
     applyPattern(pattern);
   }
 
   /**
    * Constructs a FastMessageFormat for the specified locale and pattern. The constructor first sets the locale, then
    * parses the pattern and creates a list of sub-formats for the format elements contained in it. Patterns and their
    * interpretation are specified in the
    * <a href="#patterns">class description</a>.
    *
    * @param pattern the pattern for this message format
    * @param locale the locale for this message format
    * @exception IllegalArgumentException if the pattern is invalid
    * @since 1.4
    */
   @SuppressFBWarnings("EI_EXPOSE_REP2")
   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
    */
   @SuppressFBWarnings("EI_EXPOSE_REP2")
   public void setLocale(final 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
    */
   @SuppressFBWarnings("EI_EXPOSE_REP")
   public Locale getLocale() {
     return locale;
   }
 
   /**
    * Sets the pattern used by this message format. The method parses the pattern and creates a list of subformats for
    * the format elements contained in it. Patterns and their interpretation are specified in the
    * <a href="#patterns">class description</a>.
    *
    * @param pattern the pattern for this message format
    * @exception IllegalArgumentException if the pattern is invalid
    */
   @SuppressWarnings("fallthrough") // fallthrough in switch is expected, suppress it
   @SuppressFBWarnings("CLI_CONSTANT_LIST_INDEX")
   public void applyPattern(final String pattern) {
     StringBuilder[] segments = new StringBuilder[4];
     // Allocate only segments[SEG_RAW] here. The rest are
     // allocated on demand.
     final int length = pattern.length();
     segments[SEG_RAW] = new StringBuilder(length);
 
     int part = SEG_RAW;
     int formatNumber = 0;
     boolean inQuote = false;
     int braceStack = 0;
     maxOffset = -1;
     for (int i = 0; i < length; ++i) {
       char ch = pattern.charAt(i);
       if (part == SEG_RAW) {
         if (ch == '\'') {
           int next = i + 1;
           if (next < length
                   && pattern.charAt(next) == '\'') {
             segments[part].append(ch);  // handle doubles
             i = next;
           } else {
             inQuote = !inQuote;
           }
         } else if (ch == '{' && !inQuote) {
           part = SEG_INDEX;
           if (segments[part] == null) {
             segments[part] = 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(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: " + pattern);
     }
     this.pattern = segments[0];
   }
 
   /**
    * 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
    */
   @SuppressFBWarnings({"CLI_CONSTANT_LIST_INDEX", "ITC_INHERITANCE_TYPE_CHECKING"})
   public String toPattern() {
     // later, make this more extensible
     int lastOffset = 0;
     StringBuilder result = new StringBuilder();
     for (int i = 0; i <= maxOffset; ++i) {
       FormatInfo finfo = formats[i];
       int offset = finfo.getOffset();
       copyAndFixQuotes(pattern, lastOffset, offset, result);
       lastOffset = offset;
       result.append('{').append(finfo.getArgumentNumber());
       Format fmt = finfo.getFormat();
       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 {
           throw new UnsupportedOperationException("Unsupported format " + fmt);
         }
       } 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 {
             throw new UnsupportedOperationException("Unsupported format " + fmt);
           }
         } else if (index != MODIFIER_DEFAULT) {
           result.append(',').append(DATE_TIME_MODIFIER_KEYWORDS[index]);
         }
       } else if (fmt != null) {
         throw new UnsupportedOperationException("Unsupported format " + fmt);
       }
       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(final Format[] newFormats) {
     for (int i = 0; i <= maxOffset; i++) {
       final FormatInfo finfo = formats[i];
       int j = finfo.getArgumentNumber();
       if (j < newFormats.length) {
         formats[i] = new FormatInfo(newFormats[j], finfo.getOffset(), 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(final Format[] newFormats) {
     int runsToCopy = newFormats.length;
     if (runsToCopy > maxOffset + 1) {
       runsToCopy = maxOffset + 1;
     }
     for (int i = 0; i < runsToCopy; i++) {
       FormatInfo finfo = formats[i];
       formats[i] = new FormatInfo(newFormats[i], finfo.getOffset(), finfo.getArgumentNumber());
     }
   }
 
   /**
    * 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++) {
       FormatInfo finfo = formats[j];
       int argNr = finfo.getArgumentNumber();
       if (argNr == argumentIndex) {
         formats[j] = new FormatInfo(newFormat, finfo.getOffset(), argNr);
       }
     }
   }
 
   /**
    * 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(final int formatElementIndex, final Format newFormat) {
     FormatInfo finfo = formats[formatElementIndex];
     formats[formatElementIndex] = new FormatInfo(newFormat, finfo.getOffset(), finfo.getArgumentNumber());
   }
 
   /**
    * Gets the formats used for the values passed into <code>format</code> methods or returned from <code>parse</code>
    * methods. The indices of elements in the returned array correspond to the argument indices used in the previously
    * set pattern string. The order of formats in the returned array thus corresponds to the order of elements in the
    * <code>arguments</code> array passed to the <code>format</code> methods or the result array returned by the
    * <code>parse</code> methods.
    * <p>
    * If an argument index is used for more than one format element in the pattern string, then the format used for the
    * last such format element is returned in the array. If an argument index is not used for any format element in the
    * pattern string, then null is returned in the array.
    *
    * @return the formats used for the arguments within the pattern
    * @since 1.4
    */
 //    public Format[] getFormatsByArgumentIndex() {
 //        int maximumArgumentNumber = -1;
 //        for (int i = 0; i <= maxOffset; i++) {
 //            if (argumentNumbers[i] > maximumArgumentNumber) {
 //                maximumArgumentNumber = argumentNumbers[i];
 //            }
 //        }
 //        Format[] resultArray = new Format[maximumArgumentNumber + 1];
 //        for (int i = 0; i <= maxOffset; i++) {
 //            resultArray[argumentNumbers[i]] = formats[i];
 //        }
 //        return resultArray;
 //    }
   /**
    * Gets the formats used for the format elements in the previously set pattern string. The order of formats in the
    * returned array corresponds to the order of format elements in the pattern string.
    * <p>
    * Since the order of format elements in a pattern string often changes during localization, it's generally better to
    * use the {@link #getFormatsByArgumentIndex getFormatsByArgumentIndex} method, which assumes an order of formats
    * corresponding to the order of elements in the <code>arguments</code> array passed to the <code>format</code>
    * methods or the result array returned by the <code>parse</code> methods.
    *
    * @return the formats used for the format elements in the pattern
    */
   public Format[] getFormats() {
     Format[] resultArray = new Format[maxOffset + 1];
     System.arraycopy(formats, 0, resultArray, 0, maxOffset + 1);
     return resultArray;
   }
 
   /**
    * Formats an array of objects and appends the <code>MessageFormat</code>'s pattern, with format elements replaced by
    * the formatted objects, to the provided <code>StringBuffer</code>.
    * <p>
    * The text substituted for the individual format elements is derived from the current subformat of the format element
    * and the <code>arguments</code> element at the format element's argument index as indicated by the first matching
    * line of the following table. An argument is <i>unavailable</i> if <code>arguments</code> is <code>null</code> or
    * has fewer than argumentIndex+1 elements.
    *
    * <table border=1 summary="Examples of subformat,argument,and formatted text">
    * <tr>
    * <th>Subformat
    * <th>Argument
    * <th>Formatted Text
    * <tr>
    * <td><i>any</i>
    * <td><i>unavailable</i>
    * <td><code>"{" + argumentIndex + "}"</code>
    * <tr>
    * <td><i>any</i>
    * <td><code>null</code>
    * <td><code>"null"</code>
    * <tr>
    * <td><code>instanceof ChoiceFormat</code>
    * <td><i>any</i>
    * <td><code>subformat.format(argument).indexOf('{') &gt;= 0 ?<br>
    * (new MessageFormat(subformat.format(argument), getLocale())).format(argument) : subformat.format(argument)</code>
    * <tr>
    * <td><code>!= null</code>
    * <td><i>any</i>
    * <td><code>subformat.format(argument)</code>
    * <tr>
    * <td><code>null</code>
    * <td><code>instanceof Number</code>
    * <td><code>NumberFormat.getInstance(getLocale()).format(argument)</code>
    * <tr>
    * <td><code>null</code>
    * <td><code>instanceof Date</code>
    * <td><code>DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, getLocale()).format(argument)</code>
    * <tr>
    * <td><code>null</code>
    * <td><code>instanceof String</code>
    * <td><code>argument</code>
    * <tr>
    * <td><code>null</code>
    * <td><i>any</i>
    * <td><code>argument.toString()</code>
    * </table>
    * <p>
    * If <code>pos</code> is non-null, and refers to <code>Field.ARGUMENT</code>, the location of the first formatted
    * string will be returned.
    *
    * @param arguments an array of objects to be formatted and substituted.
    * @param result where text is appended.
    * @param pos On input: an alignment field, if desired. On output: the offsets of the alignment field.
    * @return the string buffer passed in as {@code result}, with formatted text appended
    * @exception IllegalArgumentException if an argument in the <code>arguments</code> array is not of the type expected
    * by the format element(s) that use it.
    */
   public final <T extends CharSequence & Appendable> boolean[] format(Object[] arguments, T result,
           @Nullable FieldPosition pos) throws IOException {
     return subformat(arguments, result, pos, null);
   }
 
   public final <T extends CharSequence & Appendable> boolean[] format(Object[] arguments, T result) throws IOException {
     return format(arguments, result, null);
   }
 
   /**
    * Creates a MessageFormat with the given pattern and uses it to format the given arguments. This is equivalent to
    * <blockquote>
    * <code>(new {@link #MessageFormat(String) MessageFormat}(pattern)).
    * {@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}(arguments,
    * new StringBuffer(), null).toString()</code>
    * </blockquote>
    *
    * @param pattern the pattern string
    * @param arguments object(s) to format
    * @return the formatted string
    * @exception IllegalArgumentException if the pattern is invalid, or if an argument in the <code>arguments</code>
    * array is not of the type expected by the format element(s) that use it.
    */
   public static String format(final String pattern, final Object... arguments) {
     MessageFormat temp = new MessageFormat(pattern);
     return temp.format(arguments);
   }
 
   // Overrides
   /**
    * Formats an array of objects and appends the <code>MessageFormat</code>'s pattern, with format elements replaced by
    * the formatted objects, to the provided <code>StringBuffer</code>. This is equivalent to
    * <blockquote>
    * <code>{@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}((Object[])
    * arguments, result, pos)</code>
    * </blockquote>
    *
    * @param arguments an array of objects to be formatted and substituted.
    * @param result where text is appended.
    * @param pos On input: an alignment field, if desired. On output: the offsets of the alignment field.
    * @exception IllegalArgumentException if an argument in the <code>arguments</code> array is not of the type expected
    * by the format element(s) that use it.
    */
   public final <T extends CharSequence & Appendable> boolean[] format(final Object arguments, final T result,
           final FieldPosition pos) throws IOException {
     if (arguments instanceof Object[]) {
       return subformat((Object[]) arguments, result, pos, null);
     } else {
       return subformat(new 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(@Nonnull Object arguments) {
     StringBuilder result = new StringBuilder();
     ArrayList<AttributedCharacterIterator> iterators = new ArrayList<>();
     try {
       subformat((Object[]) arguments, result, null, iterators);
     } catch (IOException ex) {
       throw new UncheckedIOException(ex);
     }
     if (iterators.isEmpty()) {
       return createAttributedCharacterIterator("");
     }
     return new AttributedString(
             iterators.toArray(
                     new AttributedCharacterIterator[iterators.size()])).getIterator();
   }
 
   /**
    * 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. (zoltan:
    * yuck)
    *
    *
    * @param source the string to parse
    * @param pos the parse position
    * @return an array of parsed objects
    */
   @Nullable
   @SuppressFBWarnings({"PZLA_PREFER_ZERO_LENGTH_ARRAYS", "STT_STRING_PARSING_A_FIELD"}) // maintaining JDK behavior
   public Object[] parse(@Nullable String source, @Nonnull ParsePosition pos) {
 
     if (source == null) {
       return org.spf4j.base.Arrays.EMPTY_OBJ_ARRAY;
     }
 
     int maximumArgumentNumber = -1;
     for (int i = 0; i <= maxOffset; i++) {
       FormatInfo finfo = formats[i];
       final int argumentNumber = finfo.getArgumentNumber();
       if (argumentNumber > maximumArgumentNumber) {
         maximumArgumentNumber = argumentNumber;
       }
     }
     Object[] resultArray = new Object[maximumArgumentNumber + 1];
 
     int patternOffset = 0;
     int sourceOffset = pos.getIndex();
     ParsePosition tempStatus = new ParsePosition(0);
     for (int i = 0; i <= maxOffset; ++i) {
       // match up to format
       FormatInfo finfo = formats[i];
       int len = finfo.getOffset() - patternOffset;
       if (len == 0 || CharSequences.regionMatches(pattern, patternOffset, source, sourceOffset, len)) {
         sourceOffset += len;
         patternOffset += len;
       } else {
         pos.setErrorIndex(sourceOffset);
         return null;
       }
 
       // now use format
       if (finfo.getFormat() == 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) ? formats[i + 1].getOffset() : pattern.length();
 
         int next;
         if (patternOffset >= tempLength) {
           next = source.length();
         } else {
           next = source.indexOf(pattern.subSequence(patternOffset, tempLength).toString(), sourceOffset);
         }
 
         if (next < 0) {
           pos.setErrorIndex(sourceOffset);
           return null;
         } else {
           String strValue = source.substring(sourceOffset, next);
           int argNr = finfo.getArgumentNumber();
           if (!strValue.equals("{" + argNr + "}")) {
             resultArray[argNr] = source.substring(sourceOffset, next);
           }
           sourceOffset = next;
         }
       } else {
         tempStatus.setIndex(sourceOffset);
         resultArray[finfo.getArgumentNumber()] = finfo.getFormat().parseObject(source, tempStatus);
         if (tempStatus.getIndex() == sourceOffset) {
           pos.setErrorIndex(sourceOffset);
           return null; // leave index as is to signal error
         }
         sourceOffset = tempStatus.getIndex(); // update
       }
     }
     int len = pattern.length() - patternOffset;
     if (len == 0 || CharSequences.regionMatches(pattern, patternOffset, source, sourceOffset, len)) {
       pos.setIndex(sourceOffset + len);
     } else {
       pos.setErrorIndex(sourceOffset);
       return null;
     }
     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.
    */
   @Nullable
   public Object[] parse(String source) throws ParseException {
     ParsePosition pos = new ParsePosition(0);
     Object[] result = parse(source, pos);
     if (pos.getIndex() == 0) // unchanged, returned object is null
     {
       throw new ParseException("MessageFormat source = " + source + " parse error!", pos.getErrorIndex());
     }
 
     return result;
   }
 
   /**
    * Parses text from a string to produce an object array.
    * <p>
    * The method attempts to parse text starting at the index given by <code>pos</code>. If parsing succeeds, then the
    * index of <code>pos</code> is updated to the index after the last character used (parsing does not necessarily use
    * all characters up to the end of the string), and the parsed object array is returned. The updated <code>pos</code>
    * can be used to indicate the starting point for the next call to this method. If an error occurs, then the index of
    * <code>pos</code> is not changed, the error index of <code>pos</code> is set to the index of the character where the
    * error occurred, and null is returned.
    * <p>
    * See the {@link #parse(String, ParsePosition)} method for more information on message parsing.
    *
    * @param source A <code>String</code>, part of which should be parsed.
    * @param pos A <code>ParsePosition</code> object with index and error index information as described above.
    * @return An <code>Object</code> array parsed from the string. In case of error, returns null.
    * @exception NullPointerException if <code>pos</code> is null.
    */
   @Nullable
   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 MessageFormat 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) {
       FormatInfo finfo = formats[i];
       if (finfo != null) {
         other.formats[i] = finfo.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
             && CharSequences.equals(pattern, other.pattern)
             && ((locale != null && locale.equals(other.locale))
             || (locale == null && other.locale == null))
             && Arrays.equals(formats, other.formats));
   }
 
   /**
    * Generates a hash code for the message format object.
    */
   public int hashCode() {
     int h = hash;
     if (h == 0) {
       h = CharSequences.hashcode(pattern);
       hash = h;
     }
     return h;
   }
 
   @Override
   public StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) {
     try {
       syntethicFormat(obj, toAppendTo, pos);
       return toAppendTo;
     } catch (IOException ex) {
       throw new UncheckedIOException(ex);
     }
   }
 
   private <T extends CharSequence & Appendable> boolean[] syntethicFormat(Object obj, T toAppendTo, FieldPosition pos)
           throws IOException {
     return format(obj, toAppendTo, pos);
   }
 
 
   /**
    * Internal routine used by format. If <code>characterIterators</code> is non-null, AttributedCharacterIterator will
    * be created from the sub-formats as necessary. If <code>characterIterators</code> is null and <code>fp</code> is
    * non-null and identifies <code>Field.MESSAGE_ARGUMENT</code>, the location of the first replaced argument will be
    * set in it.
    *
    * @exception IllegalArgumentException if an argument in the <code>arguments</code> array is not of the type expected
    * by the format element(s) that use it.
    */
   @SuppressFBWarnings({"PRMC_POSSIBLY_REDUNDANT_METHOD_CALLS"}) // Unfortunately I have no other way to write this
   // without code duplication to work for StringBuilder and StringBuffer....
   private <T extends Appendable & CharSequence> boolean[] subformat(@Nullable Object[] arguments, @Nonnull T result,
           @Nullable FieldPosition fp,
           @Nullable List<AttributedCharacterIterator> characterIterators)
           throws IOException {
     int lastOffset = 0;
     int last = result.length();
     boolean[] used;
     if (arguments == null)  {
       used = org.spf4j.base.Arrays.EMPTY_BOOLEAN_ARRAY;
     } else {
       used = new boolean[arguments.length];
     }
     for (int i = 0; i <= maxOffset; ++i) {
       FormatInfo finfo = formats[i];
       int offset = finfo.getOffset();
       result.append(pattern, lastOffset, offset);
       lastOffset = offset;
       int argumentNumber = finfo.getArgumentNumber();
       if (arguments == null || argumentNumber >= arguments.length) {
         result.append('{').append(Integer.toString(argumentNumber)).append('}');
         continue;
       }
       used[argumentNumber] = true;
       Object obj = arguments[argumentNumber];
       String arg = null;
       Format subFormatter = null;
       Format fmt = finfo.getFormat();
       if (obj == null) {
         arg = "null";
       } else if (fmt != null) {
         subFormatter = fmt;
         if (subFormatter instanceof ChoiceFormat) {
           arg = subFormatter.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();
       }
 
       // 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.
         int cl = result.length();
         if (last != cl) {
           characterIterators.add(
                   createAttributedCharacterIterator(result.subSequence(last, cl).toString()));
           last = cl;
         }
         if (subFormatter != null) {
           AttributedCharacterIterator subIterator
                   = subFormatter.formatToCharacterIterator(obj);
 
           append(result, subIterator);
           int cl2 = result.length();
           if (last != cl2) {
             characterIterators.add(
                     createAttributedCharacterIterator(
                             subIterator, java.text.MessageFormat.Field.ARGUMENT,
                             Integer.valueOf(argumentNumber)));
             last = cl2;
           }
           arg = null;
         }
         if (arg != null && arg.length() > 0) {
           result.append(arg);
           characterIterators.add(
                   createAttributedCharacterIterator(
                           arg, java.text.MessageFormat.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 && java.text.MessageFormat.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.subSequence(last, result.length()).toString()));
     }
     return used;
   }
 
   /**
    * Convenience method to append all the characters in <code>iterator</code> to the StringBuffer <code>result</code>.
    */
   private static void append(Appendable result, CharacterIterator iterator) throws IOException {
     final char first = iterator.first();
     if (first != CharacterIterator.DONE) {
       result.append(first);
       char aChar;
       while ((aChar = iterator.next()) != CharacterIterator.DONE) {
         result.append(aChar);
       }
     }
   }
 
 
   @SuppressFBWarnings("CLI_CONSTANT_LIST_INDEX") //jdk inherited
   private void makeFormat(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]);
     } 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 = Math.max(4, formats.length << 2);
       FormatInfo[] newFormats = new FormatInfo[newLength];
       System.arraycopy(formats, 0, newFormats, 0, maxOffset + 1);
       formats = newFormats;
     }
     int oldMaxOffset = maxOffset;
     maxOffset = offsetNumber;
 
     // 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] = new FormatInfo(newFormat, segments[SEG_RAW].length(), argumentNumber);
   }
 
   @SuppressFBWarnings(value = {"ES_COMPARING_STRINGS_WITH_EQ", "IMPROPER_UNICODE"},
           justification = "optimization")
   private static final int findKeyword(String s, String[] list) {
     int l = list.length;
     for (int i = 0; i < l; ++i) {
       if (s.equals(list[i])) {
         return i;
       }
     }
 
     // Try trimmed lowercase.
     String ls = s.trim();
     if (ls != s) {
       for (int i = 0; i < l; ++i) {
         if (ls.equalsIgnoreCase(list[i])) {
           return i;
         }
       }
     }
     return -1;
   }
 
   private static final void copyAndFixQuotes(CharSequence 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('\'');
     }
   }
 
     private void writeObject(final java.io.ObjectOutputStream s)
         throws IOException {
         // Write out element count, and any hidden stuff
         s.defaultWriteObject();
         s.writeUTF(pattern.toString());
     }
 
 
   /**
    * 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.
    */
   @SuppressFBWarnings({"WEM_WEAK_EXCEPTION_MESSAGING", "DESERIALIZATION_GADGET"})
   private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
     in.defaultReadObject();
     pattern = in.readUTF();
     boolean isValid = maxOffset >= -1
             && formats.length > maxOffset;
     if (isValid) {
       int lastOffset = pattern.length() + 1;
       for (int i = maxOffset; i >= 0; --i) {
         FormatInfo finfo = formats[i];
         int offset = finfo.getOffset();
         if ((offset < 0) || (offset > lastOffset)) {
           isValid = false;
           break;
         } else {
           lastOffset = offset;
         }
       }
     }
     if (!isValid) {
       throw new InvalidObjectException("Could not reconstruct MessageFormat from corrupt stream");
     }
   }
 
   /**
    * Creates an <code>AttributedCharacterIterator</code> for the String <code>s</code>.
    *
    * @param s String to create AttributedCharacterIterator from
    * @return AttributedCharacterIterator wrapping s
    */
   static AttributedCharacterIterator createAttributedCharacterIterator(String s) {
     return new java.text.AttributedString(s).getIterator();
   }
 
 
   /**
    * Returns an AttributedCharacterIterator with the String <code>string</code> and additional key/value pair
    * <code>key</code>, <code>value</code>.
    *
    * @param string String to create AttributedCharacterIterator from
    * @param key Key for AttributedCharacterIterator
    * @param value Value associated with key in AttributedCharacterIterator
    * @return AttributedCharacterIterator wrapping args
    */
   static AttributedCharacterIterator createAttributedCharacterIterator(
           String string, AttributedCharacterIterator.Attribute key,
           Object value) {
     java.text.AttributedString as = new java.text.AttributedString(string);
 
     as.addAttribute(key, value);
     return as.getIterator();
   }
 
   /**
    * Creates an AttributedCharacterIterator with the contents of <code>iterator</code> and the additional attribute
    * <code>key</code> <code>value</code>.
    *
    * @param iterator Initial AttributedCharacterIterator to add arg to
    * @param key Key for AttributedCharacterIterator
    * @param value Value associated with key in AttributedCharacterIterator
    * @return AttributedCharacterIterator wrapping args
    */
   AttributedCharacterIterator createAttributedCharacterIterator(
           AttributedCharacterIterator iterator,
           AttributedCharacterIterator.Attribute key, Object value) {
     java.text.AttributedString as = new java.text.AttributedString(iterator);
 
     as.addAttribute(key, value);
     return as.getIterator();
   }
 
   @Override
   public String toString() {
     return "MessageFormat{" + "locale=" + locale + ", pattern=" + pattern + '}';
   }
 
 }