Remove copy of ICU headers from WebKit
[WebKit-https.git] / Source / WTF / icu / unicode / decimfmt.h
1 /*
2 ********************************************************************************
3 *   Copyright (C) 1997-2015, International Business Machines
4 *   Corporation and others.  All Rights Reserved.
5 ********************************************************************************
6 *
7 * File DECIMFMT.H
8 *
9 * Modification History:
10 *
11 *   Date        Name        Description
12 *   02/19/97    aliu        Converted from java.
13 *   03/20/97    clhuang     Updated per C++ implementation.
14 *   04/03/97    aliu        Rewrote parsing and formatting completely, and
15 *                           cleaned up and debugged.  Actually works now.
16 *   04/17/97    aliu        Changed DigitCount to int per code review.
17 *   07/10/97    helena      Made ParsePosition a class and get rid of the function
18 *                           hiding problems.
19 *   09/09/97    aliu        Ported over support for exponential formats.
20 *   07/20/98    stephen     Changed documentation
21 *   01/30/13    emmons      Added Scaling methods
22 ********************************************************************************
23 */
24
25 #ifndef DECIMFMT_H
26 #define DECIMFMT_H
27
28 #include "unicode/utypes.h"
29 /**
30  * \file
31  * \brief C++ API: Formats decimal numbers.
32  */
33
34 #if !UCONFIG_NO_FORMATTING
35
36 #include "unicode/dcfmtsym.h"
37 #include "unicode/numfmt.h"
38 #include "unicode/locid.h"
39 #include "unicode/fpositer.h"
40 #include "unicode/stringpiece.h"
41 #include "unicode/curramt.h"
42 #include "unicode/enumset.h"
43
44 /**
45  * \def UNUM_DECIMALFORMAT_INTERNAL_SIZE
46  * @internal
47  */
48 #if UCONFIG_FORMAT_FASTPATHS_49
49 #define UNUM_DECIMALFORMAT_INTERNAL_SIZE 16
50 #endif
51
52 U_NAMESPACE_BEGIN
53
54 class DigitList;
55 class ChoiceFormat;
56 class CurrencyPluralInfo;
57 class Hashtable;
58 class UnicodeSet;
59 class FieldPositionHandler;
60 class DecimalFormatStaticSets;
61 class FixedDecimal;
62
63 // explicit template instantiation. see digitlst.h
64 #if defined (_MSC_VER)
65 template class U_I18N_API    EnumSet<UNumberFormatAttribute,
66             UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
67             UNUM_LIMIT_BOOLEAN_ATTRIBUTE>;
68 #endif
69
70 /**
71  * DecimalFormat is a concrete subclass of NumberFormat that formats decimal
72  * numbers. It has a variety of features designed to make it possible to parse
73  * and format numbers in any locale, including support for Western, Arabic, or
74  * Indic digits.  It also supports different flavors of numbers, including
75  * integers ("123"), fixed-point numbers ("123.4"), scientific notation
76  * ("1.23E4"), percentages ("12%"), and currency amounts ("$123", "USD123",
77  * "123 US dollars").  All of these flavors can be easily localized.
78  *
79  * <p>To obtain a NumberFormat for a specific locale (including the default
80  * locale) call one of NumberFormat's factory methods such as
81  * createInstance(). Do not call the DecimalFormat constructors directly, unless
82  * you know what you are doing, since the NumberFormat factory methods may
83  * return subclasses other than DecimalFormat.
84  *
85  * <p><strong>Example Usage</strong>
86  *
87  * \code
88  *     // Normally we would have a GUI with a menu for this
89  *     int32_t locCount;
90  *     const Locale* locales = NumberFormat::getAvailableLocales(locCount);
91  *
92  *     double myNumber = -1234.56;
93  *     UErrorCode success = U_ZERO_ERROR;
94  *     NumberFormat* form;
95  *
96  *     // Print out a number with the localized number, currency and percent
97  *     // format for each locale.
98  *     UnicodeString countryName;
99  *     UnicodeString displayName;
100  *     UnicodeString str;
101  *     UnicodeString pattern;
102  *     Formattable fmtable;
103  *     for (int32_t j = 0; j < 3; ++j) {
104  *         cout << endl << "FORMAT " << j << endl;
105  *         for (int32_t i = 0; i < locCount; ++i) {
106  *             if (locales[i].getCountry(countryName).size() == 0) {
107  *                 // skip language-only
108  *                 continue;
109  *             }
110  *             switch (j) {
111  *             case 0:
112  *                 form = NumberFormat::createInstance(locales[i], success ); break;
113  *             case 1:
114  *                 form = NumberFormat::createCurrencyInstance(locales[i], success ); break;
115  *             default:
116  *                 form = NumberFormat::createPercentInstance(locales[i], success ); break;
117  *             }
118  *             if (form) {
119  *                 str.remove();
120  *                 pattern = ((DecimalFormat*)form)->toPattern(pattern);
121  *                 cout << locales[i].getDisplayName(displayName) << ": " << pattern;
122  *                 cout << "  ->  " << form->format(myNumber,str) << endl;
123  *                 form->parse(form->format(myNumber,str), fmtable, success);
124  *                 delete form;
125  *             }
126  *         }
127  *     }
128  * \endcode
129  * <P>
130  * Another example use createInstance(style)
131  * <P>
132  * <pre>
133  * <strong>// Print out a number using the localized number, currency,
134  * // percent, scientific, integer, iso currency, and plural currency
135  * // format for each locale</strong>
136  * Locale* locale = new Locale("en", "US");
137  * double myNumber = 1234.56;
138  * UErrorCode success = U_ZERO_ERROR;
139  * UnicodeString str;
140  * Formattable fmtable;
141  * for (int j=NumberFormat::kNumberStyle;
142  *      j<=NumberFormat::kPluralCurrencyStyle;
143  *      ++j) {
144  *     NumberFormat* format = NumberFormat::createInstance(locale, j, success);
145  *     str.remove();
146  *     cout << "format result " << form->format(myNumber, str) << endl;
147  *     format->parse(form->format(myNumber, str), fmtable, success);
148  * }</pre>
149  *
150  *
151  * <p><strong>Patterns</strong>
152  *
153  * <p>A DecimalFormat consists of a <em>pattern</em> and a set of
154  * <em>symbols</em>.  The pattern may be set directly using
155  * applyPattern(), or indirectly using other API methods which
156  * manipulate aspects of the pattern, such as the minimum number of integer
157  * digits.  The symbols are stored in a DecimalFormatSymbols
158  * object.  When using the NumberFormat factory methods, the
159  * pattern and symbols are read from ICU's locale data.
160  *
161  * <p><strong>Special Pattern Characters</strong>
162  *
163  * <p>Many characters in a pattern are taken literally; they are matched during
164  * parsing and output unchanged during formatting.  Special characters, on the
165  * other hand, stand for other characters, strings, or classes of characters.
166  * For example, the '#' character is replaced by a localized digit.  Often the
167  * replacement character is the same as the pattern character; in the U.S. locale,
168  * the ',' grouping character is replaced by ','.  However, the replacement is
169  * still happening, and if the symbols are modified, the grouping character
170  * changes.  Some special characters affect the behavior of the formatter by
171  * their presence; for example, if the percent character is seen, then the
172  * value is multiplied by 100 before being displayed.
173  *
174  * <p>To insert a special character in a pattern as a literal, that is, without
175  * any special meaning, the character must be quoted.  There are some exceptions to
176  * this which are noted below.
177  *
178  * <p>The characters listed here are used in non-localized patterns.  Localized
179  * patterns use the corresponding characters taken from this formatter's
180  * DecimalFormatSymbols object instead, and these characters lose
181  * their special status.  Two exceptions are the currency sign and quote, which
182  * are not localized.
183  *
184  * <table border=0 cellspacing=3 cellpadding=0>
185  *   <tr bgcolor="#ccccff">
186  *     <td align=left><strong>Symbol</strong>
187  *     <td align=left><strong>Location</strong>
188  *     <td align=left><strong>Localized?</strong>
189  *     <td align=left><strong>Meaning</strong>
190  *   <tr valign=top>
191  *     <td><code>0</code>
192  *     <td>Number
193  *     <td>Yes
194  *     <td>Digit
195  *   <tr valign=top bgcolor="#eeeeff">
196  *     <td><code>1-9</code>
197  *     <td>Number
198  *     <td>Yes
199  *     <td>'1' through '9' indicate rounding.
200  *   <tr valign=top>
201  *     <td><code>\htmlonly&#x40;\endhtmlonly</code> <!--doxygen doesn't like @-->
202  *     <td>Number
203  *     <td>No
204  *     <td>Significant digit
205  *   <tr valign=top bgcolor="#eeeeff">
206  *     <td><code>#</code>
207  *     <td>Number
208  *     <td>Yes
209  *     <td>Digit, zero shows as absent
210  *   <tr valign=top>
211  *     <td><code>.</code>
212  *     <td>Number
213  *     <td>Yes
214  *     <td>Decimal separator or monetary decimal separator
215  *   <tr valign=top bgcolor="#eeeeff">
216  *     <td><code>-</code>
217  *     <td>Number
218  *     <td>Yes
219  *     <td>Minus sign
220  *   <tr valign=top>
221  *     <td><code>,</code>
222  *     <td>Number
223  *     <td>Yes
224  *     <td>Grouping separator
225  *   <tr valign=top bgcolor="#eeeeff">
226  *     <td><code>E</code>
227  *     <td>Number
228  *     <td>Yes
229  *     <td>Separates mantissa and exponent in scientific notation.
230  *         <em>Need not be quoted in prefix or suffix.</em>
231  *   <tr valign=top>
232  *     <td><code>+</code>
233  *     <td>Exponent
234  *     <td>Yes
235  *     <td>Prefix positive exponents with localized plus sign.
236  *         <em>Need not be quoted in prefix or suffix.</em>
237  *   <tr valign=top bgcolor="#eeeeff">
238  *     <td><code>;</code>
239  *     <td>Subpattern boundary
240  *     <td>Yes
241  *     <td>Separates positive and negative subpatterns
242  *   <tr valign=top>
243  *     <td><code>\%</code>
244  *     <td>Prefix or suffix
245  *     <td>Yes
246  *     <td>Multiply by 100 and show as percentage
247  *   <tr valign=top bgcolor="#eeeeff">
248  *     <td><code>\\u2030</code>
249  *     <td>Prefix or suffix
250  *     <td>Yes
251  *     <td>Multiply by 1000 and show as per mille
252  *   <tr valign=top>
253  *     <td><code>\htmlonly&curren;\endhtmlonly</code> (<code>\\u00A4</code>)
254  *     <td>Prefix or suffix
255  *     <td>No
256  *     <td>Currency sign, replaced by currency symbol.  If
257  *         doubled, replaced by international currency symbol.
258  *         If tripled, replaced by currency plural names, for example,
259  *         "US dollar" or "US dollars" for America.
260  *         If present in a pattern, the monetary decimal separator
261  *         is used instead of the decimal separator.
262  *   <tr valign=top bgcolor="#eeeeff">
263  *     <td><code>'</code>
264  *     <td>Prefix or suffix
265  *     <td>No
266  *     <td>Used to quote special characters in a prefix or suffix,
267  *         for example, <code>"'#'#"</code> formats 123 to
268  *         <code>"#123"</code>.  To create a single quote
269  *         itself, use two in a row: <code>"# o''clock"</code>.
270  *   <tr valign=top>
271  *     <td><code>*</code>
272  *     <td>Prefix or suffix boundary
273  *     <td>Yes
274  *     <td>Pad escape, precedes pad character
275  * </table>
276  *
277  * <p>A DecimalFormat pattern contains a postive and negative
278  * subpattern, for example, "#,##0.00;(#,##0.00)".  Each subpattern has a
279  * prefix, a numeric part, and a suffix.  If there is no explicit negative
280  * subpattern, the negative subpattern is the localized minus sign prefixed to the
281  * positive subpattern. That is, "0.00" alone is equivalent to "0.00;-0.00".  If there
282  * is an explicit negative subpattern, it serves only to specify the negative
283  * prefix and suffix; the number of digits, minimal digits, and other
284  * characteristics are ignored in the negative subpattern. That means that
285  * "#,##0.0#;(#)" has precisely the same result as "#,##0.0#;(#,##0.0#)".
286  *
287  * <p>The prefixes, suffixes, and various symbols used for infinity, digits,
288  * thousands separators, decimal separators, etc. may be set to arbitrary
289  * values, and they will appear properly during formatting.  However, care must
290  * be taken that the symbols and strings do not conflict, or parsing will be
291  * unreliable.  For example, either the positive and negative prefixes or the
292  * suffixes must be distinct for parse() to be able
293  * to distinguish positive from negative values.  Another example is that the
294  * decimal separator and thousands separator should be distinct characters, or
295  * parsing will be impossible.
296  *
297  * <p>The <em>grouping separator</em> is a character that separates clusters of
298  * integer digits to make large numbers more legible.  It commonly used for
299  * thousands, but in some locales it separates ten-thousands.  The <em>grouping
300  * size</em> is the number of digits between the grouping separators, such as 3
301  * for "100,000,000" or 4 for "1 0000 0000". There are actually two different
302  * grouping sizes: One used for the least significant integer digits, the
303  * <em>primary grouping size</em>, and one used for all others, the
304  * <em>secondary grouping size</em>.  In most locales these are the same, but
305  * sometimes they are different. For example, if the primary grouping interval
306  * is 3, and the secondary is 2, then this corresponds to the pattern
307  * "#,##,##0", and the number 123456789 is formatted as "12,34,56,789".  If a
308  * pattern contains multiple grouping separators, the interval between the last
309  * one and the end of the integer defines the primary grouping size, and the
310  * interval between the last two defines the secondary grouping size. All others
311  * are ignored, so "#,##,###,####" == "###,###,####" == "##,#,###,####".
312  *
313  * <p>Illegal patterns, such as "#.#.#" or "#.###,###", will cause
314  * DecimalFormat to set a failing UErrorCode.
315  *
316  * <p><strong>Pattern BNF</strong>
317  *
318  * <pre>
319  * pattern    := subpattern (';' subpattern)?
320  * subpattern := prefix? number exponent? suffix?
321  * number     := (integer ('.' fraction)?) | sigDigits
322  * prefix     := '\\u0000'..'\\uFFFD' - specialCharacters
323  * suffix     := '\\u0000'..'\\uFFFD' - specialCharacters
324  * integer    := '#'* '0'* '0'
325  * fraction   := '0'* '#'*
326  * sigDigits  := '#'* '@' '@'* '#'*
327  * exponent   := 'E' '+'? '0'* '0'
328  * padSpec    := '*' padChar
329  * padChar    := '\\u0000'..'\\uFFFD' - quote
330  * &nbsp;
331  * Notation:
332  *   X*       0 or more instances of X
333  *   X?       0 or 1 instances of X
334  *   X|Y      either X or Y
335  *   C..D     any character from C up to D, inclusive
336  *   S-T      characters in S, except those in T
337  * </pre>
338  * The first subpattern is for positive numbers. The second (optional)
339  * subpattern is for negative numbers.
340  *
341  * <p>Not indicated in the BNF syntax above:
342  *
343  * <ul><li>The grouping separator ',' can occur inside the integer and
344  * sigDigits elements, between any two pattern characters of that
345  * element, as long as the integer or sigDigits element is not
346  * followed by the exponent element.
347  *
348  * <li>Two grouping intervals are recognized: That between the
349  *     decimal point and the first grouping symbol, and that
350  *     between the first and second grouping symbols. These
351  *     intervals are identical in most locales, but in some
352  *     locales they differ. For example, the pattern
353  *     &quot;#,##,###&quot; formats the number 123456789 as
354  *     &quot;12,34,56,789&quot;.</li>
355  *
356  * <li>The pad specifier <code>padSpec</code> may appear before the prefix,
357  * after the prefix, before the suffix, after the suffix, or not at all.
358  *
359  * <li>In place of '0', the digits '1' through '9' may be used to
360  * indicate a rounding increment.
361  * </ul>
362  *
363  * <p><strong>Parsing</strong>
364  *
365  * <p>DecimalFormat parses all Unicode characters that represent
366  * decimal digits, as defined by u_charDigitValue().  In addition,
367  * DecimalFormat also recognizes as digits the ten consecutive
368  * characters starting with the localized zero digit defined in the
369  * DecimalFormatSymbols object.  During formatting, the
370  * DecimalFormatSymbols-based digits are output.
371  *
372  * <p>During parsing, grouping separators are ignored if in lenient mode;
373  * otherwise, if present, they must be in appropriate positions.
374  *
375  * <p>For currency parsing, the formatter is able to parse every currency
376  * style formats no matter which style the formatter is constructed with.
377  * For example, a formatter instance gotten from
378  * NumberFormat.getInstance(ULocale, NumberFormat.CURRENCYSTYLE) can parse
379  * formats such as "USD1.00" and "3.00 US dollars".
380  *
381  * <p>If parse(UnicodeString&,Formattable&,ParsePosition&)
382  * fails to parse a string, it leaves the parse position unchanged.
383  * The convenience method parse(UnicodeString&,Formattable&,UErrorCode&)
384  * indicates parse failure by setting a failing
385  * UErrorCode.
386  *
387  * <p><strong>Formatting</strong>
388  *
389  * <p>Formatting is guided by several parameters, all of which can be
390  * specified either using a pattern or using the API.  The following
391  * description applies to formats that do not use <a href="#sci">scientific
392  * notation</a> or <a href="#sigdig">significant digits</a>.
393  *
394  * <ul><li>If the number of actual integer digits exceeds the
395  * <em>maximum integer digits</em>, then only the least significant
396  * digits are shown.  For example, 1997 is formatted as "97" if the
397  * maximum integer digits is set to 2.
398  *
399  * <li>If the number of actual integer digits is less than the
400  * <em>minimum integer digits</em>, then leading zeros are added.  For
401  * example, 1997 is formatted as "01997" if the minimum integer digits
402  * is set to 5.
403  *
404  * <li>If the number of actual fraction digits exceeds the <em>maximum
405  * fraction digits</em>, then rounding is performed to the
406  * maximum fraction digits.  For example, 0.125 is formatted as "0.12"
407  * if the maximum fraction digits is 2.  This behavior can be changed
408  * by specifying a rounding increment and/or a rounding mode.
409  *
410  * <li>If the number of actual fraction digits is less than the
411  * <em>minimum fraction digits</em>, then trailing zeros are added.
412  * For example, 0.125 is formatted as "0.1250" if the mimimum fraction
413  * digits is set to 4.
414  *
415  * <li>Trailing fractional zeros are not displayed if they occur
416  * <em>j</em> positions after the decimal, where <em>j</em> is less
417  * than the maximum fraction digits. For example, 0.10004 is
418  * formatted as "0.1" if the maximum fraction digits is four or less.
419  * </ul>
420  *
421  * <p><strong>Special Values</strong>
422  *
423  * <p><code>NaN</code> is represented as a single character, typically
424  * <code>\\uFFFD</code>.  This character is determined by the
425  * DecimalFormatSymbols object.  This is the only value for which
426  * the prefixes and suffixes are not used.
427  *
428  * <p>Infinity is represented as a single character, typically
429  * <code>\\u221E</code>, with the positive or negative prefixes and suffixes
430  * applied.  The infinity character is determined by the
431  * DecimalFormatSymbols object.
432  *
433  * <a name="sci"><strong>Scientific Notation</strong></a>
434  *
435  * <p>Numbers in scientific notation are expressed as the product of a mantissa
436  * and a power of ten, for example, 1234 can be expressed as 1.234 x 10<sup>3</sup>. The
437  * mantissa is typically in the half-open interval [1.0, 10.0) or sometimes [0.0, 1.0),
438  * but it need not be.  DecimalFormat supports arbitrary mantissas.
439  * DecimalFormat can be instructed to use scientific
440  * notation through the API or through the pattern.  In a pattern, the exponent
441  * character immediately followed by one or more digit characters indicates
442  * scientific notation.  Example: "0.###E0" formats the number 1234 as
443  * "1.234E3".
444  *
445  * <ul>
446  * <li>The number of digit characters after the exponent character gives the
447  * minimum exponent digit count.  There is no maximum.  Negative exponents are
448  * formatted using the localized minus sign, <em>not</em> the prefix and suffix
449  * from the pattern.  This allows patterns such as "0.###E0 m/s".  To prefix
450  * positive exponents with a localized plus sign, specify '+' between the
451  * exponent and the digits: "0.###E+0" will produce formats "1E+1", "1E+0",
452  * "1E-1", etc.  (In localized patterns, use the localized plus sign rather than
453  * '+'.)
454  *
455  * <li>The minimum number of integer digits is achieved by adjusting the
456  * exponent.  Example: 0.00123 formatted with "00.###E0" yields "12.3E-4".  This
457  * only happens if there is no maximum number of integer digits.  If there is a
458  * maximum, then the minimum number of integer digits is fixed at one.
459  *
460  * <li>The maximum number of integer digits, if present, specifies the exponent
461  * grouping.  The most common use of this is to generate <em>engineering
462  * notation</em>, in which the exponent is a multiple of three, e.g.,
463  * "##0.###E0".  The number 12345 is formatted using "##0.####E0" as "12.345E3".
464  *
465  * <li>When using scientific notation, the formatter controls the
466  * digit counts using significant digits logic.  The maximum number of
467  * significant digits limits the total number of integer and fraction
468  * digits that will be shown in the mantissa; it does not affect
469  * parsing.  For example, 12345 formatted with "##0.##E0" is "12.3E3".
470  * See the section on significant digits for more details.
471  *
472  * <li>The number of significant digits shown is determined as
473  * follows: If areSignificantDigitsUsed() returns false, then the
474  * minimum number of significant digits shown is one, and the maximum
475  * number of significant digits shown is the sum of the <em>minimum
476  * integer</em> and <em>maximum fraction</em> digits, and is
477  * unaffected by the maximum integer digits.  If this sum is zero,
478  * then all significant digits are shown.  If
479  * areSignificantDigitsUsed() returns true, then the significant digit
480  * counts are specified by getMinimumSignificantDigits() and
481  * getMaximumSignificantDigits().  In this case, the number of
482  * integer digits is fixed at one, and there is no exponent grouping.
483  *
484  * <li>Exponential patterns may not contain grouping separators.
485  * </ul>
486  *
487  * <a name="sigdig"><strong>Significant Digits</strong></a>
488  *
489  * <code>DecimalFormat</code> has two ways of controlling how many
490  * digits are shows: (a) significant digits counts, or (b) integer and
491  * fraction digit counts.  Integer and fraction digit counts are
492  * described above.  When a formatter is using significant digits
493  * counts, the number of integer and fraction digits is not specified
494  * directly, and the formatter settings for these counts are ignored.
495  * Instead, the formatter uses however many integer and fraction
496  * digits are required to display the specified number of significant
497  * digits.  Examples:
498  *
499  * <table border=0 cellspacing=3 cellpadding=0>
500  *   <tr bgcolor="#ccccff">
501  *     <td align=left>Pattern
502  *     <td align=left>Minimum significant digits
503  *     <td align=left>Maximum significant digits
504  *     <td align=left>Number
505  *     <td align=left>Output of format()
506  *   <tr valign=top>
507  *     <td><code>\@\@\@</code>
508  *     <td>3
509  *     <td>3
510  *     <td>12345
511  *     <td><code>12300</code>
512  *   <tr valign=top bgcolor="#eeeeff">
513  *     <td><code>\@\@\@</code>
514  *     <td>3
515  *     <td>3
516  *     <td>0.12345
517  *     <td><code>0.123</code>
518  *   <tr valign=top>
519  *     <td><code>\@\@##</code>
520  *     <td>2
521  *     <td>4
522  *     <td>3.14159
523  *     <td><code>3.142</code>
524  *   <tr valign=top bgcolor="#eeeeff">
525  *     <td><code>\@\@##</code>
526  *     <td>2
527  *     <td>4
528  *     <td>1.23004
529  *     <td><code>1.23</code>
530  * </table>
531  *
532  * <ul>
533  * <li>Significant digit counts may be expressed using patterns that
534  * specify a minimum and maximum number of significant digits.  These
535  * are indicated by the <code>'@'</code> and <code>'#'</code>
536  * characters.  The minimum number of significant digits is the number
537  * of <code>'@'</code> characters.  The maximum number of significant
538  * digits is the number of <code>'@'</code> characters plus the number
539  * of <code>'#'</code> characters following on the right.  For
540  * example, the pattern <code>"@@@"</code> indicates exactly 3
541  * significant digits.  The pattern <code>"@##"</code> indicates from
542  * 1 to 3 significant digits.  Trailing zero digits to the right of
543  * the decimal separator are suppressed after the minimum number of
544  * significant digits have been shown.  For example, the pattern
545  * <code>"@##"</code> formats the number 0.1203 as
546  * <code>"0.12"</code>.
547  *
548  * <li>If a pattern uses significant digits, it may not contain a
549  * decimal separator, nor the <code>'0'</code> pattern character.
550  * Patterns such as <code>"@00"</code> or <code>"@.###"</code> are
551  * disallowed.
552  *
553  * <li>Any number of <code>'#'</code> characters may be prepended to
554  * the left of the leftmost <code>'@'</code> character.  These have no
555  * effect on the minimum and maximum significant digits counts, but
556  * may be used to position grouping separators.  For example,
557  * <code>"#,#@#"</code> indicates a minimum of one significant digits,
558  * a maximum of two significant digits, and a grouping size of three.
559  *
560  * <li>In order to enable significant digits formatting, use a pattern
561  * containing the <code>'@'</code> pattern character.  Alternatively,
562  * call setSignificantDigitsUsed(TRUE).
563  *
564  * <li>In order to disable significant digits formatting, use a
565  * pattern that does not contain the <code>'@'</code> pattern
566  * character. Alternatively, call setSignificantDigitsUsed(FALSE).
567  *
568  * <li>The number of significant digits has no effect on parsing.
569  *
570  * <li>Significant digits may be used together with exponential notation. Such
571  * patterns are equivalent to a normal exponential pattern with a minimum and
572  * maximum integer digit count of one, a minimum fraction digit count of
573  * <code>getMinimumSignificantDigits() - 1</code>, and a maximum fraction digit
574  * count of <code>getMaximumSignificantDigits() - 1</code>. For example, the
575  * pattern <code>"@@###E0"</code> is equivalent to <code>"0.0###E0"</code>.
576  *
577  * <li>If signficant digits are in use, then the integer and fraction
578  * digit counts, as set via the API, are ignored.  If significant
579  * digits are not in use, then the signficant digit counts, as set via
580  * the API, are ignored.
581  *
582  * </ul>
583  *
584  * <p><strong>Padding</strong>
585  *
586  * <p>DecimalFormat supports padding the result of
587  * format() to a specific width.  Padding may be specified either
588  * through the API or through the pattern syntax.  In a pattern the pad escape
589  * character, followed by a single pad character, causes padding to be parsed
590  * and formatted.  The pad escape character is '*' in unlocalized patterns, and
591  * can be localized using DecimalFormatSymbols::setSymbol() with a
592  * DecimalFormatSymbols::kPadEscapeSymbol
593  * selector.  For example, <code>"$*x#,##0.00"</code> formats 123 to
594  * <code>"$xx123.00"</code>, and 1234 to <code>"$1,234.00"</code>.
595  *
596  * <ul>
597  * <li>When padding is in effect, the width of the positive subpattern,
598  * including prefix and suffix, determines the format width.  For example, in
599  * the pattern <code>"* #0 o''clock"</code>, the format width is 10.
600  *
601  * <li>The width is counted in 16-bit code units (UChars).
602  *
603  * <li>Some parameters which usually do not matter have meaning when padding is
604  * used, because the pattern width is significant with padding.  In the pattern
605  * "* ##,##,#,##0.##", the format width is 14.  The initial characters "##,##,"
606  * do not affect the grouping size or maximum integer digits, but they do affect
607  * the format width.
608  *
609  * <li>Padding may be inserted at one of four locations: before the prefix,
610  * after the prefix, before the suffix, or after the suffix.  If padding is
611  * specified in any other location, applyPattern()
612  * sets a failing UErrorCode.  If there is no prefix,
613  * before the prefix and after the prefix are equivalent, likewise for the
614  * suffix.
615  *
616  * <li>When specified in a pattern, the 32-bit code point immediately
617  * following the pad escape is the pad character. This may be any character,
618  * including a special pattern character. That is, the pad escape
619  * <em>escapes</em> the following character. If there is no character after
620  * the pad escape, then the pattern is illegal.
621  *
622  * </ul>
623  *
624  * <p><strong>Rounding</strong>
625  *
626  * <p>DecimalFormat supports rounding to a specific increment.  For
627  * example, 1230 rounded to the nearest 50 is 1250.  1.234 rounded to the
628  * nearest 0.65 is 1.3.  The rounding increment may be specified through the API
629  * or in a pattern.  To specify a rounding increment in a pattern, include the
630  * increment in the pattern itself.  "#,#50" specifies a rounding increment of
631  * 50.  "#,##0.05" specifies a rounding increment of 0.05.
632  *
633  * <p>In the absense of an explicit rounding increment numbers are
634  * rounded to their formatted width.
635  *
636  * <ul>
637  * <li>Rounding only affects the string produced by formatting.  It does
638  * not affect parsing or change any numerical values.
639  *
640  * <li>A <em>rounding mode</em> determines how values are rounded; see
641  * DecimalFormat::ERoundingMode.  The default rounding mode is
642  * DecimalFormat::kRoundHalfEven.  The rounding mode can only be set
643  * through the API; it can not be set with a pattern.
644  *
645  * <li>Some locales use rounding in their currency formats to reflect the
646  * smallest currency denomination.
647  *
648  * <li>In a pattern, digits '1' through '9' specify rounding, but otherwise
649  * behave identically to digit '0'.
650  * </ul>
651  *
652  * <p><strong>Synchronization</strong>
653  *
654  * <p>DecimalFormat objects are not synchronized.  Multiple
655  * threads should not access one formatter concurrently.
656  *
657  * <p><strong>Subclassing</strong>
658  *
659  * <p><em>User subclasses are not supported.</em> While clients may write
660  * subclasses, such code will not necessarily work and will not be
661  * guaranteed to work stably from release to release.
662  */
663 class U_I18N_API DecimalFormat: public NumberFormat {
664 public:
665     /**
666      * Rounding mode.
667      * @stable ICU 2.4
668      */
669     enum ERoundingMode {
670         kRoundCeiling,  /**< Round towards positive infinity */
671         kRoundFloor,    /**< Round towards negative infinity */
672         kRoundDown,     /**< Round towards zero */
673         kRoundUp,       /**< Round away from zero */
674         kRoundHalfEven, /**< Round towards the nearest integer, or
675                              towards the nearest even integer if equidistant */
676         kRoundHalfDown, /**< Round towards the nearest integer, or
677                              towards zero if equidistant */
678         kRoundHalfUp,   /**< Round towards the nearest integer, or
679                              away from zero if equidistant */
680         /**
681           *  Return U_FORMAT_INEXACT_ERROR if number does not format exactly.
682           *  @stable ICU 4.8
683           */
684         kRoundUnnecessary
685     };
686
687     /**
688      * Pad position.
689      * @stable ICU 2.4
690      */
691     enum EPadPosition {
692         kPadBeforePrefix,
693         kPadAfterPrefix,
694         kPadBeforeSuffix,
695         kPadAfterSuffix
696     };
697
698     /**
699      * Create a DecimalFormat using the default pattern and symbols
700      * for the default locale. This is a convenient way to obtain a
701      * DecimalFormat when internationalization is not the main concern.
702      * <P>
703      * To obtain standard formats for a given locale, use the factory methods
704      * on NumberFormat such as createInstance. These factories will
705      * return the most appropriate sub-class of NumberFormat for a given
706      * locale.
707      * @param status    Output param set to success/failure code. If the
708      *                  pattern is invalid this will be set to a failure code.
709      * @stable ICU 2.0
710      */
711     DecimalFormat(UErrorCode& status);
712
713     /**
714      * Create a DecimalFormat from the given pattern and the symbols
715      * for the default locale. This is a convenient way to obtain a
716      * DecimalFormat when internationalization is not the main concern.
717      * <P>
718      * To obtain standard formats for a given locale, use the factory methods
719      * on NumberFormat such as createInstance. These factories will
720      * return the most appropriate sub-class of NumberFormat for a given
721      * locale.
722      * @param pattern   A non-localized pattern string.
723      * @param status    Output param set to success/failure code. If the
724      *                  pattern is invalid this will be set to a failure code.
725      * @stable ICU 2.0
726      */
727     DecimalFormat(const UnicodeString& pattern,
728                   UErrorCode& status);
729
730     /**
731      * Create a DecimalFormat from the given pattern and symbols.
732      * Use this constructor when you need to completely customize the
733      * behavior of the format.
734      * <P>
735      * To obtain standard formats for a given
736      * locale, use the factory methods on NumberFormat such as
737      * createInstance or createCurrencyInstance. If you need only minor adjustments
738      * to a standard format, you can modify the format returned by
739      * a NumberFormat factory method.
740      *
741      * @param pattern           a non-localized pattern string
742      * @param symbolsToAdopt    the set of symbols to be used.  The caller should not
743      *                          delete this object after making this call.
744      * @param status            Output param set to success/failure code. If the
745      *                          pattern is invalid this will be set to a failure code.
746      * @stable ICU 2.0
747      */
748     DecimalFormat(  const UnicodeString& pattern,
749                     DecimalFormatSymbols* symbolsToAdopt,
750                     UErrorCode& status);
751
752 #ifndef U_HIDE_INTERNAL_API
753     /**
754      * This API is for ICU use only.
755      * Create a DecimalFormat from the given pattern, symbols, and style.
756      *
757      * @param pattern           a non-localized pattern string
758      * @param symbolsToAdopt    the set of symbols to be used.  The caller should not
759      *                          delete this object after making this call.
760      * @param style             style of decimal format
761      * @param status            Output param set to success/failure code. If the
762      *                          pattern is invalid this will be set to a failure code.
763      * @internal
764      */
765     DecimalFormat(  const UnicodeString& pattern,
766                     DecimalFormatSymbols* symbolsToAdopt,
767                     UNumberFormatStyle style,
768                     UErrorCode& status);
769
770 #if UCONFIG_HAVE_PARSEALLINPUT
771     /**
772      * @internal
773      */
774     void setParseAllInput(UNumberFormatAttributeValue value);
775 #endif
776
777 #endif  /* U_HIDE_INTERNAL_API */
778
779
780     /**
781      * Set an integer attribute on this DecimalFormat.
782      * May return U_UNSUPPORTED_ERROR if this instance does not support
783      * the specified attribute.
784      * @param attr the attribute to set
785      * @param newvalue new value
786      * @param status the error type
787      * @return *this - for chaining (example: format.setAttribute(...).setAttribute(...) )
788      * @stable ICU 51
789      */
790     virtual DecimalFormat& setAttribute( UNumberFormatAttribute attr,
791                                        int32_t newvalue,
792                                        UErrorCode &status);
793
794     /**
795      * Get an integer
796      * May return U_UNSUPPORTED_ERROR if this instance does not support
797      * the specified attribute.
798      * @param attr the attribute to set
799      * @param status the error type
800      * @return the attribute value. Undefined if there is an error.
801      * @stable ICU 51
802      */
803     virtual int32_t getAttribute( UNumberFormatAttribute attr,
804                                   UErrorCode &status) const;
805
806     
807     /**
808      * Set whether or not grouping will be used in this format.
809      * @param newValue    True, grouping will be used in this format.
810      * @see getGroupingUsed
811      * @stable ICU 53
812      */
813     virtual void setGroupingUsed(UBool newValue);
814
815     /**
816      * Sets whether or not numbers should be parsed as integers only.
817      * @param value    set True, this format will parse numbers as integers
818      *                 only.
819      * @see isParseIntegerOnly
820      * @stable ICU 53
821      */
822     virtual void setParseIntegerOnly(UBool value);
823
824     /**
825      * Set a particular UDisplayContext value in the formatter, such as
826      * UDISPCTX_CAPITALIZATION_FOR_STANDALONE.
827      * @param value The UDisplayContext value to set.
828      * @param status Input/output status. If at entry this indicates a failure
829      *               status, the function will do nothing; otherwise this will be
830      *               updated with any new status from the function. 
831      * @stable ICU 53
832      */
833     virtual void setContext(UDisplayContext value, UErrorCode& status);
834
835     /**
836      * Create a DecimalFormat from the given pattern and symbols.
837      * Use this constructor when you need to completely customize the
838      * behavior of the format.
839      * <P>
840      * To obtain standard formats for a given
841      * locale, use the factory methods on NumberFormat such as
842      * createInstance or createCurrencyInstance. If you need only minor adjustments
843      * to a standard format, you can modify the format returned by
844      * a NumberFormat factory method.
845      *
846      * @param pattern           a non-localized pattern string
847      * @param symbolsToAdopt    the set of symbols to be used.  The caller should not
848      *                          delete this object after making this call.
849      * @param parseError        Output param to receive errors occured during parsing
850      * @param status            Output param set to success/failure code. If the
851      *                          pattern is invalid this will be set to a failure code.
852      * @stable ICU 2.0
853      */
854     DecimalFormat(  const UnicodeString& pattern,
855                     DecimalFormatSymbols* symbolsToAdopt,
856                     UParseError& parseError,
857                     UErrorCode& status);
858     /**
859      * Create a DecimalFormat from the given pattern and symbols.
860      * Use this constructor when you need to completely customize the
861      * behavior of the format.
862      * <P>
863      * To obtain standard formats for a given
864      * locale, use the factory methods on NumberFormat such as
865      * createInstance or createCurrencyInstance. If you need only minor adjustments
866      * to a standard format, you can modify the format returned by
867      * a NumberFormat factory method.
868      *
869      * @param pattern           a non-localized pattern string
870      * @param symbols   the set of symbols to be used
871      * @param status            Output param set to success/failure code. If the
872      *                          pattern is invalid this will be set to a failure code.
873      * @stable ICU 2.0
874      */
875     DecimalFormat(  const UnicodeString& pattern,
876                     const DecimalFormatSymbols& symbols,
877                     UErrorCode& status);
878
879     /**
880      * Copy constructor.
881      *
882      * @param source    the DecimalFormat object to be copied from.
883      * @stable ICU 2.0
884      */
885     DecimalFormat(const DecimalFormat& source);
886
887     /**
888      * Assignment operator.
889      *
890      * @param rhs    the DecimalFormat object to be copied.
891      * @stable ICU 2.0
892      */
893     DecimalFormat& operator=(const DecimalFormat& rhs);
894
895     /**
896      * Destructor.
897      * @stable ICU 2.0
898      */
899     virtual ~DecimalFormat();
900
901     /**
902      * Clone this Format object polymorphically. The caller owns the
903      * result and should delete it when done.
904      *
905      * @return    a polymorphic copy of this DecimalFormat.
906      * @stable ICU 2.0
907      */
908     virtual Format* clone(void) const;
909
910     /**
911      * Return true if the given Format objects are semantically equal.
912      * Objects of different subclasses are considered unequal.
913      *
914      * @param other    the object to be compared with.
915      * @return         true if the given Format objects are semantically equal.
916      * @stable ICU 2.0
917      */
918     virtual UBool operator==(const Format& other) const;
919
920
921     using NumberFormat::format;
922
923     /**
924      * Format a double or long number using base-10 representation.
925      *
926      * @param number    The value to be formatted.
927      * @param appendTo  Output parameter to receive result.
928      *                  Result is appended to existing contents.
929      * @param pos       On input: an alignment field, if desired.
930      *                  On output: the offsets of the alignment field.
931      * @return          Reference to 'appendTo' parameter.
932      * @stable ICU 2.0
933      */
934     virtual UnicodeString& format(double number,
935                                   UnicodeString& appendTo,
936                                   FieldPosition& pos) const;
937
938
939     /**
940      * Format a double or long number using base-10 representation.
941      *
942      * @param number    The value to be formatted.
943      * @param appendTo  Output parameter to receive result.
944      *                  Result is appended to existing contents.
945      * @param pos       On input: an alignment field, if desired.
946      *                  On output: the offsets of the alignment field.
947      * @param status
948      * @return          Reference to 'appendTo' parameter.
949      * @internal
950      */
951     virtual UnicodeString& format(double number,
952                                   UnicodeString& appendTo,
953                                   FieldPosition& pos,
954                                   UErrorCode &status) const;
955
956     /**
957      * Format a double or long number using base-10 representation.
958      *
959      * @param number    The value to be formatted.
960      * @param appendTo  Output parameter to receive result.
961      *                  Result is appended to existing contents.
962      * @param posIter   On return, can be used to iterate over positions
963      *                  of fields generated by this format call.
964      *                  Can be NULL.
965      * @param status    Output param filled with success/failure status.
966      * @return          Reference to 'appendTo' parameter.
967      * @stable 4.4
968      */
969     virtual UnicodeString& format(double number,
970                                   UnicodeString& appendTo,
971                                   FieldPositionIterator* posIter,
972                                   UErrorCode& status) const;
973
974     /**
975      * Format a long number using base-10 representation.
976      *
977      * @param number    The value to be formatted.
978      * @param appendTo  Output parameter to receive result.
979      *                  Result is appended to existing contents.
980      * @param pos       On input: an alignment field, if desired.
981      *                  On output: the offsets of the alignment field.
982      * @return          Reference to 'appendTo' parameter.
983      * @stable ICU 2.0
984      */
985     virtual UnicodeString& format(int32_t number,
986                                   UnicodeString& appendTo,
987                                   FieldPosition& pos) const;
988
989     /**
990      * Format a long number using base-10 representation.
991      *
992      * @param number    The value to be formatted.
993      * @param appendTo  Output parameter to receive result.
994      *                  Result is appended to existing contents.
995      * @param pos       On input: an alignment field, if desired.
996      *                  On output: the offsets of the alignment field.
997      * @return          Reference to 'appendTo' parameter.
998      * @internal
999      */
1000     virtual UnicodeString& format(int32_t number,
1001                                   UnicodeString& appendTo,
1002                                   FieldPosition& pos,
1003                                   UErrorCode &status) const;
1004
1005     /**
1006      * Format a long number using base-10 representation.
1007      *
1008      * @param number    The value to be formatted.
1009      * @param appendTo  Output parameter to receive result.
1010      *                  Result is appended to existing contents.
1011      * @param posIter   On return, can be used to iterate over positions
1012      *                  of fields generated by this format call.
1013      *                  Can be NULL.
1014      * @param status    Output param filled with success/failure status.
1015      * @return          Reference to 'appendTo' parameter.
1016      * @stable 4.4
1017      */
1018     virtual UnicodeString& format(int32_t number,
1019                                   UnicodeString& appendTo,
1020                                   FieldPositionIterator* posIter,
1021                                   UErrorCode& status) const;
1022
1023     /**
1024      * Format an int64 number using base-10 representation.
1025      *
1026      * @param number    The value to be formatted.
1027      * @param appendTo  Output parameter to receive result.
1028      *                  Result is appended to existing contents.
1029      * @param pos       On input: an alignment field, if desired.
1030      *                  On output: the offsets of the alignment field.
1031      * @return          Reference to 'appendTo' parameter.
1032      * @stable ICU 2.8
1033      */
1034     virtual UnicodeString& format(int64_t number,
1035                                   UnicodeString& appendTo,
1036                                   FieldPosition& pos) const;
1037
1038     /**
1039      * Format an int64 number using base-10 representation.
1040      *
1041      * @param number    The value to be formatted.
1042      * @param appendTo  Output parameter to receive result.
1043      *                  Result is appended to existing contents.
1044      * @param pos       On input: an alignment field, if desired.
1045      *                  On output: the offsets of the alignment field.
1046      * @return          Reference to 'appendTo' parameter.
1047      * @internal
1048      */
1049     virtual UnicodeString& format(int64_t number,
1050                                   UnicodeString& appendTo,
1051                                   FieldPosition& pos,
1052                                   UErrorCode &status) const;
1053
1054     /**
1055      * Format an int64 number using base-10 representation.
1056      *
1057      * @param number    The value to be formatted.
1058      * @param appendTo  Output parameter to receive result.
1059      *                  Result is appended to existing contents.
1060      * @param posIter   On return, can be used to iterate over positions
1061      *                  of fields generated by this format call.
1062      *                  Can be NULL.
1063      * @param status    Output param filled with success/failure status.
1064      * @return          Reference to 'appendTo' parameter.
1065      * @stable 4.4
1066      */
1067     virtual UnicodeString& format(int64_t number,
1068                                   UnicodeString& appendTo,
1069                                   FieldPositionIterator* posIter,
1070                                   UErrorCode& status) const;
1071
1072     /**
1073      * Format a decimal number.
1074      * The syntax of the unformatted number is a "numeric string"
1075      * as defined in the Decimal Arithmetic Specification, available at
1076      * http://speleotrove.com/decimal
1077      *
1078      * @param number    The unformatted number, as a string.
1079      * @param appendTo  Output parameter to receive result.
1080      *                  Result is appended to existing contents.
1081      * @param posIter   On return, can be used to iterate over positions
1082      *                  of fields generated by this format call.
1083      *                  Can be NULL.
1084      * @param status    Output param filled with success/failure status.
1085      * @return          Reference to 'appendTo' parameter.
1086      * @stable 4.4
1087      */
1088     virtual UnicodeString& format(const StringPiece &number,
1089                                   UnicodeString& appendTo,
1090                                   FieldPositionIterator* posIter,
1091                                   UErrorCode& status) const;
1092
1093
1094     /**
1095      * Format a decimal number.
1096      * The number is a DigitList wrapper onto a floating point decimal number.
1097      * The default implementation in NumberFormat converts the decimal number
1098      * to a double and formats that.
1099      *
1100      * @param number    The number, a DigitList format Decimal Floating Point.
1101      * @param appendTo  Output parameter to receive result.
1102      *                  Result is appended to existing contents.
1103      * @param posIter   On return, can be used to iterate over positions
1104      *                  of fields generated by this format call.
1105      * @param status    Output param filled with success/failure status.
1106      * @return          Reference to 'appendTo' parameter.
1107      * @internal
1108      */
1109     virtual UnicodeString& format(const DigitList &number,
1110                                   UnicodeString& appendTo,
1111                                   FieldPositionIterator* posIter,
1112                                   UErrorCode& status) const;
1113
1114     /**
1115      * Format a decimal number.
1116      * The number is a DigitList wrapper onto a floating point decimal number.
1117      * The default implementation in NumberFormat converts the decimal number
1118      * to a double and formats that.
1119      *
1120      * @param number    The number, a DigitList format Decimal Floating Point.
1121      * @param appendTo  Output parameter to receive result.
1122      *                  Result is appended to existing contents.
1123      * @param pos       On input: an alignment field, if desired.
1124      *                  On output: the offsets of the alignment field.
1125      * @param status    Output param filled with success/failure status.
1126      * @return          Reference to 'appendTo' parameter.
1127      * @internal
1128      */
1129     virtual UnicodeString& format(const DigitList &number,
1130                                   UnicodeString& appendTo,
1131                                   FieldPosition& pos,
1132                                   UErrorCode& status) const;
1133
1134    using NumberFormat::parse;
1135
1136    /**
1137     * Parse the given string using this object's choices. The method
1138     * does string comparisons to try to find an optimal match.
1139     * If no object can be parsed, index is unchanged, and NULL is
1140     * returned.  The result is returned as the most parsimonious
1141     * type of Formattable that will accomodate all of the
1142     * necessary precision.  For example, if the result is exactly 12,
1143     * it will be returned as a long.  However, if it is 1.5, it will
1144     * be returned as a double.
1145     *
1146     * @param text           The text to be parsed.
1147     * @param result         Formattable to be set to the parse result.
1148     *                       If parse fails, return contents are undefined.
1149     * @param parsePosition  The position to start parsing at on input.
1150     *                       On output, moved to after the last successfully
1151     *                       parse character. On parse failure, does not change.
1152     * @see Formattable
1153     * @stable ICU 2.0
1154     */
1155     virtual void parse(const UnicodeString& text,
1156                        Formattable& result,
1157                        ParsePosition& parsePosition) const;
1158
1159     /**
1160      * Parses text from the given string as a currency amount.  Unlike
1161      * the parse() method, this method will attempt to parse a generic
1162      * currency name, searching for a match of this object's locale's
1163      * currency display names, or for a 3-letter ISO currency code.
1164      * This method will fail if this format is not a currency format,
1165      * that is, if it does not contain the currency pattern symbol
1166      * (U+00A4) in its prefix or suffix.
1167      *
1168      * @param text the string to parse
1169      * @param pos  input-output position; on input, the position within text
1170      *             to match; must have 0 <= pos.getIndex() < text.length();
1171      *             on output, the position after the last matched character.
1172      *             If the parse fails, the position in unchanged upon output.
1173      * @return     if parse succeeds, a pointer to a newly-created CurrencyAmount
1174      *             object (owned by the caller) containing information about
1175      *             the parsed currency; if parse fails, this is NULL.
1176      * @stable ICU 49
1177      */
1178     virtual CurrencyAmount* parseCurrency(const UnicodeString& text,
1179                                           ParsePosition& pos) const;
1180
1181     /**
1182      * Returns the decimal format symbols, which is generally not changed
1183      * by the programmer or user.
1184      * @return desired DecimalFormatSymbols
1185      * @see DecimalFormatSymbols
1186      * @stable ICU 2.0
1187      */
1188     virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const;
1189
1190     /**
1191      * Sets the decimal format symbols, which is generally not changed
1192      * by the programmer or user.
1193      * @param symbolsToAdopt DecimalFormatSymbols to be adopted.
1194      * @stable ICU 2.0
1195      */
1196     virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
1197
1198     /**
1199      * Sets the decimal format symbols, which is generally not changed
1200      * by the programmer or user.
1201      * @param symbols DecimalFormatSymbols.
1202      * @stable ICU 2.0
1203      */
1204     virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
1205
1206
1207     /**
1208      * Returns the currency plural format information,
1209      * which is generally not changed by the programmer or user.
1210      * @return desired CurrencyPluralInfo
1211      * @stable ICU 4.2
1212      */
1213     virtual const CurrencyPluralInfo* getCurrencyPluralInfo(void) const;
1214
1215     /**
1216      * Sets the currency plural format information,
1217      * which is generally not changed by the programmer or user.
1218      * @param toAdopt CurrencyPluralInfo to be adopted.
1219      * @stable ICU 4.2
1220      */
1221     virtual void adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt);
1222
1223     /**
1224      * Sets the currency plural format information,
1225      * which is generally not changed by the programmer or user.
1226      * @param info Currency Plural Info.
1227      * @stable ICU 4.2
1228      */
1229     virtual void setCurrencyPluralInfo(const CurrencyPluralInfo& info);
1230
1231
1232     /**
1233      * Get the positive prefix.
1234      *
1235      * @param result    Output param which will receive the positive prefix.
1236      * @return          A reference to 'result'.
1237      * Examples: +123, $123, sFr123
1238      * @stable ICU 2.0
1239      */
1240     UnicodeString& getPositivePrefix(UnicodeString& result) const;
1241
1242     /**
1243      * Set the positive prefix.
1244      *
1245      * @param newValue    the new value of the the positive prefix to be set.
1246      * Examples: +123, $123, sFr123
1247      * @stable ICU 2.0
1248      */
1249     virtual void setPositivePrefix(const UnicodeString& newValue);
1250
1251     /**
1252      * Get the negative prefix.
1253      *
1254      * @param result    Output param which will receive the negative prefix.
1255      * @return          A reference to 'result'.
1256      * Examples: -123, ($123) (with negative suffix), sFr-123
1257      * @stable ICU 2.0
1258      */
1259     UnicodeString& getNegativePrefix(UnicodeString& result) const;
1260
1261     /**
1262      * Set the negative prefix.
1263      *
1264      * @param newValue    the new value of the the negative prefix to be set.
1265      * Examples: -123, ($123) (with negative suffix), sFr-123
1266      * @stable ICU 2.0
1267      */
1268     virtual void setNegativePrefix(const UnicodeString& newValue);
1269
1270     /**
1271      * Get the positive suffix.
1272      *
1273      * @param result    Output param which will receive the positive suffix.
1274      * @return          A reference to 'result'.
1275      * Example: 123%
1276      * @stable ICU 2.0
1277      */
1278     UnicodeString& getPositiveSuffix(UnicodeString& result) const;
1279
1280     /**
1281      * Set the positive suffix.
1282      *
1283      * @param newValue    the new value of the positive suffix to be set.
1284      * Example: 123%
1285      * @stable ICU 2.0
1286      */
1287     virtual void setPositiveSuffix(const UnicodeString& newValue);
1288
1289     /**
1290      * Get the negative suffix.
1291      *
1292      * @param result    Output param which will receive the negative suffix.
1293      * @return          A reference to 'result'.
1294      * Examples: -123%, ($123) (with positive suffixes)
1295      * @stable ICU 2.0
1296      */
1297     UnicodeString& getNegativeSuffix(UnicodeString& result) const;
1298
1299     /**
1300      * Set the negative suffix.
1301      *
1302      * @param newValue    the new value of the negative suffix to be set.
1303      * Examples: 123%
1304      * @stable ICU 2.0
1305      */
1306     virtual void setNegativeSuffix(const UnicodeString& newValue);
1307
1308     /**
1309      * Get the multiplier for use in percent, permill, etc.
1310      * For a percentage, set the suffixes to have "%" and the multiplier to be 100.
1311      * (For Arabic, use arabic percent symbol).
1312      * For a permill, set the suffixes to have "\\u2031" and the multiplier to be 1000.
1313      *
1314      * @return    the multiplier for use in percent, permill, etc.
1315      * Examples: with 100, 1.23 -> "123", and "123" -> 1.23
1316      * @stable ICU 2.0
1317      */
1318     int32_t getMultiplier(void) const;
1319
1320     /**
1321      * Set the multiplier for use in percent, permill, etc.
1322      * For a percentage, set the suffixes to have "%" and the multiplier to be 100.
1323      * (For Arabic, use arabic percent symbol).
1324      * For a permill, set the suffixes to have "\\u2031" and the multiplier to be 1000.
1325      *
1326      * @param newValue    the new value of the multiplier for use in percent, permill, etc.
1327      * Examples: with 100, 1.23 -> "123", and "123" -> 1.23
1328      * @stable ICU 2.0
1329      */
1330     virtual void setMultiplier(int32_t newValue);
1331
1332     /**
1333      * Get the rounding increment.
1334      * @return A positive rounding increment, or 0.0 if a custom rounding
1335      * increment is not in effect.
1336      * @see #setRoundingIncrement
1337      * @see #getRoundingMode
1338      * @see #setRoundingMode
1339      * @stable ICU 2.0
1340      */
1341     virtual double getRoundingIncrement(void) const;
1342
1343     /**
1344      * Set the rounding increment.  In the absence of a rounding increment,
1345      *    numbers will be rounded to the number of digits displayed.
1346      * @param newValue A positive rounding increment, or 0.0 to
1347      * use the default rounding increment.
1348      * Negative increments are equivalent to 0.0.
1349      * @see #getRoundingIncrement
1350      * @see #getRoundingMode
1351      * @see #setRoundingMode
1352      * @stable ICU 2.0
1353      */
1354     virtual void setRoundingIncrement(double newValue);
1355
1356     /**
1357      * Get the rounding mode.
1358      * @return A rounding mode
1359      * @see #setRoundingIncrement
1360      * @see #getRoundingIncrement
1361      * @see #setRoundingMode
1362      * @stable ICU 2.0
1363      */
1364     virtual ERoundingMode getRoundingMode(void) const;
1365
1366     /**
1367      * Set the rounding mode.
1368      * @param roundingMode A rounding mode
1369      * @see #setRoundingIncrement
1370      * @see #getRoundingIncrement
1371      * @see #getRoundingMode
1372      * @stable ICU 2.0
1373      */
1374     virtual void setRoundingMode(ERoundingMode roundingMode);
1375
1376     /**
1377      * Get the width to which the output of format() is padded.
1378      * The width is counted in 16-bit code units.
1379      * @return the format width, or zero if no padding is in effect
1380      * @see #setFormatWidth
1381      * @see #getPadCharacterString
1382      * @see #setPadCharacter
1383      * @see #getPadPosition
1384      * @see #setPadPosition
1385      * @stable ICU 2.0
1386      */
1387     virtual int32_t getFormatWidth(void) const;
1388
1389     /**
1390      * Set the width to which the output of format() is padded.
1391      * The width is counted in 16-bit code units.
1392      * This method also controls whether padding is enabled.
1393      * @param width the width to which to pad the result of
1394      * format(), or zero to disable padding.  A negative
1395      * width is equivalent to 0.
1396      * @see #getFormatWidth
1397      * @see #getPadCharacterString
1398      * @see #setPadCharacter
1399      * @see #getPadPosition
1400      * @see #setPadPosition
1401      * @stable ICU 2.0
1402      */
1403     virtual void setFormatWidth(int32_t width);
1404
1405     /**
1406      * Get the pad character used to pad to the format width.  The
1407      * default is ' '.
1408      * @return a string containing the pad character. This will always
1409      * have a length of one 32-bit code point.
1410      * @see #setFormatWidth
1411      * @see #getFormatWidth
1412      * @see #setPadCharacter
1413      * @see #getPadPosition
1414      * @see #setPadPosition
1415      * @stable ICU 2.0
1416      */
1417     virtual UnicodeString getPadCharacterString() const;
1418
1419     /**
1420      * Set the character used to pad to the format width.  If padding
1421      * is not enabled, then this will take effect if padding is later
1422      * enabled.
1423      * @param padChar a string containing the pad charcter. If the string
1424      * has length 0, then the pad characer is set to ' '.  Otherwise
1425      * padChar.char32At(0) will be used as the pad character.
1426      * @see #setFormatWidth
1427      * @see #getFormatWidth
1428      * @see #getPadCharacterString
1429      * @see #getPadPosition
1430      * @see #setPadPosition
1431      * @stable ICU 2.0
1432      */
1433     virtual void setPadCharacter(const UnicodeString &padChar);
1434
1435     /**
1436      * Get the position at which padding will take place.  This is the location
1437      * at which padding will be inserted if the result of format()
1438      * is shorter than the format width.
1439      * @return the pad position, one of kPadBeforePrefix,
1440      * kPadAfterPrefix, kPadBeforeSuffix, or
1441      * kPadAfterSuffix.
1442      * @see #setFormatWidth
1443      * @see #getFormatWidth
1444      * @see #setPadCharacter
1445      * @see #getPadCharacterString
1446      * @see #setPadPosition
1447      * @see #EPadPosition
1448      * @stable ICU 2.0
1449      */
1450     virtual EPadPosition getPadPosition(void) const;
1451
1452     /**
1453      * Set the position at which padding will take place.  This is the location
1454      * at which padding will be inserted if the result of format()
1455      * is shorter than the format width.  This has no effect unless padding is
1456      * enabled.
1457      * @param padPos the pad position, one of kPadBeforePrefix,
1458      * kPadAfterPrefix, kPadBeforeSuffix, or
1459      * kPadAfterSuffix.
1460      * @see #setFormatWidth
1461      * @see #getFormatWidth
1462      * @see #setPadCharacter
1463      * @see #getPadCharacterString
1464      * @see #getPadPosition
1465      * @see #EPadPosition
1466      * @stable ICU 2.0
1467      */
1468     virtual void setPadPosition(EPadPosition padPos);
1469
1470     /**
1471      * Return whether or not scientific notation is used.
1472      * @return TRUE if this object formats and parses scientific notation
1473      * @see #setScientificNotation
1474      * @see #getMinimumExponentDigits
1475      * @see #setMinimumExponentDigits
1476      * @see #isExponentSignAlwaysShown
1477      * @see #setExponentSignAlwaysShown
1478      * @stable ICU 2.0
1479      */
1480     virtual UBool isScientificNotation(void) const;
1481
1482     /**
1483      * Set whether or not scientific notation is used. When scientific notation
1484      * is used, the effective maximum number of integer digits is <= 8.  If the
1485      * maximum number of integer digits is set to more than 8, the effective
1486      * maximum will be 1.  This allows this call to generate a 'default' scientific
1487      * number format without additional changes.
1488      * @param useScientific TRUE if this object formats and parses scientific
1489      * notation
1490      * @see #isScientificNotation
1491      * @see #getMinimumExponentDigits
1492      * @see #setMinimumExponentDigits
1493      * @see #isExponentSignAlwaysShown
1494      * @see #setExponentSignAlwaysShown
1495      * @stable ICU 2.0
1496      */
1497     virtual void setScientificNotation(UBool useScientific);
1498
1499     /**
1500      * Return the minimum exponent digits that will be shown.
1501      * @return the minimum exponent digits that will be shown
1502      * @see #setScientificNotation
1503      * @see #isScientificNotation
1504      * @see #setMinimumExponentDigits
1505      * @see #isExponentSignAlwaysShown
1506      * @see #setExponentSignAlwaysShown
1507      * @stable ICU 2.0
1508      */
1509     virtual int8_t getMinimumExponentDigits(void) const;
1510
1511     /**
1512      * Set the minimum exponent digits that will be shown.  This has no
1513      * effect unless scientific notation is in use.
1514      * @param minExpDig a value >= 1 indicating the fewest exponent digits
1515      * that will be shown.  Values less than 1 will be treated as 1.
1516      * @see #setScientificNotation
1517      * @see #isScientificNotation
1518      * @see #getMinimumExponentDigits
1519      * @see #isExponentSignAlwaysShown
1520      * @see #setExponentSignAlwaysShown
1521      * @stable ICU 2.0
1522      */
1523     virtual void setMinimumExponentDigits(int8_t minExpDig);
1524
1525     /**
1526      * Return whether the exponent sign is always shown.
1527      * @return TRUE if the exponent is always prefixed with either the
1528      * localized minus sign or the localized plus sign, false if only negative
1529      * exponents are prefixed with the localized minus sign.
1530      * @see #setScientificNotation
1531      * @see #isScientificNotation
1532      * @see #setMinimumExponentDigits
1533      * @see #getMinimumExponentDigits
1534      * @see #setExponentSignAlwaysShown
1535      * @stable ICU 2.0
1536      */
1537     virtual UBool isExponentSignAlwaysShown(void) const;
1538
1539     /**
1540      * Set whether the exponent sign is always shown.  This has no effect
1541      * unless scientific notation is in use.
1542      * @param expSignAlways TRUE if the exponent is always prefixed with either
1543      * the localized minus sign or the localized plus sign, false if only
1544      * negative exponents are prefixed with the localized minus sign.
1545      * @see #setScientificNotation
1546      * @see #isScientificNotation
1547      * @see #setMinimumExponentDigits
1548      * @see #getMinimumExponentDigits
1549      * @see #isExponentSignAlwaysShown
1550      * @stable ICU 2.0
1551      */
1552     virtual void setExponentSignAlwaysShown(UBool expSignAlways);
1553
1554     /**
1555      * Return the grouping size. Grouping size is the number of digits between
1556      * grouping separators in the integer portion of a number.  For example,
1557      * in the number "123,456.78", the grouping size is 3.
1558      *
1559      * @return    the grouping size.
1560      * @see setGroupingSize
1561      * @see NumberFormat::isGroupingUsed
1562      * @see DecimalFormatSymbols::getGroupingSeparator
1563      * @stable ICU 2.0
1564      */
1565     int32_t getGroupingSize(void) const;
1566
1567     /**
1568      * Set the grouping size. Grouping size is the number of digits between
1569      * grouping separators in the integer portion of a number.  For example,
1570      * in the number "123,456.78", the grouping size is 3.
1571      *
1572      * @param newValue    the new value of the grouping size.
1573      * @see getGroupingSize
1574      * @see NumberFormat::setGroupingUsed
1575      * @see DecimalFormatSymbols::setGroupingSeparator
1576      * @stable ICU 2.0
1577      */
1578     virtual void setGroupingSize(int32_t newValue);
1579
1580     /**
1581      * Return the secondary grouping size. In some locales one
1582      * grouping interval is used for the least significant integer
1583      * digits (the primary grouping size), and another is used for all
1584      * others (the secondary grouping size).  A formatter supporting a
1585      * secondary grouping size will return a positive integer unequal
1586      * to the primary grouping size returned by
1587      * getGroupingSize().  For example, if the primary
1588      * grouping size is 4, and the secondary grouping size is 2, then
1589      * the number 123456789 formats as "1,23,45,6789", and the pattern
1590      * appears as "#,##,###0".
1591      * @return the secondary grouping size, or a value less than
1592      * one if there is none
1593      * @see setSecondaryGroupingSize
1594      * @see NumberFormat::isGroupingUsed
1595      * @see DecimalFormatSymbols::getGroupingSeparator
1596      * @stable ICU 2.4
1597      */
1598     int32_t getSecondaryGroupingSize(void) const;
1599
1600     /**
1601      * Set the secondary grouping size. If set to a value less than 1,
1602      * then secondary grouping is turned off, and the primary grouping
1603      * size is used for all intervals, not just the least significant.
1604      *
1605      * @param newValue    the new value of the secondary grouping size.
1606      * @see getSecondaryGroupingSize
1607      * @see NumberFormat#setGroupingUsed
1608      * @see DecimalFormatSymbols::setGroupingSeparator
1609      * @stable ICU 2.4
1610      */
1611     virtual void setSecondaryGroupingSize(int32_t newValue);
1612
1613     /**
1614      * Allows you to get the behavior of the decimal separator with integers.
1615      * (The decimal separator will always appear with decimals.)
1616      *
1617      * @return    TRUE if the decimal separator always appear with decimals.
1618      * Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
1619      * @stable ICU 2.0
1620      */
1621     UBool isDecimalSeparatorAlwaysShown(void) const;
1622
1623     /**
1624      * Allows you to set the behavior of the decimal separator with integers.
1625      * (The decimal separator will always appear with decimals.)
1626      *
1627      * @param newValue    set TRUE if the decimal separator will always appear with decimals.
1628      * Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
1629      * @stable ICU 2.0
1630      */
1631     virtual void setDecimalSeparatorAlwaysShown(UBool newValue);
1632
1633 #ifndef U_HIDE_DRAFT_API
1634     /**
1635      * Allows you to get the parse behavior of the pattern decimal mark.
1636      *
1637      * @return    TRUE if input must contain a match to decimal mark in pattern
1638      * @draft ICU 54
1639      */
1640     UBool isDecimalPatternMatchRequired(void) const;
1641 #endif  /* U_HIDE_DRAFT_API */
1642
1643     /**
1644      * Allows you to set the behavior of the pattern decimal mark.
1645      * 
1646      * if TRUE, the input must have a decimal mark if one was specified in the pattern. When
1647      * FALSE the decimal mark may be omitted from the input.
1648      *
1649      * @param newValue    set TRUE if input must contain a match to decimal mark in pattern
1650      * @draft ICU 54
1651      */
1652     virtual void setDecimalPatternMatchRequired(UBool newValue);
1653
1654
1655     /**
1656      * Synthesizes a pattern string that represents the current state
1657      * of this Format object.
1658      *
1659      * @param result    Output param which will receive the pattern.
1660      *                  Previous contents are deleted.
1661      * @return          A reference to 'result'.
1662      * @see applyPattern
1663      * @stable ICU 2.0
1664      */
1665     virtual UnicodeString& toPattern(UnicodeString& result) const;
1666
1667     /**
1668      * Synthesizes a localized pattern string that represents the current
1669      * state of this Format object.
1670      *
1671      * @param result    Output param which will receive the localized pattern.
1672      *                  Previous contents are deleted.
1673      * @return          A reference to 'result'.
1674      * @see applyPattern
1675      * @stable ICU 2.0
1676      */
1677     virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const;
1678
1679     /**
1680      * Apply the given pattern to this Format object.  A pattern is a
1681      * short-hand specification for the various formatting properties.
1682      * These properties can also be changed individually through the
1683      * various setter methods.
1684      * <P>
1685      * There is no limit to integer digits are set
1686      * by this routine, since that is the typical end-user desire;
1687      * use setMaximumInteger if you want to set a real value.
1688      * For negative numbers, use a second pattern, separated by a semicolon
1689      * <pre>
1690      * .      Example "#,#00.0#" -> 1,234.56
1691      * </pre>
1692      * This means a minimum of 2 integer digits, 1 fraction digit, and
1693      * a maximum of 2 fraction digits.
1694      * <pre>
1695      * .      Example: "#,#00.0#;(#,#00.0#)" for negatives in parantheses.
1696      * </pre>
1697      * In negative patterns, the minimum and maximum counts are ignored;
1698      * these are presumed to be set in the positive pattern.
1699      *
1700      * @param pattern    The pattern to be applied.
1701      * @param parseError Struct to recieve information on position
1702      *                   of error if an error is encountered
1703      * @param status     Output param set to success/failure code on
1704      *                   exit. If the pattern is invalid, this will be
1705      *                   set to a failure result.
1706      * @stable ICU 2.0
1707      */
1708     virtual void applyPattern(const UnicodeString& pattern,
1709                              UParseError& parseError,
1710                              UErrorCode& status);
1711     /**
1712      * Sets the pattern.
1713      * @param pattern   The pattern to be applied.
1714      * @param status    Output param set to success/failure code on
1715      *                  exit. If the pattern is invalid, this will be
1716      *                  set to a failure result.
1717      * @stable ICU 2.0
1718      */
1719     virtual void applyPattern(const UnicodeString& pattern,
1720                              UErrorCode& status);
1721
1722     /**
1723      * Apply the given pattern to this Format object.  The pattern
1724      * is assumed to be in a localized notation. A pattern is a
1725      * short-hand specification for the various formatting properties.
1726      * These properties can also be changed individually through the
1727      * various setter methods.
1728      * <P>
1729      * There is no limit to integer digits are set
1730      * by this routine, since that is the typical end-user desire;
1731      * use setMaximumInteger if you want to set a real value.
1732      * For negative numbers, use a second pattern, separated by a semicolon
1733      * <pre>
1734      * .      Example "#,#00.0#" -> 1,234.56
1735      * </pre>
1736      * This means a minimum of 2 integer digits, 1 fraction digit, and
1737      * a maximum of 2 fraction digits.
1738      *
1739      * Example: "#,#00.0#;(#,#00.0#)" for negatives in parantheses.
1740      *
1741      * In negative patterns, the minimum and maximum counts are ignored;
1742      * these are presumed to be set in the positive pattern.
1743      *
1744      * @param pattern   The localized pattern to be applied.
1745      * @param parseError Struct to recieve information on position
1746      *                   of error if an error is encountered
1747      * @param status    Output param set to success/failure code on
1748      *                  exit. If the pattern is invalid, this will be
1749      *                  set to a failure result.
1750      * @stable ICU 2.0
1751      */
1752     virtual void applyLocalizedPattern(const UnicodeString& pattern,
1753                                        UParseError& parseError,
1754                                        UErrorCode& status);
1755
1756     /**
1757      * Apply the given pattern to this Format object.
1758      *
1759      * @param pattern   The localized pattern to be applied.
1760      * @param status    Output param set to success/failure code on
1761      *                  exit. If the pattern is invalid, this will be
1762      *                  set to a failure result.
1763      * @stable ICU 2.0
1764      */
1765     virtual void applyLocalizedPattern(const UnicodeString& pattern,
1766                                        UErrorCode& status);
1767
1768
1769     /**
1770      * Sets the maximum number of digits allowed in the integer portion of a
1771      * number. This override limits the integer digit count to 309.
1772      *
1773      * @param newValue    the new value of the maximum number of digits
1774      *                      allowed in the integer portion of a number.
1775      * @see NumberFormat#setMaximumIntegerDigits
1776      * @stable ICU 2.0
1777      */
1778     virtual void setMaximumIntegerDigits(int32_t newValue);
1779
1780     /**
1781      * Sets the minimum number of digits allowed in the integer portion of a
1782      * number. This override limits the integer digit count to 309.
1783      *
1784      * @param newValue    the new value of the minimum number of digits
1785      *                      allowed in the integer portion of a number.
1786      * @see NumberFormat#setMinimumIntegerDigits
1787      * @stable ICU 2.0
1788      */
1789     virtual void setMinimumIntegerDigits(int32_t newValue);
1790
1791     /**
1792      * Sets the maximum number of digits allowed in the fraction portion of a
1793      * number. This override limits the fraction digit count to 340.
1794      *
1795      * @param newValue    the new value of the maximum number of digits
1796      *                    allowed in the fraction portion of a number.
1797      * @see NumberFormat#setMaximumFractionDigits
1798      * @stable ICU 2.0
1799      */
1800     virtual void setMaximumFractionDigits(int32_t newValue);
1801
1802     /**
1803      * Sets the minimum number of digits allowed in the fraction portion of a
1804      * number. This override limits the fraction digit count to 340.
1805      *
1806      * @param newValue    the new value of the minimum number of digits
1807      *                    allowed in the fraction portion of a number.
1808      * @see NumberFormat#setMinimumFractionDigits
1809      * @stable ICU 2.0
1810      */
1811     virtual void setMinimumFractionDigits(int32_t newValue);
1812
1813     /**
1814      * Returns the minimum number of significant digits that will be
1815      * displayed. This value has no effect unless areSignificantDigitsUsed()
1816      * returns true.
1817      * @return the fewest significant digits that will be shown
1818      * @stable ICU 3.0
1819      */
1820     int32_t getMinimumSignificantDigits() const;
1821
1822     /**
1823      * Returns the maximum number of significant digits that will be
1824      * displayed. This value has no effect unless areSignificantDigitsUsed()
1825      * returns true.
1826      * @return the most significant digits that will be shown
1827      * @stable ICU 3.0
1828      */
1829     int32_t getMaximumSignificantDigits() const;
1830
1831     /**
1832      * Sets the minimum number of significant digits that will be
1833      * displayed.  If <code>min</code> is less than one then it is set
1834      * to one.  If the maximum significant digits count is less than
1835      * <code>min</code>, then it is set to <code>min</code>.
1836      * This function also enables the use of significant digits
1837      * by this formatter - areSignificantDigitsUsed() will return TRUE.
1838      * @see #areSignificantDigitsUsed
1839      * @param min the fewest significant digits to be shown
1840      * @stable ICU 3.0
1841      */
1842     void setMinimumSignificantDigits(int32_t min);
1843
1844     /**
1845      * Sets the maximum number of significant digits that will be
1846      * displayed.  If <code>max</code> is less than one then it is set
1847      * to one.  If the minimum significant digits count is greater
1848      * than <code>max</code>, then it is set to <code>max</code>.
1849      * This function also enables the use of significant digits
1850      * by this formatter - areSignificantDigitsUsed() will return TRUE.
1851      * @see #areSignificantDigitsUsed
1852      * @param max the most significant digits to be shown
1853      * @stable ICU 3.0
1854      */
1855     void setMaximumSignificantDigits(int32_t max);
1856
1857     /**
1858      * Returns true if significant digits are in use, or false if
1859      * integer and fraction digit counts are in use.
1860      * @return true if significant digits are in use
1861      * @stable ICU 3.0
1862      */
1863     UBool areSignificantDigitsUsed() const;
1864
1865     /**
1866      * Sets whether significant digits are in use, or integer and
1867      * fraction digit counts are in use.
1868      * @param useSignificantDigits true to use significant digits, or
1869      * false to use integer and fraction digit counts
1870      * @stable ICU 3.0
1871      */
1872     void setSignificantDigitsUsed(UBool useSignificantDigits);
1873
1874  public:
1875     /**
1876      * Sets the currency used to display currency
1877      * amounts.  This takes effect immediately, if this format is a
1878      * currency format.  If this format is not a currency format, then
1879      * the currency is used if and when this object becomes a
1880      * currency format through the application of a new pattern.
1881      * @param theCurrency a 3-letter ISO code indicating new currency
1882      * to use.  It need not be null-terminated.  May be the empty
1883      * string or NULL to indicate no currency.
1884      * @param ec input-output error code
1885      * @stable ICU 3.0
1886      */
1887     virtual void setCurrency(const UChar* theCurrency, UErrorCode& ec);
1888
1889     /**
1890      * Sets the currency used to display currency amounts.  See
1891      * setCurrency(const UChar*, UErrorCode&).
1892      * @deprecated ICU 3.0. Use setCurrency(const UChar*, UErrorCode&).
1893      */
1894     virtual void setCurrency(const UChar* theCurrency);
1895
1896 #ifndef U_HIDE_DRAFT_API
1897     /**
1898      * Sets the <tt>Currency Context</tt> object used to display currency.
1899      * This takes effect immediately, if this format is a
1900      * currency format.  
1901      * @param currencyContext new currency context object to use.  
1902      * @draft ICU 54
1903      */
1904     void setCurrencyUsage(UCurrencyUsage newUsage, UErrorCode* ec);
1905
1906     /**
1907      * Returns the <tt>Currency Context</tt> object used to display currency
1908      * @draft ICU 54
1909      */
1910     UCurrencyUsage getCurrencyUsage() const;
1911 #endif  /* U_HIDE_DRAFT_API */
1912
1913
1914 #ifndef U_HIDE_DEPRECATED_API
1915     /**
1916      * The resource tags we use to retrieve decimal format data from
1917      * locale resource bundles.
1918      * @deprecated ICU 3.4. This string has no public purpose. Please don't use it.
1919      */
1920     static const char fgNumberPatterns[];
1921 #endif  /* U_HIDE_DEPRECATED_API */
1922
1923 #ifndef U_HIDE_INTERNAL_API
1924     /**
1925      *  Get a FixedDecimal corresponding to a double as it would be
1926      *  formatted by this DecimalFormat.
1927      *  Internal, not intended for public use.
1928      *  @internal
1929      */
1930      FixedDecimal getFixedDecimal(double number, UErrorCode &status) const;
1931
1932     /**
1933      *  Get a FixedDecimal corresponding to a formattable as it would be
1934      *  formatted by this DecimalFormat.
1935      *  Internal, not intended for public use.
1936      *  @internal
1937      */
1938      FixedDecimal getFixedDecimal(const Formattable &number, UErrorCode &status) const;
1939
1940     /**
1941      *  Get a FixedDecimal corresponding to a DigitList as it would be
1942      *  formatted by this DecimalFormat. Note: the DigitList may be modified.
1943      *  Internal, not intended for public use.
1944      *  @internal
1945      */
1946      FixedDecimal getFixedDecimal(DigitList &number, UErrorCode &status) const;
1947 #endif  /* U_HIDE_INTERNAL_API */
1948
1949 public:
1950
1951     /**
1952      * Return the class ID for this class.  This is useful only for
1953      * comparing to a return value from getDynamicClassID().  For example:
1954      * <pre>
1955      * .      Base* polymorphic_pointer = createPolymorphicObject();
1956      * .      if (polymorphic_pointer->getDynamicClassID() ==
1957      * .          Derived::getStaticClassID()) ...
1958      * </pre>
1959      * @return          The class ID for all objects of this class.
1960      * @stable ICU 2.0
1961      */
1962     static UClassID U_EXPORT2 getStaticClassID(void);
1963
1964     /**
1965      * Returns a unique class ID POLYMORPHICALLY.  Pure virtual override.
1966      * This method is to implement a simple version of RTTI, since not all
1967      * C++ compilers support genuine RTTI.  Polymorphic operator==() and
1968      * clone() methods call this method.
1969      *
1970      * @return          The class ID for this object. All objects of a
1971      *                  given class have the same class ID.  Objects of
1972      *                  other classes have different class IDs.
1973      * @stable ICU 2.0
1974      */
1975     virtual UClassID getDynamicClassID(void) const;
1976
1977 private:
1978
1979     DecimalFormat(); // default constructor not implemented
1980
1981     int32_t precision() const;
1982
1983     /**
1984      *   Initialize all fields of a new DecimalFormatter to a safe default value.
1985      *      Common code for use by constructors.
1986      */
1987     void init();
1988
1989     /**
1990      * Do real work of constructing a new DecimalFormat.
1991      */
1992     void construct(UErrorCode&              status,
1993                    UParseError&             parseErr,
1994                    const UnicodeString*     pattern = 0,
1995                    DecimalFormatSymbols*    symbolsToAdopt = 0
1996                    );
1997
1998     /**
1999      * Does the real work of generating a pattern.
2000      *
2001      * @param result     Output param which will receive the pattern.
2002      *                   Previous contents are deleted.
2003      * @param localized  TRUE return localized pattern.
2004      * @return           A reference to 'result'.
2005      */
2006     UnicodeString& toPattern(UnicodeString& result, UBool localized) const;
2007
2008     /**
2009      * Does the real work of applying a pattern.
2010      * @param pattern    The pattern to be applied.
2011      * @param localized  If true, the pattern is localized; else false.
2012      * @param parseError Struct to recieve information on position
2013      *                   of error if an error is encountered
2014      * @param status     Output param set to success/failure code on
2015      *                   exit. If the pattern is invalid, this will be
2016      *                   set to a failure result.
2017      */
2018     void applyPattern(const UnicodeString& pattern,
2019                             UBool localized,
2020                             UParseError& parseError,
2021                             UErrorCode& status);
2022
2023     /*
2024      * similar to applyPattern, but without re-gen affix for currency
2025      */
2026     void applyPatternInternally(const UnicodeString& pluralCount,
2027                                 const UnicodeString& pattern,
2028                                 UBool localized,
2029                                 UParseError& parseError,
2030                                 UErrorCode& status);
2031
2032     /*
2033      * only apply pattern without expand affixes
2034      */
2035     void applyPatternWithoutExpandAffix(const UnicodeString& pattern,
2036                                         UBool localized,
2037                                         UParseError& parseError,
2038                                         UErrorCode& status);
2039
2040
2041     /*
2042      * expand affixes (after apply patter) and re-compute fFormatWidth
2043      */
2044     void expandAffixAdjustWidth(const UnicodeString* pluralCount);
2045
2046
2047     /**
2048      * Do the work of formatting a number, either a double or a long.
2049      *
2050      * @param appendTo       Output parameter to receive result.
2051      *                       Result is appended to existing contents.
2052      * @param handler        Records information about field positions.
2053      * @param digits         the digits to be formatted.
2054      * @param isInteger      if TRUE format the digits as Integer.
2055      * @return               Reference to 'appendTo' parameter.
2056      */
2057     UnicodeString& subformat(UnicodeString& appendTo,
2058                              FieldPositionHandler& handler,
2059                              DigitList&     digits,
2060                              UBool          isInteger,
2061                              UErrorCode &status) const;
2062
2063
2064     void parse(const UnicodeString& text,
2065                Formattable& result,
2066                ParsePosition& pos,
2067                UChar* currency) const;
2068
2069     enum {
2070         fgStatusInfinite,
2071         fgStatusLength      // Leave last in list.
2072     } StatusFlags;
2073
2074     UBool subparse(const UnicodeString& text,
2075                    const UnicodeString* negPrefix,
2076                    const UnicodeString* negSuffix,
2077                    const UnicodeString* posPrefix,
2078                    const UnicodeString* posSuffix,
2079                    UBool complexCurrencyParsing,
2080                    int8_t type,
2081                    ParsePosition& parsePosition,
2082                    DigitList& digits, UBool* status,
2083                    UChar* currency) const;
2084
2085     // Mixed style parsing for currency.
2086     // It parses against the current currency pattern
2087     // using complex affix comparison
2088     // parses against the currency plural patterns using complex affix comparison,
2089     // and parses against the current pattern using simple affix comparison.
2090     UBool parseForCurrency(const UnicodeString& text,
2091                            ParsePosition& parsePosition,
2092                            DigitList& digits,
2093                            UBool* status,
2094                            UChar* currency) const;
2095
2096     int32_t skipPadding(const UnicodeString& text, int32_t position) const;
2097
2098     int32_t compareAffix(const UnicodeString& input,
2099                          int32_t pos,
2100                          UBool isNegative,
2101                          UBool isPrefix,
2102                          const UnicodeString* affixPat,
2103                          UBool complexCurrencyParsing,
2104                          int8_t type,
2105                          UChar* currency) const;
2106
2107     static UnicodeString& trimMarksFromAffix(const UnicodeString& affix, UnicodeString& trimmedAffix);
2108
2109     UBool equalWithSignCompatibility(UChar32 lhs, UChar32 rhs) const;
2110
2111     int32_t compareSimpleAffix(const UnicodeString& affix,
2112                                       const UnicodeString& input,
2113                                       int32_t pos,
2114                                       UBool lenient) const;
2115
2116     static int32_t skipPatternWhiteSpace(const UnicodeString& text, int32_t pos);
2117
2118     static int32_t skipUWhiteSpace(const UnicodeString& text, int32_t pos);
2119
2120     static int32_t skipUWhiteSpaceAndMarks(const UnicodeString& text, int32_t pos);
2121
2122     static int32_t skipBidiMarks(const UnicodeString& text, int32_t pos);
2123
2124     int32_t compareComplexAffix(const UnicodeString& affixPat,
2125                                 const UnicodeString& input,
2126                                 int32_t pos,
2127                                 int8_t type,
2128                                 UChar* currency) const;
2129
2130     static int32_t match(const UnicodeString& text, int32_t pos, UChar32 ch);
2131
2132     static int32_t match(const UnicodeString& text, int32_t pos, const UnicodeString& str);
2133
2134     static UBool matchSymbol(const UnicodeString &text, int32_t position, int32_t length, const UnicodeString &symbol,
2135                              UnicodeSet *sset, UChar32 schar);
2136
2137     static UBool matchDecimal(UChar32 symbolChar,
2138                             UBool sawDecimal,  UChar32 sawDecimalChar,
2139                              const UnicodeSet *sset, UChar32 schar);
2140
2141     static UBool matchGrouping(UChar32 groupingChar,
2142                             UBool sawGrouping, UChar32 sawGroupingChar,
2143                              const UnicodeSet *sset,
2144                              UChar32 decimalChar, const UnicodeSet *decimalSet,
2145                              UChar32 schar);
2146
2147     /**
2148      * Get a decimal format symbol.
2149      * Returns a const reference to the symbol string.
2150      * @internal
2151      */
2152     inline const UnicodeString &getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol symbol) const;
2153
2154     int32_t appendAffix(UnicodeString& buf,
2155                         double number,
2156                         FieldPositionHandler& handler,
2157                         UBool isNegative,
2158                         UBool isPrefix) const;
2159
2160     /**
2161      * Append an affix to the given UnicodeString, using quotes if
2162      * there are special characters.  Single quotes themselves must be
2163      * escaped in either case.
2164      */
2165     void appendAffixPattern(UnicodeString& appendTo, const UnicodeString& affix,
2166                             UBool localized) const;
2167
2168     void appendAffixPattern(UnicodeString& appendTo,
2169                             const UnicodeString* affixPattern,
2170                             const UnicodeString& expAffix, UBool localized) const;
2171
2172     void expandAffix(const UnicodeString& pattern,
2173                      UnicodeString& affix,
2174                      double number,
2175                      FieldPositionHandler& handler,
2176                      UBool doFormat,
2177                      const UnicodeString* pluralCount) const;
2178
2179     void expandAffixes(const UnicodeString* pluralCount);
2180
2181     void addPadding(UnicodeString& appendTo,
2182                     FieldPositionHandler& handler,
2183                     int32_t prefixLen, int32_t suffixLen) const;
2184
2185     UBool isGroupingPosition(int32_t pos) const;
2186
2187     void setCurrencyForSymbols();
2188
2189     // similar to setCurrency without re-compute the affixes for currency.
2190     // If currency changes, the affix pattern for currency is not changed,
2191     // but the affix will be changed. So, affixes need to be
2192     // re-computed in setCurrency(), but not in setCurrencyInternally().
2193     virtual void setCurrencyInternally(const UChar* theCurrency, UErrorCode& ec);
2194
2195     // set up currency affix patterns for mix parsing.
2196     // The patterns saved here are the affix patterns of default currency
2197     // pattern and the unique affix patterns of the plural currency patterns.
2198     // Those patterns are used by parseForCurrency().
2199     void setupCurrencyAffixPatterns(UErrorCode& status);
2200
2201     // set up the currency affixes used in currency plural formatting.
2202     // It sets up both fAffixesForCurrency for currency pattern if the current
2203     // pattern contains 3 currency signs,
2204     // and it sets up fPluralAffixesForCurrency for currency plural patterns.
2205     void setupCurrencyAffixes(const UnicodeString& pattern,
2206                               UBool setupForCurrentPattern,
2207                               UBool setupForPluralPattern,
2208                               UErrorCode& status);
2209         
2210     // get the currency rounding with respect to currency usage
2211     double getCurrencyRounding(const UChar* currency,
2212                                UErrorCode* ec) const;
2213         
2214     // get the currency fraction with respect to currency usage
2215     int getCurrencyFractionDigits(const UChar* currency,
2216                                   UErrorCode* ec) const;
2217
2218     // hashtable operations
2219     Hashtable* initHashForAffixPattern(UErrorCode& status);
2220     Hashtable* initHashForAffix(UErrorCode& status);
2221
2222     void deleteHashForAffixPattern();
2223     void deleteHashForAffix(Hashtable*& table);
2224
2225     void copyHashForAffixPattern(const Hashtable* source,
2226                                  Hashtable* target, UErrorCode& status);
2227     void copyHashForAffix(const Hashtable* source,
2228                           Hashtable* target, UErrorCode& status);
2229
2230     UnicodeString& _format(int64_t number,
2231                            UnicodeString& appendTo,
2232                            FieldPositionHandler& handler,
2233                            UErrorCode &status) const;
2234     UnicodeString& _format(double number,
2235                            UnicodeString& appendTo,
2236                            FieldPositionHandler& handler,
2237                            UErrorCode &status) const;
2238     UnicodeString& _format(const DigitList &number,
2239                            UnicodeString& appendTo,
2240                            FieldPositionHandler& handler,
2241                            UErrorCode &status) const;
2242
2243     /**
2244      * Constants.
2245      */
2246
2247     UnicodeString           fPositivePrefix;
2248     UnicodeString           fPositiveSuffix;
2249     UnicodeString           fNegativePrefix;
2250     UnicodeString           fNegativeSuffix;
2251     UnicodeString*          fPosPrefixPattern;
2252     UnicodeString*          fPosSuffixPattern;
2253     UnicodeString*          fNegPrefixPattern;
2254     UnicodeString*          fNegSuffixPattern;
2255
2256     /**
2257      * Formatter for ChoiceFormat-based currency names.  If this field
2258      * is not null, then delegate to it to format currency symbols.
2259      * @since ICU 2.6
2260      */
2261     ChoiceFormat*           fCurrencyChoice;
2262
2263     DigitList *             fMultiplier;   // NULL for multiplier of one
2264     int32_t                 fScale;
2265     int32_t                 fGroupingSize;
2266     int32_t                 fGroupingSize2;
2267     UBool                   fDecimalSeparatorAlwaysShown;
2268     DecimalFormatSymbols*   fSymbols;
2269
2270     UBool                   fUseSignificantDigits;
2271     int32_t                 fMinSignificantDigits;
2272     int32_t                 fMaxSignificantDigits;
2273
2274     UBool                   fUseExponentialNotation;
2275     int8_t                  fMinExponentDigits;
2276     UBool                   fExponentSignAlwaysShown;
2277
2278     EnumSet<UNumberFormatAttribute,
2279             UNUM_MAX_NONBOOLEAN_ATTRIBUTE+1,
2280             UNUM_LIMIT_BOOLEAN_ATTRIBUTE>
2281                             fBoolFlags;
2282
2283     DigitList*              fRoundingIncrement;  // NULL if no rounding increment specified.
2284     ERoundingMode           fRoundingMode;
2285
2286     UChar32                 fPad;
2287     int32_t                 fFormatWidth;
2288     EPadPosition            fPadPosition;
2289
2290     /*
2291      * Following are used for currency format
2292      */
2293     // pattern used in this formatter
2294     UnicodeString fFormatPattern;
2295     // style is only valid when decimal formatter is constructed by
2296     // DecimalFormat(pattern, decimalFormatSymbol, style)
2297     int fStyle;
2298     /*
2299      * Represents whether this is a currency format, and which
2300      * currency format style.
2301      * 0: not currency format type;
2302      * 1: currency style -- symbol name, such as "$" for US dollar.
2303      * 2: currency style -- ISO name, such as USD for US dollar.
2304      * 3: currency style -- plural long name, such as "US Dollar" for
2305      *                      "1.00 US Dollar", or "US Dollars" for
2306      *                      "3.00 US Dollars".
2307      */
2308     int fCurrencySignCount;
2309
2310
2311     /* For currency parsing purose,
2312      * Need to remember all prefix patterns and suffix patterns of
2313      * every currency format pattern,
2314      * including the pattern of default currecny style
2315      * and plural currency style. And the patterns are set through applyPattern.
2316      */
2317     // TODO: innerclass?
2318     /* This is not needed in the class declaration, so it is moved into decimfmp.cpp
2319     struct AffixPatternsForCurrency : public UMemory {
2320         // negative prefix pattern
2321         UnicodeString negPrefixPatternForCurrency;
2322         // negative suffix pattern
2323         UnicodeString negSuffixPatternForCurrency;
2324         // positive prefix pattern
2325         UnicodeString posPrefixPatternForCurrency;
2326         // positive suffix pattern
2327         UnicodeString posSuffixPatternForCurrency;
2328         int8_t patternType;
2329
2330         AffixPatternsForCurrency(const UnicodeString& negPrefix,
2331                                  const UnicodeString& negSuffix,
2332                                  const UnicodeString& posPrefix,
2333                                  const UnicodeString& posSuffix,
2334                                  int8_t type) {
2335             negPrefixPatternForCurrency = negPrefix;
2336             negSuffixPatternForCurrency = negSuffix;
2337             posPrefixPatternForCurrency = posPrefix;
2338             posSuffixPatternForCurrency = posSuffix;
2339             patternType = type;
2340         }
2341     };
2342     */
2343
2344     /* affix for currency formatting when the currency sign in the pattern
2345      * equals to 3, such as the pattern contains 3 currency sign or
2346      * the formatter style is currency plural format style.
2347      */
2348     /* This is not needed in the class declaration, so it is moved into decimfmp.cpp
2349     struct AffixesForCurrency : public UMemory {
2350         // negative prefix
2351         UnicodeString negPrefixForCurrency;
2352         // negative suffix
2353         UnicodeString negSuffixForCurrency;
2354         // positive prefix
2355         UnicodeString posPrefixForCurrency;
2356         // positive suffix
2357         UnicodeString posSuffixForCurrency;
2358
2359         int32_t formatWidth;
2360
2361         AffixesForCurrency(const UnicodeString& negPrefix,
2362                            const UnicodeString& negSuffix,
2363                            const UnicodeString& posPrefix,
2364                            const UnicodeString& posSuffix) {
2365             negPrefixForCurrency = negPrefix;
2366             negSuffixForCurrency = negSuffix;
2367             posPrefixForCurrency = posPrefix;
2368             posSuffixForCurrency = posSuffix;
2369         }
2370     };
2371     */
2372
2373     // Affix pattern set for currency.
2374     // It is a set of AffixPatternsForCurrency,
2375     // each element of the set saves the negative prefix pattern,
2376     // negative suffix pattern, positive prefix pattern,
2377     // and positive suffix  pattern of a pattern.
2378     // It is used for currency mixed style parsing.
2379     // It is actually is a set.
2380     // The set contains the default currency pattern from the locale,
2381     // and the currency plural patterns.
2382     // Since it is a set, it does not contain duplicated items.
2383     // For example, if 2 currency plural patterns are the same, only one pattern
2384     // is included in the set. When parsing, we do not check whether the plural
2385     // count match or not.
2386     Hashtable* fAffixPatternsForCurrency;
2387
2388     // Following 2 are affixes for currency.
2389     // It is a hash map from plural count to AffixesForCurrency.
2390     // AffixesForCurrency saves the negative prefix,
2391     // negative suffix, positive prefix, and positive suffix of a pattern.
2392     // It is used during currency formatting only when the currency sign count
2393     // is 3. In which case, the affixes are getting from here, not
2394     // from the fNegativePrefix etc.
2395     Hashtable* fAffixesForCurrency;  // for current pattern
2396     Hashtable* fPluralAffixesForCurrency;  // for plural pattern
2397
2398     // Information needed for DecimalFormat to format/parse currency plural.
2399     CurrencyPluralInfo* fCurrencyPluralInfo;
2400
2401 #if UCONFIG_HAVE_PARSEALLINPUT
2402     UNumberFormatAttributeValue fParseAllInput;
2403 #endif
2404
2405     // Decimal Format Static Sets singleton.
2406     const DecimalFormatStaticSets *fStaticSets;
2407         
2408     // Currency Usage(STANDARD vs CASH)
2409     UCurrencyUsage fCurrencyUsage;
2410
2411 protected:
2412
2413 #ifndef U_HIDE_INTERNAL_API
2414     /**
2415      * Rounds a value according to the rules of this object.
2416      * @internal
2417      */
2418     DigitList& _round(const DigitList& number, DigitList& adjustedNum, UBool& isNegative, UErrorCode& status) const;
2419 #endif  /* U_HIDE_INTERNAL_API */
2420
2421     /**
2422      * Returns the currency in effect for this formatter.  Subclasses
2423      * should override this method as needed.  Unlike getCurrency(),
2424      * this method should never return "".
2425      * @result output parameter for null-terminated result, which must
2426      * have a capacity of at least 4
2427      * @internal
2428      */
2429     virtual void getEffectiveCurrency(UChar* result, UErrorCode& ec) const;
2430
2431   /** number of integer digits
2432    * @stable ICU 2.4
2433    */
2434     static const int32_t  kDoubleIntegerDigits;
2435   /** number of fraction digits
2436    * @stable ICU 2.4
2437    */
2438     static const int32_t  kDoubleFractionDigits;
2439
2440     /**
2441      * When someone turns on scientific mode, we assume that more than this
2442      * number of digits is due to flipping from some other mode that didn't
2443      * restrict the maximum, and so we force 1 integer digit.  We don't bother
2444      * to track and see if someone is using exponential notation with more than
2445      * this number, it wouldn't make sense anyway, and this is just to make sure
2446      * that someone turning on scientific mode with default settings doesn't
2447      * end up with lots of zeroes.
2448      * @stable ICU 2.8
2449      */
2450     static const int32_t  kMaxScientificIntegerDigits;
2451
2452 #if UCONFIG_FORMAT_FASTPATHS_49
2453  private:
2454     /**
2455      * Internal state.
2456      * @internal
2457      */
2458     uint8_t fReserved[UNUM_DECIMALFORMAT_INTERNAL_SIZE];
2459
2460
2461     /**
2462      * Called whenever any state changes. Recomputes whether fastpath is OK to use.
2463      */
2464     void handleChanged();
2465 #endif
2466 };
2467
2468 inline const UnicodeString &
2469 DecimalFormat::getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol symbol) const {
2470     return fSymbols->getConstSymbol(symbol);
2471 }
2472
2473 U_NAMESPACE_END
2474
2475 #endif /* #if !UCONFIG_NO_FORMATTING */
2476
2477 #endif // _DECIMFMT
2478 //eof