X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/57a6839dcb3bba09e8228b822b290604668416fe..c5116b9f5a666b9d59f443b3770acd6ef64dc6c3:/icuSources/i18n/unicode/decimfmt.h diff --git a/icuSources/i18n/unicode/decimfmt.h b/icuSources/i18n/unicode/decimfmt.h index d1be7403..6e6a7ff0 100644 --- a/icuSources/i18n/unicode/decimfmt.h +++ b/icuSources/i18n/unicode/decimfmt.h @@ -1,6 +1,8 @@ +// © 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html /* ******************************************************************************** -* Copyright (C) 1997-2014, International Business Machines +* Copyright (C) 1997-2016, International Business Machines * Corporation and others. All Rights Reserved. ******************************************************************************** * @@ -28,7 +30,7 @@ #include "unicode/utypes.h" /** * \file - * \brief C++ API: Formats decimal numbers. + * \brief C++ API: Compatibility APIs for decimal formatting. */ #if !UCONFIG_NO_FORMATTING @@ -41,33 +43,32 @@ #include "unicode/curramt.h" #include "unicode/enumset.h" -/** - * \def UNUM_DECIMALFORMAT_INTERNAL_SIZE - * @internal - */ -#if UCONFIG_FORMAT_FASTPATHS_49 -#define UNUM_DECIMALFORMAT_INTERNAL_SIZE 16 -#endif - +#if U_SHOW_CPLUSPLUS_API U_NAMESPACE_BEGIN -class DigitList; -class ChoiceFormat; class CurrencyPluralInfo; -class Hashtable; -class UnicodeSet; -class FieldPositionHandler; -class DecimalFormatStaticSets; -class FixedDecimal; - -// explicit template instantiation. see digitlst.h -#if defined (_MSC_VER) -template class U_I18N_API EnumSet; -#endif +class CompactDecimalFormat; + +namespace number { +class LocalizedNumberFormatter; +class FormattedNumber; +namespace impl { +class DecimalQuantity; +struct DecimalFormatFields; +} +} + +namespace numparse { +namespace impl { +class NumberParserImpl; +} +} /** + * **IMPORTANT:** New users are strongly encouraged to see if + * numberformatter.h fits their use case. Although not deprecated, this header + * is provided for backwards compatibility only. + * * 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 @@ -76,13 +77,13 @@ template class U_I18N_API EnumSetTo obtain a NumberFormat for a specific locale (including the default + * 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 + * **Example Usage** * * \code * // Normally we would have a GUI with a menu for this @@ -126,11 +127,11 @@ template class U_I18N_API EnumSet - * Another example use createInstance(style) - *

- * 

- * // Print out a number using the localized number, currency,
+ *
+ * **Another example use createInstance(style)**
+ *
+ * \code
+ * // 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");
@@ -141,11 +142,13 @@ template class U_I18N_API    EnumSetformat(myNumber, str) << endl;
  *     format->parse(form->format(myNumber, str), fmtable, success);
- * }
+ * delete form; + * } + * \endcode * * *

Patterns @@ -274,7 +277,7 @@ template class U_I18N_API EnumSetPad escape, precedes pad character * * - *

A DecimalFormat pattern contains a postive and negative + *

