ICU 71.1 71.1

decimfmt.h
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 ********************************************************************************
5 * Copyright (C) 1997-2016, International Business Machines
6 * Corporation and others. All Rights Reserved.
7 ********************************************************************************
8 *
9 * File DECIMFMT.H
10 *
11 * Modification History:
12 *
13 * Date Name Description
14 * 02/19/97 aliu Converted from java.
15 * 03/20/97 clhuang Updated per C++ implementation.
16 * 04/03/97 aliu Rewrote parsing and formatting completely, and
17 * cleaned up and debugged. Actually works now.
18 * 04/17/97 aliu Changed DigitCount to int per code review.
19 * 07/10/97 helena Made ParsePosition a class and get rid of the function
20 * hiding problems.
21 * 09/09/97 aliu Ported over support for exponential formats.
22 * 07/20/98 stephen Changed documentation
23 * 01/30/13 emmons Added Scaling methods
24 ********************************************************************************
25 */
26
27 #ifndef DECIMFMT_H
28 #define DECIMFMT_H
29
30 #include "unicode/utypes.h"
31
32 #if U_SHOW_CPLUSPLUS_API
33
39 #if !UCONFIG_NO_FORMATTING
40
41 #include "unicode/dcfmtsym.h"
42 #include "unicode/numfmt.h"
43 #include "unicode/locid.h"
44 #include "unicode/fpositer.h"
45 #include "unicode/stringpiece.h"
46 #include "unicode/curramt.h"
47 #include "unicode/enumset.h"
48
49 U_NAMESPACE_BEGIN
50
51 class CurrencyPluralInfo;
52 class CompactDecimalFormat;
53
54 namespace number {
55 class LocalizedNumberFormatter;
56 namespace impl {
57 class DecimalQuantity;
58 struct DecimalFormatFields;
59 class UFormattedNumberData;
60 }
61 }
62
63 namespace numparse {
64 namespace impl {
65 class NumberParserImpl;
66 }
67 }
68
668 class U_I18N_API DecimalFormat : public NumberFormat {
669 public:
674 enum EPadPosition {
675 kPadBeforePrefix, kPadAfterPrefix, kPadBeforeSuffix, kPadAfterSuffix
676 };
677
694 DecimalFormat(UErrorCode& status);
695
713 DecimalFormat(const UnicodeString& pattern, UErrorCode& status);
714
736 DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
737
738 #ifndef U_HIDE_INTERNAL_API
739
752 DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
753 UNumberFormatStyle style, UErrorCode& status);
754
755 #if UCONFIG_HAVE_PARSEALLINPUT
756
760 void setParseAllInput(UNumberFormatAttributeValue value);
761
762 #endif
763
764 #endif /* U_HIDE_INTERNAL_API */
765
766 private:
767
772 DecimalFormat(const DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
773
774 public:
775
786 virtual DecimalFormat& setAttribute(UNumberFormatAttribute attr, int32_t newValue, UErrorCode& status);
787
797 virtual int32_t getAttribute(UNumberFormatAttribute attr, UErrorCode& status) const;
798
799
806 void setGroupingUsed(UBool newValue) U_OVERRIDE;
807
815 void setParseIntegerOnly(UBool value) U_OVERRIDE;
816
824 void setLenient(UBool enable) U_OVERRIDE;
825
848 DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
849 UParseError& parseError, UErrorCode& status);
850
871 DecimalFormat(const UnicodeString& pattern, const DecimalFormatSymbols& symbols, UErrorCode& status);
872
879 DecimalFormat(const DecimalFormat& source);
880
887 DecimalFormat& operator=(const DecimalFormat& rhs);
888
893 ~DecimalFormat() U_OVERRIDE;
894
902 DecimalFormat* clone() const U_OVERRIDE;
903
912 bool operator==(const Format& other) const U_OVERRIDE;
913
914
915 using NumberFormat::format;
916
928 UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
929
930 #ifndef U_HIDE_INTERNAL_API
931
943 UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos,
944 UErrorCode& status) const U_OVERRIDE;
945 #endif /* U_HIDE_INTERNAL_API */
946
960 UnicodeString& format(double number, UnicodeString& appendTo, FieldPositionIterator* posIter,
961 UErrorCode& status) const U_OVERRIDE;
962
974 UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
975
976 #ifndef U_HIDE_INTERNAL_API
977
989 UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos,
990 UErrorCode& status) const U_OVERRIDE;
991 #endif /* U_HIDE_INTERNAL_API */
992
1006 UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
1007 UErrorCode& status) const U_OVERRIDE;
1008
1020 UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
1021
1022 #ifndef U_HIDE_INTERNAL_API
1023
1035 UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos,
1036 UErrorCode& status) const U_OVERRIDE;
1037 #endif /* U_HIDE_INTERNAL_API */
1038
1052 UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
1053 UErrorCode& status) const U_OVERRIDE;
1054
1071 UnicodeString& format(StringPiece number, UnicodeString& appendTo, FieldPositionIterator* posIter,
1072 UErrorCode& status) const U_OVERRIDE;
1073
1074 #ifndef U_HIDE_INTERNAL_API
1075
1091 UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
1092 FieldPositionIterator* posIter, UErrorCode& status) const U_OVERRIDE;
1093
1109 UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
1110 FieldPosition& pos, UErrorCode& status) const U_OVERRIDE;
1111
1112 #endif // U_HIDE_INTERNAL_API
1113
1114 using NumberFormat::parse;
1115
1135 void parse(const UnicodeString& text, Formattable& result,
1136 ParsePosition& parsePosition) const U_OVERRIDE;
1137
1157 CurrencyAmount* parseCurrency(const UnicodeString& text, ParsePosition& pos) const U_OVERRIDE;
1158
1166 virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const;
1167
1174 virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
1175
1182 virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
1183
1184
1191 virtual const CurrencyPluralInfo* getCurrencyPluralInfo(void) const;
1192
1199 virtual void adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt);
1200
1207 virtual void setCurrencyPluralInfo(const CurrencyPluralInfo& info);
1208
1209
1218 UnicodeString& getPositivePrefix(UnicodeString& result) const;
1219
1227 virtual void setPositivePrefix(const UnicodeString& newValue);
1228
1237 UnicodeString& getNegativePrefix(UnicodeString& result) const;
1238
1246 virtual void setNegativePrefix(const UnicodeString& newValue);
1247
1256 UnicodeString& getPositiveSuffix(UnicodeString& result) const;
1257
1265 virtual void setPositiveSuffix(const UnicodeString& newValue);
1266
1275 UnicodeString& getNegativeSuffix(UnicodeString& result) const;
1276
1284 virtual void setNegativeSuffix(const UnicodeString& newValue);
1285
1294 UBool isSignAlwaysShown() const;
1295
1304 void setSignAlwaysShown(UBool value);
1305
1318 int32_t getMultiplier(void) const;
1319
1333 virtual void setMultiplier(int32_t newValue);
1334
1347 int32_t getMultiplierScale(void) const;
1348
1368 void setMultiplierScale(int32_t newValue);
1369
1379 virtual double getRoundingIncrement(void) const;
1380
1392 virtual void setRoundingIncrement(double newValue);
1393
1402 virtual ERoundingMode getRoundingMode(void) const U_OVERRIDE;
1403
1412 virtual void setRoundingMode(ERoundingMode roundingMode) U_OVERRIDE;
1413
1425 virtual int32_t getFormatWidth(void) const;
1426
1441 virtual void setFormatWidth(int32_t width);
1442
1455 virtual UnicodeString getPadCharacterString() const;
1456
1471 virtual void setPadCharacter(const UnicodeString& padChar);
1472
1488 virtual EPadPosition getPadPosition(void) const;
1489
1506 virtual void setPadPosition(EPadPosition padPos);
1507
1518 virtual UBool isScientificNotation(void) const;
1519
1535 virtual void setScientificNotation(UBool useScientific);
1536
1547 virtual int8_t getMinimumExponentDigits(void) const;
1548
1561 virtual void setMinimumExponentDigits(int8_t minExpDig);
1562
1575 virtual UBool isExponentSignAlwaysShown(void) const;
1576
1590 virtual void setExponentSignAlwaysShown(UBool expSignAlways);
1591
1603 int32_t getGroupingSize(void) const;
1604
1616 virtual void setGroupingSize(int32_t newValue);
1617
1636 int32_t getSecondaryGroupingSize(void) const;
1637
1649 virtual void setSecondaryGroupingSize(int32_t newValue);
1650
1674 int32_t getMinimumGroupingDigits() const;
1675
1693 void setMinimumGroupingDigits(int32_t newValue);
1694
1703 UBool isDecimalSeparatorAlwaysShown(void) const;
1704
1713 virtual void setDecimalSeparatorAlwaysShown(UBool newValue);
1714
1721 UBool isDecimalPatternMatchRequired(void) const;
1722
1732 virtual void setDecimalPatternMatchRequired(UBool newValue);
1733
1741 UBool isParseNoExponent() const;
1742
1751 void setParseNoExponent(UBool value);
1752
1760 UBool isParseCaseSensitive() const;
1761
1773 void setParseCaseSensitive(UBool value);
1774
1783 UBool isFormatFailIfMoreThanMaxDigits() const;
1784
1792 void setFormatFailIfMoreThanMaxDigits(UBool value);
1793
1804 virtual UnicodeString& toPattern(UnicodeString& result) const;
1805
1816 virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const;
1817
1847 virtual void applyPattern(const UnicodeString& pattern, UParseError& parseError, UErrorCode& status);
1848
1857 virtual void applyPattern(const UnicodeString& pattern, UErrorCode& status);
1858
1889 virtual void applyLocalizedPattern(const UnicodeString& pattern, UParseError& parseError,
1890 UErrorCode& status);
1891
1901 virtual void applyLocalizedPattern(const UnicodeString& pattern, UErrorCode& status);
1902
1903
1913 void setMaximumIntegerDigits(int32_t newValue) U_OVERRIDE;
1914
1924 void setMinimumIntegerDigits(int32_t newValue) U_OVERRIDE;
1925
1935 void setMaximumFractionDigits(int32_t newValue) U_OVERRIDE;
1936
1946 void setMinimumFractionDigits(int32_t newValue) U_OVERRIDE;
1947
1955 int32_t getMinimumSignificantDigits() const;
1956
1964 int32_t getMaximumSignificantDigits() const;
1965
1977 void setMinimumSignificantDigits(int32_t min);
1978
1990 void setMaximumSignificantDigits(int32_t max);
1991
1998 UBool areSignificantDigitsUsed() const;
1999
2007 void setSignificantDigitsUsed(UBool useSignificantDigits);
2008
2021 void setCurrency(const char16_t* theCurrency, UErrorCode& ec) U_OVERRIDE;
2022
2023 #ifndef U_FORCE_HIDE_DEPRECATED_API
2024
2029 virtual void setCurrency(const char16_t* theCurrency);
2030 #endif // U_FORCE_HIDE_DEPRECATED_API
2031
2040 void setCurrencyUsage(UCurrencyUsage newUsage, UErrorCode* ec);
2041
2046 UCurrencyUsage getCurrencyUsage() const;
2047
2048 #ifndef U_HIDE_INTERNAL_API
2049
2055 void formatToDecimalQuantity(double number, number::impl::DecimalQuantity& output,
2056 UErrorCode& status) const;
2057
2064 void formatToDecimalQuantity(const Formattable& number, number::impl::DecimalQuantity& output,
2065 UErrorCode& status) const;
2066
2067 #endif /* U_HIDE_INTERNAL_API */
2068
2114 const number::LocalizedNumberFormatter* toNumberFormatter(UErrorCode& status) const;
2115
2127 static UClassID U_EXPORT2 getStaticClassID(void);
2128
2140 UClassID getDynamicClassID(void) const U_OVERRIDE;
2141
2142 private:
2143
2145 void touch(UErrorCode& status);
2146
2148 void touchNoError();
2149
2161 void setPropertiesFromPattern(const UnicodeString& pattern, int32_t ignoreRounding,
2162 UErrorCode& status);
2163
2164 const numparse::impl::NumberParserImpl* getParser(UErrorCode& status) const;
2165
2166 const numparse::impl::NumberParserImpl* getCurrencyParser(UErrorCode& status) const;
2167
2168 static void fieldPositionHelper(
2169 const number::impl::UFormattedNumberData& formatted,
2170 FieldPosition& fieldPosition,
2171 int32_t offset,
2172 UErrorCode& status);
2173
2174 static void fieldPositionIteratorHelper(
2175 const number::impl::UFormattedNumberData& formatted,
2176 FieldPositionIterator* fpi,
2177 int32_t offset,
2178 UErrorCode& status);
2179
2180 void setupFastFormat();
2181
2182 bool fastFormatDouble(double input, UnicodeString& output) const;
2183
2184 bool fastFormatInt64(int64_t input, UnicodeString& output) const;
2185
2186 void doFastFormatInt32(int32_t input, bool isNegative, UnicodeString& output) const;
2187
2188 //=====================================================================================//
2189 // INSTANCE FIELDS //
2190 //=====================================================================================//
2191
2192
2193 // One instance field for the implementation, keep all fields inside of an implementation
2194 // class defined in number_mapper.h
2195 number::impl::DecimalFormatFields* fields = nullptr;
2196
2197 // Allow child class CompactDecimalFormat to access fProperties:
2198 friend class CompactDecimalFormat;
2199
2200 // Allow MeasureFormat to use fieldPositionHelper:
2201 friend class MeasureFormat;
2202
2203 };
2204
2205 U_NAMESPACE_END
2206
2207 #endif /* #if !UCONFIG_NO_FORMATTING */
2208
2209 #endif /* U_SHOW_CPLUSPLUS_API */
2210
2211 #endif // _DECIMFMT
2212 //eof
icu::DecimalFormatSymbols
This class represents the set of symbols needed by DecimalFormat to format numbers.
Definition: dcfmtsym.h:86
icu::FieldPosition
FieldPosition is a simple class used by Format and its subclasses to identify fields in formatted out...
Definition: fieldpos.h:110
fpositer.h
C++ API: FieldPosition Iterator.
icu::NumberFormat::getDynamicClassID
virtual UClassID getDynamicClassID(void) const override=0
Returns a unique class ID POLYMORPHICALLY.
icu::NumberFormat
Definition: numfmt.h:175
utypes.h
Basic definitions for ICU, for both C and C++ APIs.
U_I18N_API
#define U_I18N_API
Definition: utypes.h:301
icu::NumberFormat::parseCurrency
virtual CurrencyAmount * parseCurrency(const UnicodeString &text, ParsePosition &pos) const
Parses text from the given string as a currency amount.
UBool
int8_t UBool
The ICU boolean type, a signed-byte integer.
Definition: umachine.h:269
icu::Formattable
Formattable objects can be passed to the Format class or its subclasses for formatting.
Definition: fmtable.h:64
icu::FieldPositionIterator
FieldPositionIterator returns the field ids and their start/limit positions generated by a call to Fo...
Definition: fpositer.h:58
icu::NumberFormat::setMaximumIntegerDigits
virtual void setMaximumIntegerDigits(int32_t newValue)
Sets the maximum number of digits allowed in the integer portion of a number.
U_OVERRIDE
#define U_OVERRIDE
Definition: umachine.h:130
icu::NumberFormat::setMaximumFractionDigits
virtual void setMaximumFractionDigits(int32_t newValue)
Sets the maximum number of digits allowed in the fraction portion of a number.
icu::NumberFormat::operator=
NumberFormat & operator=(const NumberFormat &)
Assignment operator.
UCurrencyUsage
UCurrencyUsage
Currency Usage used for Decimal Format.
Definition: ucurr.h:41
icu::NumberFormat::setParseIntegerOnly
virtual void setParseIntegerOnly(UBool value)
Sets whether or not numbers should be parsed as integers only.
icu::NumberFormat::setCurrency
virtual void setCurrency(const char16_t *theCurrency, UErrorCode &ec)
Sets the currency used to display currency amounts.
UParseError
A UParseError struct is used to returned detailed information about parsing errors.
Definition: parseerr.h:58
UNumberFormatAttribute
UNumberFormatAttribute
The possible UNumberFormat numeric attributes.
Definition: unum.h:1024
icu::Format
Base class for all formats.
Definition: format.h:98
icu::CompactDecimalFormat
IMPORTANT: New users are strongly encouraged to see if numberformatter.h fits their use case.
Definition: compactdecimalformat.h:63
stringpiece.h
C++ API: StringPiece: Read-only byte string wrapper class.
icu::UnicodeString
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:295
icu::NumberFormat::getRoundingMode
virtual ERoundingMode getRoundingMode(void) const
Get the rounding mode.
enumset.h
C++: internal template EnumSet<>
UClassID
void * UClassID
UClassID is used to identify classes without using the compiler's RTTI.
Definition: uobject.h:96
UErrorCode
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition: utypes.h:415
icu::DecimalFormat::EPadPosition
EPadPosition
Pad position.
Definition: decimfmt.h:674
icu::NumberFormat::setRoundingMode
virtual void setRoundingMode(ERoundingMode roundingMode)
Set the rounding mode.
dcfmtsym.h
C++ API: Symbols for formatting numbers.
icu::DecimalFormat
IMPORTANT: New users are strongly encouraged to see if numberformatter.h fits their use case.
Definition: decimfmt.h:668
UNumberFormatStyle
UNumberFormatStyle
The possible number format styles.
Definition: unum.h:149
icu::NumberFormat::parse
virtual void parse(const UnicodeString &text, Formattable &result, ParsePosition &parsePosition) const =0
Return a long if possible (e.g.
icu::NumberFormat::getStaticClassID
static UClassID getStaticClassID(void)
Return the class ID for this class.
icu::NumberFormat::setMinimumFractionDigits
virtual void setMinimumFractionDigits(int32_t newValue)
Sets the minimum number of digits allowed in the fraction portion of a number.
icu::MeasureFormat
Definition: measfmt.h:101
curramt.h
C++ API: Currency Amount Object.
icu::NumberFormat::setLenient
virtual void setLenient(UBool enable)
Sets whether lenient parsing should be enabled (it is off by default).
icu::NumberFormat::setGroupingUsed
virtual void setGroupingUsed(UBool newValue)
Set whether or not grouping will be used in this format.
numfmt.h
C++ API: Compatibility APIs for number formatting.
locid.h
C++ API: Locale ID object.
icu::CurrencyAmount
A currency together with a numeric amount, such as 200 USD.
Definition: curramt.h:39
icu::CurrencyPluralInfo
This class represents the information needed by DecimalFormat to format currency plural,...
Definition: currpinf.h:48
icu::ParsePosition
ParsePosition is a simple class used by Format and its subclasses to keep track of the current positi...
Definition: parsepos.h:52
icu::NumberFormat::setMinimumIntegerDigits
virtual void setMinimumIntegerDigits(int32_t newValue)
Sets the minimum number of digits allowed in the integer portion of a number.
icu::StringPiece
A string-like object that points to a sized piece of memory.
Definition: stringpiece.h:60
icu::NumberFormat::format
virtual UnicodeString & format(const Formattable &obj, UnicodeString &appendTo, FieldPosition &pos, UErrorCode &status) const override
Format an object to produce a string.
icu::number::LocalizedNumberFormatter
A NumberFormatter that has a locale associated with it; this means .format() methods are available.
Definition: numberformatter.h:2476