Logo Search packages:      
Sourcecode: icu version File versions  Download package

DecimalFormat Class Reference

#include <decimfmt.h>

Inheritance diagram for DecimalFormat:

NumberFormat Format UObject UMemory

List of all members.

Detailed Description

DecimalFormat is a concrete subclass of 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, or Indic digits. It also supports different flavors of numbers, including integers ("123"), fixed-point numbers ("123.4"), scientific notation ("1.23E4"), percentages ("12%"), and currency amounts ("$123", "USD123", "123 US dollars"). All of these flavors can be easily localized.

To obtain a NumberFormat for a specific locale (including the default locale) call one of NumberFormat's factory methods such as createInstance(). Do not call the DecimalFormat constructors directly, unless you know what you are doing, since the NumberFormat factory methods may return subclasses other than DecimalFormat.

Example Usage

     // Normally we would have a GUI with a menu for this
     int32_t locCount;
     const Locale* locales = NumberFormat::getAvailableLocales(locCount);

     double myNumber = -1234.56;
     UErrorCode success = U_ZERO_ERROR;
     NumberFormat* form;

     // Print out a number with the localized number, currency and percent
     // format for each locale.
     UnicodeString countryName;
     UnicodeString displayName;
     UnicodeString str;
     UnicodeString pattern;
     Formattable fmtable;
     for (int32_t j = 0; j < 3; ++j) {
         cout << endl << "FORMAT " << j << endl;
         for (int32_t i = 0; i < locCount; ++i) {
             if (locales[i].getCountry(countryName).size() == 0) {
                 // skip language-only
             switch (j) {
             case 0:
                 form = NumberFormat::createInstance(locales[i], success ); break;
             case 1:
                 form = NumberFormat::createCurrencyInstance(locales[i], success ); break;
                 form = NumberFormat::createPercentInstance(locales[i], success ); break;
             if (form) {
                 pattern = ((DecimalFormat*)form)->toPattern(pattern);
                 cout << locales[i].getDisplayName(displayName) << ": " << pattern;
                 cout << "  ->  " << form->format(myNumber,str) << endl;
                 form->parse(form->format(myNumber,str), fmtable, success);
                 delete form;

Another example use createInstance(style)

 // Print out a number using the localized number, currency,
 // percent, scientific, integer, iso currency, and plural currency
 // format for each locale
 Locale* locale = new Locale("en", "US");
 double myNumber = 1234.56;
 UErrorCode success = U_ZERO_ERROR;
 UnicodeString str;
 Formattable fmtable;
 for (int j=NumberFormatkNumberStyle;
      ++j) {
     NumberFormat* format = NumberFormat::createInstance(locale, j, success);
     cout << "format result " << form->format(myNumber, str) << endl;
     format->parse(form->format(myNumber, str), fmtable, success);


A DecimalFormat consists of a pattern and a set of symbols. The pattern may be set directly using applyPattern(), or indirectly using other API methods which manipulate aspects of the pattern, such as the minimum number of integer digits. The symbols are stored in a DecimalFormatSymbols object. When using the NumberFormat factory methods, the pattern and symbols are read from ICU's locale data.

Special Pattern Characters

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. For example, the '#' character is replaced by a localized digit. Often the replacement character is the same as the pattern character; in the U.S. locale, the ',' grouping character is replaced by ','. However, the replacement is still happening, and if the symbols are modified, the grouping character changes. Some special characters affect the behavior of the formatter by their presence; for example, if the percent character is seen, then the value is multiplied by 100 before being displayed.

To insert a special character in a pattern as a literal, that is, without any special meaning, the character must be quoted. There are some exceptions to this which are noted below.

The characters listed here are used in non-localized patterns. Localized patterns use the corresponding characters taken from this formatter's DecimalFormatSymbols object instead, and these characters lose their special status. Two exceptions are the currency sign and quote, which are not localized.

Symbol Location Localized? Meaning
0 Number Yes Digit
1-9 Number Yes '1' through '9' indicate rounding.
@ Number No Significant digit
# Number Yes Digit, zero shows as absent
. Number Yes Decimal separator or monetary decimal separator
- Number Yes Minus sign
, Number Yes Grouping separator
E Number Yes Separates mantissa and exponent in scientific notation. Need not be quoted in prefix or suffix.
+ Exponent Yes Prefix positive exponents with localized plus sign. Need not be quoted in prefix or suffix.
; Subpattern boundary Yes Separates positive and negative subpatterns
% Prefix or suffix Yes Multiply by 100 and show as percentage
\u2030 Prefix or suffix Yes Multiply by 1000 and show as per mille
¤ (\u00A4) Prefix or suffix No Currency sign, replaced by currency symbol. If doubled, replaced by international currency symbol. If tripled, replaced by currency plural names, for example, "US dollar" or "US dollars" for America. If present in a pattern, the monetary decimal separator is used instead of the decimal separator.
' Prefix or suffix No Used to quote special characters in a prefix or suffix, for example, "'#'#" formats 123 to "#123". To create a single quote itself, use two in a row: "# o''clock".
* Prefix or suffix boundary Yes Pad escape, precedes pad character

A DecimalFormat pattern contains a postive and negative subpattern, for example, "#,##0.00;(#,##0.00)". Each subpattern has a prefix, a numeric part, and a suffix. If there is no explicit negative subpattern, the negative subpattern is the localized minus sign prefixed to the positive subpattern. That is, "0.00" alone is equivalent to "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 ignored in the negative subpattern. That means that "#,##0.0#;(#)" has precisely the same result as "#,##0.0#;(#,##0.0#)".

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 parse() to be able to distinguish positive from negative values. Another example is that the decimal separator and thousands separator should be distinct characters, or parsing will be impossible.

The grouping separator is a character that separates clusters of integer digits to make large numbers more legible. It commonly used for thousands, but in some locales it separates ten-thousands. The grouping size is the number of digits between the grouping separators, such as 3 for "100,000,000" or 4 for "1 0000 0000". There are actually two different grouping sizes: One used for the least significant integer digits, the primary grouping size, and one used for all others, the secondary grouping size. In most locales these are the same, but sometimes they are different. For example, if the primary grouping interval is 3, and the secondary is 2, then this corresponds to the pattern "#,##,##0", and the number 123456789 is formatted as "12,34,56,789". If a pattern contains multiple grouping separators, the interval between the last one and the end of the integer defines the primary grouping size, and the interval between the last two defines the secondary grouping size. All others are ignored, so "#,##,###,####" == "###,###,####" == "##,#,###,####".

Illegal patterns, such as "#.#.#" or "#.###,###", will cause DecimalFormat to set a failing UErrorCode.

Pattern BNF

 pattern    := subpattern (';' subpattern)?
 subpattern := prefix? number exponent? suffix?
 number     := (integer ('.' fraction)?) | sigDigits
 prefix     := '\u0000'..'\uFFFD' - specialCharacters
 suffix     := '\u0000'..'\uFFFD' - specialCharacters
 integer    := '#'* '0'* '0'
 fraction   := '0'* '#'*
 sigDigits  := '#'* '@' '@'* '#'*
 exponent   := 'E' '+'? '0'* '0'
 padSpec    := '*' padChar
 padChar    := '\u0000'..'\uFFFD' - quote
   X*       0 or more instances of X
   X?       0 or 1 instances of X
   X|Y      either X or Y
   C..D     any character from C up to D, inclusive
   S-T      characters in S, except those in T
The first subpattern is for positive numbers. The second (optional) subpattern is for negative numbers.

Not indicated in the BNF syntax above:


DecimalFormat parses all Unicode characters that represent decimal digits, as defined by u_charDigitValue(). In addition, DecimalFormat also recognizes as digits the ten consecutive characters starting with the localized zero digit defined in the DecimalFormatSymbols object. During formatting, the DecimalFormatSymbols-based digits are output.

During parsing, grouping separators are ignored.

For currency parsing, the formatter is able to parse every currency style formats no matter which style the formatter is constructed with. For example, a formatter instance gotten from NumberFormat.getInstance(ULocale, NumberFormat.CURRENCYSTYLE) can parse formats such as "USD1.00" and "3.00 US dollars".

If parse(UnicodeString&,Formattable&,ParsePosition&) fails to parse a string, it leaves the parse position unchanged. The convenience method parse(UnicodeString&,Formattable&,UErrorCode&) indicates parse failure by setting a failing UErrorCode.


Formatting is guided by several parameters, all of which can be specified either using a pattern or using the API. The following description applies to formats that do not use scientific notation or significant digits.

Special Values

NaN is represented as a single character, typically \uFFFD. This character is determined by the DecimalFormatSymbols object. This is the only value for which the prefixes and suffixes are not used.

Infinity is represented as a single character, typically \u221E, with the positive or negative prefixes and suffixes applied. The infinity character is determined by the DecimalFormatSymbols object.

Scientific Notation

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 103. The mantissa is typically in the half-open interval [1.0, 10.0) or sometimes [0.0, 1.0), but it need not be. DecimalFormat supports arbitrary mantissas. DecimalFormat can be instructed to use scientific notation through the API or through the pattern. In a pattern, the exponent character immediately followed by one or more digit characters indicates scientific notation. Example: "0.###E0" formats the number 1234 as "1.234E3".

Significant Digits

DecimalFormat has two ways of controlling how many digits are shows: (a) significant digits counts, or (b) integer and fraction digit counts. Integer and fraction digit counts are described above. When a formatter is using significant digits counts, the number of integer and fraction digits is not specified directly, and the formatter settings for these counts are ignored. Instead, the formatter uses however many integer and fraction digits are required to display the specified number of significant digits. Examples:

Pattern Minimum significant digits Maximum significant digits Number Output of format()
@@@ 3 3 12345 12300
@@@ 3 3 0.12345 0.123
@@## 2 4 3.14159 3.142
@@## 2 4 1.23004 1.23


DecimalFormat supports padding the result of format() to a specific width. Padding may be specified either through the API or through the pattern syntax. In a pattern the pad escape character, followed by a single pad character, causes padding to be parsed and formatted. The pad escape character is '*' in unlocalized patterns, and can be localized using DecimalFormatSymbols::setSymbol() with a DecimalFormatSymbols::kPadEscapeSymbol selector. For example, "$*x#,##0.00" formats 123 to "$xx123.00", and 1234 to "$1,234.00".


DecimalFormat supports rounding to a specific increment. For example, 1230 rounded to the nearest 50 is 1250. 1.234 rounded to the nearest 0.65 is 1.3. The rounding increment may be specified through the API or in a pattern. To specify a rounding increment in a pattern, include the increment in the pattern itself. "#,#50" specifies a rounding increment of 50. "#,##0.05" specifies a rounding increment of 0.05.


DecimalFormat objects are not synchronized. Multiple threads should not access one formatter concurrently.


User subclasses are not supported. While clients may write subclasses, such code will not necessarily work and will not be guaranteed to work stably from release to release.

Definition at line 639 of file decimfmt.h.

Public Types

enum  EAlignmentFields {
  kIntegerField, kFractionField, kDecimalSeparatorField, kExponentSymbolField,
  kExponentSignField, kExponentField, kGroupingSeparatorField, kCurrencyField,
  kPercentField, kPermillField, kSignField, INTEGER_FIELD = kIntegerField,
  FRACTION_FIELD = kFractionField
enum  EPadPosition { kPadBeforePrefix, kPadAfterPrefix, kPadBeforeSuffix, kPadAfterSuffix }
enum  ERoundingMode {
  kRoundCeiling, kRoundFloor, kRoundDown, kRoundUp,
  kRoundHalfEven, kRoundHalfDown, kRoundHalfUp
enum  EStyles {
  kNumberStyle, kCurrencyStyle, kPercentStyle, kScientificStyle,
  kIsoCurrencyStyle, kPluralCurrencyStyle, kStyleCount

Public Member Functions

virtual void adoptCurrencyPluralInfo (CurrencyPluralInfo *toAdopt)
virtual void adoptDecimalFormatSymbols (DecimalFormatSymbols *symbolsToAdopt)
virtual void applyLocalizedPattern (const UnicodeString &pattern, UErrorCode &status)
virtual void applyLocalizedPattern (const UnicodeString &pattern, UParseError &parseError, UErrorCode &status)
virtual void applyPattern (const UnicodeString &pattern, UErrorCode &status)
virtual void applyPattern (const UnicodeString &pattern, UParseError &parseError, UErrorCode &status)
UBool areSignificantDigitsUsed () const
virtual Formatclone (void) const
 DecimalFormat (const DecimalFormat &source)
 DecimalFormat (const UnicodeString &pattern, const DecimalFormatSymbols &symbols, UErrorCode &status)
 DecimalFormat (const UnicodeString &pattern, DecimalFormatSymbols *symbolsToAdopt, UParseError &parseError, UErrorCode &status)
 DecimalFormat (const UnicodeString &pattern, DecimalFormatSymbols *symbolsToAdopt, NumberFormat::EStyles style, UErrorCode &status)
 DecimalFormat (const UnicodeString &pattern, DecimalFormatSymbols *symbolsToAdopt, UErrorCode &status)
 DecimalFormat (const UnicodeString &pattern, UErrorCode &status)
 DecimalFormat (UErrorCode &status)
virtual UnicodeStringformat (const Formattable &obj, UnicodeString &appendTo, FieldPositionIterator *posIter, UErrorCode &status) const
UnicodeStringformat (int64_t number, UnicodeString &appendTo) const
UnicodeStringformat (int32_t number, UnicodeString &appendTo) const
UnicodeStringformat (double number, UnicodeString &appendTo) const
UnicodeStringformat (const Formattable &obj, UnicodeString &appendTo, UErrorCode &status) const
virtual UnicodeStringformat (const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const
virtual UnicodeStringformat (const DigitList &number, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const
virtual UnicodeStringformat (const DigitList &number, UnicodeString &appendTo, FieldPositionIterator *posIter, UErrorCode &status) const
virtual UnicodeStringformat (const StringPiece &number, UnicodeString &appendTo, FieldPositionIterator *posIter, UErrorCode &status) const
virtual UnicodeStringformat (int64_t number, UnicodeString &appendTo, FieldPositionIterator *posIter, UErrorCode &status) const
virtual UnicodeStringformat (int64_t number, UnicodeString &appendTo, FieldPosition &pos) const
virtual UnicodeStringformat (int32_t number, UnicodeString &appendTo, FieldPositionIterator *posIter, UErrorCode &status) const
virtual UnicodeStringformat (int32_t number, UnicodeString &appendTo, FieldPosition &pos) const
virtual UnicodeStringformat (double number, UnicodeString &appendTo, FieldPositionIterator *posIter, UErrorCode &status) const
virtual UnicodeStringformat (double number, UnicodeString &appendTo, FieldPosition &pos) const
const UChar * getCurrency () const
virtual const CurrencyPluralInfogetCurrencyPluralInfo (void) const
virtual const
getDecimalFormatSymbols (void) const
virtual UClassID getDynamicClassID (void) const
virtual int32_t getFormatWidth (void) const
int32_t getGroupingSize (void) const
Locale getLocale (ULocDataLocaleType type, UErrorCode &status) const
const char * getLocaleID (ULocDataLocaleType type, UErrorCode &status) const
int32_t getMaximumFractionDigits (void) const
int32_t getMaximumIntegerDigits (void) const
int32_t getMaximumSignificantDigits () const
virtual int8_t getMinimumExponentDigits (void) const
int32_t getMinimumFractionDigits (void) const
int32_t getMinimumIntegerDigits (void) const
int32_t getMinimumSignificantDigits () const
int32_t getMultiplier (void) const
UnicodeStringgetNegativePrefix (UnicodeString &result) const
UnicodeStringgetNegativeSuffix (UnicodeString &result) const
virtual UnicodeString getPadCharacterString () const
virtual EPadPosition getPadPosition (void) const
UnicodeStringgetPositivePrefix (UnicodeString &result) const
UnicodeStringgetPositiveSuffix (UnicodeString &result) const
virtual double getRoundingIncrement (void) const
virtual ERoundingMode getRoundingMode (void) const
int32_t getSecondaryGroupingSize (void) const
UBool isDecimalSeparatorAlwaysShown (void) const
virtual UBool isExponentSignAlwaysShown (void)
UBool isGroupingUsed (void) const
UBool isParseIntegerOnly (void) const
virtual UBool isScientificNotation (void)
UBool operator!= (const Format &other) const
DecimalFormatoperator= (const DecimalFormat &rhs)
virtual UBool operator== (const Format &other) const
virtual void parse (const UnicodeString &text, Formattable &result, UErrorCode &status) const
virtual void parse (const UnicodeString &text, Formattable &result, ParsePosition &parsePosition) const
virtual FormattableparseCurrency (const UnicodeString &text, Formattable &result, ParsePosition &pos) const
void parseObject (const UnicodeString &source, Formattable &result, UErrorCode &status) const
virtual void parseObject (const UnicodeString &source, Formattable &result, ParsePosition &parse_pos) const
virtual void setCurrency (const UChar *theCurrency)
virtual void setCurrency (const UChar *theCurrency, UErrorCode &ec)
virtual void setCurrencyPluralInfo (const CurrencyPluralInfo &info)
virtual void setDecimalFormatSymbols (const DecimalFormatSymbols &symbols)
virtual void setDecimalSeparatorAlwaysShown (UBool newValue)
virtual void setExponentSignAlwaysShown (UBool expSignAlways)
virtual void setFormatWidth (int32_t width)
virtual void setGroupingSize (int32_t newValue)
virtual void setGroupingUsed (UBool newValue)
virtual void setMaximumFractionDigits (int32_t newValue)
virtual void setMaximumIntegerDigits (int32_t newValue)
void setMaximumSignificantDigits (int32_t max)
virtual void setMinimumExponentDigits (int8_t minExpDig)
virtual void setMinimumFractionDigits (int32_t newValue)
virtual void setMinimumIntegerDigits (int32_t newValue)
void setMinimumSignificantDigits (int32_t min)
virtual void setMultiplier (int32_t newValue)
virtual void setNegativePrefix (const UnicodeString &newValue)
virtual void setNegativeSuffix (const UnicodeString &newValue)
virtual void setPadCharacter (const UnicodeString &padChar)
virtual void setPadPosition (EPadPosition padPos)
virtual void setParseIntegerOnly (UBool value)
virtual void setPositivePrefix (const UnicodeString &newValue)
virtual void setPositiveSuffix (const UnicodeString &newValue)
virtual void setRoundingIncrement (double newValue)
virtual void setRoundingMode (ERoundingMode roundingMode)
virtual void setScientificNotation (UBool useScientific)
virtual void setSecondaryGroupingSize (int32_t newValue)
void setSignificantDigitsUsed (UBool useSignificantDigits)
virtual UnicodeStringtoLocalizedPattern (UnicodeString &result) const
virtual UnicodeStringtoPattern (UnicodeString &result) const
virtual ~DecimalFormat ()

Static Public Member Functions

static NumberFormat *U_EXPORT2 createCurrencyInstance (const Locale &inLocale, UErrorCode &)
static NumberFormat *U_EXPORT2 createCurrencyInstance (UErrorCode &)
static NumberFormat *U_EXPORT2 createInstance (const Locale &desiredLocale, EStyles choice, UErrorCode &success)
static NumberFormat *U_EXPORT2 createInstance (const Locale &inLocale, UErrorCode &)
static NumberFormat *U_EXPORT2 createInstance (UErrorCode &)
static NumberFormat *U_EXPORT2 createPercentInstance (const Locale &inLocale, UErrorCode &)
static NumberFormat *U_EXPORT2 createPercentInstance (UErrorCode &)
static NumberFormat *U_EXPORT2 createScientificInstance (const Locale &inLocale, UErrorCode &)
static NumberFormat *U_EXPORT2 createScientificInstance (UErrorCode &)
static StringEnumeration *U_EXPORT2 getAvailableLocales (void)
static const Locale *U_EXPORT2 getAvailableLocales (int32_t &count)
static UClassID U_EXPORT2 getStaticClassID (void)
static void U_EXPORT2 operator delete (void *, void *) U_NO_THROW
static void U_EXPORT2 operator delete (void *p) U_NO_THROW
static void U_EXPORT2 operator delete[] (void *p) U_NO_THROW
static void *U_EXPORT2 operator new (size_t, void *ptr) U_NO_THROW
static void *U_EXPORT2 operator new (size_t size) U_NO_THROW
static void *U_EXPORT2 operator new[] (size_t size) U_NO_THROW
static URegistryKey U_EXPORT2 registerFactory (NumberFormatFactory *toAdopt, UErrorCode &status)
static UBool U_EXPORT2 unregister (URegistryKey key, UErrorCode &status)

Static Public Attributes

static const char fgNumberPatterns [] = "NumberPatterns"

Protected Member Functions

virtual void getEffectiveCurrency (UChar *result, UErrorCode &ec) const
void setLocaleIDs (const char *valid, const char *actual)

Static Protected Member Functions

static void syntaxError (const UnicodeString &pattern, int32_t pos, UParseError &parseError)

Static Protected Attributes

static const int32_t kDoubleFractionDigits = 340
static const int32_t kDoubleIntegerDigits = 309
static const int32_t kMaxScientificIntegerDigits = 8

Private Types

enum  { fgStatusInfinite, fgStatusLength }
enum  { fgCurrencySignCountZero, fgCurrencySignCountInSymbolFormat, fgCurrencySignCountInISOFormat, fgCurrencySignCountInPluralFormat }

Private Member Functions

UnicodeString_format (const DigitList &number, UnicodeString &appendTo, FieldPositionHandler &handler, UErrorCode &status) const
UnicodeString_format (double number, UnicodeString &appendTo, FieldPositionHandler &handler) const
UnicodeString_format (int64_t number, UnicodeString &appendTo, FieldPositionHandler &handler) const
void addPadding (UnicodeString &appendTo, FieldPositionHandler &handler, int32_t prefixLen, int32_t suffixLen) const
int32_t appendAffix (UnicodeString &buf, double number, FieldPositionHandler &handler, UBool isNegative, UBool isPrefix) const
void appendAffixPattern (UnicodeString &appendTo, const UnicodeString *affixPattern, const UnicodeString &expAffix, UBool localized) const
void appendAffixPattern (UnicodeString &appendTo, const UnicodeString &affix, UBool localized) const
void applyPattern (const UnicodeString &pattern, UBool localized, UParseError &parseError, UErrorCode &status)
void applyPatternInternally (const UnicodeString &pluralCount, const UnicodeString &pattern, UBool localized, UParseError &parseError, UErrorCode &status)
void applyPatternWithoutExpandAffix (const UnicodeString &pattern, UBool localized, UParseError &parseError, UErrorCode &status)
int32_t compareAffix (const UnicodeString &input, int32_t pos, UBool isNegative, UBool isPrefix, const UnicodeString *affixPat, UBool currencyParsing, int8_t type, UChar *currency) const
int32_t compareComplexAffix (const UnicodeString &affixPat, const UnicodeString &input, int32_t pos, int8_t type, UChar *currency) const
void construct (UErrorCode &status, UParseError &parseErr, const UnicodeString *pattern=0, DecimalFormatSymbols *symbolsToAdopt=0)
void copyHashForAffix (const Hashtable *source, Hashtable *target, UErrorCode &status)
void copyHashForAffixPattern (const Hashtable *source, Hashtable *target, UErrorCode &status)
void deleteHashForAffix (Hashtable *&table)
void deleteHashForAffixPattern ()
void expandAffix (const UnicodeString &pattern, UnicodeString &affix, double number, FieldPositionHandler &handler, UBool doFormat, const UnicodeString *pluralCount) const
void expandAffixAdjustWidth (const UnicodeString *pluralCount)
void expandAffixes (const UnicodeString *pluralCount)
const UnicodeStringgetConstSymbol (DecimalFormatSymbols::ENumberFormatSymbol symbol) const
void init ()
HashtableinitHashForAffix (UErrorCode &status)
HashtableinitHashForAffixPattern (UErrorCode &status)
UBool isGroupingPosition (int32_t pos) const
void parse (const UnicodeString &text, Formattable &result, ParsePosition &pos, UBool parseCurrency) const
UBool parseForCurrency (const UnicodeString &text, ParsePosition &parsePosition, DigitList &digits, UBool *status, UChar *currency) const
int32_t precision () const
void setCurrencyForSymbols ()
virtual void setCurrencyInternally (const UChar *theCurrency, UErrorCode &ec)
void setupCurrencyAffixes (const UnicodeString &pattern, UBool setupForCurrentPattern, UBool setupForPluralPattern, UErrorCode &status)
void setupCurrencyAffixPatterns (UErrorCode &status)
int32_t skipPadding (const UnicodeString &text, int32_t position) const
UnicodeStringsubformat (UnicodeString &appendTo, FieldPositionHandler &handler, DigitList &digits, UBool isInteger) const
UBool subparse (const UnicodeString &text, const UnicodeString *negPrefix, const UnicodeString *negSuffix, const UnicodeString *posPrefix, const UnicodeString *posSuffix, UBool currencyParsing, int8_t type, ParsePosition &parsePosition, DigitList &digits, UBool *status, UChar *currency) const
UnicodeStringtoPattern (UnicodeString &result, UBool localized) const

Static Private Member Functions

static int32_t compareSimpleAffix (const UnicodeString &affix, const UnicodeString &input, int32_t pos)
static int32_t match (const UnicodeString &text, int32_t pos, const UnicodeString &str)
static int32_t match (const UnicodeString &text, int32_t pos, UChar32 ch)
static int32_t skipRuleWhiteSpace (const UnicodeString &text, int32_t pos)
static int32_t skipUWhiteSpace (const UnicodeString &text, int32_t pos)

Private Attributes

enum DecimalFormat:: { ... }  CurrencySignCount
int fCurrencySignCount
UBool fDecimalSeparatorAlwaysShown
UBool fExponentSignAlwaysShown
UnicodeString fFormatPattern
int32_t fFormatWidth
int32_t fGroupingSize
int32_t fGroupingSize2
int32_t fMaxSignificantDigits
int8_t fMinExponentDigits
int32_t fMinSignificantDigits
UnicodeString fNegativePrefix
UnicodeString fNegativeSuffix
UChar32 fPad
EPadPosition fPadPosition
UnicodeString fPositivePrefix
UnicodeString fPositiveSuffix
ERoundingMode fRoundingMode
int fStyle
UBool fUseExponentialNotation
UBool fUseSignificantDigits
enum DecimalFormat:: { ... }  StatusFlags

The documentation for this class was generated from the following files:

Generated by  Doxygen 1.6.0   Back to index