/*

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

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

 *

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

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

 * published by the Free Software Foundation.  Oracle designates this

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

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

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

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

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

 * questions.

 */

/*

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

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

 *

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

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

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

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

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

 *   Taligent is a registered trademark of Taligent, Inc.

 *

 */

package java.text;

import java.io.IOException;

import java.io.InvalidObjectException;

import java.io.ObjectInputStream;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.math.RoundingMode;

import java.text.spi.NumberFormatProvider;

import java.util.ArrayList;

import java.util.Currency;

import java.util.Locale;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

import sun.util.locale.provider.LocaleProviderAdapter;

import sun.util.locale.provider.ResourceBundleBasedAdapter;

/**

 * {@code DecimalFormat} is a concrete subclass of

 * {@code NumberFormat} that formats decimal numbers. It has a variety of

 * features designed to make it possible to parse and format numbers in any

 * locale, including support for Western, Arabic, and Indic digits.  It also

 * supports different kinds of numbers, including integers (123), fixed-point

 * numbers (123.4), scientific notation (1.23E4), percentages (12%), and

 * currency amounts ($123).  All of these can be localized.

 *

 * <p>To obtain a {@code NumberFormat} for a specific locale, including the

 * default locale, call one of {@code NumberFormat}'s factory methods, such

 * as {@code getInstance()}.  In general, do not call the

 * {@code DecimalFormat} constructors directly, since the

 * {@code NumberFormat} factory methods may return subclasses other than

 * {@code DecimalFormat}. If you need to customize the format object, do

 * something like this:

 *

 * <blockquote><pre>

 * NumberFormat f = NumberFormat.getInstance(loc);

 * if (f instanceof DecimalFormat) {

 *     ((DecimalFormat) f).setDecimalSeparatorAlwaysShown(true);

 * }

 * </pre></blockquote>

 *

 * <p>A {@code DecimalFormat} comprises a <em>pattern</em> and a set of

 * <em>symbols</em>.  The pattern may be set directly using

 * {@code applyPattern()}, or indirectly using the API methods.  The

 * symbols are stored in a {@code DecimalFormatSymbols} object.  When using

 * the {@code NumberFormat} factory methods, the pattern and symbols are

 * read from localized {@code ResourceBundle}s.

 *

 * <h2>Patterns</h2>

 *

 * {@code DecimalFormat} patterns have the following syntax:

 * <blockquote><pre>

 * <i>Pattern:</i>

 *         <i>PositivePattern</i>

 *         <i>PositivePattern</i> ; <i>NegativePattern</i>

 * <i>PositivePattern:</i>

 *         <i>Prefix<sub>opt</sub></i> <i>Number</i> <i>Suffix<sub>opt</sub></i>

 * <i>NegativePattern:</i>

 *         <i>Prefix<sub>opt</sub></i> <i>Number</i> <i>Suffix<sub>opt</sub></i>

 * <i>Prefix:</i>

 *         any Unicode characters except \uFFFE, \uFFFF, and special characters

 * <i>Suffix:</i>

 *         any Unicode characters except \uFFFE, \uFFFF, and special characters

 * <i>Number:</i>

 *         <i>Integer</i> <i>Exponent<sub>opt</sub></i>

 *         <i>Integer</i> . <i>Fraction</i> <i>Exponent<sub>opt</sub></i>

 * <i>Integer:</i>

 *         <i>MinimumInteger</i>

 *         #

 *         # <i>Integer</i>

 *         # , <i>Integer</i>

 * <i>MinimumInteger:</i>

 *         0

 *         0 <i>MinimumInteger</i>

 *         0 , <i>MinimumInteger</i>

 * <i>Fraction:</i>

 *         <i>MinimumFraction<sub>opt</sub></i> <i>OptionalFraction<sub>opt</sub></i>

 * <i>MinimumFraction:</i>

 *         0 <i>MinimumFraction<sub>opt</sub></i>

 * <i>OptionalFraction:</i>

 *         # <i>OptionalFraction<sub>opt</sub></i>

 * <i>Exponent:</i>

 *         E <i>MinimumExponent</i>

 * <i>MinimumExponent:</i>

 *         0 <i>MinimumExponent<sub>opt</sub></i>

 * </pre></blockquote>

 *

 * <p>A {@code DecimalFormat} pattern contains a positive and negative

 * subpattern, for example, {@code "#,##0.00;(#,##0.00)"}.  Each

 * subpattern has a prefix, numeric part, and suffix. The negative subpattern

 * is optional; if absent, then the positive subpattern prefixed with the

 * localized minus sign ({@code '-'} in most locales) is used as the

 * negative subpattern. That is, {@code "0.00"} alone is equivalent to

 * {@code "0.00;-0.00"}.  If there is an explicit negative subpattern, it

 * serves only to specify the negative prefix and suffix; the number of digits,

 * minimal digits, and other characteristics are all the same as the positive

 * pattern. That means that {@code "#,##0.0#;(#)"} produces precisely

 * the same behavior as {@code "#,##0.0#;(#,##0.0#)"}.

 *

 * <p>The prefixes, suffixes, and various symbols used for infinity, digits,

 * thousands separators, decimal separators, etc. may be set to arbitrary

 * values, and they will appear properly during formatting.  However, care must

 * be taken that the symbols and strings do not conflict, or parsing will be

 * unreliable.  For example, either the positive and negative prefixes or the

 * suffixes must be distinct for {@code DecimalFormat.parse()} to be able

 * to distinguish positive from negative values.  (If they are identical, then

 * {@code DecimalFormat} will behave as if no negative subpattern was

 * specified.)  Another example is that the decimal separator and thousands

 * separator should be distinct characters, or parsing will be impossible.

 *

 * <p>The grouping separator is commonly used for thousands, but in some

 * countries it separates ten-thousands. The grouping size is a constant number

 * of digits between the grouping characters, such as 3 for 100,000,000 or 4 for

 * 1,0000,0000.  If you supply a pattern with multiple grouping characters, the

 * interval between the last one and the end of the integer is the one that is

 * used. So {@code "#,##,###,####"} == {@code "######,####"} ==

 * {@code "##,####,####"}.

 *

 * <h3><a id="special_pattern_character">Special Pattern Characters</a></h3>

 *

 * <p>Many characters in a pattern are taken literally; they are matched during

 * parsing and output unchanged during formatting.  Special characters, on the

 * other hand, stand for other characters, strings, or classes of characters.

 * They must be quoted, unless noted otherwise, if they are to appear in the

 * prefix or suffix as literals.

 *

 * <p>The characters listed here are used in non-localized patterns.  Localized

 * patterns use the corresponding characters taken from this formatter's

 * {@code DecimalFormatSymbols} object instead, and these characters lose

 * their special status.  Two exceptions are the currency sign and quote, which

 * are not localized.

 *

 * <blockquote>

 * <table class="striped">

 * <caption style="display:none">Chart showing symbol, location, localized, and meaning.</caption>

 * <thead>

 *     <tr>

 *          <th scope="col" style="text-align:left">Symbol

 *          <th scope="col" style="text-align:left">Location

 *          <th scope="col" style="text-align:left">Localized?

 *          <th scope="col" style="text-align:left">Meaning

 * </thead>

 * <tbody>

 *     <tr style="vertical-align:top">

 *          <th scope="row">{@code 0}

 *          <td>Number

 *          <td>Yes

 *          <td>Digit

 *     <tr style="vertical-align: top">

 *          <th scope="row">{@code #}

 *          <td>Number

 *          <td>Yes

 *          <td>Digit, zero shows as absent

 *     <tr style="vertical-align:top">

 *          <th scope="row">{@code .}

 *          <td>Number

 *          <td>Yes

 *          <td>Decimal separator or monetary decimal separator

 *     <tr style="vertical-align: top">

 *          <th scope="row">{@code -}

 *          <td>Number

 *          <td>Yes

 *          <td>Minus sign

 *     <tr style="vertical-align:top">

 *          <th scope="row">{@code ,}

 *          <td>Number

 *          <td>Yes

 *          <td>Grouping separator

 *     <tr style="vertical-align: top">

 *          <th scope="row">{@code E}

 *          <td>Number

 *          <td>Yes

 *          <td>Separates mantissa and exponent in scientific notation.

 *              <em>Need not be quoted in prefix or suffix.</em>

 *     <tr style="vertical-align:top">

 *          <th scope="row">{@code ;}

 *          <td>Subpattern boundary

 *          <td>Yes

 *          <td>Separates positive and negative subpatterns

 *     <tr style="vertical-align: top">

 *          <th scope="row">{@code %}

 *          <td>Prefix or suffix

 *          <td>Yes

 *          <td>Multiply by 100 and show as percentage

 *     <tr style="vertical-align:top">

 *          <th scope="row">{@code &#92;u2030}

 *          <td>Prefix or suffix

 *          <td>Yes

 *          <td>Multiply by 1000 and show as per mille value

 *     <tr style="vertical-align: top">

 *          <th scope="row">{@code &#164;} ({@code &#92;u00A4})

 *          <td>Prefix or suffix

 *          <td>No

 *          <td>Currency sign, replaced by currency symbol.  If

 *              doubled, replaced by international currency symbol.

 *              If present in a pattern, the monetary decimal separator

 *              is used instead of the decimal separator.

 *     <tr style="vertical-align:top">

 *          <th scope="row">{@code '}

 *          <td>Prefix or suffix

 *          <td>No

 *          <td>Used to quote special characters in a prefix or suffix,

 *              for example, {@code "'#'#"} formats 123 to

 *              {@code "#123"}.  To create a single quote

 *              itself, use two in a row: {@code "# o''clock"}.

 * </tbody>

 * </table>

 * </blockquote>

 *

 * <h3>Scientific Notation</h3>

 *

 * <p>Numbers in scientific notation are expressed as the product of a mantissa

 * and a power of ten, for example, 1234 can be expressed as 1.234 x 10^3.  The

 * mantissa is often in the range 1.0 &le; x {@literal <} 10.0, but it need not

 * be.

 * {@code DecimalFormat} can be instructed to format and parse scientific

 * notation <em>only via a pattern</em>; there is currently no factory method

 * that creates a scientific notation format.  In a pattern, the exponent

 * character immediately followed by one or more digit characters indicates

 * scientific notation.  Example: {@code "0.###E0"} formats the number

 * 1234 as {@code "1.234E3"}.

 *

 * <ul>

 * <li>The number of digit characters after the exponent character gives the

 * minimum exponent digit count.  There is no maximum.  Negative exponents are

 * formatted using the localized minus sign, <em>not</em> the prefix and suffix

 * from the pattern.  This allows patterns such as {@code "0.###E0 m/s"}.

 *

 * <li>The minimum and maximum number of integer digits are interpreted

 * together:

 *

 * <ul>

 * <li>If the maximum number of integer digits is greater than their minimum number

 * and greater than 1, it forces the exponent to be a multiple of the maximum

 * number of integer digits, and the minimum number of integer digits to be

 * interpreted as 1.  The most common use of this is to generate

 * <em>engineering notation</em>, in which the exponent is a multiple of three,

 * e.g., {@code "##0.#####E0"}. Using this pattern, the number 12345

 * formats to {@code "12.345E3"}, and 123456 formats to

 * {@code "123.456E3"}.

 *

 * <li>Otherwise, the minimum number of integer digits is achieved by adjusting the

 * exponent.  Example: 0.00123 formatted with {@code "00.###E0"} yields

 * {@code "12.3E-4"}.

 * </ul>

 *

 * <li>The number of significant digits in the mantissa is the sum of the

 * <em>minimum integer</em> and <em>maximum fraction</em> digits, and is

 * unaffected by the maximum integer digits.  For example, 12345 formatted with

 * {@code "##0.##E0"} is {@code "12.3E3"}. To show all digits, set

 * the significant digits count to zero.  The number of significant digits

 * does not affect parsing.

 *

 * <li>Exponential patterns may not contain grouping separators.

 * </ul>

 *

 * <h3>Rounding</h3>

 *

 * {@code DecimalFormat} provides rounding modes defined in

 * {@link java.math.RoundingMode} for formatting.  By default, it uses

 * {@link java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}.

 *

 * <h3>Digits</h3>

 *

 * For formatting, {@code DecimalFormat} uses the ten consecutive

 * characters starting with the localized zero digit defined in the

 * {@code DecimalFormatSymbols} object as digits. For parsing, these

 * digits as well as all Unicode decimal digits, as defined by

 * {@link Character#digit Character.digit}, are recognized.

 *

 * <h4>Special Values</h4>

 *

 * <p>{@code NaN} is formatted as a string, which typically has a single character

 * {@code \uFFFD}.  This string is determined by the

 * {@code DecimalFormatSymbols} object.  This is the only value for which

 * the prefixes and suffixes are not used.

 *

 * <p>Infinity is formatted as a string, which typically has a single character

 * {@code \u221E}, with the positive or negative prefixes and suffixes

 * applied.  The infinity string is determined by the

 * {@code DecimalFormatSymbols} object.

 *

 * <p>Negative zero ({@code "-0"}) parses to

 * <ul>

 * <li>{@code BigDecimal(0)} if {@code isParseBigDecimal()} is

 * true,

 * <li>{@code Long(0)} if {@code isParseBigDecimal()} is false

 *     and {@code isParseIntegerOnly()} is true,

 * <li>{@code Double(-0.0)} if both {@code isParseBigDecimal()}

 * and {@code isParseIntegerOnly()} are false.

 * </ul>

 *

 * <h3><a id="synchronization">Synchronization</a></h3>

 *

 * <p>

 * Decimal formats are generally 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.

 *

 * <h3>Example</h3>

 *

 * <blockquote><pre>{@code

 * <strong>// Print out a number using the localized number, integer, currency,

 * // and percent format for each locale</strong>

 * Locale[] locales = NumberFormat.getAvailableLocales();

 * double myNumber = -1234.56;

 * NumberFormat form;

 * for (int j = 0; j < 4; ++j) {

 *     System.out.println("FORMAT");

 *     for (int i = 0; i < locales.length; ++i) {

 *         if (locales[i].getCountry().length() == 0) {

 *            continue; // Skip language-only locales

 *         }

 *         System.out.print(locales[i].getDisplayName());

 *         switch (j) {

 *         case 0:

 *             form = NumberFormat.getInstance(locales[i]); break;

 *         case 1:

 *             form = NumberFormat.getIntegerInstance(locales[i]); break;

 *         case 2:

 *             form = NumberFormat.getCurrencyInstance(locales[i]); break;

 *         default:

 *             form = NumberFormat.getPercentInstance(locales[i]); break;

 *         }

 *         if (form instanceof DecimalFormat) {

 *             System.out.print(": " + ((DecimalFormat) form).toPattern());

 *         }

 *         System.out.print(" -> " + form.format(myNumber));

 *         try {

 *             System.out.println(" -> " + form.parse(form.format(myNumber)));

 *         } catch (ParseException e) {}

 *     }

 * }

 * }</pre></blockquote>

 *

 * @see          <a href="http://docs.oracle.com/javase/tutorial/i18n/format/decimalFormat.html">Java Tutorial</a>

 * @see          NumberFormat

 * @see          DecimalFormatSymbols

 * @see          ParsePosition

 * @author       Mark Davis

 * @author       Alan Liu

 * @since 1.1

 */

