1 /*
2 ********************************************************************************
3 * Copyright (C) 1997-2010, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 ********************************************************************************
6 *
7 * File CHOICFMT.H
8 *
9 * Modification History:
10 *
11 * Date Name Description
12 * 02/19/97 aliu Converted from java.
13 * 03/20/97 helena Finished first cut of implementation and got rid
14 * of nextDouble/previousDouble and replaced with
15 * boolean array.
16 * 4/10/97 aliu Clean up. Modified to work on AIX.
17 * 8/6/97 nos Removed overloaded constructor, member var 'buffer'.
18 * 07/22/98 stephen Removed operator!= (implemented in Format)
19 ********************************************************************************
20 */
21
22 #ifndef CHOICFMT_H
23 #define CHOICFMT_H
24
25 #include "unicode/utypes.h"
26
27 /**
28 * \file
29 * \brief C++ API: Choice Format.
30 */
31
32 #if !UCONFIG_NO_FORMATTING
33
34 #include "unicode/unistr.h"
35 #include "unicode/numfmt.h"
36 #include "unicode/fieldpos.h"
37 #include "unicode/format.h"
38
39 U_NAMESPACE_BEGIN
40
41 class MessageFormat;
42
43 /**
44 * ChoiceFormat converts between ranges of numeric values
45 * and string names for those ranges. A <code>ChoiceFormat</code> splits
46 * the real number line <code>-Inf</code> to <code>+Inf</code> into two
47 * or more contiguous ranges. Each range is mapped to a
48 * string. <code>ChoiceFormat</code> is generally used in a
49 * <code>MessageFormat</code> for displaying grammatically correct
50 * plurals such as "There are 2 files."</p>
51 *
52 * <p>There are two methods of defining a <code>ChoiceFormat</code>; both
53 * are equivalent. The first is by using a string pattern. This is the
54 * preferred method in most cases. The second method is through direct
55 * specification of the arrays that make up the
56 * <code>ChoiceFormat</code>.</p>
57 *
58 * <p><strong>Patterns</strong></p>
59 *
60 * <p>In most cases, the preferred way to define a
61 * <code>ChoiceFormat</code> is with a pattern. Here is an example of a
62 * <code>ChoiceFormat</code> pattern:</p>
63 *
64 * \htmlonly<pre> 0≤are no files|1≤is one file|1<are many files</pre>\endhtmlonly
65 *
66 * <p>or equivalently,</p>
67 *
68 * \htmlonly<pre> 0#are no files|1#is one file|1<are many files</pre>\endhtmlonly
69 *
70 * <p>The pattern consists of a number or <em>range specifiers</em>
71 * separated by vertical bars '|' (U+007C). There is no
72 * vertical bar after the last range. Each range specifier is of the
73 * form:</p>
74 *
75 * \htmlonly<blockquote><em>Number Separator String</em></blockquote>\endhtmlonly
76 *
77 * <p><em>Number</em> is a floating point number that can be parsed by a
78 * default <code>NumberFormat</code> for the US locale. It gives the
79 * lower limit of this range. The lower limit is either inclusive or
80 * exclusive, depending on the <em>separator</em>. The upper limit is
81 * given by the lower limit of the next range. The Unicode infinity
82 * sign \htmlonly∞ \endhtmlonly (U+221E) is recognized for positive infinity. It may be preceded by
83 * '-' (U+002D) to indicate negative infinity.</p>
84 *
85 * <p><em>String</em> is the format string for this range, with special
86 * characters enclosed in single quotes (<code>'The #
87 * sign'</code>). Single quotes themselves are indicated by two single
88 * quotes in a row (<code>'o''clock'</code>).</p>
89 *
90 * <p><em>Separator</em> is one of the following single characters:
91 *
92 * <ul>
93 * <li>\htmlonly'≤' \endhtmlonly (U+2264) or '#' (U+0023)
94 * indicates that the lower limit given by <em>Number</em> is
95 * inclusive. (The two characters are equivalent to ChoiceFormat.)
96 * This means that the limit value <em>Number</em> belongs to this
97 * range. Another way of saying this is that the corresponding
98 * closure is <code>FALSE</code>.</li>
99 *
100 * <li>'<' (U+003C) indicates that the lower limit given by
101 * <em>Number</em> is exclusive. This means that the value
102 * <em>Number</em> belongs to the prior range.</li> Another way of
103 * saying this is that the corresponding closure is
104 * <code>TRUE</code>.
105 * </ul>
106 *
107 * <p>See below for more information about closures.</p>
108 *
109 * <p><strong>Arrays</strong></p>
110 *
111 * <p>A <code>ChoiceFormat</code> defining <code>n</code> intervals
112 * (<code>n</code> >= 2) is specified by three arrays of
113 * <code>n</code> items:
114 *
115 * <ul>
116 * <li><code>double limits[]</code> gives the start of each
117 * interval. This must be a non-decreasing list of values, none of
118 * which may be <code>NaN</code>.</li>
119 * <li><code>UBool closures[]</code> determines whether each limit
120 * value is contained in the interval below it or in the interval
121 * above it. If <code>closures[i]</code> is <code>FALSE</code>, then
122 * <code>limits[i]</code> is a member of interval
123 * <code>i</code>. Otherwise it is a member of interval
124 * <code>i+1</code>. If no closures array is specified, this is
125 * equivalent to having all closures be <code>FALSE</code>. Closures
126 * allow one to specify half-open, open, or closed intervals.</li>
127 * <li><code>UnicodeString formats[]</code> gives the string label
128 * associated with each interval.</li>
129 * </ul>
130 *
131 * <p><strong>Formatting and Parsing</strong></p>
132 *
133 * <p>During formatting, a number is converted to a
134 * string. <code>ChoiceFormat</code> accomplishes this by mapping the
135 * number to an interval using the following rule. Given a number
136 * <code>X</code> and and index value <code>j</code> in the range
137 * <code>0..n-1</code>, where <code>n</code> is the number of ranges:</p>
138 *
139 * \htmlonly<blockquote>\endhtmlonly<code>X</code> matches <code>j</code> if and only if
140 * <code>limit[j] <= X < limit[j+1]</code>
141 * \htmlonly</blockquote>\endhtmlonly
142 *
143 * <p>(This assumes that all closures are <code>FALSE</code>. If some
144 * closures are <code>TRUE</code> then the relations must be changed to
145 * <code><=</code> or <code><</code> as appropriate.) If there is
146 * no match, then either the first or last index is used, depending on
147 * whether the number is too low or too high. Once a number is mapped to
148 * an interval <code>j</code>, the string <code>formats[j]</code> is
149 * output.</p>
150 *
151 * <p>During parsing, a string is converted to a
152 * number. <code>ChoiceFormat</code> finds the element
153 * <code>formats[j]</code> equal to the string, and returns
154 * <code>limits[j]</code> as the parsed value.</p>
155 *
156 * <p><strong>Notes</strong></p>
157 *
158 * <p>The first limit value does not define a range boundary. For
159 * example, in the pattern \htmlonly"<code>1.0#a|2.0#b</code>"\endhtmlonly, the
160 * intervals are [-Inf, 2.0) and [2.0, +Inf]. It appears that the first
161 * interval should be [1.0, 2.0). However, since all values that are too
162 * small are mapped to range zero, the first interval is effectively
163 * [-Inf, 2.0). However, the first limit value <em>is</em> used during
164 * formatting. In this example, <code>parse("a")</code> returns
165 * 1.0.</p>
166 *
167 * <p>There are no gaps between intervals and the entire number line is
168 * covered. A <code>ChoiceFormat</code> maps <em>all</em> possible
169 * double values to a finite set of intervals.</p>
170 *
171 * <p>The non-number <code>NaN</code> is mapped to interval zero during
172 * formatting.</p>
173 *
174 * <p><strong>Examples</strong></p>
175 *
176 * <p>Here is an example of two arrays that map the number
177 * <code>1..7</code> to the English day of the week abbreviations
178 * <code>Sun..Sat</code>. No closures array is given; this is the same as
179 * specifying all closures to be <code>FALSE</code>.</p>
180 *
181 * <pre> {1,2,3,4,5,6,7},
182 * {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}</pre>
183 *
184 * <p>Here is an example that maps the ranges [-Inf, 1), [1, 1], and (1,
185 * +Inf] to three strings. That is, the number line is split into three
186 * ranges: x < 1.0, x = 1.0, and x > 1.0.</p>
187 *
188 * <pre> {0, 1, 1},
189 * {FALSE, FALSE, TRUE},
190 * {"no files", "one file", "many files"}</pre>
191 *
192 * <p>Here is a simple example that shows formatting and parsing: </p>
193 *
194 * \code
195 * #include <unicode/choicfmt.h>
196 * #include <unicode/unistr.h>
197 * #include <iostream.h>
198 *
199 * int main(int argc, char *argv[]) {
200 * double limits[] = {1,2,3,4,5,6,7};
201 * UnicodeString monthNames[] = {
202 * "Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
203 * ChoiceFormat fmt(limits, monthNames, 7);
204 * UnicodeString str;
205 * char buf[256];
206 * for (double x = 1.0; x <= 8.0; x += 1.0) {
207 * fmt.format(x, str);
208 * str.extract(0, str.length(), buf, 256, "");
209 * str.truncate(0);
210 * cout << x << " -> "
211 * << buf << endl;
212 * }
213 * cout << endl;
214 * return 0;
215 * }
216 * \endcode
217 *
218 * <p>Here is a more complex example using a <code>ChoiceFormat</code>
219 * constructed from a pattern together with a
220 * <code>MessageFormat</code>.</p>
221 *
222 * \code
223 * #include <unicode/choicfmt.h>
224 * #include <unicode/msgfmt.h>
225 * #include <unicode/unistr.h>
226 * #include <iostream.h>
227 *
228 * int main(int argc, char *argv[]) {
229 * UErrorCode status = U_ZERO_ERROR;
230 * double filelimits[] = {0,1,2};
231 * UnicodeString filepart[] =
232 * {"are no files","is one file","are {0} files"};
233 * ChoiceFormat* fileform = new ChoiceFormat(filelimits, filepart, 3 );
234 * Format* testFormats[] =
235 * {fileform, NULL, NumberFormat::createInstance(status)};
236 * MessageFormat pattform("There {0} on {1}", status );
237 * pattform.adoptFormats(testFormats, 3);
238 * Formattable testArgs[] = {0L, "Disk A"};
239 * FieldPosition fp(0);
240 * UnicodeString str;
241 * char buf[256];
242 * for (int32_t i = 0; i < 4; ++i) {
243 * Formattable fInt(i);
244 * testArgs[0] = fInt;
245 * pattform.format(testArgs, 2, str, fp, status );
246 * str.extract(0, str.length(), buf, "");
247 * str.truncate(0);
248 * cout << "Output for i=" << i << " : " << buf << endl;
249 * }
250 * cout << endl;
251 * return 0;
252 * }
253 * \endcode
254 *
255 * <p><em>User subclasses are not supported.</em> While clients may write
256 * subclasses, such code will not necessarily work and will not be
257 * guaranteed to work stably from release to release.
258 */
259 class U_I18N_API ChoiceFormat: public NumberFormat {
260 public:
261 /**
262 * Construct a new ChoiceFormat with the limits and the corresponding formats
263 * based on the pattern.
264 *
265 * @param pattern Pattern used to construct object.
266 * @param status Output param to receive success code. If the
267 * pattern cannot be parsed, set to failure code.
268 * @stable ICU 2.0
269 */
270 ChoiceFormat(const UnicodeString& pattern,
271 UErrorCode& status);
272
273
274 /**
275 * Construct a new ChoiceFormat with the given limits and formats. Copy
276 * the limits and formats instead of adopting them.
277 *
278 * @param limits Array of limit values.
279 * @param formats Array of formats.
280 * @param count Size of 'limits' and 'formats' arrays.
281 * @stable ICU 2.0
282 */
283
284 ChoiceFormat(const double* limits,
285 const UnicodeString* formats,
286 int32_t count );
287
288 /**
289 * Construct a new ChoiceFormat with the given limits and formats.
290 * Copy the limits and formats (instead of adopting them). By
291 * default, each limit in the array specifies the inclusive lower
292 * bound of its range, and the exclusive upper bound of the previous
293 * range. However, if the isLimitOpen element corresponding to a
294 * limit is TRUE, then the limit is the exclusive lower bound of its
295 * range, and the inclusive upper bound of the previous range.
296 * @param limits Array of limit values
297 * @param closures Array of booleans specifying whether each
298 * element of 'limits' is open or closed. If FALSE, then the
299 * corresponding limit is a member of the range above it. If TRUE,
300 * then the limit belongs to the range below it.
301 * @param formats Array of formats
302 * @param count Size of 'limits', 'closures', and 'formats' arrays
303 * @stable ICU 2.4
304 */
305 ChoiceFormat(const double* limits,
306 const UBool* closures,
307 const UnicodeString* formats,
308 int32_t count);
309
310 /**
311 * Copy constructor.
312 *
313 * @param that ChoiceFormat object to be copied from
314 * @stable ICU 2.0
315 */
316 ChoiceFormat(const ChoiceFormat& that);
317
318 /**
319 * Assignment operator.
320 *
321 * @param that ChoiceFormat object to be copied
322 * @stable ICU 2.0
323 */
324 const ChoiceFormat& operator=(const ChoiceFormat& that);
325
326 /**
327 * Destructor.
328 * @stable ICU 2.0
329 */
330 virtual ~ChoiceFormat();
331
332 /**
333 * Clone this Format object polymorphically. The caller owns the
334 * result and should delete it when done.
335 *
336 * @return a copy of this object
337 * @stable ICU 2.0
338 */
339 virtual Format* clone(void) const;
340
341 /**
342 * Return true if the given Format objects are semantically equal.
343 * Objects of different subclasses are considered unequal.
344 *
345 * @param other ChoiceFormat object to be compared
346 * @return true if other is the same as this.
347 * @stable ICU 2.0
348 */
349 virtual UBool operator==(const Format& other) const;
350
351 /**
352 * Sets the pattern.
353 * @param pattern The pattern to be applied.
354 * @param status Output param set to success/failure code on
355 * exit. If the pattern is invalid, this will be
356 * set to a failure result.
357 * @stable ICU 2.0
358 */
359 virtual void applyPattern(const UnicodeString& pattern,
360 UErrorCode& status);
361
362 /**
363 * Sets the pattern.
364 * @param pattern The pattern to be applied.
365 * @param parseError Struct to recieve information on position
366 * of error if an error is encountered
367 * @param status Output param set to success/failure code on
368 * exit. If the pattern is invalid, this will be
369 * set to a failure result.
370 * @stable ICU 2.0
371 */
372 virtual void applyPattern(const UnicodeString& pattern,
373 UParseError& parseError,
374 UErrorCode& status);
375 /**
376 * Gets the pattern.
377 *
378 * @param pattern Output param which will recieve the pattern
379 * Previous contents are deleted.
380 * @return A reference to 'pattern'
381 * @stable ICU 2.0
382 */
383 virtual UnicodeString& toPattern(UnicodeString &pattern) const;
384
385 /**
386 * Set the choices to be used in formatting.
387 *
388 * @param limitsToCopy Contains the top value that you want
389 * parsed with that format,and should be in
390 * ascending sorted order. When formatting X,
391 * the choice will be the i, where limit[i]
392 * <= X < limit[i+1].
393 * @param formatsToCopy The format strings you want to use for each limit.
394 * @param count The size of the above arrays.
395 * @stable ICU 2.0
396 */
397 virtual void setChoices(const double* limitsToCopy,
398 const UnicodeString* formatsToCopy,
399 int32_t count );
400
401 /**
402 * Set the choices to be used in formatting. See class description
403 * for documenatation of the limits, closures, and formats arrays.
404 * @param limits Array of limits
405 * @param closures Array of limit booleans
406 * @param formats Array of format string
407 * @param count The size of the above arrays
408 * @stable ICU 2.4
409 */
410 virtual void setChoices(const double* limits,
411 const UBool* closures,
412 const UnicodeString* formats,
413 int32_t count);
414
415 /**
416 * Get the limits passed in the constructor.
417 *
418 * @param count The size of the limits arrays
419 * @return the limits.
420 * @stable ICU 2.0
421 */
422 virtual const double* getLimits(int32_t& count) const;
423
424 /**
425 * Get the limit booleans passed in the constructor. The caller
426 * must not delete the result.
427 *
428 * @param count The size of the arrays
429 * @return the closures
430 * @stable ICU 2.4
431 */
432 virtual const UBool* getClosures(int32_t& count) const;
433
434 /**
435 * Get the formats passed in the constructor.
436 *
437 * @param count The size of the arrays
438 * @return the formats.
439 * @stable ICU 2.0
440 */
441 virtual const UnicodeString* getFormats(int32_t& count) const;
442
443
444 using NumberFormat::format;
445
446 /**
447 * Format a double or long number using this object's choices.
448 *
449 * @param number The value to be formatted.
450 * @param appendTo Output parameter to receive result.
451 * Result is appended to existing contents.
452 * @param pos On input: an alignment field, if desired.
453 * On output: the offsets of the alignment field.
454 * @return Reference to 'appendTo' parameter.
455 * @stable ICU 2.0
456 */
457 virtual UnicodeString& format(double number,
458 UnicodeString& appendTo,
459 FieldPosition& pos) const;
460 /**
461 * Format a int_32t number using this object's choices.
462 *
463 * @param number The value to be formatted.
464 * @param appendTo Output parameter to receive result.
465 * Result is appended to existing contents.
466 * @param pos On input: an alignment field, if desired.
467 * On output: the offsets of the alignment field.
468 * @return Reference to 'appendTo' parameter.
469 * @stable ICU 2.0
470 */
471 virtual UnicodeString& format(int32_t number,
472 UnicodeString& appendTo,
473 FieldPosition& pos) const;
474
475 /**
476 * Format an int64_t number using this object's choices.
477 *
478 * @param number The value to be formatted.
479 * @param appendTo Output parameter to receive result.
480 * Result is appended to existing contents.
481 * @param pos On input: an alignment field, if desired.
482 * On output: the offsets of the alignment field.
483 * @return Reference to 'appendTo' parameter.
484 * @stable ICU 2.8
485 */
486 virtual UnicodeString& format(int64_t number,
487 UnicodeString& appendTo,
488 FieldPosition& pos) const;
489
490 /**
491 * Format an array of objects using this object's choices.
492 *
493 * @param objs The array of objects to be formatted.
494 * @param cnt The size of objs.
495 * @param appendTo Output parameter to receive result.
496 * Result is appended to existing contents.
497 * @param pos On input: an alignment field, if desired.
498 * On output: the offsets of the alignment field.
499 * @param success Output param set to success/failure code on
500 * exit.
501 * @return Reference to 'appendTo' parameter.
502 * @stable ICU 2.0
503 */
504 virtual UnicodeString& format(const Formattable* objs,
505 int32_t cnt,
506 UnicodeString& appendTo,
507 FieldPosition& pos,
508 UErrorCode& success) const;
509 /**
510 * Format an object using this object's choices.
511 *
512 *
513 * @param obj The object to be formatted.
514 * @param appendTo Output parameter to receive result.
515 * Result is appended to existing contents.
516 * @param pos On input: an alignment field, if desired.
517 * On output: the offsets of the alignment field.
518 * @param status Output param set to success/failure code on
519 * exit.
520 * @return Reference to 'appendTo' parameter.
521 * @stable ICU 2.0
522 */
523 virtual UnicodeString& format(const Formattable& obj,
524 UnicodeString& appendTo,
525 FieldPosition& pos,
526 UErrorCode& status) const;
527
528 /**
529 * Redeclared NumberFormat method.
530 *
531 * @param obj The object to be formatted.
532 * @param appendTo Output parameter to receive result.
533 * Result is appended to existing contents.
534 * @param status Output param set to success/failure code on
535 * exit.
536 * @return Reference to 'appendTo' parameter.
537 * @stable ICU 2.0
538 */
539 UnicodeString& format(const Formattable& obj,
540 UnicodeString& appendTo,
541 UErrorCode& status) const;
542
543 /**
544 * Redeclared NumberFormat method.
545 * Format a double number. These methods call the NumberFormat
546 * pure virtual format() methods with the default FieldPosition.
547 *
548 * @param number The value to be formatted.
549 * @param appendTo Output parameter to receive result.
550 * Result is appended to existing contents.
551 * @return Reference to 'appendTo' parameter.
552 * @stable ICU 2.0
553 */
554 UnicodeString& format( double number,
555 UnicodeString& appendTo) const;
556
557 /**
558 * Redeclared NumberFormat method.
559 * Format a long number. These methods call the NumberFormat
560 * pure virtual format() methods with the default FieldPosition.
561 *
562 * @param number The value to be formatted.
563 * @param appendTo Output parameter to receive result.
564 * Result is appended to existing contents.
565 * @return Reference to 'appendTo' parameter.
566 * @stable ICU 2.0
567 */
568 UnicodeString& format( int32_t number,
569 UnicodeString& appendTo) const;
570
571 /**
572 * Return a long if possible (e.g. within range LONG_MAX,
573 * LONG_MAX], and with no decimals), otherwise a double. If
574 * IntegerOnly is set, will stop at a decimal point (or equivalent;
575 * e.g. for rational numbers "1 2/3", will stop after the 1).
576 * <P>
577 * If no object can be parsed, parsePosition is unchanged, and NULL is
578 * returned.
579 *
580 * @param text The text to be parsed.
581 * @param result Formattable to be set to the parse result.
582 * If parse fails, return contents are undefined.
583 * @param parsePosition The position to start parsing at on input.
584 * On output, moved to after the last successfully
585 * parse character. On parse failure, does not change.
586 * @see NumberFormat::isParseIntegerOnly
587 * @stable ICU 2.0
588 */
589 virtual void parse(const UnicodeString& text,
590 Formattable& result,
591 ParsePosition& parsePosition) const;
592
593 /**
594 * Return a long if possible (e.g. within range LONG_MAX,
595 * LONG_MAX], and with no decimals), otherwise a double. If
596 * IntegerOnly is set, will stop at a decimal point (or equivalent;
597 * e.g. for rational numbers "1 2/3", will stop after the 1).
598 * <P>
599 * If no object can be parsed, parsePosition is unchanged, and NULL is
600 * returned.
601 *
602 * @param text The text to be parsed.
603 * @param result Formattable to be set to the parse result.
604 * If parse fails, return contents are undefined.
605 * @param status Output param with the formatted string.
606 * @see NumberFormat::isParseIntegerOnly
607 * @stable ICU 2.0
608 */
609 virtual void parse(const UnicodeString& text,
610 Formattable& result,
611 UErrorCode& status) const;
612
613
614 public:
615 /**
616 * Returns a unique class ID POLYMORPHICALLY. Pure virtual override.
617 * This method is to implement a simple version of RTTI, since not all
618 * C++ compilers support genuine RTTI. Polymorphic operator==() and
619 * clone() methods call this method.
620 *
621 * @return The class ID for this object. All objects of a
622 * given class have the same class ID. Objects of
623 * other classes have different class IDs.
624 * @stable ICU 2.0
625 */
626 virtual UClassID getDynamicClassID(void) const;
627
628 /**
629 * Return the class ID for this class. This is useful only for
630 * comparing to a return value from getDynamicClassID(). For example:
631 * <pre>
632 * . Base* polymorphic_pointer = createPolymorphicObject();
633 * . if (polymorphic_pointer->getDynamicClassID() ==
634 * . Derived::getStaticClassID()) ...
635 * </pre>
636 * @return The class ID for all objects of this class.
637 * @stable ICU 2.0
638 */
639 static UClassID U_EXPORT2 getStaticClassID(void);
640
641 private:
642 // static cache management (thread-safe)
643 // static NumberFormat* getNumberFormat(UErrorCode &status); // call this function to 'check out' a numberformat from the cache.
644 // static void releaseNumberFormat(NumberFormat *adopt); // call this function to 'return' the number format to the cache.
645
646 /**
647 * Converts a string to a double value using a default NumberFormat object
648 * which is static (shared by all ChoiceFormat instances).
649 * @param string the string to be converted with.
650 * @return the converted double number.
651 */
652 static double stod(const UnicodeString& string);
653
654 /**
655 * Converts a double value to a string using a default NumberFormat object
656 * which is static (shared by all ChoiceFormat instances).
657 * @param value the double number to be converted with.
658 * @param string the result string.
659 * @return the converted string.
660 */
661 static UnicodeString& dtos(double value, UnicodeString& string);
662
663 ChoiceFormat(); // default constructor not implemented
664
665 /**
666 * Construct a new ChoiceFormat with the limits and the corresponding formats
667 * based on the pattern.
668 *
669 * @param newPattern Pattern used to construct object.
670 * @param parseError Struct to recieve information on position
671 * of error if an error is encountered.
672 * @param status Output param to receive success code. If the
673 * pattern cannot be parsed, set to failure code.
674 * @stable ICU 2.0
675 */
676 ChoiceFormat(const UnicodeString& newPattern,
677 UParseError& parseError,
678 UErrorCode& status);
679
680 friend class MessageFormat;
681 /**
682 * Each ChoiceFormat divides the range -Inf..+Inf into fCount
683 * intervals. The intervals are:
684 *
685 * 0: fChoiceLimits[0]..fChoiceLimits[1]
686 * 1: fChoiceLimits[1]..fChoiceLimits[2]
687 * ...
688 * fCount-2: fChoiceLimits[fCount-2]..fChoiceLimits[fCount-1]
689 * fCount-1: fChoiceLimits[fCount-1]..+Inf
690 *
691 * Interval 0 is special; during formatting (mapping numbers to
692 * strings), it also contains all numbers less than
693 * fChoiceLimits[0], as well as NaN values.
694 *
695 * Interval i maps to and from string fChoiceFormats[i]. When
696 * parsing (mapping strings to numbers), then intervals map to
697 * their lower limit, that is, interval i maps to fChoiceLimit[i].
698 *
699 * The intervals may be closed, half open, or open. This affects
700 * formatting but does not affect parsing. Interval i is affected
701 * by fClosures[i] and fClosures[i+1]. If fClosures[i]
702 * is FALSE, then the value fChoiceLimits[i] is in interval i.
703 * That is, intervals i and i are:
704 *
705 * i-1: ... x < fChoiceLimits[i]
706 * i: fChoiceLimits[i] <= x ...
707 *
708 * If fClosures[i] is TRUE, then the value fChoiceLimits[i] is
709 * in interval i-1. That is, intervals i-1 and i are:
710 *
711 * i-1: ... x <= fChoiceLimits[i]
712 * i: fChoiceLimits[i] < x ...
713 *
714 * Because of the nature of interval 0, fClosures[0] has no
715 * effect.
716
717 */
718 double* fChoiceLimits;
719 UBool* fClosures;
720 UnicodeString* fChoiceFormats;
721 int32_t fCount;
722 };
723
724 inline UnicodeString&
format(const Formattable & obj,UnicodeString & appendTo,UErrorCode & status)725 ChoiceFormat::format(const Formattable& obj,
726 UnicodeString& appendTo,
727 UErrorCode& status) const {
728 // Don't use Format:: - use immediate base class only,
729 // in case immediate base modifies behavior later.
730 return NumberFormat::format(obj, appendTo, status);
731 }
732
733 inline UnicodeString&
format(double number,UnicodeString & appendTo)734 ChoiceFormat::format(double number,
735 UnicodeString& appendTo) const {
736 return NumberFormat::format(number, appendTo);
737 }
738
739 inline UnicodeString&
format(int32_t number,UnicodeString & appendTo)740 ChoiceFormat::format(int32_t number,
741 UnicodeString& appendTo) const {
742 return NumberFormat::format(number, appendTo);
743 }
744 U_NAMESPACE_END
745
746 #endif /* #if !UCONFIG_NO_FORMATTING */
747
748 #endif // _CHOICFMT
749 //eof
750