A DecimalFormat pattern contains a positive 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 @@ -408,7 +411,7 @@ template class U_I18N_API EnumSetIf the number of actual fraction digits is less than the * minimum fraction digits, then trailing zeros are added. - * For example, 0.125 is formatted as "0.1250" if the mimimum fraction + * For example, 0.125 is formatted as "0.1250" if the minimum fraction * digits is set to 4. * *

  • Trailing fractional zeros are not displayed if they occur @@ -573,9 +576,9 @@ template class U_I18N_API EnumSetgetMaximumSignificantDigits() - 1. For example, the * pattern "@@###E0" is equivalent to "0.0###E0". * - *
  • If signficant digits are in use, then the integer and fraction + *
  • If significant digits are in use, then the integer and fraction * digit counts, as set via the API, are ignored. If significant - * digits are not in use, then the signficant digit counts, as set via + * digits are not in use, then the significant digit counts, as set via * the API, are ignored. * * @@ -597,7 +600,7 @@ template class U_I18N_API EnumSet"* #0 o''clock", the format width is 10. * - *
  • The width is counted in 16-bit code units (UChars). + *
  • The width is counted in 16-bit code units (char16_ts). * *
  • Some parameters which usually do not matter have meaning when padding is * used, because the pattern width is significant with padding. In the pattern @@ -629,7 +632,7 @@ template class U_I18N_API EnumSetIn the absense of an explicit rounding increment numbers are + *

    In the absence of an explicit rounding increment numbers are * rounded to their formatted width. * *

      @@ -659,39 +662,14 @@ template class U_I18N_API EnumSet + * NOTE: New users are strongly encouraged to use + * #icu::number::NumberFormatter instead of DecimalFormat. * @param status Output param set to success/failure code. If the * pattern is invalid this will be set to a failure code. * @stable ICU 2.0 @@ -718,13 +699,15 @@ public: * on NumberFormat such as createInstance. These factories will * return the most appropriate sub-class of NumberFormat for a given * locale. + *

      + * NOTE: New users are strongly encouraged to use + * #icu::number::NumberFormatter instead of DecimalFormat. * @param pattern A non-localized pattern string. * @param status Output param set to success/failure code. If the * pattern is invalid this will be set to a failure code. * @stable ICU 2.0 */ - DecimalFormat(const UnicodeString& pattern, - UErrorCode& status); + DecimalFormat(const UnicodeString& pattern, UErrorCode& status); /** * Create a DecimalFormat from the given pattern and symbols. @@ -736,6 +719,9 @@ public: * createInstance or createCurrencyInstance. If you need only minor adjustments * to a standard format, you can modify the format returned by * a NumberFormat factory method. + *

      + * NOTE: New users are strongly encouraged to use + * #icu::number::NumberFormatter instead of DecimalFormat. * * @param pattern a non-localized pattern string * @param symbolsToAdopt the set of symbols to be used. The caller should not @@ -744,11 +730,10 @@ public: * pattern is invalid this will be set to a failure code. * @stable ICU 2.0 */ - DecimalFormat( const UnicodeString& pattern, - DecimalFormatSymbols* symbolsToAdopt, - UErrorCode& status); + DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status); #ifndef U_HIDE_INTERNAL_API + /** * This API is for ICU use only. * Create a DecimalFormat from the given pattern, symbols, and style. @@ -761,34 +746,41 @@ public: * pattern is invalid this will be set to a failure code. * @internal */ - DecimalFormat( const UnicodeString& pattern, - DecimalFormatSymbols* symbolsToAdopt, - UNumberFormatStyle style, - UErrorCode& status); + DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, + UNumberFormatStyle style, UErrorCode& status); #if UCONFIG_HAVE_PARSEALLINPUT + /** * @internal */ void setParseAllInput(UNumberFormatAttributeValue value); + #endif #endif /* U_HIDE_INTERNAL_API */ + private: + + /** + * Internal constructor for DecimalFormat; sets up internal fields. All public constructors should + * call this constructor. + */ + DecimalFormat(const DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status); + + public: /** * Set an integer attribute on this DecimalFormat. * May return U_UNSUPPORTED_ERROR if this instance does not support * the specified attribute. * @param attr the attribute to set - * @param newvalue new value + * @param newValue new value * @param status the error type * @return *this - for chaining (example: format.setAttribute(...).setAttribute(...) ) * @stable ICU 51 */ - virtual DecimalFormat& setAttribute( UNumberFormatAttribute attr, - int32_t newvalue, - UErrorCode &status); + virtual DecimalFormat& setAttribute(UNumberFormatAttribute attr, int32_t newValue, UErrorCode& status); /** * Get an integer @@ -799,38 +791,34 @@ public: * @return the attribute value. Undefined if there is an error. * @stable ICU 51 */ - virtual int32_t getAttribute( UNumberFormatAttribute attr, - UErrorCode &status) const; + virtual int32_t getAttribute(UNumberFormatAttribute attr, UErrorCode& status) const; + - /** * Set whether or not grouping will be used in this format. * @param newValue True, grouping will be used in this format. * @see getGroupingUsed - * @draft ICU 53 + * @stable ICU 53 */ - virtual void setGroupingUsed(UBool newValue); + void setGroupingUsed(UBool newValue) U_OVERRIDE; /** * Sets whether or not numbers should be parsed as integers only. * @param value set True, this format will parse numbers as integers * only. * @see isParseIntegerOnly - * @draft ICU 53 + * @stable ICU 53 */ - virtual void setParseIntegerOnly(UBool value); + void setParseIntegerOnly(UBool value) U_OVERRIDE; - /* Cannot use #ifndef U_HIDE_DRAFT_API for the following draft method since it is virtual */ /** - * Set a particular UDisplayContext value in the formatter, such as - * UDISPCTX_CAPITALIZATION_FOR_STANDALONE. - * @param value The UDisplayContext value to set. - * @param status Input/output status. If at entry this indicates a failure - * status, the function will do nothing; otherwise this will be - * updated with any new status from the function. - * @draft ICU 53 + * Sets whether lenient parsing should be enabled (it is off by default). + * + * @param enable \c TRUE if lenient parsing should be used, + * \c FALSE otherwise. + * @stable ICU 4.8 */ - virtual void setContext(UDisplayContext value, UErrorCode& status); + void setLenient(UBool enable) U_OVERRIDE; /** * Create a DecimalFormat from the given pattern and symbols. @@ -842,19 +830,21 @@ public: * createInstance or createCurrencyInstance. If you need only minor adjustments * to a standard format, you can modify the format returned by * a NumberFormat factory method. + *

      + * NOTE: New users are strongly encouraged to use + * #icu::number::NumberFormatter instead of DecimalFormat. * * @param pattern a non-localized pattern string * @param symbolsToAdopt the set of symbols to be used. The caller should not * delete this object after making this call. - * @param parseError Output param to receive errors occured during parsing + * @param parseError Output param to receive errors occurred during parsing * @param status Output param set to success/failure code. If the * pattern is invalid this will be set to a failure code. * @stable ICU 2.0 */ - DecimalFormat( const UnicodeString& pattern, - DecimalFormatSymbols* symbolsToAdopt, - UParseError& parseError, - UErrorCode& status); + DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, + UParseError& parseError, UErrorCode& status); + /** * Create a DecimalFormat from the given pattern and symbols. * Use this constructor when you need to completely customize the @@ -865,6 +855,9 @@ public: * createInstance or createCurrencyInstance. If you need only minor adjustments * to a standard format, you can modify the format returned by * a NumberFormat factory method. + *

      + * NOTE: New users are strongly encouraged to use + * #icu::number::NumberFormatter instead of DecimalFormat. * * @param pattern a non-localized pattern string * @param symbols the set of symbols to be used @@ -872,9 +865,7 @@ public: * pattern is invalid this will be set to a failure code. * @stable ICU 2.0 */ - DecimalFormat( const UnicodeString& pattern, - const DecimalFormatSymbols& symbols, - UErrorCode& status); + DecimalFormat(const UnicodeString& pattern, const DecimalFormatSymbols& symbols, UErrorCode& status); /** * Copy constructor. @@ -896,7 +887,7 @@ public: * Destructor. * @stable ICU 2.0 */ - virtual ~DecimalFormat(); + ~DecimalFormat() U_OVERRIDE; /** * Clone this Format object polymorphically. The caller owns the @@ -905,7 +896,7 @@ public: * @return a polymorphic copy of this DecimalFormat. * @stable ICU 2.0 */ - virtual Format* clone(void) const; + Format* clone(void) const U_OVERRIDE; /** * Return true if the given Format objects are semantically equal. @@ -915,7 +906,7 @@ public: * @return true if the given Format objects are semantically equal. * @stable ICU 2.0 */ - virtual UBool operator==(const Format& other) const; + UBool operator==(const Format& other) const U_OVERRIDE; using NumberFormat::format; @@ -931,11 +922,9 @@ public: * @return Reference to 'appendTo' parameter. * @stable ICU 2.0 */ - virtual UnicodeString& format(double number, - UnicodeString& appendTo, - FieldPosition& pos) const; - + UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE; +#ifndef U_HIDE_INTERNAL_API /** * Format a double or long number using base-10 representation. * @@ -948,10 +937,9 @@ public: * @return Reference to 'appendTo' parameter. * @internal */ - virtual UnicodeString& format(double number, - UnicodeString& appendTo, - FieldPosition& pos, - UErrorCode &status) const; + UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos, + UErrorCode& status) const U_OVERRIDE; +#endif /* U_HIDE_INTERNAL_API */ /** * Format a double or long number using base-10 representation. @@ -964,12 +952,10 @@ public: * Can be NULL. * @param status Output param filled with success/failure status. * @return Reference to 'appendTo' parameter. - * @stable 4.4 + * @stable ICU 4.4 */ - virtual UnicodeString& format(double number, - UnicodeString& appendTo, - FieldPositionIterator* posIter, - UErrorCode& status) const; + UnicodeString& format(double number, UnicodeString& appendTo, FieldPositionIterator* posIter, + UErrorCode& status) const U_OVERRIDE; /** * Format a long number using base-10 representation. @@ -982,10 +968,9 @@ public: * @return Reference to 'appendTo' parameter. * @stable ICU 2.0 */ - virtual UnicodeString& format(int32_t number, - UnicodeString& appendTo, - FieldPosition& pos) const; + UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE; +#ifndef U_HIDE_INTERNAL_API /** * Format a long number using base-10 representation. * @@ -994,13 +979,13 @@ public: * Result is appended to existing contents. * @param pos On input: an alignment field, if desired. * On output: the offsets of the alignment field. + * @param status Output param filled with success/failure status. * @return Reference to 'appendTo' parameter. * @internal */ - virtual UnicodeString& format(int32_t number, - UnicodeString& appendTo, - FieldPosition& pos, - UErrorCode &status) const; + UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos, + UErrorCode& status) const U_OVERRIDE; +#endif /* U_HIDE_INTERNAL_API */ /** * Format a long number using base-10 representation. @@ -1013,12 +998,10 @@ public: * Can be NULL. * @param status Output param filled with success/failure status. * @return Reference to 'appendTo' parameter. - * @stable 4.4 + * @stable ICU 4.4 */ - virtual UnicodeString& format(int32_t number, - UnicodeString& appendTo, - FieldPositionIterator* posIter, - UErrorCode& status) const; + UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPositionIterator* posIter, + UErrorCode& status) const U_OVERRIDE; /** * Format an int64 number using base-10 representation. @@ -1031,10 +1014,9 @@ public: * @return Reference to 'appendTo' parameter. * @stable ICU 2.8 */ - virtual UnicodeString& format(int64_t number, - UnicodeString& appendTo, - FieldPosition& pos) const; + UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE; +#ifndef U_HIDE_INTERNAL_API /** * Format an int64 number using base-10 representation. * @@ -1043,13 +1025,13 @@ public: * Result is appended to existing contents. * @param pos On input: an alignment field, if desired. * On output: the offsets of the alignment field. + * @param status Output param filled with success/failure status. * @return Reference to 'appendTo' parameter. * @internal */ - virtual UnicodeString& format(int64_t number, - UnicodeString& appendTo, - FieldPosition& pos, - UErrorCode &status) const; + UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos, + UErrorCode& status) const U_OVERRIDE; +#endif /* U_HIDE_INTERNAL_API */ /** * Format an int64 number using base-10 representation. @@ -1062,12 +1044,10 @@ public: * Can be NULL. * @param status Output param filled with success/failure status. * @return Reference to 'appendTo' parameter. - * @stable 4.4 + * @stable ICU 4.4 */ - virtual UnicodeString& format(int64_t number, - UnicodeString& appendTo, - FieldPositionIterator* posIter, - UErrorCode& status) const; + UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPositionIterator* posIter, + UErrorCode& status) const U_OVERRIDE; /** * Format a decimal number. @@ -1083,21 +1063,20 @@ public: * Can be NULL. * @param status Output param filled with success/failure status. * @return Reference to 'appendTo' parameter. - * @stable 4.4 + * @stable ICU 4.4 */ - virtual UnicodeString& format(const StringPiece &number, - UnicodeString& appendTo, - FieldPositionIterator* posIter, - UErrorCode& status) const; + UnicodeString& format(StringPiece number, UnicodeString& appendTo, FieldPositionIterator* posIter, + UErrorCode& status) const U_OVERRIDE; +#ifndef U_HIDE_INTERNAL_API /** * Format a decimal number. - * The number is a DigitList wrapper onto a floating point decimal number. + * The number is a DecimalQuantity wrapper onto a floating point decimal number. * The default implementation in NumberFormat converts the decimal number * to a double and formats that. * - * @param number The number, a DigitList format Decimal Floating Point. + * @param number The number, a DecimalQuantity format Decimal Floating Point. * @param appendTo Output parameter to receive result. * Result is appended to existing contents. * @param posIter On return, can be used to iterate over positions @@ -1106,18 +1085,16 @@ public: * @return Reference to 'appendTo' parameter. * @internal */ - virtual UnicodeString& format(const DigitList &number, - UnicodeString& appendTo, - FieldPositionIterator* posIter, - UErrorCode& status) const; + UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo, + FieldPositionIterator* posIter, UErrorCode& status) const U_OVERRIDE; /** * Format a decimal number. - * The number is a DigitList wrapper onto a floating point decimal number. + * The number is a DecimalQuantity wrapper onto a floating point decimal number. * The default implementation in NumberFormat converts the decimal number * to a double and formats that. * - * @param number The number, a DigitList format Decimal Floating Point. + * @param number The number, a DecimalQuantity format Decimal Floating Point. * @param appendTo Output parameter to receive result. * Result is appended to existing contents. * @param pos On input: an alignment field, if desired. @@ -1126,35 +1103,34 @@ public: * @return Reference to 'appendTo' parameter. * @internal */ - virtual UnicodeString& format(const DigitList &number, - UnicodeString& appendTo, - FieldPosition& pos, - UErrorCode& status) const; - - using NumberFormat::parse; - - /** - * Parse the given string using this object's choices. The method - * does string comparisons to try to find an optimal match. - * If no object can be parsed, index is unchanged, and NULL is - * returned. The result is returned as the most parsimonious - * type of Formattable that will accomodate all of the - * necessary precision. For example, if the result is exactly 12, - * it will be returned as a long. However, if it is 1.5, it will - * be returned as a double. - * - * @param text The text to be parsed. - * @param result Formattable to be set to the parse result. - * If parse fails, return contents are undefined. - * @param parsePosition The position to start parsing at on input. - * On output, moved to after the last successfully - * parse character. On parse failure, does not change. - * @see Formattable - * @stable ICU 2.0 - */ - virtual void parse(const UnicodeString& text, - Formattable& result, - ParsePosition& parsePosition) const; + UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo, + FieldPosition& pos, UErrorCode& status) const U_OVERRIDE; + +#endif // U_HIDE_INTERNAL_API + + using NumberFormat::parse; + + /** + * Parse the given string using this object's choices. The method + * does string comparisons to try to find an optimal match. + * If no object can be parsed, index is unchanged, and NULL is + * returned. The result is returned as the most parsimonious + * type of Formattable that will accommodate all of the + * necessary precision. For example, if the result is exactly 12, + * it will be returned as a long. However, if it is 1.5, it will + * be returned as a double. + * + * @param text The text to be parsed. + * @param result Formattable to be set to the parse result. + * If parse fails, return contents are undefined. + * @param parsePosition The position to start parsing at on input. + * On output, moved to after the last successfully + * parse character. On parse failure, does not change. + * @see Formattable + * @stable ICU 2.0 + */ + void parse(const UnicodeString& text, Formattable& result, + ParsePosition& parsePosition) const U_OVERRIDE; /** * Parses text from the given string as a currency amount. Unlike @@ -1175,8 +1151,7 @@ public: * the parsed currency; if parse fails, this is NULL. * @stable ICU 49 */ - virtual CurrencyAmount* parseCurrency(const UnicodeString& text, - ParsePosition& pos) const; + CurrencyAmount* parseCurrency(const UnicodeString& text, ParsePosition& pos) const U_OVERRIDE; /** * Returns the decimal format symbols, which is generally not changed @@ -1305,12 +1280,36 @@ public: */ virtual void setNegativeSuffix(const UnicodeString& newValue); +#ifndef U_HIDE_DRAFT_API + /** + * Whether to show the plus sign on positive (non-negative) numbers; for example, "+12" + * + * For more control over sign display, use NumberFormatter. + * + * @return Whether the sign is shown on positive numbers and zero. + * @draft ICU 64 + */ + UBool isSignAlwaysShown() const; + + /** + * Set whether to show the plus sign on positive (non-negative) numbers; for example, "+12". + * + * For more control over sign display, use NumberFormatter. + * + * @param value true to always show a sign; false to hide the sign on positive numbers and zero. + * @draft ICU 64 + */ + void setSignAlwaysShown(UBool value); +#endif /* U_HIDE_DRAFT_API */ + /** * Get the multiplier for use in percent, permill, etc. * For a percentage, set the suffixes to have "%" and the multiplier to be 100. * (For Arabic, use arabic percent symbol). * For a permill, set the suffixes to have "\\u2031" and the multiplier to be 1000. * + * The number may also be multiplied by a power of ten; see getMultiplierScale(). + * * @return the multiplier for use in percent, permill, etc. * Examples: with 100, 1.23 -> "123", and "123" -> 1.23 * @stable ICU 2.0 @@ -1323,12 +1322,52 @@ public: * (For Arabic, use arabic percent symbol). * For a permill, set the suffixes to have "\\u2031" and the multiplier to be 1000. * + * This method only supports integer multipliers. To multiply by a non-integer, pair this + * method with setMultiplierScale(). + * * @param newValue the new value of the multiplier for use in percent, permill, etc. * Examples: with 100, 1.23 -> "123", and "123" -> 1.23 * @stable ICU 2.0 */ virtual void setMultiplier(int32_t newValue); +#ifndef U_HIDE_DRAFT_API + /** + * Gets the power of ten by which number should be multiplied before formatting, which + * can be combined with setMultiplier() to multiply by any arbitrary decimal value. + * + * A multiplier scale of 2 corresponds to multiplication by 100, and a multiplier scale + * of -2 corresponds to multiplication by 0.01. + * + * This method is analogous to UNUM_SCALE in getAttribute. + * + * @return the current value of the power-of-ten multiplier. + * @draft ICU 62 + */ + int32_t getMultiplierScale(void) const; + + /** + * Sets a power of ten by which number should be multiplied before formatting, which + * can be combined with setMultiplier() to multiply by any arbitrary decimal value. + * + * A multiplier scale of 2 corresponds to multiplication by 100, and a multiplier scale + * of -2 corresponds to multiplication by 0.01. + * + * For example, to multiply numbers by 0.5 before formatting, you can do: + * + * 

      +     * df.setMultiplier(5);