public class DecimalFormat extends NumberFormat {

    /**

     * Creates a DecimalFormat using the default pattern and symbols

     * for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.

     * This is a convenient way to obtain a

     * DecimalFormat when internationalization is not the main concern.

     * <p>

     * To obtain standard formats for a given locale, use the factory methods

     * on NumberFormat such as getNumberInstance. These factories will

     * return the most appropriate sub-class of NumberFormat for a given

     * locale.

     *

     * @see java.text.NumberFormat#getInstance

     * @see java.text.NumberFormat#getNumberInstance

     * @see java.text.NumberFormat#getCurrencyInstance

     * @see java.text.NumberFormat#getPercentInstance

     */

    public DecimalFormat() {

        // Get the pattern for the default locale.

        Locale def = Locale.getDefault(Locale.Category.FORMAT);

        LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(NumberFormatProvider.class, def);

        if (!(adapter instanceof ResourceBundleBasedAdapter)) {

            adapter = LocaleProviderAdapter.getResourceBundleBased();

        }

        String[] all = adapter.getLocaleResources(def).getNumberPatterns();

        // Always applyPattern after the symbols are set

        this.symbols = DecimalFormatSymbols.getInstance(def);

        applyPattern(all[0], false);

    }

    /**

     * Creates a DecimalFormat using the given pattern and the symbols

     * for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.

     * This is a convenient way to obtain a

     * DecimalFormat when internationalization is not the main concern.

     * <p>

     * To obtain standard formats for a given locale, use the factory methods

     * on NumberFormat such as getNumberInstance. These factories will

     * return the most appropriate sub-class of NumberFormat for a given

     * locale.

     *

     * @param pattern a non-localized pattern string.

     * @throws    NullPointerException if {@code pattern} is null

     * @throws    IllegalArgumentException if the given pattern is invalid.

     * @see java.text.NumberFormat#getInstance

     * @see java.text.NumberFormat#getNumberInstance

     * @see java.text.NumberFormat#getCurrencyInstance

     * @see java.text.NumberFormat#getPercentInstance

     */

