/*

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

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

 *

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

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

 * published by the Free Software Foundation.  Oracle designates this

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

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

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

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

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

 * questions.

 */

/*

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

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

 *

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

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

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

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

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

 *   Taligent is a registered trademark of Taligent, Inc.

 *

 */

package java.text;

import java.io.InvalidObjectException;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.math.RoundingMode;

import java.util.ArrayList;

import java.util.Currency;

import java.util.Locale;

import java.util.ResourceBundle;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ConcurrentMap;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

import sun.util.resources.LocaleData;

/**

 * <code>DecimalFormat</code> is a concrete subclass of

 * <code>NumberFormat</code> 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</code> for a specific locale, including the

 * default locale, call one of <code>NumberFormat</code>'s factory methods, such

 * as <code>getInstance()</code>.  In general, do not call the

 * <code>DecimalFormat</code> constructors directly, since the

 * <code>NumberFormat</code> factory methods may return subclasses other than

 * <code>DecimalFormat</code>. 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</code> comprises a <em>pattern</em> and a set of

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

 * <code>applyPattern()</code>, or indirectly using the API methods.  The

 * symbols are stored in a <code>DecimalFormatSymbols</code> object.  When using

 * the <code>NumberFormat</code> factory methods, the pattern and symbols are

 * read from localized <code>ResourceBundle</code>s.

 *

 * <h4>Patterns</h4>

 *

 * <code>DecimalFormat</code> 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</code> pattern contains a positive and negative

 * subpattern, for example, <code>"#,##0.00;(#,##0.00)"</code>.  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>'-'</code> in most locales) is used as the

 * negative subpattern. That is, <code>"0.00"</code> alone is equivalent to

 * <code>"0.00;-0.00"</code>.  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#;(#)"</code> produces precisely

 * the same behavior as <code>"#,##0.0#;(#,##0.0#)"</code>.

 *

 * <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()</code> to be able

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

 * <code>DecimalFormat</code> 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>"######,####"</code> ==

 * <code>"##,####,####"</code>.

 *

 * <h4>Special Pattern Characters</h4>

 *

 * <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</code> object instead, and these characters lose

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

 * are not localized.

 *

 * <blockquote>

 * <table border=0 cellspacing=3 cellpadding=0 summary="Chart showing symbol,

 *  location, localized, and meaning.">

 *     <tr bgcolor="#ccccff">

 *          <th align=left>Symbol

 *          <th align=left>Location

 *          <th align=left>Localized?

 *          <th align=left>Meaning

 *     <tr valign=top>

 *          <td><code>0</code>

 *          <td>Number

 *          <td>Yes

 *          <td>Digit

 *     <tr valign=top bgcolor="#eeeeff">

 *          <td><code>#</code>

 *          <td>Number

 *          <td>Yes

 *          <td>Digit, zero shows as absent

 *     <tr valign=top>

 *          <td><code>.</code>

 *          <td>Number

 *          <td>Yes

 *          <td>Decimal separator or monetary decimal separator

 *     <tr valign=top bgcolor="#eeeeff">

 *          <td><code>-</code>

 *          <td>Number

 *          <td>Yes

 *          <td>Minus sign

 *     <tr valign=top>

 *          <td><code>,</code>

 *          <td>Number

 *          <td>Yes

 *          <td>Grouping separator

 *     <tr valign=top bgcolor="#eeeeff">

 *          <td><code>E</code>

 *          <td>Number

 *          <td>Yes

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

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

 *     <tr valign=top>

 *          <td><code>;</code>

 *          <td>Subpattern boundary

 *          <td>Yes

 *          <td>Separates positive and negative subpatterns

 *     <tr valign=top bgcolor="#eeeeff">

 *          <td><code>%</code>

 *          <td>Prefix or suffix

 *          <td>Yes

 *          <td>Multiply by 100 and show as percentage

 *     <tr valign=top>

 *          <td><code>&#92;u2030</code>

 *          <td>Prefix or suffix

 *          <td>Yes

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

 *     <tr valign=top bgcolor="#eeeeff">

 *          <td><code>&#164;</code> (<code>&#92;u00A4</code>)

 *          <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 valign=top>

 *          <td><code>'</code>

 *          <td>Prefix or suffix

 *          <td>No

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

 *              for example, <code>"'#'#"</code> formats 123 to

 *              <code>"#123"</code>.  To create a single quote

 *              itself, use two in a row: <code>"# o''clock"</code>.

 * </table>

 * </blockquote>

 *

 * <h4>Scientific Notation</h4>

 *

 * <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 <= x < 10.0, but it need not be.

 * <code>DecimalFormat</code> 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"</code> formats the number

 * 1234 as <code>"1.234E3"</code>.

 *

 * <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"</code>.

 *

 * <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"</code>. Using this pattern, the number 12345

 * formats to <code>"12.345E3"</code>, and 123456 formats to

 * <code>"123.456E3"</code>.

 *

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

 * exponent.  Example: 0.00123 formatted with <code>"00.###E0"</code> yields

 * <code>"12.3E-4"</code>.

 * </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"</code> is <code>"12.3E3"</code>. 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>

 *

 * <h4>Rounding</h4>

 *

 * <code>DecimalFormat</code> provides rounding modes defined in

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

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

 *

 * <h4>Digits</h4>

 *

 * For formatting, <code>DecimalFormat</code> uses the ten consecutive

 * characters starting with the localized zero digit defined in the

 * <code>DecimalFormatSymbols</code> 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</code> is formatted as a string, which typically has a single character

 * <code>&#92;uFFFD</code>.  This string is determined by the

 * <code>DecimalFormatSymbols</code> 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>&#92;u221E</code>, with the positive or negative prefixes and suffixes

 * applied.  The infinity string is determined by the

 * <code>DecimalFormatSymbols</code> object.

 *

 * <p>Negative zero (<code>"-0"</code>) parses to

 * <ul>

 * <li><code>BigDecimal(0)</code> if <code>isParseBigDecimal()</code> is

 * true,

 * <li><code>Long(0)</code> if <code>isParseBigDecimal()</code> is false

 *     and <code>isParseIntegerOnly()</code> is true,

 * <li><code>Double(-0.0)</code> if both <code>isParseBigDecimal()</code>

 * and <code>isParseIntegerOnly()</code> are false.

 * </ul>

 *

 * <h4><a name="synchronization">Synchronization</a></h4>

 *

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

 *

 * <h4>Example</h4>

 *

 * <blockquote><pre>

 * <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://java.sun.com/docs/books/tutorial/i18n/format/decimalFormat.html">Java Tutorial</a>

 * @see          NumberFormat

 * @see          DecimalFormatSymbols

 * @see          ParsePosition

 * @author       Mark Davis

 * @author       Alan Liu

 */

