ICU 57.1: decimfmt.h Source File

00001 /*
00002 ********************************************************************************
00003 *   Copyright (C) 1997-2016, 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 *   01/30/13    emmons      Added Scaling methods
00022 ********************************************************************************
00023 */
00024 
00025 #ifndef DECIMFMT_H
00026 #define DECIMFMT_H
00027 
00028 #include "unicode/utypes.h"
00034 #if !UCONFIG_NO_FORMATTING
00035 
00036 #include "unicode/dcfmtsym.h"
00037 #include "unicode/numfmt.h"
00038 #include "unicode/locid.h"
00039 #include "unicode/fpositer.h"
00040 #include "unicode/stringpiece.h"
00041 #include "unicode/curramt.h"
00042 #include "unicode/enumset.h"
00043 
00044 #ifndef U_HIDE_INTERNAL_API
00045 
00049 #if UCONFIG_FORMAT_FASTPATHS_49
00050 #define UNUM_DECIMALFORMAT_INTERNAL_SIZE 16
00051 #endif
00052 #endif  /* U_HIDE_INTERNAL_API */
00053 
00054 U_NAMESPACE_BEGIN
00055 
00056 class DigitList;
00057 class CurrencyPluralInfo;
00058 class Hashtable;
00059 class UnicodeSet;
00060 class FieldPositionHandler;
00061 class DecimalFormatStaticSets;
00062 class FixedDecimal;
00063 class DecimalFormatImpl;
00064 class PluralRules;
00065 class VisibleDigitsWithExponent;
00066 
00067 // explicit template instantiation. see digitlst.h
00068 #if defined (_MSC_VER)
00069 template class U_I18N_API    EnumSet<UNumberFormatAttribute,
00070             UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
00071             UNUM_LIMIT_BOOLEAN_ATTRIBUTE>;
00072 #endif
00073 
00667 class U_I18N_API DecimalFormat: public NumberFormat {
00668 public:
00673     enum ERoundingMode {
00674         kRoundCeiling,  
00675         kRoundFloor,    
00676         kRoundDown,     
00677         kRoundUp,       
00678         kRoundHalfEven, 
00680         kRoundHalfDown, 
00682         kRoundHalfUp,   
00688         kRoundUnnecessary
00689     };
00690 
00695     enum EPadPosition {
00696         kPadBeforePrefix,
00697         kPadAfterPrefix,
00698         kPadBeforeSuffix,
00699         kPadAfterSuffix
00700     };
00701 
00715     DecimalFormat(UErrorCode& status);
00716 
00731     DecimalFormat(const UnicodeString& pattern,
00732                   UErrorCode& status);
00733 
00752     DecimalFormat(  const UnicodeString& pattern,
00753                     DecimalFormatSymbols* symbolsToAdopt,
00754                     UErrorCode& status);
00755 
00756 #ifndef U_HIDE_INTERNAL_API
00757 
00769     DecimalFormat(  const UnicodeString& pattern,
00770                     DecimalFormatSymbols* symbolsToAdopt,
00771                     UNumberFormatStyle style,
00772                     UErrorCode& status);
00773 
00774 #if UCONFIG_HAVE_PARSEALLINPUT
00775 
00778     void setParseAllInput(UNumberFormatAttributeValue value);
00779 #endif
00780 
00781 #endif  /* U_HIDE_INTERNAL_API */
00782 
00783 
00794     virtual DecimalFormat& setAttribute( UNumberFormatAttribute attr,
00795                                        int32_t newvalue,
00796                                        UErrorCode &status);
00797 
00807     virtual int32_t getAttribute( UNumberFormatAttribute attr,
00808                                   UErrorCode &status) const;
00809 
00810 
00817     virtual void setGroupingUsed(UBool newValue);
00818 
00826     virtual void setParseIntegerOnly(UBool value);
00827 
00837     virtual void setContext(UDisplayContext value, UErrorCode& status);
00838 
00858     DecimalFormat(  const UnicodeString& pattern,
00859                     DecimalFormatSymbols* symbolsToAdopt,
00860                     UParseError& parseError,
00861                     UErrorCode& status);
00879     DecimalFormat(  const UnicodeString& pattern,
00880                     const DecimalFormatSymbols& symbols,
00881                     UErrorCode& status);
00882 
00889     DecimalFormat(const DecimalFormat& source);
00890 
00897     DecimalFormat& operator=(const DecimalFormat& rhs);
00898 
00903     virtual ~DecimalFormat();
00904 
00912     virtual Format* clone(void) const;
00913 
00922     virtual UBool operator==(const Format& other) const;
00923 
00924 
00925     using NumberFormat::format;
00926 
00938     virtual UnicodeString& format(double number,
00939                                   UnicodeString& appendTo,
00940                                   FieldPosition& pos) const;
00941 
00942 
00955     virtual UnicodeString& format(double number,
00956                                   UnicodeString& appendTo,
00957                                   FieldPosition& pos,
00958                                   UErrorCode &status) const;
00959 
00973     virtual UnicodeString& format(double number,
00974                                   UnicodeString& appendTo,
00975                                   FieldPositionIterator* posIter,
00976                                   UErrorCode& status) const;
00977 
00989     virtual UnicodeString& format(int32_t number,
00990                                   UnicodeString& appendTo,
00991                                   FieldPosition& pos) const;
00992 
01004     virtual UnicodeString& format(int32_t number,
01005                                   UnicodeString& appendTo,
01006                                   FieldPosition& pos,
01007                                   UErrorCode &status) const;
01008 
01022     virtual UnicodeString& format(int32_t number,
01023                                   UnicodeString& appendTo,
01024                                   FieldPositionIterator* posIter,
01025                                   UErrorCode& status) const;
01026 
01038     virtual UnicodeString& format(int64_t number,
01039                                   UnicodeString& appendTo,
01040                                   FieldPosition& pos) const;
01041 
01053     virtual UnicodeString& format(int64_t number,
01054                                   UnicodeString& appendTo,
01055                                   FieldPosition& pos,
01056                                   UErrorCode &status) const;
01057 
01071     virtual UnicodeString& format(int64_t number,
01072                                   UnicodeString& appendTo,
01073                                   FieldPositionIterator* posIter,
01074                                   UErrorCode& status) const;
01075 
01092     virtual UnicodeString& format(const StringPiece &number,
01093                                   UnicodeString& appendTo,
01094                                   FieldPositionIterator* posIter,
01095                                   UErrorCode& status) const;
01096 
01097 
01113     virtual UnicodeString& format(const DigitList &number,
01114                                   UnicodeString& appendTo,
01115                                   FieldPositionIterator* posIter,
01116                                   UErrorCode& status) const;
01117 
01129     virtual UnicodeString& format(
01130             const VisibleDigitsWithExponent &number,
01131             UnicodeString& appendTo,
01132             FieldPosition& pos,
01133             UErrorCode& status) const;
01134 
01146     virtual UnicodeString& format(
01147             const VisibleDigitsWithExponent &number,
01148             UnicodeString& appendTo,
01149             FieldPositionIterator* posIter,
01150             UErrorCode& status) const;
01151 
01167     virtual UnicodeString& format(const DigitList &number,
01168                                   UnicodeString& appendTo,
01169                                   FieldPosition& pos,
01170                                   UErrorCode& status) const;
01171 
01172    using NumberFormat::parse;
01173 
01193     virtual void parse(const UnicodeString& text,
01194                        Formattable& result,
01195                        ParsePosition& parsePosition) const;
01196 
01216     virtual CurrencyAmount* parseCurrency(const UnicodeString& text,
01217                                           ParsePosition& pos) const;
01218 
01226     virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const;
01227 
01234     virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
01235 
01242     virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
01243 
01244 
01251     virtual const CurrencyPluralInfo* getCurrencyPluralInfo(void) const;
01252 
01259     virtual void adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt);
01260 
01267     virtual void setCurrencyPluralInfo(const CurrencyPluralInfo& info);
01268 
01269 
01278     UnicodeString& getPositivePrefix(UnicodeString& result) const;
01279 
01287     virtual void setPositivePrefix(const UnicodeString& newValue);
01288 
01297     UnicodeString& getNegativePrefix(UnicodeString& result) const;
01298 
01306     virtual void setNegativePrefix(const UnicodeString& newValue);
01307 
01316     UnicodeString& getPositiveSuffix(UnicodeString& result) const;
01317 
01325     virtual void setPositiveSuffix(const UnicodeString& newValue);
01326 
01335     UnicodeString& getNegativeSuffix(UnicodeString& result) const;
01336 
01344     virtual void setNegativeSuffix(const UnicodeString& newValue);
01345 
01356     int32_t getMultiplier(void) const;
01357 
01368     virtual void setMultiplier(int32_t newValue);
01369 
01379     virtual double getRoundingIncrement(void) const;
01380 
01392     virtual void setRoundingIncrement(double newValue);
01393 
01402     virtual ERoundingMode getRoundingMode(void) const;
01403 
01412     virtual void setRoundingMode(ERoundingMode roundingMode);
01413 
01425     virtual int32_t getFormatWidth(void) const;
01426 
01441     virtual void setFormatWidth(int32_t width);
01442 
01455     virtual UnicodeString getPadCharacterString() const;
01456 
01471     virtual void setPadCharacter(const UnicodeString &padChar);
01472 
01488     virtual EPadPosition getPadPosition(void) const;
01489 
01506     virtual void setPadPosition(EPadPosition padPos);
01507 
01518     virtual UBool isScientificNotation(void) const;
01519 
01535     virtual void setScientificNotation(UBool useScientific);
01536 
01547     virtual int8_t getMinimumExponentDigits(void) const;
01548 
01561     virtual void setMinimumExponentDigits(int8_t minExpDig);
01562 
01575     virtual UBool isExponentSignAlwaysShown(void) const;
01576 
01590     virtual void setExponentSignAlwaysShown(UBool expSignAlways);
01591 
01603     int32_t getGroupingSize(void) const;
01604 
01616     virtual void setGroupingSize(int32_t newValue);
01617 
01636     int32_t getSecondaryGroupingSize(void) const;
01637 
01649     virtual void setSecondaryGroupingSize(int32_t newValue);
01650 
01651 #ifndef U_HIDE_INTERNAL_API
01652 
01674     int32_t getMinimumGroupingDigits() const;
01675 
01676 #endif  /* U_HIDE_INTERNAL_API */
01677 
01678         /* Cannot use #ifndef U_HIDE_INTERNAL_API for the following draft method since it is virtual. */
01687     virtual void setMinimumGroupingDigits(int32_t newValue);
01688 
01689 
01698     UBool isDecimalSeparatorAlwaysShown(void) const;
01699 
01708     virtual void setDecimalSeparatorAlwaysShown(UBool newValue);
01709 
01716     UBool isDecimalPatternMatchRequired(void) const;
01717 
01727     virtual void setDecimalPatternMatchRequired(UBool newValue);
01728 
01729 
01740     virtual UnicodeString& toPattern(UnicodeString& result) const;
01741 
01752     virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const;
01753 
01783     virtual void applyPattern(const UnicodeString& pattern,
01784                              UParseError& parseError,
01785                              UErrorCode& status);
01794     virtual void applyPattern(const UnicodeString& pattern,
01795                              UErrorCode& status);
01796 
01827     virtual void applyLocalizedPattern(const UnicodeString& pattern,
01828                                        UParseError& parseError,
01829                                        UErrorCode& status);
01830 
01840     virtual void applyLocalizedPattern(const UnicodeString& pattern,
01841                                        UErrorCode& status);
01842 
01843 
01853     virtual void setMaximumIntegerDigits(int32_t newValue);
01854 
01864     virtual void setMinimumIntegerDigits(int32_t newValue);
01865 
01875     virtual void setMaximumFractionDigits(int32_t newValue);
01876 
01886     virtual void setMinimumFractionDigits(int32_t newValue);
01887 
01895     int32_t getMinimumSignificantDigits() const;
01896 
01904     int32_t getMaximumSignificantDigits() const;
01905 
01917     void setMinimumSignificantDigits(int32_t min);
01918 
01930     void setMaximumSignificantDigits(int32_t max);
01931 
01938     UBool areSignificantDigitsUsed() const;
01939 
01947     void setSignificantDigitsUsed(UBool useSignificantDigits);
01948 
01949  public:
01962     virtual void setCurrency(const UChar* theCurrency, UErrorCode& ec);
01963 
01969     virtual void setCurrency(const UChar* theCurrency);
01970 
01978     void setCurrencyUsage(UCurrencyUsage newUsage, UErrorCode* ec);
01979 
01984     UCurrencyUsage getCurrencyUsage() const;
01985 
01986 
01987 #ifndef U_HIDE_DEPRECATED_API
01988 
01993     static const char fgNumberPatterns[];
01994 #endif  /* U_HIDE_DEPRECATED_API */
01995 
01996 #ifndef U_HIDE_INTERNAL_API
01997 
02003      FixedDecimal getFixedDecimal(double number, UErrorCode &status) const;
02004 
02011      FixedDecimal getFixedDecimal(const Formattable &number, UErrorCode &status) const;
02012 
02019      FixedDecimal getFixedDecimal(DigitList &number, UErrorCode &status) const;
02020 
02027      VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
02028              double number,
02029              VisibleDigitsWithExponent &digits,
02030              UErrorCode &status) const;
02031 
02038      VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
02039              const Formattable &number,
02040              VisibleDigitsWithExponent &digits,
02041              UErrorCode &status) const;
02042 
02050      VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
02051              DigitList &number,
02052              VisibleDigitsWithExponent &digits,
02053              UErrorCode &status) const;
02054 
02055 #endif  /* U_HIDE_INTERNAL_API */
02056 
02057 public:
02058 
02070     static UClassID U_EXPORT2 getStaticClassID(void);
02071 
02083     virtual UClassID getDynamicClassID(void) const;
02084 
02085 private:
02086 
02087     DecimalFormat(); // default constructor not implemented
02088 
02093     void init();
02094 
02098     void construct(UErrorCode&              status,
02099                    UParseError&             parseErr,
02100                    const UnicodeString*     pattern = 0,
02101                    DecimalFormatSymbols*    symbolsToAdopt = 0
02102                    );
02103 
02104     void parse(const UnicodeString& text,
02105                Formattable& result,
02106                ParsePosition& pos,
02107                UChar* currency) const;
02108 
02109     enum {
02110         fgStatusInfinite,
02111         fgStatusLength      // Leave last in list.
02112     } StatusFlags;
02113 
02114     UBool subparse(const UnicodeString& text,
02115                    const UnicodeString* negPrefix,
02116                    const UnicodeString* negSuffix,
02117                    const UnicodeString* posPrefix,
02118                    const UnicodeString* posSuffix,
02119                    UBool complexCurrencyParsing,
02120                    int8_t type,
02121                    ParsePosition& parsePosition,
02122                    DigitList& digits, UBool* status,
02123                    UChar* currency) const;
02124 
02125     // Mixed style parsing for currency.
02126     // It parses against the current currency pattern
02127     // using complex affix comparison
02128     // parses against the currency plural patterns using complex affix comparison,
02129     // and parses against the current pattern using simple affix comparison.
02130     UBool parseForCurrency(const UnicodeString& text,
02131                            ParsePosition& parsePosition,
02132                            DigitList& digits,
02133                            UBool* status,
02134                            UChar* currency) const;
02135 
02136     int32_t skipPadding(const UnicodeString& text, int32_t position) const;
02137 
02138     int32_t compareAffix(const UnicodeString& input,
02139                          int32_t pos,
02140                          UBool isNegative,
02141                          UBool isPrefix,
02142                          const UnicodeString* affixPat,
02143                          UBool complexCurrencyParsing,
02144                          int8_t type,
02145                          UChar* currency) const;
02146 
02147     static UnicodeString& trimMarksFromAffix(const UnicodeString& affix, UnicodeString& trimmedAffix);
02148 
02149     UBool equalWithSignCompatibility(UChar32 lhs, UChar32 rhs) const;
02150 
02151     int32_t compareSimpleAffix(const UnicodeString& affix,
02152                                       const UnicodeString& input,
02153                                       int32_t pos,
02154                                       UBool lenient) const;
02155 
02156     static int32_t skipPatternWhiteSpace(const UnicodeString& text, int32_t pos);
02157 
02158     static int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos);
02159 
02160     static int32_t skipUWhiteSpaceAndMarks(const UnicodeString& text, int32_t pos);
02161 
02162     static int32_t skipBidiMarks(const UnicodeString& text, int32_t pos);
02163 
02164     int32_t compareComplexAffix(const UnicodeString& affixPat,
02165                                 const UnicodeString& input,
02166                                 int32_t pos,
02167                                 int8_t type,
02168                                 UChar* currency) const;
02169 
02170     static int32_t match(const UnicodeString& text, int32_t pos, UChar32 ch);
02171 
02172     static int32_t match(const UnicodeString& text, int32_t pos, const UnicodeString& str);
02173 
02174     static UBool matchSymbol(const UnicodeString &text, int32_t position, int32_t length, const UnicodeString &symbol,
02175                              UnicodeSet *sset, UChar32 schar);
02176 
02177     static UBool matchDecimal(UChar32 symbolChar,
02178                             UBool sawDecimal,  UChar32 sawDecimalChar,
02179                              const UnicodeSet *sset, UChar32 schar);
02180 
02181     static UBool matchGrouping(UChar32 groupingChar,
02182                             UBool sawGrouping, UChar32 sawGroupingChar,
02183                              const UnicodeSet *sset,
02184                              UChar32 decimalChar, const UnicodeSet *decimalSet,
02185                              UChar32 schar);
02186 
02187     // set up currency affix patterns for mix parsing.
02188     // The patterns saved here are the affix patterns of default currency
02189     // pattern and the unique affix patterns of the plural currency patterns.
02190     // Those patterns are used by parseForCurrency().
02191     void setupCurrencyAffixPatterns(UErrorCode& status);
02192 
02193     // get the currency rounding with respect to currency usage
02194     double getCurrencyRounding(const UChar* currency,
02195                                UErrorCode* ec) const;
02196 
02197     // get the currency fraction with respect to currency usage
02198     int getCurrencyFractionDigits(const UChar* currency,
02199                                   UErrorCode* ec) const;
02200 
02201     // hashtable operations
02202     Hashtable* initHashForAffixPattern(UErrorCode& status);
02203 
02204     void deleteHashForAffixPattern();
02205 
02206     void copyHashForAffixPattern(const Hashtable* source,
02207                                  Hashtable* target, UErrorCode& status);
02208 
02209     DecimalFormatImpl *fImpl;
02210 
02216     EnumSet<UNumberFormatAttribute,
02217             UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
02218             UNUM_LIMIT_BOOLEAN_ATTRIBUTE>
02219                             fBoolFlags;
02220 
02221 
02222     // style is only valid when decimal formatter is constructed by
02223     // DecimalFormat(pattern, decimalFormatSymbol, style)
02224     int fStyle;
02225 
02226 
02227     // Affix pattern set for currency.
02228     // It is a set of AffixPatternsForCurrency,
02229     // each element of the set saves the negative prefix pattern,
02230     // negative suffix pattern, positive prefix pattern,
02231     // and positive suffix  pattern of a pattern.
02232     // It is used for currency mixed style parsing.
02233     // It is actually is a set.
02234     // The set contains the default currency pattern from the locale,
02235     // and the currency plural patterns.
02236     // Since it is a set, it does not contain duplicated items.
02237     // For example, if 2 currency plural patterns are the same, only one pattern
02238     // is included in the set. When parsing, we do not check whether the plural
02239     // count match or not.
02240     Hashtable* fAffixPatternsForCurrency;
02241 
02242     // Information needed for DecimalFormat to format/parse currency plural.
02243     CurrencyPluralInfo* fCurrencyPluralInfo;
02244 
02245 #if UCONFIG_HAVE_PARSEALLINPUT
02246     UNumberFormatAttributeValue fParseAllInput;
02247 #endif
02248 
02249     // Decimal Format Static Sets singleton.
02250     const DecimalFormatStaticSets *fStaticSets;
02251 
02252 protected:
02253 
02254 #ifndef U_HIDE_INTERNAL_API
02255 
02259     DigitList& _round(const DigitList& number, DigitList& adjustedNum, UBool& isNegative, UErrorCode& status) const;
02260 #endif  /* U_HIDE_INTERNAL_API */
02261 
02270     virtual void getEffectiveCurrency(UChar* result, UErrorCode& ec) const;
02271 
02275     static const int32_t  kDoubleIntegerDigits;
02279     static const int32_t  kDoubleFractionDigits;
02280 
02291     static const int32_t  kMaxScientificIntegerDigits;
02292 
02293 };
02294 
02295 U_NAMESPACE_END
02296 
02297 #endif /* #if !UCONFIG_NO_FORMATTING */
02298 
02299 #endif // _DECIMFMT
02300 //eof