ICU 60.1: decimfmt.h Source File

00001 // © 2016 and later: Unicode, Inc. and others.
00002 // License & terms of use: http://www.unicode.org/copyright.html
00003 /*
00004 ********************************************************************************
00005 *   Copyright (C) 1997-2016, International Business Machines
00006 *   Corporation and others.  All Rights Reserved.
00007 ********************************************************************************
00008 *
00009 * File DECIMFMT.H
00010 *
00011 * Modification History:
00012 *
00013 *   Date        Name        Description
00014 *   02/19/97    aliu        Converted from java.
00015 *   03/20/97    clhuang     Updated per C++ implementation.
00016 *   04/03/97    aliu        Rewrote parsing and formatting completely, and
00017 *                           cleaned up and debugged.  Actually works now.
00018 *   04/17/97    aliu        Changed DigitCount to int per code review.
00019 *   07/10/97    helena      Made ParsePosition a class and get rid of the function
00020 *                           hiding problems.
00021 *   09/09/97    aliu        Ported over support for exponential formats.
00022 *   07/20/98    stephen     Changed documentation
00023 *   01/30/13    emmons      Added Scaling methods
00024 ********************************************************************************
00025 */
00026 
00027 #ifndef DECIMFMT_H
00028 #define DECIMFMT_H
00029 
00030 #include "unicode/utypes.h"
00036 #if !UCONFIG_NO_FORMATTING
00037 
00038 #include "unicode/dcfmtsym.h"
00039 #include "unicode/numfmt.h"
00040 #include "unicode/locid.h"
00041 #include "unicode/fpositer.h"
00042 #include "unicode/stringpiece.h"
00043 #include "unicode/curramt.h"
00044 #include "unicode/enumset.h"
00045 
00046 #ifndef U_HIDE_INTERNAL_API
00047 
00051 #if UCONFIG_FORMAT_FASTPATHS_49
00052 #define UNUM_DECIMALFORMAT_INTERNAL_SIZE 16
00053 #endif
00054 #endif  /* U_HIDE_INTERNAL_API */
00055 
00056 U_NAMESPACE_BEGIN
00057 
00058 class DigitList;
00059 class CurrencyPluralInfo;
00060 class Hashtable;
00061 class UnicodeSet;
00062 class FieldPositionHandler;
00063 class DecimalFormatStaticSets;
00064 class FixedDecimal;
00065 class DecimalFormatImpl;
00066 class PluralRules;
00067 class VisibleDigitsWithExponent;
00068 
00069 // explicit template instantiation. see digitlst.h
00070 #if defined (_MSC_VER)
00071 template class U_I18N_API    EnumSet<UNumberFormatAttribute,
00072             UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
00073             UNUM_LIMIT_BOOLEAN_ATTRIBUTE>;
00074 #endif
00075 
00669 class U_I18N_API DecimalFormat: public NumberFormat {
00670 public:
00675     enum EPadPosition {
00676         kPadBeforePrefix,
00677         kPadAfterPrefix,
00678         kPadBeforeSuffix,
00679         kPadAfterSuffix
00680     };
00681 
00695     DecimalFormat(UErrorCode& status);
00696 
00711     DecimalFormat(const UnicodeString& pattern,
00712                   UErrorCode& status);
00713 
00732     DecimalFormat(  const UnicodeString& pattern,
00733                     DecimalFormatSymbols* symbolsToAdopt,
00734                     UErrorCode& status);
00735 
00736 #ifndef U_HIDE_INTERNAL_API
00737 
00749     DecimalFormat(  const UnicodeString& pattern,
00750                     DecimalFormatSymbols* symbolsToAdopt,
00751                     UNumberFormatStyle style,
00752                     UErrorCode& status);
00753 
00754 #if UCONFIG_HAVE_PARSEALLINPUT
00755 
00758     void setParseAllInput(UNumberFormatAttributeValue value);
00759 #endif
00760 
00761 #endif  /* U_HIDE_INTERNAL_API */
00762 
00763 
00774     virtual DecimalFormat& setAttribute( UNumberFormatAttribute attr,
00775                                        int32_t newvalue,
00776                                        UErrorCode &status);
00777 
00787     virtual int32_t getAttribute( UNumberFormatAttribute attr,
00788                                   UErrorCode &status) const;
00789 
00790 
00797     virtual void setGroupingUsed(UBool newValue);
00798 
00806     virtual void setParseIntegerOnly(UBool value);
00807 
00817     virtual void setContext(UDisplayContext value, UErrorCode& status);
00818 
00838     DecimalFormat(  const UnicodeString& pattern,
00839                     DecimalFormatSymbols* symbolsToAdopt,
00840                     UParseError& parseError,
00841                     UErrorCode& status);
00859     DecimalFormat(  const UnicodeString& pattern,
00860                     const DecimalFormatSymbols& symbols,
00861                     UErrorCode& status);
00862 
00869     DecimalFormat(const DecimalFormat& source);
00870 
00877     DecimalFormat& operator=(const DecimalFormat& rhs);
00878 
00883     virtual ~DecimalFormat();
00884 
00892     virtual Format* clone(void) const;
00893 
00902     virtual UBool operator==(const Format& other) const;
00903 
00904 
00905     using NumberFormat::format;
00906 
00918     virtual UnicodeString& format(double number,
00919                                   UnicodeString& appendTo,
00920                                   FieldPosition& pos) const;
00921 
00922 
00935     virtual UnicodeString& format(double number,
00936                                   UnicodeString& appendTo,
00937                                   FieldPosition& pos,
00938                                   UErrorCode &status) const;
00939 
00953     virtual UnicodeString& format(double number,
00954                                   UnicodeString& appendTo,
00955                                   FieldPositionIterator* posIter,
00956                                   UErrorCode& status) const;
00957 
00969     virtual UnicodeString& format(int32_t number,
00970                                   UnicodeString& appendTo,
00971                                   FieldPosition& pos) const;
00972 
00984     virtual UnicodeString& format(int32_t number,
00985                                   UnicodeString& appendTo,
00986                                   FieldPosition& pos,
00987                                   UErrorCode &status) const;
00988 
01002     virtual UnicodeString& format(int32_t number,
01003                                   UnicodeString& appendTo,
01004                                   FieldPositionIterator* posIter,
01005                                   UErrorCode& status) const;
01006 
01018     virtual UnicodeString& format(int64_t number,
01019                                   UnicodeString& appendTo,
01020                                   FieldPosition& pos) const;
01021 
01033     virtual UnicodeString& format(int64_t number,
01034                                   UnicodeString& appendTo,
01035                                   FieldPosition& pos,
01036                                   UErrorCode &status) const;
01037 
01051     virtual UnicodeString& format(int64_t number,
01052                                   UnicodeString& appendTo,
01053                                   FieldPositionIterator* posIter,
01054                                   UErrorCode& status) const;
01055 
01072     virtual UnicodeString& format(StringPiece number,
01073                                   UnicodeString& appendTo,
01074                                   FieldPositionIterator* posIter,
01075                                   UErrorCode& status) const;
01076 
01077 
01093     virtual UnicodeString& format(const DigitList &number,
01094                                   UnicodeString& appendTo,
01095                                   FieldPositionIterator* posIter,
01096                                   UErrorCode& status) const;
01097 
01109     virtual UnicodeString& format(
01110             const VisibleDigitsWithExponent &number,
01111             UnicodeString& appendTo,
01112             FieldPosition& pos,
01113             UErrorCode& status) const;
01114 
01126     virtual UnicodeString& format(
01127             const VisibleDigitsWithExponent &number,
01128             UnicodeString& appendTo,
01129             FieldPositionIterator* posIter,
01130             UErrorCode& status) const;
01131 
01147     virtual UnicodeString& format(const DigitList &number,
01148                                   UnicodeString& appendTo,
01149                                   FieldPosition& pos,
01150                                   UErrorCode& status) const;
01151 
01152    using NumberFormat::parse;
01153 
01173     virtual void parse(const UnicodeString& text,
01174                        Formattable& result,
01175                        ParsePosition& parsePosition) const;
01176 
01196     virtual CurrencyAmount* parseCurrency(const UnicodeString& text,
01197                                           ParsePosition& pos) const;
01198 
01206     virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const;
01207 
01214     virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
01215 
01222     virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
01223 
01224 
01231     virtual const CurrencyPluralInfo* getCurrencyPluralInfo(void) const;
01232 
01239     virtual void adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt);
01240 
01247     virtual void setCurrencyPluralInfo(const CurrencyPluralInfo& info);
01248 
01249 
01258     UnicodeString& getPositivePrefix(UnicodeString& result) const;
01259 
01267     virtual void setPositivePrefix(const UnicodeString& newValue);
01268 
01277     UnicodeString& getNegativePrefix(UnicodeString& result) const;
01278 
01286     virtual void setNegativePrefix(const UnicodeString& newValue);
01287 
01296     UnicodeString& getPositiveSuffix(UnicodeString& result) const;
01297 
01305     virtual void setPositiveSuffix(const UnicodeString& newValue);
01306 
01315     UnicodeString& getNegativeSuffix(UnicodeString& result) const;
01316 
01324     virtual void setNegativeSuffix(const UnicodeString& newValue);
01325 
01336     int32_t getMultiplier(void) const;
01337 
01348     virtual void setMultiplier(int32_t newValue);
01349 
01359     virtual double getRoundingIncrement(void) const;
01360 
01372     virtual void setRoundingIncrement(double newValue);
01373 
01382     virtual ERoundingMode getRoundingMode(void) const;
01383 
01392     virtual void setRoundingMode(ERoundingMode roundingMode);
01393 
01405     virtual int32_t getFormatWidth(void) const;
01406 
01421     virtual void setFormatWidth(int32_t width);
01422 
01435     virtual UnicodeString getPadCharacterString() const;
01436 
01451     virtual void setPadCharacter(const UnicodeString &padChar);
01452 
01468     virtual EPadPosition getPadPosition(void) const;
01469 
01486     virtual void setPadPosition(EPadPosition padPos);
01487 
01498     virtual UBool isScientificNotation(void) const;
01499 
01515     virtual void setScientificNotation(UBool useScientific);
01516 
01527     virtual int8_t getMinimumExponentDigits(void) const;
01528 
01541     virtual void setMinimumExponentDigits(int8_t minExpDig);
01542 
01555     virtual UBool isExponentSignAlwaysShown(void) const;
01556 
01570     virtual void setExponentSignAlwaysShown(UBool expSignAlways);
01571 
01583     int32_t getGroupingSize(void) const;
01584 
01596     virtual void setGroupingSize(int32_t newValue);
01597 
01616     int32_t getSecondaryGroupingSize(void) const;
01617 
01629     virtual void setSecondaryGroupingSize(int32_t newValue);
01630 
01631 #ifndef U_HIDE_INTERNAL_API
01632 
01654     int32_t getMinimumGroupingDigits() const;
01655 
01656 #endif  /* U_HIDE_INTERNAL_API */
01657 
01658         /* Cannot use #ifndef U_HIDE_INTERNAL_API for the following draft method since it is virtual. */
01667     virtual void setMinimumGroupingDigits(int32_t newValue);
01668 
01669 
01678     UBool isDecimalSeparatorAlwaysShown(void) const;
01679 
01688     virtual void setDecimalSeparatorAlwaysShown(UBool newValue);
01689 
01696     UBool isDecimalPatternMatchRequired(void) const;
01697 
01707     virtual void setDecimalPatternMatchRequired(UBool newValue);
01708 
01709 
01720     virtual UnicodeString& toPattern(UnicodeString& result) const;
01721 
01732     virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const;
01733 
01763     virtual void applyPattern(const UnicodeString& pattern,
01764                              UParseError& parseError,
01765                              UErrorCode& status);
01774     virtual void applyPattern(const UnicodeString& pattern,
01775                              UErrorCode& status);
01776 
01807     virtual void applyLocalizedPattern(const UnicodeString& pattern,
01808                                        UParseError& parseError,
01809                                        UErrorCode& status);
01810 
01820     virtual void applyLocalizedPattern(const UnicodeString& pattern,
01821                                        UErrorCode& status);
01822 
01823 
01833     virtual void setMaximumIntegerDigits(int32_t newValue);
01834 
01844     virtual void setMinimumIntegerDigits(int32_t newValue);
01845 
01855     virtual void setMaximumFractionDigits(int32_t newValue);
01856 
01866     virtual void setMinimumFractionDigits(int32_t newValue);
01867 
01875     int32_t getMinimumSignificantDigits() const;
01876 
01884     int32_t getMaximumSignificantDigits() const;
01885 
01897     void setMinimumSignificantDigits(int32_t min);
01898 
01910     void setMaximumSignificantDigits(int32_t max);
01911 
01918     UBool areSignificantDigitsUsed() const;
01919 
01927     void setSignificantDigitsUsed(UBool useSignificantDigits);
01928 
01929  public:
01942     virtual void setCurrency(const char16_t* theCurrency, UErrorCode& ec);
01943 
01949     virtual void setCurrency(const char16_t* theCurrency);
01950 
01958     void setCurrencyUsage(UCurrencyUsage newUsage, UErrorCode* ec);
01959 
01964     UCurrencyUsage getCurrencyUsage() const;
01965 
01966 
01972     static const char fgNumberPatterns[];
01973 
01974 #ifndef U_HIDE_INTERNAL_API
01975 
01981      FixedDecimal getFixedDecimal(double number, UErrorCode &status) const;
01982 
01989      FixedDecimal getFixedDecimal(const Formattable &number, UErrorCode &status) const;
01990 
01997      FixedDecimal getFixedDecimal(DigitList &number, UErrorCode &status) const;
01998 
02005      VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
02006              double number,
02007              VisibleDigitsWithExponent &digits,
02008              UErrorCode &status) const;
02009 
02016      VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
02017              const Formattable &number,
02018              VisibleDigitsWithExponent &digits,
02019              UErrorCode &status) const;
02020 
02028      VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
02029              DigitList &number,
02030              VisibleDigitsWithExponent &digits,
02031              UErrorCode &status) const;
02032 
02033 #endif  /* U_HIDE_INTERNAL_API */
02034 
02035 public:
02036 
02048     static UClassID U_EXPORT2 getStaticClassID(void);
02049 
02061     virtual UClassID getDynamicClassID(void) const;
02062 
02063 private:
02064 
02065     DecimalFormat(); // default constructor not implemented
02066 
02071     void init();
02072 
02076     void construct(UErrorCode&              status,
02077                    UParseError&             parseErr,
02078                    const UnicodeString*     pattern = 0,
02079                    DecimalFormatSymbols*    symbolsToAdopt = 0
02080                    );
02081 
02082     void handleCurrencySignInPattern(UErrorCode& status);
02083 
02084     void parse(const UnicodeString& text,
02085                Formattable& result,
02086                ParsePosition& pos,
02087                char16_t* currency) const;
02088 
02089     enum {
02090         fgStatusInfinite,
02091         fgStatusLength      // Leave last in list.
02092     } StatusFlags;
02093 
02094     UBool subparse(const UnicodeString& text,
02095                    const UnicodeString* negPrefix,
02096                    const UnicodeString* negSuffix,
02097                    const UnicodeString* posPrefix,
02098                    const UnicodeString* posSuffix,
02099                    UBool complexCurrencyParsing,
02100                    int8_t type,
02101                    ParsePosition& parsePosition,
02102                    DigitList& digits, UBool* status,
02103                    char16_t* currency) const;
02104 
02105     // Mixed style parsing for currency.
02106     // It parses against the current currency pattern
02107     // using complex affix comparison
02108     // parses against the currency plural patterns using complex affix comparison,
02109     // and parses against the current pattern using simple affix comparison.
02110     UBool parseForCurrency(const UnicodeString& text,
02111                            ParsePosition& parsePosition,
02112                            DigitList& digits,
02113                            UBool* status,
02114                            char16_t* currency) const;
02115 
02116     int32_t skipPadding(const UnicodeString& text, int32_t position) const;
02117 
02118     int32_t compareAffix(const UnicodeString& input,
02119                          int32_t pos,
02120                          UBool isNegative,
02121                          UBool isPrefix,
02122                          const UnicodeString* affixPat,
02123                          UBool complexCurrencyParsing,
02124                          int8_t type,
02125                          char16_t* currency) const;
02126 
02127     static UnicodeString& trimMarksFromAffix(const UnicodeString& affix, UnicodeString& trimmedAffix);
02128 
02129     UBool equalWithSignCompatibility(UChar32 lhs, UChar32 rhs) const;
02130 
02131     int32_t compareSimpleAffix(const UnicodeString& affix,
02132                                       const UnicodeString& input,
02133                                       int32_t pos,
02134                                       UBool lenient) const;
02135 
02136     static int32_t skipPatternWhiteSpace(const UnicodeString& text, int32_t pos);
02137 
02138     static int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos);
02139 
02140     static int32_t skipUWhiteSpaceAndMarks(const UnicodeString& text, int32_t pos);
02141 
02142     static int32_t skipBidiMarks(const UnicodeString& text, int32_t pos);
02143 
02144     int32_t compareComplexAffix(const UnicodeString& affixPat,
02145                                 const UnicodeString& input,
02146                                 int32_t pos,
02147                                 int8_t type,
02148                                 char16_t* currency) const;
02149 
02150     static int32_t match(const UnicodeString& text, int32_t pos, UChar32 ch);
02151 
02152     static int32_t match(const UnicodeString& text, int32_t pos, const UnicodeString& str);
02153 
02154     static UBool matchSymbol(const UnicodeString &text, int32_t position, int32_t length, const UnicodeString &symbol,
02155                              UnicodeSet *sset, UChar32 schar);
02156 
02157     static UBool matchDecimal(UChar32 symbolChar,
02158                             UBool sawDecimal,  UChar32 sawDecimalChar,
02159                              const UnicodeSet *sset, UChar32 schar);
02160 
02161     static UBool matchGrouping(UChar32 groupingChar,
02162                             UBool sawGrouping, UChar32 sawGroupingChar,
02163                              const UnicodeSet *sset,
02164                              UChar32 decimalChar, const UnicodeSet *decimalSet,
02165                              UChar32 schar);
02166 
02167     // set up currency affix patterns for mix parsing.
02168     // The patterns saved here are the affix patterns of default currency
02169     // pattern and the unique affix patterns of the plural currency patterns.
02170     // Those patterns are used by parseForCurrency().
02171     void setupCurrencyAffixPatterns(UErrorCode& status);
02172 
02173     // get the currency rounding with respect to currency usage
02174     double getCurrencyRounding(const char16_t* currency,
02175                                UErrorCode* ec) const;
02176 
02177     // get the currency fraction with respect to currency usage
02178     int getCurrencyFractionDigits(const char16_t* currency,
02179                                   UErrorCode* ec) const;
02180 
02181     // hashtable operations
02182     Hashtable* initHashForAffixPattern(UErrorCode& status);
02183 
02184     void deleteHashForAffixPattern();
02185 
02186     void copyHashForAffixPattern(const Hashtable* source,
02187                                  Hashtable* target, UErrorCode& status);
02188 
02189     DecimalFormatImpl *fImpl;
02190 
02196     EnumSet<UNumberFormatAttribute,
02197             UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
02198             UNUM_LIMIT_BOOLEAN_ATTRIBUTE>
02199                             fBoolFlags;
02200 
02201 
02202     // style is only valid when decimal formatter is constructed by
02203     // DecimalFormat(pattern, decimalFormatSymbol, style)
02204     int fStyle;
02205 
02206 
02207     // Affix pattern set for currency.
02208     // It is a set of AffixPatternsForCurrency,
02209     // each element of the set saves the negative prefix pattern,
02210     // negative suffix pattern, positive prefix pattern,
02211     // and positive suffix  pattern of a pattern.
02212     // It is used for currency mixed style parsing.
02213     // It is actually is a set.
02214     // The set contains the default currency pattern from the locale,
02215     // and the currency plural patterns.
02216     // Since it is a set, it does not contain duplicated items.
02217     // For example, if 2 currency plural patterns are the same, only one pattern
02218     // is included in the set. When parsing, we do not check whether the plural
02219     // count match or not.
02220     Hashtable* fAffixPatternsForCurrency;
02221 
02222     // Information needed for DecimalFormat to format/parse currency plural.
02223     CurrencyPluralInfo* fCurrencyPluralInfo;
02224 
02225 #if UCONFIG_HAVE_PARSEALLINPUT
02226     UNumberFormatAttributeValue fParseAllInput;
02227 #endif
02228 
02229     // Decimal Format Static Sets singleton.
02230     const DecimalFormatStaticSets *fStaticSets;
02231 
02232 protected:
02233 
02234 #ifndef U_HIDE_INTERNAL_API
02235 
02239     DigitList& _round(const DigitList& number, DigitList& adjustedNum, UBool& isNegative, UErrorCode& status) const;
02240 #endif  /* U_HIDE_INTERNAL_API */
02241 
02250     virtual void getEffectiveCurrency(char16_t* 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 
02275 U_NAMESPACE_END
02276 
02277 #endif /* #if !UCONFIG_NO_FORMATTING */
02278 
02279 #endif // _DECIMFMT
02280 //eof