+     * df.setMultiplierScale(-1);
+     *
      + * + * This method is analogous to UNUM_SCALE in setAttribute. + * + * @param newValue the new value of the power-of-ten multiplier. + * @draft ICU 62 + */ + void setMultiplierScale(int32_t newValue); +#endif /* U_HIDE_DRAFT_API */ + /** * Get the rounding increment. * @return A positive rounding increment, or 0.0 if a custom rounding @@ -1361,7 +1400,7 @@ public: * @see #setRoundingMode * @stable ICU 2.0 */ - virtual ERoundingMode getRoundingMode(void) const; + virtual ERoundingMode getRoundingMode(void) const U_OVERRIDE; /** * Set the rounding mode. @@ -1371,7 +1410,7 @@ public: * @see #getRoundingMode * @stable ICU 2.0 */ - virtual void setRoundingMode(ERoundingMode roundingMode); + virtual void setRoundingMode(ERoundingMode roundingMode) U_OVERRIDE; /** * Get the width to which the output of format() is padded. @@ -1420,8 +1459,8 @@ public: * Set the character used to pad to the format width. If padding * is not enabled, then this will take effect if padding is later * enabled. - * @param padChar a string containing the pad charcter. If the string - * has length 0, then the pad characer is set to ' '. Otherwise + * @param padChar a string containing the pad character. If the string + * has length 0, then the pad character is set to ' '. Otherwise * padChar.char32At(0) will be used as the pad character. * @see #setFormatWidth * @see #getFormatWidth @@ -1430,7 +1469,7 @@ public: * @see #setPadPosition * @stable ICU 2.0 */ - virtual void setPadCharacter(const UnicodeString &padChar); + virtual void setPadCharacter(const UnicodeString& padChar); /** * Get the position at which padding will take place. This is the location @@ -1610,6 +1649,46 @@ public: */ virtual void setSecondaryGroupingSize(int32_t newValue); +#ifndef U_HIDE_DRAFT_API + /** + * Returns the minimum number of grouping digits. + * Grouping separators are output if there are at least this many + * digits to the left of the first (rightmost) grouping separator, + * that is, there are at least (minimum grouping + grouping size) integer digits. + * (Subject to isGroupingUsed().) + * + * For example, if this value is 2, and the grouping size is 3, then + * 9999 -> "9999" and 10000 -> "10,000" + * + * The default value for this attribute is 0. + * A value of 1, 0, or lower, means that the use of grouping separators + * only depends on the grouping size (and on isGroupingUsed()). + * + * NOTE: The CLDR data is used in NumberFormatter but not in DecimalFormat. + * This is for backwards compatibility reasons. + * + * For more control over grouping strategies, use NumberFormatter. + * + * @see setMinimumGroupingDigits + * @see getGroupingSize + * @draft ICU 64 + */ + int32_t getMinimumGroupingDigits() const; + + /** + * Sets the minimum grouping digits. Setting to a value less than or + * equal to 1 turns off minimum grouping digits. + * + * For more control over grouping strategies, use NumberFormatter. + * + * @param newValue the new value of minimum grouping digits. + * @see getMinimumGroupingDigits + * @draft ICU 64 + */ + void setMinimumGroupingDigits(int32_t newValue); +#endif /* U_HIDE_DRAFT_API */ + + /** * Allows you to get the behavior of the decimal separator with integers. * (The decimal separator will always appear with decimals.) @@ -1630,6 +1709,88 @@ public: */ virtual void setDecimalSeparatorAlwaysShown(UBool newValue); + /** + * Allows you to get the parse behavior of the pattern decimal mark. + * + * @return TRUE if input must contain a match to decimal mark in pattern + * @stable ICU 54 + */ + UBool isDecimalPatternMatchRequired(void) const; + + /** + * Allows you to set the parse behavior of the pattern decimal mark. + * + * if TRUE, the input must have a decimal mark if one was specified in the pattern. When + * FALSE the decimal mark may be omitted from the input. + * + * @param newValue set TRUE if input must contain a match to decimal mark in pattern + * @stable ICU 54 + */ + virtual void setDecimalPatternMatchRequired(UBool newValue); + +#ifndef U_HIDE_DRAFT_API + /** + * Returns whether to ignore exponents when parsing. + * + * @return Whether to ignore exponents when parsing. + * @see #setParseNoExponent + * @draft ICU 64 + */ + UBool isParseNoExponent() const; + + /** + * Specifies whether to stop parsing when an exponent separator is encountered. For + * example, parses "123E4" to 123 (with parse position 3) instead of 1230000 (with parse position + * 5). + * + * @param value true to prevent exponents from being parsed; false to allow them to be parsed. + * @draft ICU 64 + */ + void setParseNoExponent(UBool value); + + /** + * Returns whether parsing is sensitive to case (lowercase/uppercase). + * + * @return Whether parsing is case-sensitive. + * @see #setParseCaseSensitive + * @draft ICU 64 + */ + UBool isParseCaseSensitive() const; + + /** + * Whether to pay attention to case when parsing; default is to ignore case (perform + * case-folding). For example, "A" == "a" in case-insensitive but not case-sensitive mode. + * + * Currency symbols are never case-folded. For example, "us$1.00" will not parse in case-insensitive + * mode, even though "US$1.00" parses. + * + * @param value true to enable case-sensitive parsing (the default); false to force + * case-sensitive parsing behavior. + * @draft ICU 64 + */ + void setParseCaseSensitive(UBool value); + + /** + * Returns whether truncation of high-order integer digits should result in an error. + * By default, setMaximumIntegerDigits truncates high-order digits silently. + * + * @return Whether an error code is set if high-order digits are truncated. + * @see setFormatFailIfMoreThanMaxDigits + * @draft ICU 64 + */ + UBool isFormatFailIfMoreThanMaxDigits() const; + + /** + * Sets whether truncation of high-order integer digits should result in an error. + * By default, setMaximumIntegerDigits truncates high-order digits silently. + * + * @param value Whether to set an error code if high-order digits are truncated. + * @draft ICU 64 + */ + void setFormatFailIfMoreThanMaxDigits(UBool value); +#endif /* U_HIDE_DRAFT_API */ + + /** * Synthesizes a pattern string that represents the current state * of this Format object. @@ -1683,9 +1844,8 @@ public: * set to a failure result. * @stable ICU 2.0 */ - virtual void applyPattern(const UnicodeString& pattern, - UParseError& parseError, - UErrorCode& status); + virtual void applyPattern(const UnicodeString& pattern, UParseError& parseError, UErrorCode& status); + /** * Sets the pattern. * @param pattern The pattern to be applied. @@ -1694,8 +1854,7 @@ public: * set to a failure result. * @stable ICU 2.0 */ - virtual void applyPattern(const UnicodeString& pattern, - UErrorCode& status); + virtual void applyPattern(const UnicodeString& pattern, UErrorCode& status); /** * Apply the given pattern to this Format object. The pattern @@ -1727,8 +1886,7 @@ public: * set to a failure result. * @stable ICU 2.0 */ - virtual void applyLocalizedPattern(const UnicodeString& pattern, - UParseError& parseError, + virtual void applyLocalizedPattern(const UnicodeString& pattern, UParseError& parseError, UErrorCode& status); /** @@ -1740,8 +1898,7 @@ public: * set to a failure result. * @stable ICU 2.0 */ - virtual void applyLocalizedPattern(const UnicodeString& pattern, - UErrorCode& status); + virtual void applyLocalizedPattern(const UnicodeString& pattern, UErrorCode& status); /** @@ -1753,7 +1910,7 @@ public: * @see NumberFormat#setMaximumIntegerDigits * @stable ICU 2.0 */ - virtual void setMaximumIntegerDigits(int32_t newValue); + void setMaximumIntegerDigits(int32_t newValue) U_OVERRIDE; /** * Sets the minimum number of digits allowed in the integer portion of a @@ -1764,7 +1921,7 @@ public: * @see NumberFormat#setMinimumIntegerDigits * @stable ICU 2.0 */ - virtual void setMinimumIntegerDigits(int32_t newValue); + void setMinimumIntegerDigits(int32_t newValue) U_OVERRIDE; /** * Sets the maximum number of digits allowed in the fraction portion of a @@ -1775,7 +1932,7 @@ public: * @see NumberFormat#setMaximumFractionDigits * @stable ICU 2.0 */ - virtual void setMaximumFractionDigits(int32_t newValue); + void setMaximumFractionDigits(int32_t newValue) U_OVERRIDE; /** * Sets the minimum number of digits allowed in the fraction portion of a @@ -1786,7 +1943,7 @@ public: * @see NumberFormat#setMinimumFractionDigits * @stable ICU 2.0 */ - virtual void setMinimumFractionDigits(int32_t newValue); + void setMinimumFractionDigits(int32_t newValue) U_OVERRIDE; /** * Returns the minimum number of significant digits that will be @@ -1849,7 +2006,18 @@ public: */ void setSignificantDigitsUsed(UBool useSignificantDigits); - public: + /** + * Group-set several settings used for numbers in date formats. + * Avoids calls to touch for each separate setting. + * Equivalent to: + * setGroupingUsed(FALSE); + * setDecimalSeparatorAlwaysShown(FALSE); + * setParseIntegerOnly(TRUE); + * setMinimumFractionDigits(0); + * @internal + */ + void setDateSettings(void) U_OVERRIDE; + /** * Sets the currency used to display currency * amounts. This takes effect immediately, if this format is a @@ -1862,49 +2030,116 @@ public: * @param ec input-output error code * @stable ICU 3.0 */ - virtual void setCurrency(const UChar* theCurrency, UErrorCode& ec); + void setCurrency(const char16_t* theCurrency, UErrorCode& ec) U_OVERRIDE; /** * Sets the currency used to display currency amounts. See - * setCurrency(const UChar*, UErrorCode&). - * @deprecated ICU 3.0. Use setCurrency(const UChar*, UErrorCode&). + * setCurrency(const char16_t*, UErrorCode&). + * @deprecated ICU 3.0. Use setCurrency(const char16_t*, UErrorCode&). */ - virtual void setCurrency(const UChar* theCurrency); + virtual void setCurrency(const char16_t* theCurrency); /** - * The resource tags we use to retrieve decimal format data from - * locale resource bundles. - * @deprecated ICU 3.4. This string has no public purpose. Please don't use it. + * Sets the `Currency Usage` object used to display currency. + * This takes effect immediately, if this format is a + * currency format. + * @param newUsage new currency usage object to use. + * @param ec input-output error code + * @stable ICU 54 */ - static const char fgNumberPatterns[]; + void setCurrencyUsage(UCurrencyUsage newUsage, UErrorCode* ec); -#ifndef U_HIDE_INTERNAL_API /** - * Get a FixedDecimal corresponding to a double as it would be - * formatted by this DecimalFormat. - * Internal, not intended for public use. - * @internal + * Returns the `Currency Usage` object used to display currency + * @stable ICU 54 */ - FixedDecimal getFixedDecimal(double number, UErrorCode &status) const; + UCurrencyUsage getCurrencyUsage() const; + +#ifndef U_HIDE_INTERNAL_API /** - * Get a FixedDecimal corresponding to a formattable as it would be - * formatted by this DecimalFormat. + * Format a number and save it into the given DecimalQuantity. * Internal, not intended for public use. * @internal */ - FixedDecimal getFixedDecimal(const Formattable &number, UErrorCode &status) const; + void formatToDecimalQuantity(double number, number::impl::DecimalQuantity& output, + UErrorCode& status) const; /** - * Get a FixedDecimal corresponding to a DigitList as it would be - * formatted by this DecimalFormat. Note: the DigitList may be modified. + * Get a DecimalQuantity corresponding to a formattable as it would be + * formatted by this DecimalFormat. * Internal, not intended for public use. * @internal */ - FixedDecimal getFixedDecimal(DigitList &number, UErrorCode &status) const; + void formatToDecimalQuantity(const Formattable& number, number::impl::DecimalQuantity& output, + UErrorCode& status) const; + #endif /* U_HIDE_INTERNAL_API */ -public: +#ifndef U_HIDE_DRAFT_API + /** + * Converts this DecimalFormat to a (Localized)NumberFormatter. Starting + * in ICU 60, NumberFormatter is the recommended way to format numbers. + * You can use the returned LocalizedNumberFormatter to format numbers and + * get a FormattedNumber, which contains a string as well as additional + * annotations about the formatted value. + * + * If a memory allocation failure occurs, the return value of this method + * might be null. If you are concerned about correct recovery from + * out-of-memory situations, use this pattern: + * + * 
      +     * FormattedNumber result;
