X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/374ca955a76ecab1204ca8bfa63ff9238d998416..c5116b9f5a666b9d59f443b3770acd6ef64dc6c3:/icuSources/i18n/unicode/decimfmt.h diff --git a/icuSources/i18n/unicode/decimfmt.h b/icuSources/i18n/unicode/decimfmt.h index 4fe6d32c..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-2004, International Business Machines +* Copyright (C) 1997-2016, International Business Machines * Corporation and others. All Rights Reserved. ******************************************************************************** * @@ -17,52 +19,81 @@ * 07/10/97 helena Made ParsePosition a class and get rid of the function * hiding problems. * 09/09/97 aliu Ported over support for exponential formats. -* 07/20/98 stephen Changed documentation +* 07/20/98 stephen Changed documentation +* 01/30/13 emmons Added Scaling methods ******************************************************************************** */ - + #ifndef DECIMFMT_H #define DECIMFMT_H - + #include "unicode/utypes.h" +/** + * \file + * \brief C++ API: Compatibility APIs for decimal formatting. + */ #if !UCONFIG_NO_FORMATTING #include "unicode/dcfmtsym.h" #include "unicode/numfmt.h" #include "unicode/locid.h" +#include "unicode/fpositer.h" +#include "unicode/stringpiece.h" +#include "unicode/curramt.h" +#include "unicode/enumset.h" +#if U_SHOW_CPLUSPLUS_API U_NAMESPACE_BEGIN -class DigitList; -class ChoiceFormat; +class CurrencyPluralInfo; +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 * Indic digits. It also supports different flavors of numbers, including * integers ("123"), fixed-point numbers ("123.4"), scientific notation - * ("1.23E4"), percentages ("12%"), and currency amounts ("$123"). All of these - * flavors can be easily localized. + * ("1.23E4"), percentages ("12%"), and currency amounts ("$123", "USD123", + * "123 US dollars"). All of these flavors can be easily localized. * - *
To 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 * int32_t locCount; * const Locale* locales = NumberFormat::getAvailableLocales(locCount); - * + * * double myNumber = -1234.56; * UErrorCode success = U_ZERO_ERROR; * NumberFormat* form; - * + * * // Print out a number with the localized number, currency and percent * // format for each locale. * UnicodeString countryName; @@ -91,12 +122,35 @@ class ChoiceFormat; * cout << locales[i].getDisplayName(displayName) << ": " << pattern; * cout << " -> " << form->format(myNumber,str) << endl; * form->parse(form->format(myNumber,str), fmtable, success); - * delete form; + * delete form; * } * } * } * \endcode * + * **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"); + * double myNumber = 1234.56; + * UErrorCode success = U_ZERO_ERROR; + * UnicodeString str; + * Formattable fmtable; + * for (int j=NumberFormat::kNumberStyle; + * j<=NumberFormat::kPluralCurrencyStyle; + * ++j) { + * NumberFormat* form = NumberFormat::createInstance(locale, j, success); + * str.remove(); + * cout << "format result " << form->format(myNumber, str) << endl; + * format->parse(form->format(myNumber, str), fmtable, success); + * delete form; + * } + * \endcode + * + * *
Patterns * *
A DecimalFormat consists of a pattern and a set of @@ -106,7 +160,7 @@ class ChoiceFormat; * digits. The symbols are stored in a DecimalFormatSymbols * object. When using the NumberFormat factory methods, the * pattern and symbols are read from ICU's locale data. - * + * *
Special Pattern Characters * *
Many characters in a pattern are taken literally; they are matched during @@ -204,6 +258,8 @@ class ChoiceFormat; *
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 @@ -284,7 +340,7 @@ class ChoiceFormat; * * The first subpattern is for positive numbers. The second (optional) * subpattern is for negative numbers. - * + * *
Not indicated in the BNF syntax above: * *
padSpec
may appear before the prefix,
* after the prefix, before the suffix, after the suffix, or not at all.
*
@@ -318,6 +374,12 @@ class ChoiceFormat;
*
* During parsing, grouping separators are ignored. * + *
For currency parsing, the formatter is able to parse every currency + * style formats no matter which style the formatter is constructed with. + * For example, a formatter instance gotten from + * NumberFormat.getInstance(ULocale, NumberFormat.CURRENCYSTYLE) can parse + * formats such as "USD1.00" and "3.00 US dollars". + * *
If parse(UnicodeString&,Formattable&,ParsePosition&) * fails to parse a string, it leaves the parse position unchanged. * The convenience method parse(UnicodeString&,Formattable&,UErrorCode&) @@ -342,14 +404,14 @@ class ChoiceFormat; * is set to 5. * *
getMaximumSignificantDigits() - 1
. For example, the
* pattern "@@###E0"
is equivalent to "0.0###E0"
.
*
- * "* #0 o''clock"
, the format width is 10.
*
- * In the absence of an explicit rounding increment numbers are + * rounded to their formatted width. + * *
+ * 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 @@ -651,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. @@ -669,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 @@ -677,9 +730,95 @@ 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. + * + * @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 style style of decimal format + * @param status Output param set to success/failure code. If the + * pattern is invalid this will be set to a failure code. + * @internal + */ + 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 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); + + /** + * Get an integer + * May return U_UNSUPPORTED_ERROR if this instance does not support + * the specified attribute. + * @param attr the attribute to set + * @param status the error type + * @return the attribute value. Undefined if there is an error. + * @stable ICU 51 + */ + 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 + * @stable ICU 53 + */ + 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 + * @stable ICU 53 + */ + void setParseIntegerOnly(UBool value) U_OVERRIDE; + + /** + * 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 + */ + void setLenient(UBool enable) U_OVERRIDE; /** * Create a DecimalFormat from the given pattern and symbols. @@ -691,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 @@ -714,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 @@ -721,13 +865,11 @@ 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. - * + * * @param source the DecimalFormat object to be copied from. * @stable ICU 2.0 */ @@ -745,7 +887,7 @@ public: * Destructor. * @stable ICU 2.0 */ - virtual ~DecimalFormat(); + ~DecimalFormat() U_OVERRIDE; /** * Clone this Format object polymorphically. The caller owns the @@ -754,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. @@ -764,7 +906,10 @@ 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; /** * Format a double or long number using base-10 representation. @@ -776,26 +921,44 @@ public: * On output: the offsets of the alignment field. * @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 long number using base-10 representation. + * Format a double or long number using base-10 representation. * * @param number The value to be formatted. * @param appendTo Output parameter to receive result. * 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 * @return Reference to 'appendTo' parameter. - * @stable ICU 2.0 + * @internal */ - virtual UnicodeString& format(int32_t number, - UnicodeString& appendTo, - FieldPosition& pos) const; + UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos, + UErrorCode& status) const U_OVERRIDE; +#endif /* U_HIDE_INTERNAL_API */ + /** - * Format an int64 number using base-10 representation. + * Format a double or long number using base-10 representation. + * + * @param number The value to be formatted. + * @param appendTo Output parameter to receive result. + * Result is appended to existing contents. + * @param posIter On return, can be used to iterate over positions + * of fields generated by this format call. + * Can be NULL. + * @param status Output param filled with success/failure status. + * @return Reference to 'appendTo' parameter. + * @stable ICU 4.4 + */ + UnicodeString& format(double number, UnicodeString& appendTo, FieldPositionIterator* posIter, + UErrorCode& status) const U_OVERRIDE; + + /** + * Format a long number using base-10 representation. * * @param number The value to be formatted. * @param appendTo Output parameter to receive result. @@ -803,119 +966,171 @@ public: * @param pos On input: an alignment field, if desired. * On output: the offsets of the alignment field. * @return Reference to 'appendTo' parameter. - * @draft ICU 2.8 + * @stable ICU 2.0 */ - virtual UnicodeString& format(int64_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 Formattable using base-10 representation. + * Format a long number using base-10 representation. * - * @param obj The value to be formatted. + * @param number The value to be formatted. * @param appendTo Output parameter to receive result. * 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 Error code indicating success or failure. + * @param status Output param filled with success/failure status. * @return Reference to 'appendTo' parameter. - * @stable ICU 2.0 + * @internal */ - virtual UnicodeString& format(const Formattable& obj, - 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 */ /** - * Redeclared NumberFormat method. - * Formats an object to produce a string. + * Format a long number using base-10 representation. * - * @param obj The object to format. + * @param number The value to be formatted. * @param appendTo Output parameter to receive result. * Result is appended to existing contents. - * @param status Output parameter filled in with success or failure status. + * @param posIter On return, can be used to iterate over positions + * of fields generated by this format call. + * Can be NULL. + * @param status Output param filled with success/failure status. * @return Reference to 'appendTo' parameter. - * @stable ICU 2.0 + * @stable ICU 4.4 */ - UnicodeString& format(const Formattable& obj, - UnicodeString& appendTo, - UErrorCode& status) const; + UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPositionIterator* posIter, + UErrorCode& status) const U_OVERRIDE; /** - * Redeclared NumberFormat method. - * Format a double number. + * Format an int64 number using base-10 representation. * * @param number The value to be formatted. * @param appendTo Output parameter to receive result. * Result is appended to existing contents. + * @param pos On input: an alignment field, if desired. + * On output: the offsets of the alignment field. * @return Reference to 'appendTo' parameter. - * @stable ICU 2.0 + * @stable ICU 2.8 */ - UnicodeString& format(double number, - UnicodeString& appendTo) const; + UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE; +#ifndef U_HIDE_INTERNAL_API /** - * Redeclared NumberFormat method. - * Format a long number. These methods call the NumberFormat - * pure virtual format() methods with the default FieldPosition. + * Format an int64 number using base-10 representation. * * @param number The value to be formatted. * @param appendTo Output parameter to receive result. * 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. - * @stable ICU 2.0 + * @internal */ - UnicodeString& format(int32_t number, - UnicodeString& appendTo) const; + UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos, + UErrorCode& status) const U_OVERRIDE; +#endif /* U_HIDE_INTERNAL_API */ /** - * Redeclared NumberFormat method. - * Format an int64 number. These methods call the NumberFormat - * pure virtual format() methods with the default FieldPosition. + * Format an int64 number using base-10 representation. * * @param number The value to be formatted. * @param appendTo Output parameter to receive result. * Result is appended to existing contents. + * @param posIter On return, can be used to iterate over positions + * of fields generated by this format call. + * Can be NULL. + * @param status Output param filled with success/failure status. + * @return Reference to 'appendTo' parameter. + * @stable ICU 4.4 + */ + UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPositionIterator* posIter, + UErrorCode& status) const U_OVERRIDE; + + /** + * Format a decimal number. + * The syntax of the unformatted number is a "numeric string" + * as defined in the Decimal Arithmetic Specification, available at + * http://speleotrove.com/decimal + * + * @param number The unformatted number, as a string. + * @param appendTo Output parameter to receive result. + * Result is appended to existing contents. + * @param posIter On return, can be used to iterate over positions + * of fields generated by this format call. + * Can be NULL. + * @param status Output param filled with success/failure status. + * @return Reference to 'appendTo' parameter. + * @stable ICU 4.4 + */ + 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 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 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 + * of fields generated by this format call. + * @param status Output param filled with success/failure status. * @return Reference to 'appendTo' parameter. - * @draft ICU 2.8 - */ - UnicodeString& format(int64_t number, - UnicodeString& appendTo) const; - /** - * 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; - - // Declare here again to get rid of function hiding problems. - /** - * Parse the given string using this object's choices. + * @internal + */ + UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo, + FieldPositionIterator* posIter, UErrorCode& status) const U_OVERRIDE; + + /** + * Format a 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 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. + * On output: the offsets of the alignment field. + * @param status Output param filled with success/failure status. + * @return Reference to 'appendTo' parameter. + * @internal + */ + 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. - * @param status Output parameter filled in with success or failure status. + * 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, - UErrorCode& status) const; + void parse(const UnicodeString& text, Formattable& result, + ParsePosition& parsePosition) const U_OVERRIDE; /** * Parses text from the given string as a currency amount. Unlike @@ -927,18 +1142,16 @@ public: * (U+00A4) in its prefix or suffix. * * @param text the string to parse - * @param result output parameter to receive result. This will have - * its currency set to the parsed ISO currency code. - * @param pos input-output position; on input, the position within - * text to match; must have 0 <= pos.getIndex() < text.length(); - * on output, the position after the last matched character. If - * the parse fails, the position in unchanged upon output. - * @return a reference to result - * @internal + * @param pos input-output position; on input, the position within text + * to match; must have 0 <= pos.getIndex() < text.length(); + * on output, the position after the last matched character. + * If the parse fails, the position in unchanged upon output. + * @return if parse succeeds, a pointer to a newly-created CurrencyAmount + * object (owned by the caller) containing information about + * the parsed currency; if parse fails, this is NULL. + * @stable ICU 49 */ - virtual Formattable& parseCurrency(const UnicodeString& text, - Formattable& result, - ParsePosition& pos) const; + CurrencyAmount* parseCurrency(const UnicodeString& text, ParsePosition& pos) const U_OVERRIDE; /** * Returns the decimal format symbols, which is generally not changed @@ -966,6 +1179,31 @@ public: virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols); + /** + * Returns the currency plural format information, + * which is generally not changed by the programmer or user. + * @return desired CurrencyPluralInfo + * @stable ICU 4.2 + */ + virtual const CurrencyPluralInfo* getCurrencyPluralInfo(void) const; + + /** + * Sets the currency plural format information, + * which is generally not changed by the programmer or user. + * @param toAdopt CurrencyPluralInfo to be adopted. + * @stable ICU 4.2 + */ + virtual void adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt); + + /** + * Sets the currency plural format information, + * which is generally not changed by the programmer or user. + * @param info Currency Plural Info. + * @stable ICU 4.2 + */ + virtual void setCurrencyPluralInfo(const CurrencyPluralInfo& info); + + /** * Get the positive prefix. * @@ -1042,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 @@ -1060,16 +1322,56 @@ 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 rounding - * is not in effect. + * @return A positive rounding increment, or 0.0 if a custom rounding + * increment is not in effect. * @see #setRoundingIncrement * @see #getRoundingMode * @see #setRoundingMode @@ -1078,9 +1380,10 @@ public: virtual double getRoundingIncrement(void) const; /** - * Set the rounding increment. This method also controls whether - * rounding is enabled. - * @param newValue A positive rounding increment, or 0.0 to disable rounding. + * Set the rounding increment. In the absence of a rounding increment, + * numbers will be rounded to the number of digits displayed. + * @param newValue A positive rounding increment, or 0.0 to + * use the default rounding increment. * Negative increments are equivalent to 0.0. * @see #getRoundingIncrement * @see #getRoundingMode @@ -1097,25 +1400,24 @@ public: * @see #setRoundingMode * @stable ICU 2.0 */ - virtual ERoundingMode getRoundingMode(void) const; + virtual ERoundingMode getRoundingMode(void) const U_OVERRIDE; /** - * Set the rounding mode. This has no effect unless the rounding - * increment is greater than zero. + * Set the rounding mode. * @param roundingMode A rounding mode * @see #setRoundingIncrement * @see #getRoundingIncrement * @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. * The width is counted in 16-bit code units. * @return the format width, or zero if no padding is in effect * @see #setFormatWidth - * @see #getPadCharacter + * @see #getPadCharacterString * @see #setPadCharacter * @see #getPadPosition * @see #setPadPosition @@ -1131,7 +1433,7 @@ public: * format(), or zero to disable padding. A negative * width is equivalent to 0. * @see #getFormatWidth - * @see #getPadCharacter + * @see #getPadCharacterString * @see #setPadCharacter * @see #getPadPosition * @see #setPadPosition @@ -1157,17 +1459,17 @@ 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 - * @see #getPadCharacter + * @see #getPadCharacterString * @see #getPadPosition * @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 @@ -1179,12 +1481,9 @@ public: * @see #setFormatWidth * @see #getFormatWidth * @see #setPadCharacter - * @see #getPadCharacter + * @see #getPadCharacterString * @see #setPadPosition - * @see #kPadBeforePrefix - * @see #kPadAfterPrefix - * @see #kPadBeforeSuffix - * @see #kPadAfterSuffix + * @see #EPadPosition * @stable ICU 2.0 */ virtual EPadPosition getPadPosition(void) const; @@ -1200,12 +1499,9 @@ public: * @see #setFormatWidth * @see #getFormatWidth * @see #setPadCharacter - * @see #getPadCharacter + * @see #getPadCharacterString * @see #getPadPosition - * @see #kPadBeforePrefix - * @see #kPadAfterPrefix - * @see #kPadBeforeSuffix - * @see #kPadAfterSuffix + * @see #EPadPosition * @stable ICU 2.0 */ virtual void setPadPosition(EPadPosition padPos); @@ -1220,7 +1516,7 @@ public: * @see #setExponentSignAlwaysShown * @stable ICU 2.0 */ - virtual UBool isScientificNotation(void); + virtual UBool isScientificNotation(void) const; /** * Set whether or not scientific notation is used. When scientific notation @@ -1277,7 +1573,7 @@ public: * @see #setExponentSignAlwaysShown * @stable ICU 2.0 */ - virtual UBool isExponentSignAlwaysShown(void); + virtual UBool isExponentSignAlwaysShown(void) const; /** * Set whether the exponent sign is always shown. This has no effect @@ -1353,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.) @@ -1373,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. @@ -1396,7 +1814,7 @@ public: * @stable ICU 2.0 */ virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const; - + /** * Apply the given pattern to this Format object. A pattern is a * short-hand specification for the various formatting properties. @@ -1419,16 +1837,15 @@ public: * these are presumed to be set in the positive pattern. * * @param pattern The pattern to be applied. - * @param parseError Struct to recieve information on position + * @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. * @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. @@ -1436,9 +1853,8 @@ public: * exit. If the pattern is invalid, this will be * 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 @@ -1463,15 +1879,14 @@ public: * these are presumed to be set in the positive pattern. * * @param pattern The localized pattern to be applied. - * @param parseError Struct to recieve information on position + * @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. * @stable ICU 2.0 */ - virtual void applyLocalizedPattern(const UnicodeString& pattern, - UParseError& parseError, + virtual void applyLocalizedPattern(const UnicodeString& pattern, UParseError& parseError, UErrorCode& status); /** @@ -1483,60 +1898,59 @@ 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); /** * Sets the maximum number of digits allowed in the integer portion of a * number. This override limits the integer digit count to 309. * - * @param newValue the new value of the maximum number of digits + * @param newValue the new value of the maximum number of digits * allowed in the integer portion of a number. * @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 * number. This override limits the integer digit count to 309. - * - * @param newValue the new value of the minimum number of digits + * + * @param newValue the new value of the minimum number of digits * allowed in the integer portion of a number. * @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 * number. This override limits the fraction digit count to 340. * - * @param newValue the new value of the maximum number of digits + * @param newValue the new value of the maximum number of digits * allowed in the fraction portion of a number. * @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 * number. This override limits the fraction digit count to 340. * - * @param newValue the new value of the minimum number of digits + * @param newValue the new value of the minimum number of digits * allowed in the fraction portion of a number. * @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 * displayed. This value has no effect unless areSignificantDigitsUsed() * returns true. * @return the fewest significant digits that will be shown - * @draft ICU 3.0 + * @stable ICU 3.0 */ int32_t getMinimumSignificantDigits() const; @@ -1545,7 +1959,7 @@ public: * displayed. This value has no effect unless areSignificantDigitsUsed() * returns true. * @return the most significant digits that will be shown - * @draft ICU 3.0 + * @stable ICU 3.0 */ int32_t getMaximumSignificantDigits() const; @@ -1553,10 +1967,12 @@ public: * Sets the minimum number of significant digits that will be * displayed. If
min
is less than one then it is set
* to one. If the maximum significant digits count is less than
- * min
, then it is set to min
. This
- * value has no effect unless areSignificantDigits() returns true.
- * @param min the fewest significant digits to be shown
- * @draft ICU 3.0
+ * min
, then it is set to min
.
+ * This function also enables the use of significant digits
+ * by this formatter - areSignificantDigitsUsed() will return TRUE.
+ * @see #areSignificantDigitsUsed
+ * @param min the fewest significant digits to be shown
+ * @stable ICU 3.0
*/
void setMinimumSignificantDigits(int32_t min);
@@ -1565,10 +1981,11 @@ public:
* displayed. If max
is less than one then it is set
* to one. If the minimum significant digits count is greater
* than max
, then it is set to max
.
- * This value has no effect unless areSignificantDigits() returns
- * true.
- * @param max the most significant digits to be shown
- * @draft ICU 3.0
+ * This function also enables the use of significant digits
+ * by this formatter - areSignificantDigitsUsed() will return TRUE.
+ * @see #areSignificantDigitsUsed
+ * @param max the most significant digits to be shown
+ * @stable ICU 3.0
*/
void setMaximumSignificantDigits(int32_t max);
@@ -1576,7 +1993,7 @@ public:
* Returns true if significant digits are in use, or false if
* integer and fraction digit counts are in use.
* @return true if significant digits are in use
- * @draft ICU 3.0
+ * @stable ICU 3.0
*/
UBool areSignificantDigitsUsed() const;
@@ -1585,11 +2002,22 @@ public:
* fraction digit counts are in use.
* @param useSignificantDigits true to use significant digits, or
* false to use integer and fraction digit counts
- * @draft ICU 3.0
+ * @stable ICU 3.0
*/
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
@@ -1600,25 +2028,118 @@ public:
* to use. It need not be null-terminated. May be the empty
* string or NULL to indicate no currency.
* @param ec input-output error code
- * @draft ICU 3.0
+ * @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.
- * @stable ICU 2.0
+ * 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
+ */
+ void setCurrencyUsage(UCurrencyUsage newUsage, UErrorCode* ec);
+
+ /**
+ * Returns the `Currency Usage` object used to display currency
+ * @stable ICU 54
*/
- static const char fgNumberPatterns[];
+ UCurrencyUsage getCurrencyUsage() const;
-public:
+#ifndef U_HIDE_INTERNAL_API
+
+ /**
+ * Format a number and save it into the given DecimalQuantity.
+ * Internal, not intended for public use.
+ * @internal
+ */
+ void formatToDecimalQuantity(double number, number::impl::DecimalQuantity& output,
+ UErrorCode& status) const;
+
+ /**
+ * Get a DecimalQuantity corresponding to a formattable as it would be
+ * formatted by this DecimalFormat.
+ * Internal, not intended for public use.
+ * @internal
+ */
+ void formatToDecimalQuantity(const Formattable& number, number::impl::DecimalQuantity& output,
+ UErrorCode& status) const;
+
+#endif /* U_HIDE_INTERNAL_API */
+
+#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 @@ -1644,255 +2165,78 @@ public: * other classes have different class IDs. * @stable ICU 2.0 */ - virtual UClassID getDynamicClassID(void) const; + UClassID getDynamicClassID(void) const U_OVERRIDE; -private: - DecimalFormat(); // default constructor not implemented - - int32_t precision(UBool isIntegral) const; - - /** - * Do real work of constructing a new DecimalFormat. - */ - void construct(UErrorCode& status, - UParseError& parseErr, - const UnicodeString* pattern = 0, - DecimalFormatSymbols* symbolsToAdopt = 0 - ); +#ifndef U_HIDE_INTERNAL_API /** - * 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; - - /** - * 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); - /** - * Do the work of formatting a number, either a double or a long. - * - * @param appendTo Output parameter to receive result. - * Result is appended to existing contents. - * @param fieldPosition On input: an alignment field, if desired. - * On output: the offsets of the alignment field. - * @param digits the digits to be formatted. - * @param isInteger if TRUE format the digits as Integer. - * @return Reference to 'appendTo' parameter. - */ - UnicodeString& subformat(UnicodeString& appendTo, - FieldPosition& fieldPosition, - DigitList& digits, - UBool isInteger) const; - - void parse(const UnicodeString& text, - Formattable& result, - ParsePosition& pos, - UBool parseCurrency) const; - - enum { - fgStatusInfinite, - fgStatusLength // Leave last in list. - } StatusFlags; - - UBool subparse(const UnicodeString& text, ParsePosition& parsePosition, - DigitList& digits, UBool* status, - UChar* currency) const; - - int32_t skipPadding(const UnicodeString& text, int32_t position) const; - - int32_t compareAffix(const UnicodeString& input, - int32_t pos, - UBool isNegative, - UBool isPrefix, - UChar* currency) const; - - static int32_t compareSimpleAffix(const UnicodeString& affix, - const UnicodeString& input, - int32_t pos); - - static int32_t skipRuleWhiteSpace(const UnicodeString& text, int32_t pos); - - static int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos); - - int32_t compareComplexAffix(const UnicodeString& affixPat, - const UnicodeString& input, - int32_t pos, - 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); - - /** - * Get a decimal format symbol. - * Returns a const reference to the symbol string. + * Set whether DecimalFormatSymbols copy in toNumberFormatter + * is deep (clone) or shallow (pointer copy). Apple