    public DecimalFormat(String pattern) {

        // Always applyPattern after the symbols are set

        this.symbols = DecimalFormatSymbols.getInstance(Locale.getDefault(Locale.Category.FORMAT));

        applyPattern(pattern, false);

    }

    /**

     * Creates a DecimalFormat using the given pattern and symbols.

     * Use this constructor when you need to completely customize the

     * behavior of the format.

     * <p>

     * To obtain standard formats for a given

     * locale, use the factory methods on NumberFormat such as

     * getInstance or getCurrencyInstance. If you need only minor adjustments

     * to a standard format, you can modify the format returned by

     * a NumberFormat factory method.

     *

     * @param pattern a non-localized pattern string

     * @param symbols the set of symbols to be used

     * @throws    NullPointerException if any of the given arguments is null

     * @throws    IllegalArgumentException if the given pattern is invalid

     * @see java.text.NumberFormat#getInstance

     * @see java.text.NumberFormat#getNumberInstance

     * @see java.text.NumberFormat#getCurrencyInstance

     * @see java.text.NumberFormat#getPercentInstance

     * @see java.text.DecimalFormatSymbols

     */

    public DecimalFormat (String pattern, DecimalFormatSymbols symbols) {

        // Always applyPattern after the symbols are set

        this.symbols = (DecimalFormatSymbols)symbols.clone();

        applyPattern(pattern, false);

    }

