ICU 4.4.2 4.4.2
|
00001 /* 00002 ******************************************************************************** 00003 * Copyright (C) 1997-2010, International Business Machines 00004 * Corporation and others. All Rights Reserved. 00005 ******************************************************************************** 00006 * 00007 * File DECIMFMT.H 00008 * 00009 * Modification History: 00010 * 00011 * Date Name Description 00012 * 02/19/97 aliu Converted from java. 00013 * 03/20/97 clhuang Updated per C++ implementation. 00014 * 04/03/97 aliu Rewrote parsing and formatting completely, and 00015 * cleaned up and debugged. Actually works now. 00016 * 04/17/97 aliu Changed DigitCount to int per code review. 00017 * 07/10/97 helena Made ParsePosition a class and get rid of the function 00018 * hiding problems. 00019 * 09/09/97 aliu Ported over support for exponential formats. 00020 * 07/20/98 stephen Changed documentation 00021 ******************************************************************************** 00022 */ 00023 00024 #ifndef DECIMFMT_H 00025 #define DECIMFMT_H 00026 00027 #include "unicode/utypes.h" 00033 #if !UCONFIG_NO_FORMATTING 00034 00035 #include "unicode/dcfmtsym.h" 00036 #include "unicode/numfmt.h" 00037 #include "unicode/locid.h" 00038 #include "unicode/fpositer.h" 00039 #include "unicode/stringpiece.h" 00040 00041 union UHashTok; 00042 00043 U_NAMESPACE_BEGIN 00044 00045 class DigitList; 00046 class ChoiceFormat; 00047 class CurrencyPluralInfo; 00048 class Hashtable; 00049 class FieldPositionHandler; 00050 00639 class U_I18N_API DecimalFormat: public NumberFormat { 00640 public: 00645 enum ERoundingMode { 00646 kRoundCeiling, 00647 kRoundFloor, 00648 kRoundDown, 00649 kRoundUp, 00650 kRoundHalfEven, 00652 kRoundHalfDown, 00654 kRoundHalfUp 00656 // We don't support ROUND_UNNECESSARY 00657 }; 00658 00663 enum EPadPosition { 00664 kPadBeforePrefix, 00665 kPadAfterPrefix, 00666 kPadBeforeSuffix, 00667 kPadAfterSuffix 00668 }; 00669 00683 DecimalFormat(UErrorCode& status); 00684 00699 DecimalFormat(const UnicodeString& pattern, 00700 UErrorCode& status); 00701 00720 DecimalFormat( const UnicodeString& pattern, 00721 DecimalFormatSymbols* symbolsToAdopt, 00722 UErrorCode& status); 00723 00736 DecimalFormat( const UnicodeString& pattern, 00737 DecimalFormatSymbols* symbolsToAdopt, 00738 NumberFormat::EStyles style, 00739 UErrorCode& status); 00740 00760 DecimalFormat( const UnicodeString& pattern, 00761 DecimalFormatSymbols* symbolsToAdopt, 00762 UParseError& parseError, 00763 UErrorCode& status); 00781 DecimalFormat( const UnicodeString& pattern, 00782 const DecimalFormatSymbols& symbols, 00783 UErrorCode& status); 00784 00791 DecimalFormat(const DecimalFormat& source); 00792 00799 DecimalFormat& operator=(const DecimalFormat& rhs); 00800 00805 virtual ~DecimalFormat(); 00806 00814 virtual Format* clone(void) const; 00815 00824 virtual UBool operator==(const Format& other) const; 00825 00826 00827 using NumberFormat::format; 00828 00840 virtual UnicodeString& format(double number, 00841 UnicodeString& appendTo, 00842 FieldPosition& pos) const; 00843 00857 virtual UnicodeString& format(double number, 00858 UnicodeString& appendTo, 00859 FieldPositionIterator* posIter, 00860 UErrorCode& status) const; 00861 00873 virtual UnicodeString& format(int32_t number, 00874 UnicodeString& appendTo, 00875 FieldPosition& pos) const; 00876 00890 virtual UnicodeString& format(int32_t number, 00891 UnicodeString& appendTo, 00892 FieldPositionIterator* posIter, 00893 UErrorCode& status) const; 00894 00906 virtual UnicodeString& format(int64_t number, 00907 UnicodeString& appendTo, 00908 FieldPosition& pos) const; 00909 00923 virtual UnicodeString& format(int64_t number, 00924 UnicodeString& appendTo, 00925 FieldPositionIterator* posIter, 00926 UErrorCode& status) const; 00927 00944 virtual UnicodeString& format(const StringPiece &number, 00945 UnicodeString& appendTo, 00946 FieldPositionIterator* posIter, 00947 UErrorCode& status) const; 00948 00949 00965 virtual UnicodeString& format(const DigitList &number, 00966 UnicodeString& appendTo, 00967 FieldPositionIterator* posIter, 00968 UErrorCode& status) const; 00969 00985 virtual UnicodeString& format(const DigitList &number, 00986 UnicodeString& appendTo, 00987 FieldPosition& pos, 00988 UErrorCode& status) const; 00989 00990 01003 virtual UnicodeString& format(const Formattable& obj, 01004 UnicodeString& appendTo, 01005 FieldPosition& pos, 01006 UErrorCode& status) const; 01007 01019 UnicodeString& format(const Formattable& obj, 01020 UnicodeString& appendTo, 01021 UErrorCode& status) const; 01022 01033 UnicodeString& format(double number, 01034 UnicodeString& appendTo) const; 01035 01047 UnicodeString& format(int32_t number, 01048 UnicodeString& appendTo) const; 01049 01061 UnicodeString& format(int64_t number, 01062 UnicodeString& appendTo) const; 01082 virtual void parse(const UnicodeString& text, 01083 Formattable& result, 01084 ParsePosition& parsePosition) const; 01085 01086 // Declare here again to get rid of function hiding problems. 01095 virtual void parse(const UnicodeString& text, 01096 Formattable& result, 01097 UErrorCode& status) const; 01098 01118 virtual Formattable& parseCurrency(const UnicodeString& text, 01119 Formattable& result, 01120 ParsePosition& pos) const; 01121 01129 virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const; 01130 01137 virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt); 01138 01145 virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols); 01146 01147 01154 virtual const CurrencyPluralInfo* getCurrencyPluralInfo(void) const; 01155 01162 virtual void adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt); 01163 01170 virtual void setCurrencyPluralInfo(const CurrencyPluralInfo& info); 01171 01172 01181 UnicodeString& getPositivePrefix(UnicodeString& result) const; 01182 01190 virtual void setPositivePrefix(const UnicodeString& newValue); 01191 01200 UnicodeString& getNegativePrefix(UnicodeString& result) const; 01201 01209 virtual void setNegativePrefix(const UnicodeString& newValue); 01210 01219 UnicodeString& getPositiveSuffix(UnicodeString& result) const; 01220 01228 virtual void setPositiveSuffix(const UnicodeString& newValue); 01229 01238 UnicodeString& getNegativeSuffix(UnicodeString& result) const; 01239 01247 virtual void setNegativeSuffix(const UnicodeString& newValue); 01248 01259 int32_t getMultiplier(void) const; 01260 01271 virtual void setMultiplier(int32_t newValue); 01272 01282 virtual double getRoundingIncrement(void) const; 01283 01294 virtual void setRoundingIncrement(double newValue); 01295 01304 virtual ERoundingMode getRoundingMode(void) const; 01305 01315 virtual void setRoundingMode(ERoundingMode roundingMode); 01316 01328 virtual int32_t getFormatWidth(void) const; 01329 01344 virtual void setFormatWidth(int32_t width); 01345 01358 virtual UnicodeString getPadCharacterString() const; 01359 01374 virtual void setPadCharacter(const UnicodeString &padChar); 01375 01391 virtual EPadPosition getPadPosition(void) const; 01392 01409 virtual void setPadPosition(EPadPosition padPos); 01410 01421 virtual UBool isScientificNotation(void); 01422 01438 virtual void setScientificNotation(UBool useScientific); 01439 01450 virtual int8_t getMinimumExponentDigits(void) const; 01451 01464 virtual void setMinimumExponentDigits(int8_t minExpDig); 01465 01478 virtual UBool isExponentSignAlwaysShown(void); 01479 01493 virtual void setExponentSignAlwaysShown(UBool expSignAlways); 01494 01506 int32_t getGroupingSize(void) const; 01507 01519 virtual void setGroupingSize(int32_t newValue); 01520 01539 int32_t getSecondaryGroupingSize(void) const; 01540 01552 virtual void setSecondaryGroupingSize(int32_t newValue); 01553 01562 UBool isDecimalSeparatorAlwaysShown(void) const; 01563 01572 virtual void setDecimalSeparatorAlwaysShown(UBool newValue); 01573 01584 virtual UnicodeString& toPattern(UnicodeString& result) const; 01585 01596 virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const; 01597 01627 virtual void applyPattern(const UnicodeString& pattern, 01628 UParseError& parseError, 01629 UErrorCode& status); 01638 virtual void applyPattern(const UnicodeString& pattern, 01639 UErrorCode& status); 01640 01671 virtual void applyLocalizedPattern(const UnicodeString& pattern, 01672 UParseError& parseError, 01673 UErrorCode& status); 01674 01684 virtual void applyLocalizedPattern(const UnicodeString& pattern, 01685 UErrorCode& status); 01686 01687 01697 virtual void setMaximumIntegerDigits(int32_t newValue); 01698 01708 virtual void setMinimumIntegerDigits(int32_t newValue); 01709 01719 virtual void setMaximumFractionDigits(int32_t newValue); 01720 01730 virtual void setMinimumFractionDigits(int32_t newValue); 01731 01739 int32_t getMinimumSignificantDigits() const; 01740 01748 int32_t getMaximumSignificantDigits() const; 01749 01759 void setMinimumSignificantDigits(int32_t min); 01760 01771 void setMaximumSignificantDigits(int32_t max); 01772 01779 UBool areSignificantDigitsUsed() const; 01780 01788 void setSignificantDigitsUsed(UBool useSignificantDigits); 01789 01790 public: 01803 virtual void setCurrency(const UChar* theCurrency, UErrorCode& ec); 01804 01810 virtual void setCurrency(const UChar* theCurrency); 01811 01817 static const char fgNumberPatterns[]; 01818 01819 public: 01820 01832 static UClassID U_EXPORT2 getStaticClassID(void); 01833 01845 virtual UClassID getDynamicClassID(void) const; 01846 01847 private: 01848 01849 DecimalFormat(); // default constructor not implemented 01850 01851 int32_t precision() const; 01852 01857 void init(); 01858 01862 void construct(UErrorCode& status, 01863 UParseError& parseErr, 01864 const UnicodeString* pattern = 0, 01865 DecimalFormatSymbols* symbolsToAdopt = 0 01866 ); 01867 01876 UnicodeString& toPattern(UnicodeString& result, UBool localized) const; 01877 01888 void applyPattern(const UnicodeString& pattern, 01889 UBool localized, 01890 UParseError& parseError, 01891 UErrorCode& status); 01892 01893 /* 01894 * similar to applyPattern, but without re-gen affix for currency 01895 */ 01896 void applyPatternInternally(const UnicodeString& pluralCount, 01897 const UnicodeString& pattern, 01898 UBool localized, 01899 UParseError& parseError, 01900 UErrorCode& status); 01901 01902 /* 01903 * only apply pattern without expand affixes 01904 */ 01905 void applyPatternWithoutExpandAffix(const UnicodeString& pattern, 01906 UBool localized, 01907 UParseError& parseError, 01908 UErrorCode& status); 01909 01910 01911 /* 01912 * expand affixes (after apply patter) and re-compute fFormatWidth 01913 */ 01914 void expandAffixAdjustWidth(const UnicodeString* pluralCount); 01915 01916 01927 UnicodeString& subformat(UnicodeString& appendTo, 01928 FieldPositionHandler& handler, 01929 DigitList& digits, 01930 UBool isInteger) const; 01931 01932 01933 void parse(const UnicodeString& text, 01934 Formattable& result, 01935 ParsePosition& pos, 01936 UBool parseCurrency) const; 01937 01938 enum { 01939 fgStatusInfinite, 01940 fgStatusLength // Leave last in list. 01941 } StatusFlags; 01942 01943 UBool subparse(const UnicodeString& text, 01944 const UnicodeString* negPrefix, 01945 const UnicodeString* negSuffix, 01946 const UnicodeString* posPrefix, 01947 const UnicodeString* posSuffix, 01948 UBool currencyParsing, 01949 int8_t type, 01950 ParsePosition& parsePosition, 01951 DigitList& digits, UBool* status, 01952 UChar* currency) const; 01953 01954 // Mixed style parsing for currency. 01955 // It parses against the current currency pattern 01956 // using complex affix comparison 01957 // parses against the currency plural patterns using complex affix comparison, 01958 // and parses against the current pattern using simple affix comparison. 01959 UBool parseForCurrency(const UnicodeString& text, 01960 ParsePosition& parsePosition, 01961 DigitList& digits, 01962 UBool* status, 01963 UChar* currency) const; 01964 01965 int32_t skipPadding(const UnicodeString& text, int32_t position) const; 01966 01967 int32_t compareAffix(const UnicodeString& input, 01968 int32_t pos, 01969 UBool isNegative, 01970 UBool isPrefix, 01971 const UnicodeString* affixPat, 01972 UBool currencyParsing, 01973 int8_t type, 01974 UChar* currency) const; 01975 01976 static int32_t compareSimpleAffix(const UnicodeString& affix, 01977 const UnicodeString& input, 01978 int32_t pos); 01979 01980 static int32_t skipRuleWhiteSpace(const UnicodeString& text, int32_t pos); 01981 01982 static int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos); 01983 01984 int32_t compareComplexAffix(const UnicodeString& affixPat, 01985 const UnicodeString& input, 01986 int32_t pos, 01987 int8_t type, 01988 UChar* currency) const; 01989 01990 static int32_t match(const UnicodeString& text, int32_t pos, UChar32 ch); 01991 01992 static int32_t match(const UnicodeString& text, int32_t pos, const UnicodeString& str); 01993 01999 inline const UnicodeString &getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol symbol) const; 02000 02001 int32_t appendAffix(UnicodeString& buf, 02002 double number, 02003 FieldPositionHandler& handler, 02004 UBool isNegative, 02005 UBool isPrefix) const; 02006 02012 void appendAffixPattern(UnicodeString& appendTo, const UnicodeString& affix, 02013 UBool localized) const; 02014 02015 void appendAffixPattern(UnicodeString& appendTo, 02016 const UnicodeString* affixPattern, 02017 const UnicodeString& expAffix, UBool localized) const; 02018 02019 void expandAffix(const UnicodeString& pattern, 02020 UnicodeString& affix, 02021 double number, 02022 FieldPositionHandler& handler, 02023 UBool doFormat, 02024 const UnicodeString* pluralCount) const; 02025 02026 void expandAffixes(const UnicodeString* pluralCount); 02027 02028 void addPadding(UnicodeString& appendTo, 02029 FieldPositionHandler& handler, 02030 int32_t prefixLen, int32_t suffixLen) const; 02031 02032 UBool isGroupingPosition(int32_t pos) const; 02033 02034 void setCurrencyForSymbols(); 02035 02036 // similar to setCurrency without re-compute the affixes for currency. 02037 // If currency changes, the affix pattern for currency is not changed, 02038 // but the affix will be changed. So, affixes need to be 02039 // re-computed in setCurrency(), but not in setCurrencyInternally(). 02040 virtual void setCurrencyInternally(const UChar* theCurrency, UErrorCode& ec); 02041 02042 // set up currency affix patterns for mix parsing. 02043 // The patterns saved here are the affix patterns of default currency 02044 // pattern and the unique affix patterns of the plural currency patterns. 02045 // Those patterns are used by parseForCurrency(). 02046 void setupCurrencyAffixPatterns(UErrorCode& status); 02047 02048 // set up the currency affixes used in currency plural formatting. 02049 // It sets up both fAffixesForCurrency for currency pattern if the current 02050 // pattern contains 3 currency signs, 02051 // and it sets up fPluralAffixesForCurrency for currency plural patterns. 02052 void setupCurrencyAffixes(const UnicodeString& pattern, 02053 UBool setupForCurrentPattern, 02054 UBool setupForPluralPattern, 02055 UErrorCode& status); 02056 02057 // hashtable operations 02058 Hashtable* initHashForAffixPattern(UErrorCode& status); 02059 Hashtable* initHashForAffix(UErrorCode& status); 02060 02061 void deleteHashForAffixPattern(); 02062 void deleteHashForAffix(Hashtable*& table); 02063 02064 void copyHashForAffixPattern(const Hashtable* source, 02065 Hashtable* target, UErrorCode& status); 02066 void copyHashForAffix(const Hashtable* source, 02067 Hashtable* target, UErrorCode& status); 02068 02069 UnicodeString& _format(int64_t number, 02070 UnicodeString& appendTo, 02071 FieldPositionHandler& handler) const; 02072 UnicodeString& _format(double number, 02073 UnicodeString& appendTo, 02074 FieldPositionHandler& handler) const; 02075 UnicodeString& _format(const DigitList &number, 02076 UnicodeString& appendTo, 02077 FieldPositionHandler& handler, 02078 UErrorCode &status) const; 02079 02080 // currency sign count 02081 enum { 02082 fgCurrencySignCountZero, 02083 fgCurrencySignCountInSymbolFormat, 02084 fgCurrencySignCountInISOFormat, 02085 fgCurrencySignCountInPluralFormat 02086 } CurrencySignCount; 02087 02092 UnicodeString fPositivePrefix; 02093 UnicodeString fPositiveSuffix; 02094 UnicodeString fNegativePrefix; 02095 UnicodeString fNegativeSuffix; 02096 UnicodeString* fPosPrefixPattern; 02097 UnicodeString* fPosSuffixPattern; 02098 UnicodeString* fNegPrefixPattern; 02099 UnicodeString* fNegSuffixPattern; 02100 02106 ChoiceFormat* fCurrencyChoice; 02107 02108 DigitList * fMultiplier; // NULL for multiplier of one 02109 int32_t fGroupingSize; 02110 int32_t fGroupingSize2; 02111 UBool fDecimalSeparatorAlwaysShown; 02112 DecimalFormatSymbols* fSymbols; 02113 02114 UBool fUseSignificantDigits; 02115 int32_t fMinSignificantDigits; 02116 int32_t fMaxSignificantDigits; 02117 02118 UBool fUseExponentialNotation; 02119 int8_t fMinExponentDigits; 02120 UBool fExponentSignAlwaysShown; 02121 02122 DigitList* fRoundingIncrement; // NULL if no rounding increment specified. 02123 ERoundingMode fRoundingMode; 02124 02125 UChar32 fPad; 02126 int32_t fFormatWidth; 02127 EPadPosition fPadPosition; 02128 02129 /* 02130 * Following are used for currency format 02131 */ 02132 // pattern used in this formatter 02133 UnicodeString fFormatPattern; 02134 // style is only valid when decimal formatter is constructed by 02135 // DecimalFormat(pattern, decimalFormatSymbol, style) 02136 int fStyle; 02137 /* 02138 * Represents whether this is a currency format, and which 02139 * currency format style. 02140 * 0: not currency format type; 02141 * 1: currency style -- symbol name, such as "$" for US dollar. 02142 * 2: currency style -- ISO name, such as USD for US dollar. 02143 * 3: currency style -- plural long name, such as "US Dollar" for 02144 * "1.00 US Dollar", or "US Dollars" for 02145 * "3.00 US Dollars". 02146 */ 02147 int fCurrencySignCount; 02148 02149 02150 /* For currency parsing purose, 02151 * Need to remember all prefix patterns and suffix patterns of 02152 * every currency format pattern, 02153 * including the pattern of default currecny style 02154 * and plural currency style. And the patterns are set through applyPattern. 02155 */ 02156 // TODO: innerclass? 02157 /* This is not needed in the class declaration, so it is moved into decimfmp.cpp 02158 struct AffixPatternsForCurrency : public UMemory { 02159 // negative prefix pattern 02160 UnicodeString negPrefixPatternForCurrency; 02161 // negative suffix pattern 02162 UnicodeString negSuffixPatternForCurrency; 02163 // positive prefix pattern 02164 UnicodeString posPrefixPatternForCurrency; 02165 // positive suffix pattern 02166 UnicodeString posSuffixPatternForCurrency; 02167 int8_t patternType; 02168 02169 AffixPatternsForCurrency(const UnicodeString& negPrefix, 02170 const UnicodeString& negSuffix, 02171 const UnicodeString& posPrefix, 02172 const UnicodeString& posSuffix, 02173 int8_t type) { 02174 negPrefixPatternForCurrency = negPrefix; 02175 negSuffixPatternForCurrency = negSuffix; 02176 posPrefixPatternForCurrency = posPrefix; 02177 posSuffixPatternForCurrency = posSuffix; 02178 patternType = type; 02179 } 02180 }; 02181 */ 02182 02183 /* affix for currency formatting when the currency sign in the pattern 02184 * equals to 3, such as the pattern contains 3 currency sign or 02185 * the formatter style is currency plural format style. 02186 */ 02187 /* This is not needed in the class declaration, so it is moved into decimfmp.cpp 02188 struct AffixesForCurrency : public UMemory { 02189 // negative prefix 02190 UnicodeString negPrefixForCurrency; 02191 // negative suffix 02192 UnicodeString negSuffixForCurrency; 02193 // positive prefix 02194 UnicodeString posPrefixForCurrency; 02195 // positive suffix 02196 UnicodeString posSuffixForCurrency; 02197 02198 int32_t formatWidth; 02199 02200 AffixesForCurrency(const UnicodeString& negPrefix, 02201 const UnicodeString& negSuffix, 02202 const UnicodeString& posPrefix, 02203 const UnicodeString& posSuffix) { 02204 negPrefixForCurrency = negPrefix; 02205 negSuffixForCurrency = negSuffix; 02206 posPrefixForCurrency = posPrefix; 02207 posSuffixForCurrency = posSuffix; 02208 } 02209 }; 02210 */ 02211 02212 // Affix pattern set for currency. 02213 // It is a set of AffixPatternsForCurrency, 02214 // each element of the set saves the negative prefix pattern, 02215 // negative suffix pattern, positive prefix pattern, 02216 // and positive suffix pattern of a pattern. 02217 // It is used for currency mixed style parsing. 02218 // It is actually is a set. 02219 // The set contains the default currency pattern from the locale, 02220 // and the currency plural patterns. 02221 // Since it is a set, it does not contain duplicated items. 02222 // For example, if 2 currency plural patterns are the same, only one pattern 02223 // is included in the set. When parsing, we do not check whether the plural 02224 // count match or not. 02225 Hashtable* fAffixPatternsForCurrency; 02226 02227 // Following 2 are affixes for currency. 02228 // It is a hash map from plural count to AffixesForCurrency. 02229 // AffixesForCurrency saves the negative prefix, 02230 // negative suffix, positive prefix, and positive suffix of a pattern. 02231 // It is used during currency formatting only when the currency sign count 02232 // is 3. In which case, the affixes are getting from here, not 02233 // from the fNegativePrefix etc. 02234 Hashtable* fAffixesForCurrency; // for current pattern 02235 Hashtable* fPluralAffixesForCurrency; // for plural pattern 02236 02237 // Information needed for DecimalFormat to format/parse currency plural. 02238 CurrencyPluralInfo* fCurrencyPluralInfo; 02239 02240 protected: 02241 02250 virtual void getEffectiveCurrency(UChar* result, UErrorCode& ec) const; 02251 02255 static const int32_t kDoubleIntegerDigits; 02259 static const int32_t kDoubleFractionDigits; 02260 02271 static const int32_t kMaxScientificIntegerDigits; 02272 }; 02273 02274 inline UnicodeString& 02275 DecimalFormat::format(const Formattable& obj, 02276 UnicodeString& appendTo, 02277 UErrorCode& status) const { 02278 // Don't use Format:: - use immediate base class only, 02279 // in case immediate base modifies behavior later. 02280 return NumberFormat::format(obj, appendTo, status); 02281 } 02282 02283 inline UnicodeString& 02284 DecimalFormat::format(double number, 02285 UnicodeString& appendTo) const { 02286 FieldPosition pos(0); 02287 return format(number, appendTo, pos); 02288 } 02289 02290 inline UnicodeString& 02291 DecimalFormat::format(int32_t number, 02292 UnicodeString& appendTo) const { 02293 FieldPosition pos(0); 02294 return format((int64_t)number, appendTo, pos); 02295 } 02296 02297 inline const UnicodeString & 02298 DecimalFormat::getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol symbol) const { 02299 return fSymbols->getConstSymbol(symbol); 02300 } 02301 02302 U_NAMESPACE_END 02303 02304 #endif /* #if !UCONFIG_NO_FORMATTING */ 02305 02306 #endif // _DECIMFMT 02307 //eof