/*

* Copyright (c) 1996, 2016, 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.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.locale.provider.LocaleProviderAdapter;

import sun.util.locale.provider.ResourceBundleBasedAdapter;

/**

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

*

* <h3>Patterns</h3>

*

* <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_opt</i> <i>Number</i> <i>Suffix_opt</i>

* <i>NegativePattern:</i>

* <i>Prefix_opt</i> <i>Number</i> <i>Suffix_opt</i>

* <i>Prefix:</i>

* any Unicode characters except &#92;uFFFE, &#92;uFFFF, and special characters

* <i>Suffix:</i>

* any Unicode characters except &#92;uFFFE, &#92;uFFFF, and special characters

* <i>Number:</i>

* <i>Integer</i> <i>Exponent_opt</i>

* <i>Integer</i> . <i>Fraction</i> <i>Exponent_opt</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_opt</i> <i>OptionalFraction_opt</i>

* <i>MinimumFraction:</i>

* 0 <i>MinimumFraction_opt</i>

* <i>OptionalFraction:</i>

* # <i>OptionalFraction_opt</i>

* <i>Exponent:</i>

* E <i>MinimumExponent</i>

* <i>MinimumExponent:</i>

* 0 <i>MinimumExponent_opt</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 style="background-color: rgb(204, 204, 255);">

* <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 style="vertical-align: top; background-color: rgb(238, 238, 255);">

* <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 style="vertical-align: top; background-color: rgb(238, 238, 255);">

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

* <td>Number

* <td>Yes

* <td>Minus sign

* <tr valign=top>

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

* <td>Number

* <td>Yes

* <td>Grouping separator

* <tr style="vertical-align: top; background-color: rgb(238, 238, 255);">

* <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 style="vertical-align: top; background-color: rgb(238, 238, 255);">

* <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 style="vertical-align: top; background-color: rgb(238, 238, 255);">

* <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 &le; x {@literal <} 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>{@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="https://docs.oracle.com/javase/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 {@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.

* @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 = 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

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

*/

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

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

*/

@Override

public StringBuffer format(double number, StringBuffer result,

FieldPosition fieldPosition) {

// If fieldPosition is a DontCareFieldPosition instance we can

// try to go to fast-path code.

boolean tryFastPath = false;

if (fieldPosition == DontCareFieldPosition.INSTANCE)

tryFastPath = true;

else {

fieldPosition.setBeginIndex(0);

fieldPosition.setEndIndex(0);

}

if (tryFastPath) {

String tempResult = fastFormat(number);

if (tempResult != null) {

result.append(tempResult);

return result;

}

}

// if fast-path could not work, we fallback to standard code.

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

*/

@Override

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

*/

@Override

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());

}

// ==== Begin fast-path formating logic for double =========================

/* Fast-path formatting will be used for format(double ...) methods iff a

* number of conditions are met (see checkAndSetFastPathStatus()):

* - Only if instance properties meet the right predefined conditions.

* - The abs value of the double to format is <= Integer.MAX_VALUE.

*

* The basic approach is to split the binary to decimal conversion of a

* double value into two phases:

* * The conversion of the integer portion of the double.

* * The conversion of the fractional portion of the double

* (limited to two or three digits).

*

* The isolation and conversion of the integer portion of the double is

* straightforward. The conversion of the fraction is more subtle and relies

* on some rounding properties of double to the decimal precisions in

* question. Using the terminology of BigDecimal, this fast-path algorithm

* is applied when a double value has a magnitude less than Integer.MAX_VALUE

* and rounding is to nearest even and the destination format has two or

* three digits of *scale* (digits after the decimal point).

*

* Under a rounding to nearest even policy, the returned result is a digit

* string of a number in the (in this case decimal) destination format

* closest to the exact numerical value of the (in this case binary) input

* value. If two destination format numbers are equally distant, the one

* with the last digit even is returned. To compute such a correctly rounded

* value, some information about digits beyond the smallest returned digit

* position needs to be consulted.

*

* In general, a guard digit, a round digit, and a sticky *bit* are needed

* beyond the returned digit position. If the discarded portion of the input

* is sufficiently large, the returned digit string is incremented. In round

* to nearest even, this threshold to increment occurs near the half-way

* point between digits. The sticky bit records if there are any remaining

* trailing digits of the exact input value in the new format; the sticky bit

* is consulted only in close to half-way rounding cases.

*

* Given the computation of the digit and bit values, rounding is then

* reduced to a table lookup problem. For decimal, the even/odd cases look

* like this:

*

* Last Round Sticky

* 6 5 0 => 6 // exactly halfway, return even digit.

* 6 5 1 => 7 // a little bit more than halfway, round up.

* 7 5 0 => 8 // exactly halfway, round up to even.

* 7 5 1 => 8 // a little bit more than halfway, round up.

* With analogous entries for other even and odd last-returned digits.

*

* However, decimal negative powers of 5 smaller than 0.5 are *not* exactly

* representable as binary fraction. In particular, 0.005 (the round limit

* for a two-digit scale) and 0.0005 (the round limit for a three-digit

* scale) are not representable. Therefore, for input values near these cases

* the sticky bit is known to be set which reduces the rounding logic to:

*

* Last Round Sticky

* 6 5 1 => 7 // a little bit more than halfway, round up.

* 7 5 1 => 8 // a little bit more than halfway, round up.

*

* In other words, if the round digit is 5, the sticky bit is known to be

* set. If the round digit is something other than 5, the sticky bit is not

* relevant. Therefore, some of the logic about whether or not to increment

* the destination *decimal* value can occur based on tests of *binary*

* computations of the binary input number.

*/

/**

* Check validity of using fast-path for this instance. If fast-path is valid

* for this instance, sets fast-path state as true and initializes fast-path

* utility fields as needed.

*

* This method is supposed to be called rarely, otherwise that will break the

* fast-path performance. That means avoiding frequent changes of the

* properties of the instance, since for most properties, each time a change

* happens, a call to this method is needed at the next format call.

*

* FAST-PATH RULES:

* Similar to the default DecimalFormat instantiation case.

* More precisely:

* - HALF_EVEN rounding mode,

* - isGroupingUsed() is true,

* - groupingSize of 3,

* - multiplier is 1,

* - Decimal separator not mandatory,

* - No use of exponential notation,

* - minimumIntegerDigits is exactly 1 and maximumIntegerDigits at least 10

* - For number of fractional digits, the exact values found in the default case:

* Currency : min = max = 2.

* Decimal : min = 0. max = 3.

*

*/

private boolean checkAndSetFastPathStatus() {

boolean fastPathWasOn = isFastPath;

if ((roundingMode == RoundingMode.HALF_EVEN) &&

(isGroupingUsed()) &&

(groupingSize == 3) &&

(multiplier == 1) &&

(!decimalSeparatorAlwaysShown) &&

(!useExponentialNotation)) {

// The fast-path algorithm is semi-hardcoded against

// minimumIntegerDigits and maximumIntegerDigits.

isFastPath = ((minimumIntegerDigits == 1) &&

(maximumIntegerDigits >= 10));

// The fast-path algorithm is hardcoded against

// minimumFractionDigits and maximumFractionDigits.

if (isFastPath) {

if (isCurrencyFormat) {

if ((minimumFractionDigits != 2) ||

(maximumFractionDigits != 2))

isFastPath = false;

} else if ((minimumFractionDigits != 0) ||

(maximumFractionDigits != 3))

isFastPath = false;

}

} else

isFastPath = false;