1 /*
2 ********************************************************************************
3 * Copyright (C) 1997-2005, 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 #ifdef U_USE_CHOICE_FORMAT_DEPRECATES
386 /**
387 * Set the choices to be used in formatting. The arrays are adopted and
388 * should not be deleted by the caller.
389 *
390 * @param limitsToAdopt Contains the top value that you want
391 * parsed with that format,and should be in
392 * ascending sorted order. When formatting X,
393 * the choice will be the i, where limit[i]
394 * <= X < limit[i+1].
395 * @param formatsToAdopt The format strings you want to use for each limit.
396 * @param count The size of the above arrays.
397 * @obsolete ICU 2.6. Use setChoices instead since this API will be removed in that release.
398 */
399 virtual void adoptChoices(double* limitsToAdopt,
400 UnicodeString* formatsToAdopt,
401 int32_t count );
402
403 /**
404 * Set the choices to be used in formatting. The arrays are adopted
405 * and should not be deleted by the caller. See class description
406 * for documenatation of the limits, closures, and formats arrays.
407 * @param limitsToAdopt Array of limits to adopt
408 * @param closuresToAdopt Array of limit booleans to adopt
409 * @param formatsToAdopt Array of format string to adopt
410 * @param count The size of the above arrays
411 * @obsolete ICU 2.6. Use setChoices instead since this API will be removed in that release.
412 */
413 virtual void adoptChoices(double* limitsToAdopt,
414 UBool* closuresToAdopt,
415 UnicodeString* formatsToAdopt,
416 int32_t count);
417 #endif
418
419 /**
420 * Set the choices to be used in formatting.
421 *
422 * @param limitsToCopy Contains the top value that you want
423 * parsed with that format,and should be in
424 * ascending sorted order. When formatting X,
425 * the choice will be the i, where limit[i]
426 * <= X < limit[i+1].
427 * @param formatsToCopy The format strings you want to use for each limit.
428 * @param count The size of the above arrays.
429 * @stable ICU 2.0
430 */
431 virtual void setChoices(const double* limitsToCopy,
432 const UnicodeString* formatsToCopy,
433 int32_t count );
434
435 /**
436 * Set the choices to be used in formatting. See class description
437 * for documenatation of the limits, closures, and formats arrays.
438 * @param limits Array of limits
439 * @param closures Array of limit booleans
440 * @param formats Array of format string
441 * @param count The size of the above arrays
442 * @stable ICU 2.4
443 */
444 virtual void setChoices(const double* limits,
445 const UBool* closures,
446 const UnicodeString* formats,
447 int32_t count);
448
449 /**
450 * Get the limits passed in the constructor.
451 *
452 * @param count The size of the limits arrays
453 * @return the limits.
454 * @stable ICU 2.0
455 */
456 virtual const double* getLimits(int32_t& count) const;
457
458 /**
459 * Get the limit booleans passed in the constructor. The caller
460 * must not delete the result.
461 *
462 * @param count The size of the arrays
463 * @return the closures
464 * @stable ICU 2.4
465 */
466 virtual const UBool* getClosures(int32_t& count) const;
467
468 /**
469 * Get the formats passed in the constructor.
470 *
471 * @param count The size of the arrays
472 * @return the formats.
473 * @stable ICU 2.0
474 */
475 virtual const UnicodeString* getFormats(int32_t& count) const;
476
477 /**
478 * Format a double or long number using this object's choices.
479 *
480 * @param number The value to be formatted.
481 * @param appendTo Output parameter to receive result.
482 * Result is appended to existing contents.
483 * @param pos On input: an alignment field, if desired.
484 * On output: the offsets of the alignment field.
485 * @return Reference to 'appendTo' parameter.
486 * @stable ICU 2.0
487 */
488 virtual UnicodeString& format(double number,
489 UnicodeString& appendTo,
490 FieldPosition& pos) const;
491 /**
492 * Format a int_32t number using this object's choices.
493 *
494 * @param number The value to be formatted.
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 * @return Reference to 'appendTo' parameter.
500 * @stable ICU 2.0
501 */
502 virtual UnicodeString& format(int32_t number,
503 UnicodeString& appendTo,
504 FieldPosition& pos) const;
505
506 /**
507 * Format an int64_t number using this object's choices.
508 *
509 * @param number The value to be formatted.
510 * @param appendTo Output parameter to receive result.
511 * Result is appended to existing contents.
512 * @param pos On input: an alignment field, if desired.
513 * On output: the offsets of the alignment field.
514 * @return Reference to 'appendTo' parameter.
515 * @stable ICU 2.8
516 */
517 virtual UnicodeString& format(int64_t number,
518 UnicodeString& appendTo,
519 FieldPosition& pos) const;
520
521 /**
522 * Format an array of objects using this object's choices.
523 *
524 * @param objs The array of objects to be formatted.
525 * @param cnt The size of objs.
526 * @param appendTo Output parameter to receive result.
527 * Result is appended to existing contents.
528 * @param pos On input: an alignment field, if desired.
529 * On output: the offsets of the alignment field.
530 * @param success Output param set to success/failure code on
531 * exit.
532 * @return Reference to 'appendTo' parameter.
533 * @stable ICU 2.0
534 */
535 virtual UnicodeString& format(const Formattable* objs,
536 int32_t cnt,
537 UnicodeString& appendTo,
538 FieldPosition& pos,
539 UErrorCode& success) const;
540 /**
541 * Format an object using this object's choices.
542 *
543 *
544 * @param obj The object to be formatted.
545 * @param appendTo Output parameter to receive result.
546 * Result is appended to existing contents.
547 * @param pos On input: an alignment field, if desired.
548 * On output: the offsets of the alignment field.
549 * @param status Output param set to success/failure code on
550 * exit.
551 * @return Reference to 'appendTo' parameter.
552 * @stable ICU 2.0
553 */
554 virtual UnicodeString& format(const Formattable& obj,
555 UnicodeString& appendTo,
556 FieldPosition& pos,
557 UErrorCode& status) const;
558
559 /**
560 * Redeclared NumberFormat method.
561 *
562 * @param obj The object to be formatted.
563 * @param appendTo Output parameter to receive result.
564 * Result is appended to existing contents.
565 * @param status Output param set to success/failure code on
566 * exit.
567 * @return Reference to 'appendTo' parameter.
568 * @stable ICU 2.0
569 */
570 UnicodeString& format(const Formattable& obj,
571 UnicodeString& appendTo,
572 UErrorCode& status) const;
573
574 /**
575 * Redeclared NumberFormat method.
576 * Format a double number. These methods call the NumberFormat
577 * pure virtual format() methods with the default FieldPosition.
578 *
579 * @param number The value to be formatted.
580 * @param appendTo Output parameter to receive result.
581 * Result is appended to existing contents.
582 * @return Reference to 'appendTo' parameter.
583 * @stable ICU 2.0
584 */
585 UnicodeString& format( double number,
586 UnicodeString& appendTo) const;
587
588 /**
589 * Redeclared NumberFormat method.
590 * Format a long number. These methods call the NumberFormat
591 * pure virtual format() methods with the default FieldPosition.
592 *
593 * @param number The value to be formatted.
594 * @param appendTo Output parameter to receive result.
595 * Result is appended to existing contents.
596 * @return Reference to 'appendTo' parameter.
597 * @stable ICU 2.0
598 */
599 UnicodeString& format( int32_t number,
600 UnicodeString& appendTo) const;
601
602 /**
603 * Return a long if possible (e.g. within range LONG_MAX,
604 * LONG_MAX], and with no decimals), otherwise a double. If
605 * IntegerOnly is set, will stop at a decimal point (or equivalent;
606 * e.g. for rational numbers "1 2/3", will stop after the 1).
607 * <P>
608 * If no object can be parsed, parsePosition is unchanged, and NULL is
609 * returned.
610 *
611 * @param text The text to be parsed.
612 * @param result Formattable to be set to the parse result.
613 * If parse fails, return contents are undefined.
614 * @param parsePosition The position to start parsing at on input.
615 * On output, moved to after the last successfully
616 * parse character. On parse failure, does not change.
617 * @see NumberFormat::isParseIntegerOnly
618 * @stable ICU 2.0
619 */
620 virtual void parse(const UnicodeString& text,
621 Formattable& result,
622 ParsePosition& parsePosition) const;
623
624 /**
625 * Return a long if possible (e.g. within range LONG_MAX,
626 * LONG_MAX], and with no decimals), otherwise a double. If
627 * IntegerOnly is set, will stop at a decimal point (or equivalent;
628 * e.g. for rational numbers "1 2/3", will stop after the 1).
629 * <P>
630 * If no object can be parsed, parsePosition is unchanged, and NULL is
631 * returned.
632 *
633 * @param text The text to be parsed.
634 * @param result Formattable to be set to the parse result.
635 * If parse fails, return contents are undefined.
636 * @param status Output param with the formatted string.
637 * @see NumberFormat::isParseIntegerOnly
638 * @stable ICU 2.0
639 */
640 virtual void parse(const UnicodeString& text,
641 Formattable& result,
642 UErrorCode& status) const;
643
644
645 public:
646 /**
647 * Returns a unique class ID POLYMORPHICALLY. Pure virtual override.
648 * This method is to implement a simple version of RTTI, since not all
649 * C++ compilers support genuine RTTI. Polymorphic operator==() and
650 * clone() methods call this method.
651 *
652 * @return The class ID for this object. All objects of a
653 * given class have the same class ID. Objects of
654 * other classes have different class IDs.
655 * @stable ICU 2.0
656 */
657 virtual UClassID getDynamicClassID(void) const;
658
659 /**
660 * Return the class ID for this class. This is useful only for
661 * comparing to a return value from getDynamicClassID(). For example:
662 * <pre>
663 * . Base* polymorphic_pointer = createPolymorphicObject();
664 * . if (polymorphic_pointer->getDynamicClassID() ==
665 * . Derived::getStaticClassID()) ...
666 * </pre>
667 * @return The class ID for all objects of this class.
668 * @stable ICU 2.0
669 */
670 static UClassID U_EXPORT2 getStaticClassID(void);
671
672 private:
673 // static cache management (thread-safe)
674 // static NumberFormat* getNumberFormat(UErrorCode &status); // call this function to 'check out' a numberformat from the cache.
675 // static void releaseNumberFormat(NumberFormat *adopt); // call this function to 'return' the number format to the cache.
676
677 /**
678 * Converts a string to a double value using a default NumberFormat object
679 * which is static (shared by all ChoiceFormat instances).
680 * @param string the string to be converted with.
681 * @return the converted double number.
682 */
683 static double stod(const UnicodeString& string);
684
685 /**
686 * Converts a double value to a string using a default NumberFormat object
687 * which is static (shared by all ChoiceFormat instances).
688 * @param value the double number to be converted with.
689 * @param string the result string.
690 * @return the converted string.
691 */
692 static UnicodeString& dtos(double value, UnicodeString& string);
693
694 ChoiceFormat(); // default constructor not implemented
695
696 /**
697 * Construct a new ChoiceFormat with the limits and the corresponding formats
698 * based on the pattern.
699 *
700 * @param newPattern Pattern used to construct object.
701 * @param parseError Struct to recieve information on position
702 * of error if an error is encountered.
703 * @param status Output param to receive success code. If the
704 * pattern cannot be parsed, set to failure code.
705 * @stable ICU 2.0
706 */
707 ChoiceFormat(const UnicodeString& newPattern,
708 UParseError& parseError,
709 UErrorCode& status);
710
711 friend class MessageFormat;
712 /**
713 * Each ChoiceFormat divides the range -Inf..+Inf into fCount
714 * intervals. The intervals are:
715 *
716 * 0: fChoiceLimits[0]..fChoiceLimits[1]
717 * 1: fChoiceLimits[1]..fChoiceLimits[2]
718 * ...
719 * fCount-2: fChoiceLimits[fCount-2]..fChoiceLimits[fCount-1]
720 * fCount-1: fChoiceLimits[fCount-1]..+Inf
721 *
722 * Interval 0 is special; during formatting (mapping numbers to
723 * strings), it also contains all numbers less than
724 * fChoiceLimits[0], as well as NaN values.
725 *
726 * Interval i maps to and from string fChoiceFormats[i]. When
727 * parsing (mapping strings to numbers), then intervals map to
728 * their lower limit, that is, interval i maps to fChoiceLimit[i].
729 *
730 * The intervals may be closed, half open, or open. This affects
731 * formatting but does not affect parsing. Interval i is affected
732 * by fClosures[i] and fClosures[i+1]. If fClosures[i]
733 * is FALSE, then the value fChoiceLimits[i] is in interval i.
734 * That is, intervals i and i are:
735 *
736 * i-1: ... x < fChoiceLimits[i]
737 * i: fChoiceLimits[i] <= x ...
738 *
739 * If fClosures[i] is TRUE, then the value fChoiceLimits[i] is
740 * in interval i-1. That is, intervals i-1 and i are:
741 *
742 * i-1: ... x <= fChoiceLimits[i]
743 * i: fChoiceLimits[i] < x ...
744 *
745 * Because of the nature of interval 0, fClosures[0] has no
746 * effect.
747
748 */
749 double* fChoiceLimits;
750 UBool* fClosures;
751 UnicodeString* fChoiceFormats;
752 int32_t fCount;
753 };
754
755 inline UnicodeString&
format(const Formattable & obj,UnicodeString & appendTo,UErrorCode & status)756 ChoiceFormat::format(const Formattable& obj,
757 UnicodeString& appendTo,
758 UErrorCode& status) const {
759 // Don't use Format:: - use immediate base class only,
760 // in case immediate base modifies behavior later.
761 return NumberFormat::format(obj, appendTo, status);
762 }
763
764 inline UnicodeString&
format(double number,UnicodeString & appendTo)765 ChoiceFormat::format(double number,
766 UnicodeString& appendTo) const {
767 return NumberFormat::format(number, appendTo);
768 }
769
770 inline UnicodeString&
format(int32_t number,UnicodeString & appendTo)771 ChoiceFormat::format(int32_t number,
772 UnicodeString& appendTo) const {
773 return NumberFormat::format(number, appendTo);
774 }
775 U_NAMESPACE_END
776
777 #endif /* #if !UCONFIG_NO_FORMATTING */
778
779 #endif // _CHOICFMT
780 //eof
781