+     * if (auto* ptr = df->toNumberFormatter(status)) {
+     *     result = ptr->formatDouble(123, status);
+     * }
+     *
      + * + * If you are not concerned about out-of-memory situations, or if your + * environment throws exceptions when memory allocation failure occurs, + * you can chain the methods, like this: + * + * 
      +     * FormattedNumber result = df
+     *     ->toNumberFormatter(status)
+     *     ->formatDouble(123, status);
+     *
      + * + * NOTE: The returned LocalizedNumberFormatter is owned by this DecimalFormat. + * If a non-const method is called on the DecimalFormat, or if the DecimalFormat + * is deleted, the object becomes invalid. If you plan to keep the return value + * beyond the lifetime of the DecimalFormat, copy it to a local variable: + * + * 
      +     * LocalizedNumberFormatter lnf;
+     * if (auto* ptr = df->toNumberFormatter(status)) {
+     *     lnf = *ptr;
+     * }
+     *
      + * + * @param status Set on failure, like U_MEMORY_ALLOCATION_ERROR. + * @return A pointer to an internal object, or nullptr on failure. + * Do not delete the return value! + * @draft ICU 64 + */ + const number::LocalizedNumberFormatter* toNumberFormatter(UErrorCode& status) const; +#endif /* U_HIDE_DRAFT_API */ + +#ifndef U_HIDE_DEPRECATED_API + /** + * Deprecated: Like {@link #toNumberFormatter(UErrorCode&) const}, + * but does not take an error code. + * + * The new signature should be used in case an error occurs while returning the + * LocalizedNumberFormatter. + * + * This old signature will be removed in ICU 65. + * + * @return A reference to an internal object. + * @deprecated ICU 64 + */ + const number::LocalizedNumberFormatter& toNumberFormatter() const; +#endif /* U_HIDE_DEPRECATED_API */ /** * Return the class ID for this class. This is useful only for @@ -1930,495 +2165,78 @@ public: * other classes have different class IDs. * @stable ICU 2.0 */ - virtual UClassID getDynamicClassID(void) const; - -private: - - DecimalFormat(); // default constructor not implemented - - int32_t precision() const; - - /** - * Initialize all fields of a new DecimalFormatter to a safe default value. - * Common code for use by constructors. - */ - void init(); - - /** - * Do real work of constructing a new DecimalFormat. - */ - void construct(UErrorCode& status, - UParseError& parseErr, - const UnicodeString* pattern = 0, - DecimalFormatSymbols* symbolsToAdopt = 0 - ); + UClassID getDynamicClassID(void) const U_OVERRIDE; - /** - * Does the real work of generating a pattern. - * - * @param result Output param which will receive the pattern. - * Previous contents are deleted. - * @param localized TRUE return localized pattern. - * @return A reference to 'result'. - */ - UnicodeString& toPattern(UnicodeString& result, UBool localized) const; +#ifndef U_HIDE_INTERNAL_API /** - * Does the real work of applying a pattern. - * @param pattern The pattern to be applied. - * @param localized If true, the pattern is localized; else false. - * @param parseError Struct to recieve information on position - * of error if an error is encountered - * @param status Output param set to success/failure code on - * exit. If the pattern is invalid, this will be - * set to a failure result. - */ - void applyPattern(const UnicodeString& pattern, - UBool localized, - UParseError& parseError, - UErrorCode& status); - - /* - * similar to applyPattern, but without re-gen affix for currency + * Set whether DecimalFormatSymbols copy in toNumberFormatter + * is deep (clone) or shallow (pointer copy). Apple + * @internal */ - void applyPatternInternally(const UnicodeString& pluralCount, - const UnicodeString& pattern, - UBool localized, - UParseError& parseError, - UErrorCode& status); + void setDFSShallowCopy(UBool shallow); - /* - * only apply pattern without expand affixes - */ - void applyPatternWithoutExpandAffix(const UnicodeString& pattern, - UBool localized, - UParseError& parseError, - UErrorCode& status); +#endif /* U_HIDE_INTERNAL_API */ +private: - /* - * expand affixes (after apply patter) and re-compute fFormatWidth - */ - void expandAffixAdjustWidth(const UnicodeString* pluralCount); + /** Rebuilds the formatter object from the property bag. */ + void touch(UErrorCode& status); + /** Rebuilds the formatter object, ignoring any error code. */ + void touchNoError(); /** - * Do the work of formatting a number, either a double or a long. + * Updates the property bag with settings from the given pattern. * - * @param appendTo Output parameter to receive result. - * Result is appended to existing contents. - * @param handler Records information about field positions. - * @param digits the digits to be formatted. - * @param isInteger if TRUE format the digits as Integer. - * @return Reference to 'appendTo' parameter. + * @param pattern The pattern string to parse. + * @param ignoreRounding Whether to leave out rounding information (minFrac, maxFrac, and rounding + * increment) when parsing the pattern. This may be desirable if a custom rounding mode, such + * as CurrencyUsage, is to be used instead. One of {@link + * PatternStringParser#IGNORE_ROUNDING_ALWAYS}, {@link PatternStringParser#IGNORE_ROUNDING_IF_CURRENCY}, + * or {@link PatternStringParser#IGNORE_ROUNDING_NEVER}. + * @see PatternAndPropertyUtils#parseToExistingProperties */ - UnicodeString& subformat(UnicodeString& appendTo, - FieldPositionHandler& handler, - DigitList& digits, - UBool isInteger, - UErrorCode &status) const; - + void setPropertiesFromPattern(const UnicodeString& pattern, int32_t ignoreRounding, + UErrorCode& status); - void parse(const UnicodeString& text, - Formattable& result, - ParsePosition& pos, - UChar* currency) const; + const numparse::impl::NumberParserImpl* getParser(UErrorCode& status) const; - enum { - fgStatusInfinite, - fgStatusLength // Leave last in list. - } StatusFlags; + const numparse::impl::NumberParserImpl* getCurrencyParser(UErrorCode& status) const; - UBool subparse(const UnicodeString& text, - const UnicodeString* negPrefix, - const UnicodeString* negSuffix, - const UnicodeString* posPrefix, - const UnicodeString* posSuffix, - UBool complexCurrencyParsing, - int8_t type, - ParsePosition& parsePosition, - DigitList& digits, UBool* status, - UChar* currency) const; + static void fieldPositionHelper(const number::FormattedNumber& formatted, FieldPosition& fieldPosition, + int32_t offset, UErrorCode& status); - // Mixed style parsing for currency. - // It parses against the current currency pattern - // using complex affix comparison - // parses against the currency plural patterns using complex affix comparison, - // and parses against the current pattern using simple affix comparison. - UBool parseForCurrency(const UnicodeString& text, - ParsePosition& parsePosition, - DigitList& digits, - UBool* status, - UChar* currency) const; + static void fieldPositionIteratorHelper(const number::FormattedNumber& formatted, + FieldPositionIterator* fpi, int32_t offset, UErrorCode& status); - int32_t skipPadding(const UnicodeString& text, int32_t position) const; + void setupFastFormat(); - int32_t compareAffix(const UnicodeString& input, - int32_t pos, - UBool isNegative, - UBool isPrefix, - const UnicodeString* affixPat, - UBool complexCurrencyParsing, - int8_t type, - UChar* currency) const; + bool fastFormatDouble(double input, UnicodeString& output) const; - static UnicodeString& trimMarksFromAffix(const UnicodeString& affix, UnicodeString& trimmedAffix); + bool fastFormatInt64(int64_t input, UnicodeString& output) const; - UBool equalWithSignCompatibility(UChar32 lhs, UChar32 rhs) const; + void doFastFormatInt32(int32_t input, bool isNegative, UnicodeString& output) const; - int32_t compareSimpleAffix(const UnicodeString& affix, - const UnicodeString& input, - int32_t pos, - UBool lenient) const; + //=====================================================================================// + // INSTANCE FIELDS // + //=====================================================================================// - static int32_t skipPatternWhiteSpace(const UnicodeString& text, int32_t pos); - static int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos); + // One instance field for the implementation, keep all fields inside of an implementation + // class defined in number_mapper.h + number::impl::DecimalFormatFields* fields = nullptr; - static int32_t skipUWhiteSpaceAndMarks(const UnicodeString& text, int32_t pos); + // Allow child class CompactDecimalFormat to access fProperties: + friend class CompactDecimalFormat; - static int32_t skipBidiMarks(const UnicodeString& text, int32_t pos); - - int32_t compareComplexAffix(const UnicodeString& affixPat, - const UnicodeString& input, - int32_t pos, - int8_t type, - UChar* currency) const; - - static int32_t match(const UnicodeString& text, int32_t pos, UChar32 ch); - - static int32_t match(const UnicodeString& text, int32_t pos, const UnicodeString& str); - - static UBool matchSymbol(const UnicodeString &text, int32_t position, int32_t length, const UnicodeString &symbol, - UnicodeSet *sset, UChar32 schar); - - static UBool matchDecimal(UChar32 symbolChar, - UBool sawDecimal, UChar32 sawDecimalChar, - const UnicodeSet *sset, UChar32 schar); - - static UBool matchGrouping(UChar32 groupingChar, - UBool sawGrouping, UChar32 sawGroupingChar, - const UnicodeSet *sset, - UChar32 decimalChar, const UnicodeSet *decimalSet, - UChar32 schar); - - /** - * Get a decimal format symbol. - * Returns a const reference to the symbol string. - * @internal - */ - inline const UnicodeString &getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol symbol) const; - - int32_t appendAffix(UnicodeString& buf, - double number, - FieldPositionHandler& handler, - UBool isNegative, - UBool isPrefix) const; - - /** - * Append an affix to the given UnicodeString, using quotes if - * there are special characters. Single quotes themselves must be - * escaped in either case. - */ - void appendAffixPattern(UnicodeString& appendTo, const UnicodeString& affix, - UBool localized) const; - - void appendAffixPattern(UnicodeString& appendTo, - const UnicodeString* affixPattern, - const UnicodeString& expAffix, UBool localized) const; - - void expandAffix(const UnicodeString& pattern, - UnicodeString& affix, - double number, - FieldPositionHandler& handler, - UBool doFormat, - const UnicodeString* pluralCount) const; - - void expandAffixes(const UnicodeString* pluralCount); - - void addPadding(UnicodeString& appendTo, - FieldPositionHandler& handler, - int32_t prefixLen, int32_t suffixLen) const; - - UBool isGroupingPosition(int32_t pos) const; - - void setCurrencyForSymbols(); - - // similar to setCurrency without re-compute the affixes for currency. - // If currency changes, the affix pattern for currency is not changed, - // but the affix will be changed. So, affixes need to be - // re-computed in setCurrency(), but not in setCurrencyInternally(). - virtual void setCurrencyInternally(const UChar* theCurrency, UErrorCode& ec); - - // set up currency affix patterns for mix parsing. - // The patterns saved here are the affix patterns of default currency - // pattern and the unique affix patterns of the plural currency patterns. - // Those patterns are used by parseForCurrency(). - void setupCurrencyAffixPatterns(UErrorCode& status); - - // set up the currency affixes used in currency plural formatting. - // It sets up both fAffixesForCurrency for currency pattern if the current - // pattern contains 3 currency signs, - // and it sets up fPluralAffixesForCurrency for currency plural patterns. - void setupCurrencyAffixes(const UnicodeString& pattern, - UBool setupForCurrentPattern, - UBool setupForPluralPattern, - UErrorCode& status); - - // hashtable operations - Hashtable* initHashForAffixPattern(UErrorCode& status); - Hashtable* initHashForAffix(UErrorCode& status); - - void deleteHashForAffixPattern(); - void deleteHashForAffix(Hashtable*& table); - - void copyHashForAffixPattern(const Hashtable* source, - Hashtable* target, UErrorCode& status); - void copyHashForAffix(const Hashtable* source, - Hashtable* target, UErrorCode& status); - - UnicodeString& _format(int64_t number, - UnicodeString& appendTo, - FieldPositionHandler& handler, - UErrorCode &status) const; - UnicodeString& _format(double number, - UnicodeString& appendTo, - FieldPositionHandler& handler, - UErrorCode &status) const; - UnicodeString& _format(const DigitList &number, - UnicodeString& appendTo, - FieldPositionHandler& handler, - UErrorCode &status) const; - - /** - * Constants. - */ - - UnicodeString fPositivePrefix; - UnicodeString fPositiveSuffix; - UnicodeString fNegativePrefix; - UnicodeString fNegativeSuffix; - UnicodeString* fPosPrefixPattern; - UnicodeString* fPosSuffixPattern; - UnicodeString* fNegPrefixPattern; - UnicodeString* fNegSuffixPattern; - - /** - * Formatter for ChoiceFormat-based currency names. If this field - * is not null, then delegate to it to format currency symbols. - * @since ICU 2.6 - */ - ChoiceFormat* fCurrencyChoice; - - DigitList * fMultiplier; // NULL for multiplier of one - int32_t fScale; - int32_t fGroupingSize; - int32_t fGroupingSize2; - UBool fDecimalSeparatorAlwaysShown; - DecimalFormatSymbols* fSymbols; - - UBool fUseSignificantDigits; - int32_t fMinSignificantDigits; - int32_t fMaxSignificantDigits; - - UBool fUseExponentialNotation; - int8_t fMinExponentDigits; - UBool fExponentSignAlwaysShown; - - EnumSet - fBoolFlags; - - DigitList* fRoundingIncrement; // NULL if no rounding increment specified. - ERoundingMode fRoundingMode; - - UChar32 fPad; - int32_t fFormatWidth; - EPadPosition fPadPosition; - - /* - * Following are used for currency format - */ - // pattern used in this formatter - UnicodeString fFormatPattern; - // style is only valid when decimal formatter is constructed by - // DecimalFormat(pattern, decimalFormatSymbol, style) - int fStyle; - /* - * Represents whether this is a currency format, and which - * currency format style. - * 0: not currency format type; - * 1: currency style -- symbol name, such as "$" for US dollar. - * 2: currency style -- ISO name, such as USD for US dollar. - * 3: currency style -- plural long name, such as "US Dollar" for - * "1.00 US Dollar", or "US Dollars" for - * "3.00 US Dollars". - */ - int fCurrencySignCount; - - - /* For currency parsing purose, - * Need to remember all prefix patterns and suffix patterns of - * every currency format pattern, - * including the pattern of default currecny style - * and plural currency style. And the patterns are set through applyPattern. - */ - // TODO: innerclass? - /* This is not needed in the class declaration, so it is moved into decimfmp.cpp - struct AffixPatternsForCurrency : public UMemory { - // negative prefix pattern - UnicodeString negPrefixPatternForCurrency; - // negative suffix pattern - UnicodeString negSuffixPatternForCurrency; - // positive prefix pattern - UnicodeString posPrefixPatternForCurrency; - // positive suffix pattern - UnicodeString posSuffixPatternForCurrency; - int8_t patternType; - - AffixPatternsForCurrency(const UnicodeString& negPrefix, - const UnicodeString& negSuffix, - const UnicodeString& posPrefix, - const UnicodeString& posSuffix, - int8_t type) { - negPrefixPatternForCurrency = negPrefix; - negSuffixPatternForCurrency = negSuffix; - posPrefixPatternForCurrency = posPrefix; - posSuffixPatternForCurrency = posSuffix; - patternType = type; - } - }; - */ - - /* affix for currency formatting when the currency sign in the pattern - * equals to 3, such as the pattern contains 3 currency sign or - * the formatter style is currency plural format style. - */ - /* This is not needed in the class declaration, so it is moved into decimfmp.cpp - struct AffixesForCurrency : public UMemory { - // negative prefix - UnicodeString negPrefixForCurrency; - // negative suffix - UnicodeString negSuffixForCurrency; - // positive prefix - UnicodeString posPrefixForCurrency; - // positive suffix - UnicodeString posSuffixForCurrency; - - int32_t formatWidth; - - AffixesForCurrency(const UnicodeString& negPrefix, - const UnicodeString& negSuffix, - const UnicodeString& posPrefix, - const UnicodeString& posSuffix) { - negPrefixForCurrency = negPrefix; - negSuffixForCurrency = negSuffix; - posPrefixForCurrency = posPrefix; - posSuffixForCurrency = posSuffix; - } - }; - */ - - // Affix pattern set for currency. - // It is a set of AffixPatternsForCurrency, - // each element of the set saves the negative prefix pattern, - // negative suffix pattern, positive prefix pattern, - // and positive suffix pattern of a pattern. - // It is used for currency mixed style parsing. - // It is actually is a set. - // The set contains the default currency pattern from the locale, - // and the currency plural patterns. - // Since it is a set, it does not contain duplicated items. - // For example, if 2 currency plural patterns are the same, only one pattern - // is included in the set. When parsing, we do not check whether the plural - // count match or not. - Hashtable* fAffixPatternsForCurrency; - - // Following 2 are affixes for currency. - // It is a hash map from plural count to AffixesForCurrency. - // AffixesForCurrency saves the negative prefix, - // negative suffix, positive prefix, and positive suffix of a pattern. - // It is used during currency formatting only when the currency sign count - // is 3. In which case, the affixes are getting from here, not - // from the fNegativePrefix etc. - Hashtable* fAffixesForCurrency; // for current pattern - Hashtable* fPluralAffixesForCurrency; // for plural pattern - - // Information needed for DecimalFormat to format/parse currency plural. - CurrencyPluralInfo* fCurrencyPluralInfo; + // Allow MeasureFormat to use fieldPositionHelper: + friend class MeasureFormat; -#if UCONFIG_HAVE_PARSEALLINPUT - UNumberFormatAttributeValue fParseAllInput; -#endif - - // Decimal Format Static Sets singleton. - const DecimalFormatStaticSets *fStaticSets; - - -protected: - -#ifndef U_HIDE_INTERNAL_API - /** - * Rounds a value according to the rules of this object. - * @internal - */ - DigitList& _round(const DigitList& number, DigitList& adjustedNum, UBool& isNegative, UErrorCode& status) const; -#endif /* U_HIDE_INTERNAL_API */ - - /** - * Returns the currency in effect for this formatter. Subclasses - * should override this method as needed. Unlike getCurrency(), - * this method should never return "". - * @result output parameter for null-terminated result, which must - * have a capacity of at least 4 - * @internal - */ - virtual void getEffectiveCurrency(UChar* result, UErrorCode& ec) const; - - /** number of integer digits - * @stable ICU 2.4 - */ - static const int32_t kDoubleIntegerDigits; - /** number of fraction digits - * @stable ICU 2.4 - */ - static const int32_t kDoubleFractionDigits; - - /** - * When someone turns on scientific mode, we assume that more than this - * number of digits is due to flipping from some other mode that didn't - * restrict the maximum, and so we force 1 integer digit. We don't bother - * to track and see if someone is using exponential notation with more than - * this number, it wouldn't make sense anyway, and this is just to make sure - * that someone turning on scientific mode with default settings doesn't - * end up with lots of zeroes. - * @stable ICU 2.8 - */ - static const int32_t kMaxScientificIntegerDigits; - -#if UCONFIG_FORMAT_FASTPATHS_49 - private: - /** - * Internal state. - * @internal - */ - uint8_t fReserved[UNUM_DECIMALFORMAT_INTERNAL_SIZE]; - - - /** - * Called whenever any state changes. Recomputes whether fastpath is OK to use. - */ - void handleChanged(); -#endif }; -inline const UnicodeString & -DecimalFormat::getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol symbol) const { - return fSymbols->getConstSymbol(symbol); -} - U_NAMESPACE_END +#endif // U_SHOW_CPLUSPLUS_API #endif /* #if !UCONFIG_NO_FORMATTING */