    // Overrides

    /**

     * Formats a number and appends the resulting text to the given string

     * buffer.

     * The number can be of any subclass of {@link java.lang.Number}.

     * <p>

     * This implementation uses the maximum precision permitted.

     * @param number     the number to format

     * @param toAppendTo the {@code StringBuffer} to which the formatted

     *                   text is to be appended

     * @param pos        keeps track on the position of the field within the

     *                   returned string. For example, for formatting a number

     *                   {@code 1234567.89} in {@code Locale.US} locale,

     *                   if the given {@code fieldPosition} is

     *                   {@link NumberFormat#INTEGER_FIELD}, the begin index

     *                   and end index of {@code fieldPosition} will be set

     *                   to 0 and 9, respectively for the output string

     *                   {@code 1,234,567.89}.

     * @return           the value passed in as {@code toAppendTo}

     * @throws           IllegalArgumentException if {@code number} is

     *                   null or not an instance of {@code Number}.

     * @throws           NullPointerException if {@code toAppendTo} or

     *                   {@code pos} is null

     * @throws           ArithmeticException if rounding is needed with rounding

     *                   mode being set to RoundingMode.UNNECESSARY

     * @see              java.text.FieldPosition

     */

    @Override

    public final StringBuffer format(Object number,

                                     StringBuffer toAppendTo,

                                     FieldPosition pos) {

        if (number instanceof Long || number instanceof Integer ||

                   number instanceof Short || number instanceof Byte ||

                   number instanceof AtomicInteger ||

                   number instanceof AtomicLong ||

                   (number instanceof BigInteger &&

                    ((BigInteger)number).bitLength () < 64)) {

            return format(((Number)number).longValue(), toAppendTo, pos);

        } else if (number instanceof BigDecimal) {