public class DecimalFormat extends NumberFormat {

    /**

     * Creates a DecimalFormat using the default pattern and symbols

     * for the default 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() {

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

        // try to get the pattern from the cache

        String pattern = cachedLocaleData.get(def);

        if (pattern == null) {  /* cache miss */

            // Get the pattern for the default locale.

            ResourceBundle rb = LocaleData.getNumberFormatData(def);

            String[] all = rb.getStringArray("NumberPatterns");

            pattern = all[0];

            /* update cache */

            cachedLocaleData.putIfAbsent(def, pattern);

        }

        // Always applyPattern after the symbols are set

        this.symbols = new DecimalFormatSymbols(def);

        applyPattern(pattern, false);

    }

    /**

     * Creates a DecimalFormat using the given pattern and the symbols

     * for the default 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.

     * @exception NullPointerException if <code>pattern</code> is null

     * @exception 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 = new DecimalFormatSymbols(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

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

     * @exception 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</code> to which the formatted

     *                   text is to be appended

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

     *                   On output: the offsets of the alignment field.

     * @return           the value passed in as <code>toAppendTo</code>

     * @exception        IllegalArgumentException if <code>number</code> is

     *                   null or not an instance of <code>Number</code>.

     * @exception        NullPointerException if <code>toAppendTo</code> or

     *                   <code>pos</code> is null

     * @exception        ArithmeticException if rounding is needed with rounding

     *                   mode being set to RoundingMode.UNNECESSARY

     * @see              java.text.FieldPosition

     */

    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) {

            return format((BigDecimal)number, toAppendTo, pos);

        } else if (number instanceof BigInteger) {

            return format((BigInteger)number, toAppendTo, pos);

        } else if (number instanceof Number) {

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

        } else {

            throw new IllegalArgumentException("Cannot format given Object as a Number");

        }

    }

    /**

     * Formats a double to produce a string.

     * @param number    The double to format

     * @param result    where the text is to be appended

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

     * On output: the offsets of the alignment field.

     * @exception ArithmeticException if rounding is needed with rounding

     *            mode being set to RoundingMode.UNNECESSARY

     * @return The formatted number string

     * @see java.text.FieldPosition

     */

    public StringBuffer format(double number, StringBuffer result,

                               FieldPosition fieldPosition) {

        fieldPosition.setBeginIndex(0);

        fieldPosition.setEndIndex(0);

        return format(number, result, fieldPosition.getFieldDelegate());

    }

    /**

     * Formats a double to produce a string.

     * @param number    The double to format

     * @param result    where the text is to be appended

     * @param delegate notified of locations of sub fields

     * @exception       ArithmeticException if rounding is needed with rounding

     *                  mode being set to RoundingMode.UNNECESSARY

     * @return The formatted number string

     */

    private StringBuffer format(double number, StringBuffer result,

                                FieldDelegate delegate) {

        if (Double.isNaN(number) ||

           (Double.isInfinite(number) && multiplier == 0)) {

            int iFieldStart = result.length();

            result.append(symbols.getNaN());

            delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,

                               iFieldStart, result.length(), result);

            return result;

        }

        /* Detecting whether a double is negative is easy with the exception of

         * the value -0.0.  This is a double which has a zero mantissa (and

         * exponent), but a negative sign bit.  It is semantically distinct from

         * a zero with a positive sign bit, and this distinction is important

         * to certain kinds of computations.  However, it's a little tricky to

         * detect, since (-0.0 == 0.0) and !(-0.0 < 0.0).  How then, you may

         * ask, does it behave distinctly from +0.0?  Well, 1/(-0.0) ==

         * -Infinity.  Proper detection of -0.0 is needed to deal with the

         * issues raised by bugs 4106658, 4106667, and 4147706.  Liu 7/6/98.

         */

        boolean isNegative = ((number < 0.0) || (number == 0.0 && 1/number < 0.0)) ^ (multiplier < 0);

        if (multiplier != 1) {

            number *= multiplier;

        }

        if (Double.isInfinite(number)) {

            if (isNegative) {

                append(result, negativePrefix, delegate,

                       getNegativePrefixFieldPositions(), Field.SIGN);

            } else {

                append(result, positivePrefix, delegate,

                       getPositivePrefixFieldPositions(), Field.SIGN);

            }

            int iFieldStart = result.length();

            result.append(symbols.getInfinity());

            delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,

                               iFieldStart, result.length(), result);

            if (isNegative) {

                append(result, negativeSuffix, delegate,

                       getNegativeSuffixFieldPositions(), Field.SIGN);

            } else {

                append(result, positiveSuffix, delegate,

                       getPositiveSuffixFieldPositions(), Field.SIGN);

            }

            return result;

        }

        if (isNegative) {

            number = -number;

        }

        // at this point we are guaranteed a nonnegative finite number.

        assert(number >= 0 && !Double.isInfinite(number));

        synchronized(digitList) {

            int maxIntDigits = super.getMaximumIntegerDigits();

            int minIntDigits = super.getMinimumIntegerDigits();

            int maxFraDigits = super.getMaximumFractionDigits();

            int minFraDigits = super.getMinimumFractionDigits();

            digitList.set(isNegative, number, useExponentialNotation ?

                          maxIntDigits + maxFraDigits : maxFraDigits,

                          !useExponentialNotation);

            return subformat(result, delegate, isNegative, false,

                       maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);

        }

    }

    /**

     * Format a long to produce a string.

     * @param number    The long to format

     * @param result    where the text is to be appended

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

     * On output: the offsets of the alignment field.

     * @exception       ArithmeticException if rounding is needed with rounding

     *                  mode being set to RoundingMode.UNNECESSARY

     * @return The formatted number string

     * @see java.text.FieldPosition

     */

    public StringBuffer format(long number, StringBuffer result,

                               FieldPosition fieldPosition) {

        fieldPosition.setBeginIndex(0);

        fieldPosition.setEndIndex(0);

        return format(number, result, fieldPosition.getFieldDelegate());

    }

    /**

     * Format a long to produce a string.

     * @param number    The long to format

     * @param result    where the text is to be appended

     * @param delegate notified of locations of sub fields

     * @return The formatted number string

     * @exception        ArithmeticException if rounding is needed with rounding

     *                   mode being set to RoundingMode.UNNECESSARY

     * @see java.text.FieldPosition

     */

    private StringBuffer format(long number, StringBuffer result,

                               FieldDelegate delegate) {

        boolean isNegative = (number < 0);

        if (isNegative) {

            number = -number;

        }

        // In general, long values always represent real finite numbers, so

        // we don't have to check for +/- Infinity or NaN.  However, there

        // is one case we have to be careful of:  The multiplier can push

        // a number near MIN_VALUE or MAX_VALUE outside the legal range.  We

        // check for this before multiplying, and if it happens we use

        // BigInteger instead.

        boolean useBigInteger = false;

        if (number < 0) { // This can only happen if number == Long.MIN_VALUE.

            if (multiplier != 0) {

                useBigInteger = true;

            }

        } else if (multiplier != 1 && multiplier != 0) {

            long cutoff = Long.MAX_VALUE / multiplier;

            if (cutoff < 0) {

                cutoff = -cutoff;

            }

            useBigInteger = (number > cutoff);

        }

        if (useBigInteger) {

            if (isNegative) {

                number = -number;

            }

            BigInteger bigIntegerValue = BigInteger.valueOf(number);

            return format(bigIntegerValue, result, delegate, true);

        }

        number *= multiplier;

        if (number == 0) {

            isNegative = false;

        } else {

            if (multiplier < 0) {

                number = -number;

                isNegative = !isNegative;

            }

        }

        synchronized(digitList) {

            int maxIntDigits = super.getMaximumIntegerDigits();

            int minIntDigits = super.getMinimumIntegerDigits();

            int maxFraDigits = super.getMaximumFractionDigits();

            int minFraDigits = super.getMinimumFractionDigits();

            digitList.set(isNegative, number,

                     useExponentialNotation ? maxIntDigits + maxFraDigits : 0);

            return subformat(result, delegate, isNegative, true,

                       maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);

        }

    }

    /**

     * Formats a BigDecimal to produce a string.

     * @param number    The BigDecimal to format

     * @param result    where the text is to be appended

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

     * On output: the offsets of the alignment field.

     * @return The formatted number string

     * @exception        ArithmeticException if rounding is needed with rounding

     *                   mode being set to RoundingMode.UNNECESSARY

     * @see java.text.FieldPosition

     */

    private StringBuffer format(BigDecimal number, StringBuffer result,

                                FieldPosition fieldPosition) {

        fieldPosition.setBeginIndex(0);

        fieldPosition.setEndIndex(0);

        return format(number, result, fieldPosition.getFieldDelegate());

    }

    /**

     * Formats a BigDecimal to produce a string.

     * @param number    The BigDecimal to format

     * @param result    where the text is to be appended

     * @param delegate notified of locations of sub fields

     * @exception        ArithmeticException if rounding is needed with rounding

     *                   mode being set to RoundingMode.UNNECESSARY

     * @return The formatted number string

     */

    private StringBuffer format(BigDecimal number, StringBuffer result,

                                FieldDelegate delegate) {

        if (multiplier != 1) {

            number = number.multiply(getBigDecimalMultiplier());

        }

        boolean isNegative = number.signum() == -1;

        if (isNegative) {

            number = number.negate();

        }

        synchronized(digitList) {

            int maxIntDigits = getMaximumIntegerDigits();

            int minIntDigits = getMinimumIntegerDigits();

            int maxFraDigits = getMaximumFractionDigits();

            int minFraDigits = getMinimumFractionDigits();

            int maximumDigits = maxIntDigits + maxFraDigits;

            digitList.set(isNegative, number, useExponentialNotation ?

                ((maximumDigits < 0) ? Integer.MAX_VALUE : maximumDigits) :

                maxFraDigits, !useExponentialNotation);

            return subformat(result, delegate, isNegative, false,

                maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);

        }

    }

    /**

     * Format a BigInteger to produce a string.

     * @param number    The BigInteger to format

     * @param result    where the text is to be appended

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

     * On output: the offsets of the alignment field.

     * @return The formatted number string

     * @exception        ArithmeticException if rounding is needed with rounding

     *                   mode being set to RoundingMode.UNNECESSARY

     * @see java.text.FieldPosition

     */

    private StringBuffer format(BigInteger number, StringBuffer result,

                               FieldPosition fieldPosition) {

        fieldPosition.setBeginIndex(0);

        fieldPosition.setEndIndex(0);

        return format(number, result, fieldPosition.getFieldDelegate(), false);

    }

    /**

     * Format a BigInteger to produce a string.

     * @param number    The BigInteger to format

     * @param result    where the text is to be appended

     * @param delegate notified of locations of sub fields

     * @return The formatted number string

     * @exception        ArithmeticException if rounding is needed with rounding

     *                   mode being set to RoundingMode.UNNECESSARY

     * @see java.text.FieldPosition

     */

    private StringBuffer format(BigInteger number, StringBuffer result,

                               FieldDelegate delegate, boolean formatLong) {

        if (multiplier != 1) {

            number = number.multiply(getBigIntegerMultiplier());

        }

        boolean isNegative = number.signum() == -1;

        if (isNegative) {

            number = number.negate();

        }

        synchronized(digitList) {

            int maxIntDigits, minIntDigits, maxFraDigits, minFraDigits, maximumDigits;

            if (formatLong) {

                maxIntDigits = super.getMaximumIntegerDigits();

                minIntDigits = super.getMinimumIntegerDigits();

                maxFraDigits = super.getMaximumFractionDigits();

                minFraDigits = super.getMinimumFractionDigits();

                maximumDigits = maxIntDigits + maxFraDigits;

            } else {

                maxIntDigits = getMaximumIntegerDigits();

                minIntDigits = getMinimumIntegerDigits();

                maxFraDigits = getMaximumFractionDigits();

                minFraDigits = getMinimumFractionDigits();

                maximumDigits = maxIntDigits + maxFraDigits;

                if (maximumDigits < 0) {

                    maximumDigits = Integer.MAX_VALUE;

                }

            }

            digitList.set(isNegative, number,

                          useExponentialNotation ? maximumDigits : 0);

            return subformat(result, delegate, isNegative, true,

                maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);

        }

    }

    /**

     * Formats an Object 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>

     * Each attribute key of the AttributedCharacterIterator will be of type

     * <code>NumberFormat.Field</code>, with the attribute value being the

     * same as the attribute key.

     *

     * @exception NullPointerException if obj is null.

     * @exception IllegalArgumentException when the Format cannot format the

     *            given object.

     * @exception        ArithmeticException if rounding is needed with rounding

     *                   mode being set to RoundingMode.UNNECESSARY

     * @param obj The object to format

     * @return AttributedCharacterIterator describing the formatted value.

     * @since 1.4

     */

    public AttributedCharacterIterator formatToCharacterIterator(Object obj) {

        CharacterIteratorFieldDelegate delegate =

                         new CharacterIteratorFieldDelegate();

        StringBuffer sb = new StringBuffer();

        if (obj instanceof Double || obj instanceof Float) {

            format(((Number)obj).doubleValue(), sb, delegate);

        } else if (obj instanceof Long || obj instanceof Integer ||

                   obj instanceof Short || obj instanceof Byte ||

                   obj instanceof AtomicInteger || obj instanceof AtomicLong) {

            format(((Number)obj).longValue(), sb, delegate);

        } else if (obj instanceof BigDecimal) {

            format((BigDecimal)obj, sb, delegate);

        } else if (obj instanceof BigInteger) {

            format((BigInteger)obj, sb, delegate, false);

        } else if (obj == null) {

            throw new NullPointerException(

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

        } else {

            throw new IllegalArgumentException(

                "Cannot format given Object as a Number");

        }

        return delegate.getIterator(sb.toString());

    }

    /**

     * Complete the formatting of a finite number.  On entry, the digitList must

     * be filled in with the correct digits.

     */

    private StringBuffer subformat(StringBuffer result, FieldDelegate delegate,

                                   boolean isNegative, boolean isInteger,

                                   int maxIntDigits, int minIntDigits,

                                   int maxFraDigits, int minFraDigits) {

        // NOTE: This isn't required anymore because DigitList takes care of this.

        //

        //  // The negative of the exponent represents the number of leading

        //  // zeros between the decimal and the first non-zero digit, for

        //  // a value < 0.1 (e.g., for 0.00123, -fExponent == 2).  If this

        //  // is more than the maximum fraction digits, then we have an underflow

        //  // for the printed representation.  We recognize this here and set

        //  // the DigitList representation to zero in this situation.

        //

        //  if (-digitList.decimalAt >= getMaximumFractionDigits())

        //  {

        //      digitList.count = 0;

        //  }

        char zero = symbols.getZeroDigit();

        int zeroDelta = zero - '0'; // '0' is the DigitList representation of zero

        char grouping = symbols.getGroupingSeparator();

        char decimal = isCurrencyFormat ?

            symbols.getMonetaryDecimalSeparator() :

            symbols.getDecimalSeparator();

        /* Per bug 4147706, DecimalFormat must respect the sign of numbers which

         * format as zero.  This allows sensible computations and preserves

         * relations such as signum(1/x) = signum(x), where x is +Infinity or

         * -Infinity.  Prior to this fix, we always formatted zero values as if

         * they were positive.  Liu 7/6/98.

         */

        if (digitList.isZero()) {

            digitList.decimalAt = 0; // Normalize

        }

        if (isNegative) {

            append(result, negativePrefix, delegate,

                   getNegativePrefixFieldPositions(), Field.SIGN);

        } else {

            append(result, positivePrefix, delegate,

                   getPositivePrefixFieldPositions(), Field.SIGN);

        }

        if (useExponentialNotation) {

            int iFieldStart = result.length();

            int iFieldEnd = -1;

            int fFieldStart = -1;

            // Minimum integer digits are handled in exponential format by

            // adjusting the exponent.  For example, 0.01234 with 3 minimum

            // integer digits is "123.4E-4".

            // Maximum integer digits are interpreted as indicating the

            // repeating range.  This is useful for engineering notation, in

            // which the exponent is restricted to a multiple of 3.  For

            // example, 0.01234 with 3 maximum integer digits is "12.34e-3".

            // If maximum integer digits are > 1 and are larger than

            // minimum integer digits, then minimum integer digits are

            // ignored.

            int exponent = digitList.decimalAt;

            int repeat = maxIntDigits;

            int minimumIntegerDigits = minIntDigits;

            if (repeat > 1 && repeat > minIntDigits) {

                // A repeating range is defined; adjust to it as follows.

                // If repeat == 3, we have 6,5,4=>3; 3,2,1=>0; 0,-1,-2=>-3;

                // -3,-4,-5=>-6, etc. This takes into account that the

                // exponent we have here is off by one from what we expect;

                // it is for the format 0.MMMMMx10^n.

                if (exponent >= 1) {

                    exponent = ((exponent - 1) / repeat) * repeat;

                } else {

                    // integer division rounds towards 0

                    exponent = ((exponent - repeat) / repeat) * repeat;

                }

                minimumIntegerDigits = 1;

            } else {

                // No repeating range is defined; use minimum integer digits.

                exponent -= minimumIntegerDigits;

            }

            // We now output a minimum number of digits, and more if there

            // are more digits, up to the maximum number of digits.  We

            // place the decimal point after the "integer" digits, which

            // are the first (decimalAt - exponent) digits.

            int minimumDigits = minIntDigits + minFraDigits;

            if (minimumDigits < 0) {    // overflow?

                minimumDigits = Integer.MAX_VALUE;

            }

            // The number of integer digits is handled specially if the number

            // is zero, since then there may be no digits.

            int integerDigits = digitList.isZero() ? minimumIntegerDigits :

                    digitList.decimalAt - exponent;

            if (minimumDigits < integerDigits) {

                minimumDigits = integerDigits;

            }

            int totalDigits = digitList.count;

            if (minimumDigits > totalDigits) {

                totalDigits = minimumDigits;

            }

            boolean addedDecimalSeparator = false;

            for (int i=0; i<totalDigits; ++i) {

                if (i == integerDigits) {

                    // Record field information for caller.

                    iFieldEnd = result.length();

                    result.append(decimal);

                    addedDecimalSeparator = true;

                    // Record field information for caller.

                    fFieldStart = result.length();

                }

                result.append((i < digitList.count) ?

                              (char)(digitList.digits[i] + zeroDelta) :

                              zero);

            }

            if (decimalSeparatorAlwaysShown && totalDigits == integerDigits) {

                // Record field information for caller.

                iFieldEnd = result.length();

                result.append(decimal);

                addedDecimalSeparator = true;

                // Record field information for caller.

                fFieldStart = result.length();

            }

            // Record field information