codekingpro/portable-devtools
116k
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4********************************************************************************
5* Copyright (C) 1997-2016, International Business Machines
6* Corporation and others. All Rights Reserved.
7********************************************************************************
8*
9* File DECIMFMT.H
10*
11* Modification History:
12*
13* Date Name Description
14* 02/19/97 aliu Converted from java.
15* 03/20/97 clhuang Updated per C++ implementation.
16* 04/03/97 aliu Rewrote parsing and formatting completely, and
17* cleaned up and debugged. Actually works now.
18* 04/17/97 aliu Changed DigitCount to int per code review.
19* 07/10/97 helena Made ParsePosition a class and get rid of the function
20* hiding problems.
21* 09/09/97 aliu Ported over support for exponential formats.
22* 07/20/98 stephen Changed documentation
23* 01/30/13 emmons Added Scaling methods
24********************************************************************************
25*/
26
27#ifndef DECIMFMT_H
28#define DECIMFMT_H
29
30#include "unicode/utypes.h"
31
32#if U_SHOW_CPLUSPLUS_API
33
34/**
35 * \file
36 * \brief C++ API: Compatibility APIs for decimal formatting.
37 */
38
39#if !UCONFIG_NO_FORMATTING
40
41#include "unicode/dcfmtsym.h"
42#include "unicode/numfmt.h"
43#include "unicode/locid.h"
44#include "unicode/fpositer.h"
45#include "unicode/stringpiece.h"
46#include "unicode/curramt.h"
47#include "unicode/enumset.h"
48
49U_NAMESPACE_BEGIN
50
51class CurrencyPluralInfo;
52class CompactDecimalFormat;
53
54namespace number {
55class LocalizedNumberFormatter;
56namespace impl {
57class DecimalQuantity;
58struct DecimalFormatFields;
59class UFormattedNumberData;
60}
61}
62
63namespace numparse {
64namespace impl {
65class NumberParserImpl;
66}
67}
68
69/**
70 * **IMPORTANT:** New users are strongly encouraged to see if
71 * numberformatter.h fits their use case. Although not deprecated, this header
72 * is provided for backwards compatibility only.
73 *
74 * DecimalFormat is a concrete subclass of NumberFormat that formats decimal
75 * numbers. It has a variety of features designed to make it possible to parse
76 * and format numbers in any locale, including support for Western, Arabic, or
77 * Indic digits. It also supports different flavors of numbers, including
78 * integers ("123"), fixed-point numbers ("123.4"), scientific notation
79 * ("1.23E4"), percentages ("12%"), and currency amounts ("$123", "USD123",
80 * "123 US dollars"). All of these flavors can be easily localized.
81 *
82 * To obtain a NumberFormat for a specific locale (including the default
83 * locale) call one of NumberFormat's factory methods such as
84 * createInstance(). Do not call the DecimalFormat constructors directly, unless
85 * you know what you are doing, since the NumberFormat factory methods may
86 * return subclasses other than DecimalFormat.
87 *
88 * **Example Usage**
89 *
90 * \code
91 * // Normally we would have a GUI with a menu for this
92 * int32_t locCount;
93 * const Locale* locales = NumberFormat::getAvailableLocales(locCount);
94 *
95 * double myNumber = -1234.56;
96 * UErrorCode success = U_ZERO_ERROR;
97 * NumberFormat* form;
98 *
99 * // Print out a number with the localized number, currency and percent
100 * // format for each locale.
101 * UnicodeString countryName;
102 * UnicodeString displayName;
103 * UnicodeString str;
104 * UnicodeString pattern;
105 * Formattable fmtable;
106 * for (int32_t j = 0; j < 3; ++j) {
107 * cout << endl << "FORMAT " << j << endl;
108 * for (int32_t i = 0; i < locCount; ++i) {
109 * if (locales[i].getCountry(countryName).size() == 0) {
110 * // skip language-only
111 * continue;
112 * }
113 * switch (j) {
114 * case 0:
115 * form = NumberFormat::createInstance(locales[i], success ); break;
116 * case 1:
117 * form = NumberFormat::createCurrencyInstance(locales[i], success ); break;
118 * default:
119 * form = NumberFormat::createPercentInstance(locales[i], success ); break;
120 * }
121 * if (form) {
122 * str.remove();
123 * pattern = ((DecimalFormat*)form)->toPattern(pattern);
124 * cout << locales[i].getDisplayName(displayName) << ": " << pattern;
125 * cout << " -> " << form->format(myNumber,str) << endl;
126 * form->parse(form->format(myNumber,str), fmtable, success);
127 * delete form;
128 * }
129 * }
130 * }
131 * \endcode
132 *
133 * **Another example use createInstance(style)**
134 *
135 * \code
136 * // Print out a number using the localized number, currency,
137 * // percent, scientific, integer, iso currency, and plural currency
138 * // format for each locale</strong>
139 * Locale* locale = new Locale("en", "US");
140 * double myNumber = 1234.56;
141 * UErrorCode success = U_ZERO_ERROR;
142 * UnicodeString str;
143 * Formattable fmtable;
144 * for (int j=NumberFormat::kNumberStyle;
145 * j<=NumberFormat::kPluralCurrencyStyle;
146 * ++j) {
147 * NumberFormat* form = NumberFormat::createInstance(locale, j, success);
148 * str.remove();
149 * cout << "format result " << form->format(myNumber, str) << endl;
150 * format->parse(form->format(myNumber, str), fmtable, success);
151 * delete form;
152 * }
153 * \endcode
154 *
155 *
156 * <p><strong>Patterns</strong>
157 *
158 * <p>A DecimalFormat consists of a <em>pattern</em> and a set of
159 * <em>symbols</em>. The pattern may be set directly using
160 * applyPattern(), or indirectly using other API methods which
161 * manipulate aspects of the pattern, such as the minimum number of integer
162 * digits. The symbols are stored in a DecimalFormatSymbols
163 * object. When using the NumberFormat factory methods, the
164 * pattern and symbols are read from ICU's locale data.
165 *
166 * <p><strong>Special Pattern Characters</strong>
167 *
168 * <p>Many characters in a pattern are taken literally; they are matched during
169 * parsing and output unchanged during formatting. Special characters, on the
170 * other hand, stand for other characters, strings, or classes of characters.
171 * For example, the '#' character is replaced by a localized digit. Often the
172 * replacement character is the same as the pattern character; in the U.S. locale,
173 * the ',' grouping character is replaced by ','. However, the replacement is
174 * still happening, and if the symbols are modified, the grouping character
175 * changes. Some special characters affect the behavior of the formatter by
176 * their presence; for example, if the percent character is seen, then the
177 * value is multiplied by 100 before being displayed.
178 *
179 * <p>To insert a special character in a pattern as a literal, that is, without
180 * any special meaning, the character must be quoted. There are some exceptions to
181 * this which are noted below.
182 *
183 * <p>The characters listed here are used in non-localized patterns. Localized
184 * patterns use the corresponding characters taken from this formatter's
185 * DecimalFormatSymbols object instead, and these characters lose
186 * their special status. Two exceptions are the currency sign and quote, which
187 * are not localized.
188 *
189 * <table border=0 cellspacing=3 cellpadding=0>
190 * <tr bgcolor="#ccccff">
191 * <td align=left><strong>Symbol</strong>
192 * <td align=left><strong>Location</strong>
193 * <td align=left><strong>Localized?</strong>
194 * <td align=left><strong>Meaning</strong>
195 * <tr valign=top>
196 * <td><code>0</code>
197 * <td>Number
198 * <td>Yes
199 * <td>Digit
200 * <tr valign=top bgcolor="#eeeeff">
201 * <td><code>1-9</code>
202 * <td>Number
203 * <td>Yes
204 * <td>'1' through '9' indicate rounding.
205 * <tr valign=top>
206 * <td><code>\htmlonly@\endhtmlonly</code> <!--doxygen doesn't like @-->
207 * <td>Number
208 * <td>No
209 * <td>Significant digit
210 * <tr valign=top bgcolor="#eeeeff">
211 * <td><code>#</code>
212 * <td>Number
213 * <td>Yes
214 * <td>Digit, zero shows as absent
215 * <tr valign=top>
216 * <td><code>.</code>
217 * <td>Number
218 * <td>Yes
219 * <td>Decimal separator or monetary decimal separator
220 * <tr valign=top bgcolor="#eeeeff">
221 * <td><code>-</code>
222 * <td>Number
223 * <td>Yes
224 * <td>Minus sign
225 * <tr valign=top>
226 * <td><code>,</code>
227 * <td>Number
228 * <td>Yes
229 * <td>Grouping separator
230 * <tr valign=top bgcolor="#eeeeff">
231 * <td><code>E</code>
232 * <td>Number
233 * <td>Yes
234 * <td>Separates mantissa and exponent in scientific notation.
235 * <em>Need not be quoted in prefix or suffix.</em>
236 * <tr valign=top>
237 * <td><code>+</code>
238 * <td>Exponent
239 * <td>Yes
240 * <td>Prefix positive exponents with localized plus sign.
241 * <em>Need not be quoted in prefix or suffix.</em>
242 * <tr valign=top bgcolor="#eeeeff">
243 * <td><code>;</code>
244 * <td>Subpattern boundary
245 * <td>Yes
246 * <td>Separates positive and negative subpatterns
247 * <tr valign=top>
248 * <td><code>\%</code>
249 * <td>Prefix or suffix
250 * <td>Yes
251 * <td>Multiply by 100 and show as percentage
252 * <tr valign=top bgcolor="#eeeeff">
253 * <td><code>\\u2030</code>
254 * <td>Prefix or suffix
255 * <td>Yes
256 * <td>Multiply by 1000 and show as per mille
257 * <tr valign=top>
258 * <td><code>\htmlonly¤\endhtmlonly</code> (<code>\\u00A4</code>)
259 * <td>Prefix or suffix
260 * <td>No
261 * <td>Currency sign, replaced by currency symbol. If
262 * doubled, replaced by international currency symbol.
263 * If tripled, replaced by currency plural names, for example,
264 * "US dollar" or "US dollars" for America.
265 * If present in a pattern, the monetary decimal separator
266 * is used instead of the decimal separator.
267 * <tr valign=top bgcolor="#eeeeff">
268 * <td><code>'</code>
269 * <td>Prefix or suffix
270 * <td>No
271 * <td>Used to quote special characters in a prefix or suffix,
272 * for example, <code>"'#'#"</code> formats 123 to
273 * <code>"#123"</code>. To create a single quote
274 * itself, use two in a row: <code>"# o''clock"</code>.
275 * <tr valign=top>
276 * <td><code>*</code>
277 * <td>Prefix or suffix boundary
278 * <td>Yes
279 * <td>Pad escape, precedes pad character
280 * </table>
281 *
282 * <p>A DecimalFormat pattern contains a positive and negative
283 * subpattern, for example, "#,##0.00;(#,##0.00)". Each subpattern has a
284 * prefix, a numeric part, and a suffix. If there is no explicit negative
285 * subpattern, the negative subpattern is the localized minus sign prefixed to the
286 * positive subpattern. That is, "0.00" alone is equivalent to "0.00;-0.00". If there
287 * is an explicit negative subpattern, it serves only to specify the negative
288 * prefix and suffix; the number of digits, minimal digits, and other
289 * characteristics are ignored in the negative subpattern. That means that
290 * "#,##0.0#;(#)" has precisely the same result as "#,##0.0#;(#,##0.0#)".
291 *
292 * <p>The prefixes, suffixes, and various symbols used for infinity, digits,
293 * thousands separators, decimal separators, etc. may be set to arbitrary
294 * values, and they will appear properly during formatting. However, care must
295 * be taken that the symbols and strings do not conflict, or parsing will be
296 * unreliable. For example, either the positive and negative prefixes or the
297 * suffixes must be distinct for parse() to be able
298 * to distinguish positive from negative values. Another example is that the
299 * decimal separator and thousands separator should be distinct characters, or
300 * parsing will be impossible.
301 *
302 * <p>The <em>grouping separator</em> is a character that separates clusters of
303 * integer digits to make large numbers more legible. It commonly used for
304 * thousands, but in some locales it separates ten-thousands. The <em>grouping
305 * size</em> is the number of digits between the grouping separators, such as 3
306 * for "100,000,000" or 4 for "1 0000 0000". There are actually two different
307 * grouping sizes: One used for the least significant integer digits, the
308 * <em>primary grouping size</em>, and one used for all others, the
309 * <em>secondary grouping size</em>. In most locales these are the same, but
310 * sometimes they are different. For example, if the primary grouping interval
311 * is 3, and the secondary is 2, then this corresponds to the pattern
312 * "#,##,##0", and the number 123456789 is formatted as "12,34,56,789". If a
313 * pattern contains multiple grouping separators, the interval between the last
314 * one and the end of the integer defines the primary grouping size, and the
315 * interval between the last two defines the secondary grouping size. All others
316 * are ignored, so "#,##,###,####" == "###,###,####" == "##,#,###,####".
317 *
318 * <p>Illegal patterns, such as "#.#.#" or "#.###,###", will cause
319 * DecimalFormat to set a failing UErrorCode.
320 *
321 * <p><strong>Pattern BNF</strong>
322 *
323 * <pre>
324 * pattern := subpattern (';' subpattern)?
325 * subpattern := prefix? number exponent? suffix?
326 * number := (integer ('.' fraction)?) | sigDigits
327 * prefix := '\\u0000'..'\\uFFFD' - specialCharacters
328 * suffix := '\\u0000'..'\\uFFFD' - specialCharacters
329 * integer := '#'* '0'* '0'
330 * fraction := '0'* '#'*
331 * sigDigits := '#'* '@' '@'* '#'*
332 * exponent := 'E' '+'? '0'* '0'
333 * padSpec := '*' padChar
334 * padChar := '\\u0000'..'\\uFFFD' - quote
335 *
336 * Notation:
337 * X* 0 or more instances of X
338 * X? 0 or 1 instances of X
339 * X|Y either X or Y
340 * C..D any character from C up to D, inclusive
341 * S-T characters in S, except those in T
342 * </pre>
343 * The first subpattern is for positive numbers. The second (optional)
344 * subpattern is for negative numbers.
345 *
346 * <p>Not indicated in the BNF syntax above:
347 *
348 * <ul><li>The grouping separator ',' can occur inside the integer and
349 * sigDigits elements, between any two pattern characters of that
350 * element, as long as the integer or sigDigits element is not
351 * followed by the exponent element.
352 *
353 * <li>Two grouping intervals are recognized: That between the
354 * decimal point and the first grouping symbol, and that
355 * between the first and second grouping symbols. These
356 * intervals are identical in most locales, but in some
357 * locales they differ. For example, the pattern
358 * "#,##,###" formats the number 123456789 as
359 * "12,34,56,789".</li>
360 *
361 * <li>The pad specifier <code>padSpec</code> may appear before the prefix,
362 * after the prefix, before the suffix, after the suffix, or not at all.
363 *
364 * <li>In place of '0', the digits '1' through '9' may be used to
365 * indicate a rounding increment.
366 * </ul>
367 *
368 * <p><strong>Parsing</strong>
369 *
370 * <p>DecimalFormat parses all Unicode characters that represent
371 * decimal digits, as defined by u_charDigitValue(). In addition,
372 * DecimalFormat also recognizes as digits the ten consecutive
373 * characters starting with the localized zero digit defined in the
374 * DecimalFormatSymbols object. During formatting, the
375 * DecimalFormatSymbols-based digits are output.
376 *
377 * <p>During parsing, grouping separators are ignored if in lenient mode;
378 * otherwise, if present, they must be in appropriate positions.
379 *
380 * <p>For currency parsing, the formatter is able to parse every currency
381 * style formats no matter which style the formatter is constructed with.
382 * For example, a formatter instance gotten from
383 * NumberFormat.getInstance(ULocale, NumberFormat.CURRENCYSTYLE) can parse
384 * formats such as "USD1.00" and "3.00 US dollars".
385 *
386 * <p>If parse(UnicodeString&,Formattable&,ParsePosition&)
387 * fails to parse a string, it leaves the parse position unchanged.
388 * The convenience method parse(UnicodeString&,Formattable&,UErrorCode&)
389 * indicates parse failure by setting a failing
390 * UErrorCode.
391 *
392 * <p><strong>Formatting</strong>
393 *
394 * <p>Formatting is guided by several parameters, all of which can be
395 * specified either using a pattern or using the API. The following
396 * description applies to formats that do not use <a href="#sci">scientific
397 * notation</a> or <a href="#sigdig">significant digits</a>.
398 *
399 * <ul><li>If the number of actual integer digits exceeds the
400 * <em>maximum integer digits</em>, then only the least significant
401 * digits are shown. For example, 1997 is formatted as "97" if the
402 * maximum integer digits is set to 2.
403 *
404 * <li>If the number of actual integer digits is less than the
405 * <em>minimum integer digits</em>, then leading zeros are added. For
406 * example, 1997 is formatted as "01997" if the minimum integer digits
407 * is set to 5.
408 *
409 * <li>If the number of actual fraction digits exceeds the <em>maximum
410 * fraction digits</em>, then rounding is performed to the
411 * maximum fraction digits. For example, 0.125 is formatted as "0.12"
412 * if the maximum fraction digits is 2. This behavior can be changed
413 * by specifying a rounding increment and/or a rounding mode.
414 *
415 * <li>If the number of actual fraction digits is less than the
416 * <em>minimum fraction digits</em>, then trailing zeros are added.
417 * For example, 0.125 is formatted as "0.1250" if the minimum fraction
418 * digits is set to 4.
419 *
420 * <li>Trailing fractional zeros are not displayed if they occur
421 * <em>j</em> positions after the decimal, where <em>j</em> is less
422 * than the maximum fraction digits. For example, 0.10004 is
423 * formatted as "0.1" if the maximum fraction digits is four or less.
424 * </ul>
425 *
426 * <p><strong>Special Values</strong>
427 *
428 * <p><code>NaN</code> is represented as a single character, typically
429 * <code>\\uFFFD</code>. This character is determined by the
430 * DecimalFormatSymbols object. This is the only value for which
431 * the prefixes and suffixes are not used.
432 *
433 * <p>Infinity is represented as a single character, typically
434 * <code>\\u221E</code>, with the positive or negative prefixes and suffixes
435 * applied. The infinity character is determined by the
436 * DecimalFormatSymbols object.
437 *
438 * <a name="sci"><strong>Scientific Notation</strong></a>
439 *
440 * <p>Numbers in scientific notation are expressed as the product of a mantissa
441 * and a power of ten, for example, 1234 can be expressed as 1.234 x 10<sup>3</sup>. The
442 * mantissa is typically in the half-open interval [1.0, 10.0) or sometimes [0.0, 1.0),
443 * but it need not be. DecimalFormat supports arbitrary mantissas.
444 * DecimalFormat can be instructed to use scientific
445 * notation through the API or through the pattern. In a pattern, the exponent
446 * character immediately followed by one or more digit characters indicates
447 * scientific notation. Example: "0.###E0" formats the number 1234 as
448 * "1.234E3".
449 *
450 * <ul>
451 * <li>The number of digit characters after the exponent character gives the
452 * minimum exponent digit count. There is no maximum. Negative exponents are
453 * formatted using the localized minus sign, <em>not</em> the prefix and suffix
454 * from the pattern. This allows patterns such as "0.###E0 m/s". To prefix
455 * positive exponents with a localized plus sign, specify '+' between the
456 * exponent and the digits: "0.###E+0" will produce formats "1E+1", "1E+0",
457 * "1E-1", etc. (In localized patterns, use the localized plus sign rather than
458 * '+'.)
459 *
460 * <li>The minimum number of integer digits is achieved by adjusting the
461 * exponent. Example: 0.00123 formatted with "00.###E0" yields "12.3E-4". This
462 * only happens if there is no maximum number of integer digits. If there is a
463 * maximum, then the minimum number of integer digits is fixed at one.
464 *
465 * <li>The maximum number of integer digits, if present, specifies the exponent
466 * grouping. The most common use of this is to generate <em>engineering
467 * notation</em>, in which the exponent is a multiple of three, e.g.,
468 * "##0.###E0". The number 12345 is formatted using "##0.####E0" as "12.345E3".
469 *
470 * <li>When using scientific notation, the formatter controls the
471 * digit counts using significant digits logic. The maximum number of
472 * significant digits limits the total number of integer and fraction
473 * digits that will be shown in the mantissa; it does not affect
474 * parsing. For example, 12345 formatted with "##0.##E0" is "12.3E3".
475 * See the section on significant digits for more details.
476 *
477 * <li>The number of significant digits shown is determined as
478 * follows: If areSignificantDigitsUsed() returns false, then the
479 * minimum number of significant digits shown is one, and the maximum
480 * number of significant digits shown is the sum of the <em>minimum
481 * integer</em> and <em>maximum fraction</em> digits, and is
482 * unaffected by the maximum integer digits. If this sum is zero,
483 * then all significant digits are shown. If
484 * areSignificantDigitsUsed() returns true, then the significant digit
485 * counts are specified by getMinimumSignificantDigits() and
486 * getMaximumSignificantDigits(). In this case, the number of
487 * integer digits is fixed at one, and there is no exponent grouping.
488 *
489 * <li>Exponential patterns may not contain grouping separators.
490 * </ul>
491 *
492 * <a name="sigdig"><strong>Significant Digits</strong></a>
493 *
494 * <code>DecimalFormat</code> has two ways of controlling how many
495 * digits are shows: (a) significant digits counts, or (b) integer and
496 * fraction digit counts. Integer and fraction digit counts are
497 * described above. When a formatter is using significant digits
498 * counts, the number of integer and fraction digits is not specified
499 * directly, and the formatter settings for these counts are ignored.
500 * Instead, the formatter uses however many integer and fraction
501 * digits are required to display the specified number of significant
502 * digits. Examples:
503 *
504 * <table border=0 cellspacing=3 cellpadding=0>
505 * <tr bgcolor="#ccccff">
506 * <td align=left>Pattern
507 * <td align=left>Minimum significant digits
508 * <td align=left>Maximum significant digits
509 * <td align=left>Number
510 * <td align=left>Output of format()
511 * <tr valign=top>
512 * <td><code>\@\@\@</code>
513 * <td>3
514 * <td>3
515 * <td>12345
516 * <td><code>12300</code>
517 * <tr valign=top bgcolor="#eeeeff">
518 * <td><code>\@\@\@</code>
519 * <td>3
520 * <td>3
521 * <td>0.12345
522 * <td><code>0.123</code>
523 * <tr valign=top>
524 * <td><code>\@\@##</code>
525 * <td>2
526 * <td>4
527 * <td>3.14159
528 * <td><code>3.142</code>
529 * <tr valign=top bgcolor="#eeeeff">
530 * <td><code>\@\@##</code>
531 * <td>2
532 * <td>4
533 * <td>1.23004
534 * <td><code>1.23</code>
535 * </table>
536 *
537 * <ul>
538 * <li>Significant digit counts may be expressed using patterns that
539 * specify a minimum and maximum number of significant digits. These
540 * are indicated by the <code>'@'</code> and <code>'#'</code>
541 * characters. The minimum number of significant digits is the number
542 * of <code>'@'</code> characters. The maximum number of significant
543 * digits is the number of <code>'@'</code> characters plus the number
544 * of <code>'#'</code> characters following on the right. For
545 * example, the pattern <code>"@@@"</code> indicates exactly 3
546 * significant digits. The pattern <code>"@##"</code> indicates from
547 * 1 to 3 significant digits. Trailing zero digits to the right of
548 * the decimal separator are suppressed after the minimum number of
549 * significant digits have been shown. For example, the pattern
550 * <code>"@##"</code> formats the number 0.1203 as
551 * <code>"0.12"</code>.
552 *
553 * <li>If a pattern uses significant digits, it may not contain a
554 * decimal separator, nor the <code>'0'</code> pattern character.
555 * Patterns such as <code>"@00"</code> or <code>"@.###"</code> are
556 * disallowed.
557 *
558 * <li>Any number of <code>'#'</code> characters may be prepended to
559 * the left of the leftmost <code>'@'</code> character. These have no
560 * effect on the minimum and maximum significant digits counts, but
561 * may be used to position grouping separators. For example,
562 * <code>"#,#@#"</code> indicates a minimum of one significant digits,
563 * a maximum of two significant digits, and a grouping size of three.
564 *
565 * <li>In order to enable significant digits formatting, use a pattern
566 * containing the <code>'@'</code> pattern character. Alternatively,
567 * call setSignificantDigitsUsed(TRUE).
568 *
569 * <li>In order to disable significant digits formatting, use a
570 * pattern that does not contain the <code>'@'</code> pattern
571 * character. Alternatively, call setSignificantDigitsUsed(FALSE).
572 *
573 * <li>The number of significant digits has no effect on parsing.
574 *
575 * <li>Significant digits may be used together with exponential notation. Such
576 * patterns are equivalent to a normal exponential pattern with a minimum and
577 * maximum integer digit count of one, a minimum fraction digit count of
578 * <code>getMinimumSignificantDigits() - 1</code>, and a maximum fraction digit
579 * count of <code>getMaximumSignificantDigits() - 1</code>. For example, the
580 * pattern <code>"@@###E0"</code> is equivalent to <code>"0.0###E0"</code>.
581 *
582 * <li>If significant digits are in use, then the integer and fraction
583 * digit counts, as set via the API, are ignored. If significant
584 * digits are not in use, then the significant digit counts, as set via
585 * the API, are ignored.
586 *
587 * </ul>
588 *
589 * <p><strong>Padding</strong>
590 *
591 * <p>DecimalFormat supports padding the result of
592 * format() to a specific width. Padding may be specified either
593 * through the API or through the pattern syntax. In a pattern the pad escape
594 * character, followed by a single pad character, causes padding to be parsed
595 * and formatted. The pad escape character is '*' in unlocalized patterns, and
596 * can be localized using DecimalFormatSymbols::setSymbol() with a
597 * DecimalFormatSymbols::kPadEscapeSymbol
598 * selector. For example, <code>"$*x#,##0.00"</code> formats 123 to
599 * <code>"$xx123.00"</code>, and 1234 to <code>"$1,234.00"</code>.
600 *
601 * <ul>
602 * <li>When padding is in effect, the width of the positive subpattern,
603 * including prefix and suffix, determines the format width. For example, in
604 * the pattern <code>"* #0 o''clock"</code>, the format width is 10.
605 *
606 * <li>The width is counted in 16-bit code units (char16_ts).
607 *
608 * <li>Some parameters which usually do not matter have meaning when padding is
609 * used, because the pattern width is significant with padding. In the pattern
610 * "* ##,##,#,##0.##", the format width is 14. The initial characters "##,##,"
611 * do not affect the grouping size or maximum integer digits, but they do affect
612 * the format width.
613 *
614 * <li>Padding may be inserted at one of four locations: before the prefix,
615 * after the prefix, before the suffix, or after the suffix. If padding is
616 * specified in any other location, applyPattern()
617 * sets a failing UErrorCode. If there is no prefix,
618 * before the prefix and after the prefix are equivalent, likewise for the
619 * suffix.
620 *
621 * <li>When specified in a pattern, the 32-bit code point immediately
622 * following the pad escape is the pad character. This may be any character,
623 * including a special pattern character. That is, the pad escape
624 * <em>escapes</em> the following character. If there is no character after
625 * the pad escape, then the pattern is illegal.
626 *
627 * </ul>
628 *
629 * <p><strong>Rounding</strong>
630 *
631 * <p>DecimalFormat supports rounding to a specific increment. For
632 * example, 1230 rounded to the nearest 50 is 1250. 1.234 rounded to the
633 * nearest 0.65 is 1.3. The rounding increment may be specified through the API
634 * or in a pattern. To specify a rounding increment in a pattern, include the
635 * increment in the pattern itself. "#,#50" specifies a rounding increment of
636 * 50. "#,##0.05" specifies a rounding increment of 0.05.
637 *
638 * <p>In the absence of an explicit rounding increment numbers are
639 * rounded to their formatted width.
640 *
641 * <ul>
642 * <li>Rounding only affects the string produced by formatting. It does
643 * not affect parsing or change any numerical values.
644 *
645 * <li>A <em>rounding mode</em> determines how values are rounded; see
646 * DecimalFormat::ERoundingMode. The default rounding mode is
647 * DecimalFormat::kRoundHalfEven. The rounding mode can only be set
648 * through the API; it can not be set with a pattern.
649 *
650 * <li>Some locales use rounding in their currency formats to reflect the
651 * smallest currency denomination.
652 *
653 * <li>In a pattern, digits '1' through '9' specify rounding, but otherwise
654 * behave identically to digit '0'.
655 * </ul>
656 *
657 * <p><strong>Synchronization</strong>
658 *
659 * <p>DecimalFormat objects are not synchronized. Multiple
660 * threads should not access one formatter concurrently.
661 *
662 * <p><strong>Subclassing</strong>
663 *
664 * <p><em>User subclasses are not supported.</em> While clients may write
665 * subclasses, such code will not necessarily work and will not be
666 * guaranteed to work stably from release to release.
667 */
668class U_I18N_API DecimalFormat : public NumberFormat {
669 public:
670 /**
671 * Pad position.
672 * @stable ICU 2.4
673 */
674 enum EPadPosition {
675 kPadBeforePrefix, kPadAfterPrefix, kPadBeforeSuffix, kPadAfterSuffix
676 };
677
678 /**
679 * Create a DecimalFormat using the default pattern and symbols
680 * for the default locale. This is a convenient way to obtain a
681 * DecimalFormat when internationalization is not the main concern.
682 * <P>
683 * To obtain standard formats for a given locale, use the factory methods
684 * on NumberFormat such as createInstance. These factories will
685 * return the most appropriate sub-class of NumberFormat for a given
686 * locale.
687 * <p>
688 * <strong>NOTE:</strong> New users are strongly encouraged to use
689 * #icu::number::NumberFormatter instead of DecimalFormat.
690 * @param status Output param set to success/failure code. If the
691 * pattern is invalid this will be set to a failure code.
692 * @stable ICU 2.0
693 */
694 DecimalFormat(UErrorCode& status);
695
696 /**
697 * Create a DecimalFormat from the given pattern and the symbols
698 * for the default locale. This is a convenient way to obtain a
699 * DecimalFormat when internationalization is not the main concern.
700 * <P>
701 * To obtain standard formats for a given locale, use the factory methods
702 * on NumberFormat such as createInstance. These factories will
703 * return the most appropriate sub-class of NumberFormat for a given
704 * locale.
705 * <p>
706 * <strong>NOTE:</strong> New users are strongly encouraged to use
707 * #icu::number::NumberFormatter instead of DecimalFormat.
708 * @param pattern A non-localized pattern string.
709 * @param status Output param set to success/failure code. If the
710 * pattern is invalid this will be set to a failure code.
711 * @stable ICU 2.0
712 */
713 DecimalFormat(const UnicodeString& pattern, UErrorCode& status);
714
715 /**
716 * Create a DecimalFormat from the given pattern and symbols.
717 * Use this constructor when you need to completely customize the
718 * behavior of the format.
719 * <P>
720 * To obtain standard formats for a given
721 * locale, use the factory methods on NumberFormat such as
722 * createInstance or createCurrencyInstance. If you need only minor adjustments
723 * to a standard format, you can modify the format returned by
724 * a NumberFormat factory method.
725 * <p>
726 * <strong>NOTE:</strong> New users are strongly encouraged to use
727 * #icu::number::NumberFormatter instead of DecimalFormat.
728 *
729 * @param pattern a non-localized pattern string
730 * @param symbolsToAdopt the set of symbols to be used. The caller should not
731 * delete this object after making this call.
732 * @param status Output param set to success/failure code. If the
733 * pattern is invalid this will be set to a failure code.
734 * @stable ICU 2.0
735 */
736 DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
737
738#ifndef U_HIDE_INTERNAL_API
739
740 /**
741 * This API is for ICU use only.
742 * Create a DecimalFormat from the given pattern, symbols, and style.
743 *
744 * @param pattern a non-localized pattern string
745 * @param symbolsToAdopt the set of symbols to be used. The caller should not
746 * delete this object after making this call.
747 * @param style style of decimal format
748 * @param status Output param set to success/failure code. If the
749 * pattern is invalid this will be set to a failure code.
750 * @internal
751 */
752 DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
753 UNumberFormatStyle style, UErrorCode& status);
754
755#if UCONFIG_HAVE_PARSEALLINPUT
756
757 /**
758 * @internal
759 */
760 void setParseAllInput(UNumberFormatAttributeValue value);
761
762#endif
763
764#endif /* U_HIDE_INTERNAL_API */
765
766 private:
767
768 /**
769 * Internal constructor for DecimalFormat; sets up internal fields. All public constructors should
770 * call this constructor.
771 */
772 DecimalFormat(const DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status);
773
774 public:
775
776 /**
777 * Set an integer attribute on this DecimalFormat.
778 * May return U_UNSUPPORTED_ERROR if this instance does not support
779 * the specified attribute.
780 * @param attr the attribute to set
781 * @param newValue new value
782 * @param status the error type
783 * @return *this - for chaining (example: format.setAttribute(...).setAttribute(...) )
784 * @stable ICU 51
785 */
786 virtual DecimalFormat& setAttribute(UNumberFormatAttribute attr, int32_t newValue, UErrorCode& status);
787
788 /**
789 * Get an integer
790 * May return U_UNSUPPORTED_ERROR if this instance does not support
791 * the specified attribute.
792 * @param attr the attribute to set
793 * @param status the error type
794 * @return the attribute value. Undefined if there is an error.
795 * @stable ICU 51
796 */
797 virtual int32_t getAttribute(UNumberFormatAttribute attr, UErrorCode& status) const;
798
799
800 /**
801 * Set whether or not grouping will be used in this format.
802 * @param newValue True, grouping will be used in this format.
803 * @see getGroupingUsed
804 * @stable ICU 53
805 */
806 void setGroupingUsed(UBool newValue) U_OVERRIDE;
807
808 /**
809 * Sets whether or not numbers should be parsed as integers only.
810 * @param value set True, this format will parse numbers as integers
811 * only.
812 * @see isParseIntegerOnly
813 * @stable ICU 53
814 */
815 void setParseIntegerOnly(UBool value) U_OVERRIDE;
816
817 /**
818 * Sets whether lenient parsing should be enabled (it is off by default).
819 *
820 * @param enable \c TRUE if lenient parsing should be used,
821 * \c FALSE otherwise.
822 * @stable ICU 4.8
823 */
824 void setLenient(UBool enable) U_OVERRIDE;
825
826 /**
827 * Create a DecimalFormat from the given pattern and symbols.
828 * Use this constructor when you need to completely customize the
829 * behavior of the format.
830 * <P>
831 * To obtain standard formats for a given
832 * locale, use the factory methods on NumberFormat such as
833 * createInstance or createCurrencyInstance. If you need only minor adjustments
834 * to a standard format, you can modify the format returned by
835 * a NumberFormat factory method.
836 * <p>
837 * <strong>NOTE:</strong> New users are strongly encouraged to use
838 * #icu::number::NumberFormatter instead of DecimalFormat.
839 *
840 * @param pattern a non-localized pattern string
841 * @param symbolsToAdopt the set of symbols to be used. The caller should not
842 * delete this object after making this call.
843 * @param parseError Output param to receive errors occurred during parsing
844 * @param status Output param set to success/failure code. If the
845 * pattern is invalid this will be set to a failure code.
846 * @stable ICU 2.0
847 */
848 DecimalFormat(const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt,
849 UParseError& parseError, UErrorCode& status);
850
851 /**
852 * Create a DecimalFormat from the given pattern and symbols.
853 * Use this constructor when you need to completely customize the
854 * behavior of the format.
855 * <P>
856 * To obtain standard formats for a given
857 * locale, use the factory methods on NumberFormat such as
858 * createInstance or createCurrencyInstance. If you need only minor adjustments
859 * to a standard format, you can modify the format returned by
860 * a NumberFormat factory method.
861 * <p>
862 * <strong>NOTE:</strong> New users are strongly encouraged to use
863 * #icu::number::NumberFormatter instead of DecimalFormat.
864 *
865 * @param pattern a non-localized pattern string
866 * @param symbols the set of symbols to be used
867 * @param status Output param set to success/failure code. If the
868 * pattern is invalid this will be set to a failure code.
869 * @stable ICU 2.0
870 */
871 DecimalFormat(const UnicodeString& pattern, const DecimalFormatSymbols& symbols, UErrorCode& status);
872
873 /**
874 * Copy constructor.
875 *
876 * @param source the DecimalFormat object to be copied from.
877 * @stable ICU 2.0
878 */
879 DecimalFormat(const DecimalFormat& source);
880
881 /**
882 * Assignment operator.
883 *
884 * @param rhs the DecimalFormat object to be copied.
885 * @stable ICU 2.0
886 */
887 DecimalFormat& operator=(const DecimalFormat& rhs);
888
889 /**
890 * Destructor.
891 * @stable ICU 2.0
892 */
893 ~DecimalFormat() U_OVERRIDE;
894
895 /**
896 * Clone this Format object polymorphically. The caller owns the
897 * result and should delete it when done.
898 *
899 * @return a polymorphic copy of this DecimalFormat.
900 * @stable ICU 2.0
901 */
902 DecimalFormat* clone() const U_OVERRIDE;
903
904 /**
905 * Return true if the given Format objects are semantically equal.
906 * Objects of different subclasses are considered unequal.
907 *
908 * @param other the object to be compared with.
909 * @return true if the given Format objects are semantically equal.
910 * @stable ICU 2.0
911 */
912 UBool operator==(const Format& other) const U_OVERRIDE;
913
914
915 using NumberFormat::format;
916
917 /**
918 * Format a double or long number using base-10 representation.
919 *
920 * @param number The value to be formatted.
921 * @param appendTo Output parameter to receive result.
922 * Result is appended to existing contents.
923 * @param pos On input: an alignment field, if desired.
924 * On output: the offsets of the alignment field.
925 * @return Reference to 'appendTo' parameter.
926 * @stable ICU 2.0
927 */
928 UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
929
930#ifndef U_HIDE_INTERNAL_API
931 /**
932 * Format a double or long number using base-10 representation.
933 *
934 * @param number The value to be formatted.
935 * @param appendTo Output parameter to receive result.
936 * Result is appended to existing contents.
937 * @param pos On input: an alignment field, if desired.
938 * On output: the offsets of the alignment field.
939 * @param status
940 * @return Reference to 'appendTo' parameter.
941 * @internal
942 */
943 UnicodeString& format(double number, UnicodeString& appendTo, FieldPosition& pos,
944 UErrorCode& status) const U_OVERRIDE;
945#endif /* U_HIDE_INTERNAL_API */
946
947 /**
948 * Format a double or long number using base-10 representation.
949 *
950 * @param number The value to be formatted.
951 * @param appendTo Output parameter to receive result.
952 * Result is appended to existing contents.
953 * @param posIter On return, can be used to iterate over positions
954 * of fields generated by this format call.
955 * Can be NULL.
956 * @param status Output param filled with success/failure status.
957 * @return Reference to 'appendTo' parameter.
958 * @stable ICU 4.4
959 */
960 UnicodeString& format(double number, UnicodeString& appendTo, FieldPositionIterator* posIter,
961 UErrorCode& status) const U_OVERRIDE;
962
963 /**
964 * Format a long number using base-10 representation.
965 *
966 * @param number The value to be formatted.
967 * @param appendTo Output parameter to receive result.
968 * Result is appended to existing contents.
969 * @param pos On input: an alignment field, if desired.
970 * On output: the offsets of the alignment field.
971 * @return Reference to 'appendTo' parameter.
972 * @stable ICU 2.0
973 */
974 UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
975
976#ifndef U_HIDE_INTERNAL_API
977 /**
978 * Format a long number using base-10 representation.
979 *
980 * @param number The value to be formatted.
981 * @param appendTo Output parameter to receive result.
982 * Result is appended to existing contents.
983 * @param pos On input: an alignment field, if desired.
984 * On output: the offsets of the alignment field.
985 * @param status Output param filled with success/failure status.
986 * @return Reference to 'appendTo' parameter.
987 * @internal
988 */
989 UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPosition& pos,
990 UErrorCode& status) const U_OVERRIDE;
991#endif /* U_HIDE_INTERNAL_API */
992
993 /**
994 * Format a long number using base-10 representation.
995 *
996 * @param number The value to be formatted.
997 * @param appendTo Output parameter to receive result.
998 * Result is appended to existing contents.
999 * @param posIter On return, can be used to iterate over positions
1000 * of fields generated by this format call.
1001 * Can be NULL.
1002 * @param status Output param filled with success/failure status.
1003 * @return Reference to 'appendTo' parameter.
1004 * @stable ICU 4.4
1005 */
1006 UnicodeString& format(int32_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
1007 UErrorCode& status) const U_OVERRIDE;
1008
1009 /**
1010 * Format an int64 number using base-10 representation.
1011 *
1012 * @param number The value to be formatted.
1013 * @param appendTo Output parameter to receive result.
1014 * Result is appended to existing contents.
1015 * @param pos On input: an alignment field, if desired.
1016 * On output: the offsets of the alignment field.
1017 * @return Reference to 'appendTo' parameter.
1018 * @stable ICU 2.8
1019 */
1020 UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos) const U_OVERRIDE;
1021
1022#ifndef U_HIDE_INTERNAL_API
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 * @param status Output param filled with success/failure status.
1032 * @return Reference to 'appendTo' parameter.
1033 * @internal
1034 */
1035 UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPosition& pos,
1036 UErrorCode& status) const U_OVERRIDE;
1037#endif /* U_HIDE_INTERNAL_API */
1038
1039 /**
1040 * Format an int64 number using base-10 representation.
1041 *
1042 * @param number The value to be formatted.
1043 * @param appendTo Output parameter to receive result.
1044 * Result is appended to existing contents.
1045 * @param posIter On return, can be used to iterate over positions
1046 * of fields generated by this format call.
1047 * Can be NULL.
1048 * @param status Output param filled with success/failure status.
1049 * @return Reference to 'appendTo' parameter.
1050 * @stable ICU 4.4
1051 */
1052 UnicodeString& format(int64_t number, UnicodeString& appendTo, FieldPositionIterator* posIter,
1053 UErrorCode& status) const U_OVERRIDE;
1054
1055 /**
1056 * Format a decimal number.
1057 * The syntax of the unformatted number is a "numeric string"
1058 * as defined in the Decimal Arithmetic Specification, available at
1059 * http://speleotrove.com/decimal
1060 *
1061 * @param number The unformatted number, as a string.
1062 * @param appendTo Output parameter to receive result.
1063 * Result is appended to existing contents.
1064 * @param posIter On return, can be used to iterate over positions
1065 * of fields generated by this format call.
1066 * Can be NULL.
1067 * @param status Output param filled with success/failure status.
1068 * @return Reference to 'appendTo' parameter.
1069 * @stable ICU 4.4
1070 */
1071 UnicodeString& format(StringPiece number, UnicodeString& appendTo, FieldPositionIterator* posIter,
1072 UErrorCode& status) const U_OVERRIDE;
1073
1074#ifndef U_HIDE_INTERNAL_API
1075
1076 /**
1077 * Format a decimal number.
1078 * The number is a DecimalQuantity wrapper onto a floating point decimal number.
1079 * The default implementation in NumberFormat converts the decimal number
1080 * to a double and formats that.
1081 *
1082 * @param number The number, a DecimalQuantity format Decimal Floating Point.
1083 * @param appendTo Output parameter to receive result.
1084 * Result is appended to existing contents.
1085 * @param posIter On return, can be used to iterate over positions
1086 * of fields generated by this format call.
1087 * @param status Output param filled with success/failure status.
1088 * @return Reference to 'appendTo' parameter.
1089 * @internal
1090 */
1091 UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
1092 FieldPositionIterator* posIter, UErrorCode& status) const U_OVERRIDE;
1093
1094 /**
1095 * Format a decimal number.
1096 * The number is a DecimalQuantity 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 DecimalQuantity format Decimal Floating Point.
1101 * @param appendTo Output parameter to receive result.
1102 * Result is appended to existing contents.
1103 * @param pos On input: an alignment field, if desired.
1104 * On output: the offsets of the alignment field.
1105 * @param status Output param filled with success/failure status.
1106 * @return Reference to 'appendTo' parameter.
1107 * @internal
1108 */
1109 UnicodeString& format(const number::impl::DecimalQuantity& number, UnicodeString& appendTo,
1110 FieldPosition& pos, UErrorCode& status) const U_OVERRIDE;
1111
1112#endif // U_HIDE_INTERNAL_API
1113
1114 using NumberFormat::parse;
1115
1116 /**
1117 * Parse the given string using this object's choices. The method
1118 * does string comparisons to try to find an optimal match.
1119 * If no object can be parsed, index is unchanged, and NULL is
1120 * returned. The result is returned as the most parsimonious
1121 * type of Formattable that will accommodate all of the
1122 * necessary precision. For example, if the result is exactly 12,
1123 * it will be returned as a long. However, if it is 1.5, it will
1124 * be returned as a double.
1125 *
1126 * @param text The text to be parsed.
1127 * @param result Formattable to be set to the parse result.
1128 * If parse fails, return contents are undefined.
1129 * @param parsePosition The position to start parsing at on input.
1130 * On output, moved to after the last successfully
1131 * parse character. On parse failure, does not change.
1132 * @see Formattable
1133 * @stable ICU 2.0
1134 */
1135 void parse(const UnicodeString& text, Formattable& result,
1136 ParsePosition& parsePosition) const U_OVERRIDE;
1137
1138 /**
1139 * Parses text from the given string as a currency amount. Unlike
1140 * the parse() method, this method will attempt to parse a generic
1141 * currency name, searching for a match of this object's locale's
1142 * currency display names, or for a 3-letter ISO currency code.
1143 * This method will fail if this format is not a currency format,
1144 * that is, if it does not contain the currency pattern symbol
1145 * (U+00A4) in its prefix or suffix.
1146 *
1147 * @param text the string to parse
1148 * @param pos input-output position; on input, the position within text
1149 * to match; must have 0 <= pos.getIndex() < text.length();
1150 * on output, the position after the last matched character.
1151 * If the parse fails, the position in unchanged upon output.
1152 * @return if parse succeeds, a pointer to a newly-created CurrencyAmount
1153 * object (owned by the caller) containing information about
1154 * the parsed currency; if parse fails, this is NULL.
1155 * @stable ICU 49
1156 */
1157 CurrencyAmount* parseCurrency(const UnicodeString& text, ParsePosition& pos) const U_OVERRIDE;
1158
1159 /**
1160 * Returns the decimal format symbols, which is generally not changed
1161 * by the programmer or user.
1162 * @return desired DecimalFormatSymbols
1163 * @see DecimalFormatSymbols
1164 * @stable ICU 2.0
1165 */
1166 virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const;
1167
1168 /**
1169 * Sets the decimal format symbols, which is generally not changed
1170 * by the programmer or user.
1171 * @param symbolsToAdopt DecimalFormatSymbols to be adopted.
1172 * @stable ICU 2.0
1173 */
1174 virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt);
1175
1176 /**
1177 * Sets the decimal format symbols, which is generally not changed
1178 * by the programmer or user.
1179 * @param symbols DecimalFormatSymbols.
1180 * @stable ICU 2.0
1181 */
1182 virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols);
1183
1184
1185 /**
1186 * Returns the currency plural format information,
1187 * which is generally not changed by the programmer or user.
1188 * @return desired CurrencyPluralInfo
1189 * @stable ICU 4.2
1190 */
1191 virtual const CurrencyPluralInfo* getCurrencyPluralInfo(void) const;
1192
1193 /**
1194 * Sets the currency plural format information,
1195 * which is generally not changed by the programmer or user.
1196 * @param toAdopt CurrencyPluralInfo to be adopted.
1197 * @stable ICU 4.2
1198 */
1199 virtual void adoptCurrencyPluralInfo(CurrencyPluralInfo* toAdopt);
1200