1 /*
2 ********************************************************************************
3 * Copyright (C) 1997-2011, 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 #ifndef U_HIDE_DEPRECATED_API
34
35 #include "unicode/fieldpos.h"
36 #include "unicode/format.h"
37 #include "unicode/messagepattern.h"
38 #include "unicode/numfmt.h"
39 #include "unicode/unistr.h"
40
41 U_NAMESPACE_BEGIN
42
43 class MessageFormat;
44
45 /**
46 * ChoiceFormat converts between ranges of numeric values and strings for those ranges.
47 * The strings must conform to the MessageFormat pattern syntax.
48 *
49 * <p><em><code>ChoiceFormat</code> is probably not what you need.
50 * Please use <code>MessageFormat</code>
51 * with <code>plural</code> arguments for proper plural selection,
52 * and <code>select</code> arguments for simple selection among a fixed set of choices!</em></p>
53 *
54 * <p>A <code>ChoiceFormat</code> splits
55 * the real number line \htmlonly<code>-∞</code> to
56 * <code>+∞</code>\endhtmlonly into two
57 * or more contiguous ranges. Each range is mapped to a
58 * string.</p>
59 *
60 * <p><code>ChoiceFormat</code> was originally intended
61 * for displaying grammatically correct
62 * plurals such as "There is one file." vs. "There are 2 files."
63 * <em>However,</em> plural rules for many languages
64 * are too complex for the capabilities of ChoiceFormat,
65 * and its requirement of specifying the precise rules for each message
66 * is unmanageable for translators.</p>
67 *
68 * <p>There are two methods of defining a <code>ChoiceFormat</code>; both
69 * are equivalent. The first is by using a string pattern. This is the
70 * preferred method in most cases. The second method is through direct
71 * specification of the arrays that logically make up the
72 * <code>ChoiceFormat</code>.</p>
73 *
74 * <p>Note: Typically, choice formatting is done (if done at all) via <code>MessageFormat</code>
75 * with a <code>choice</code> argument type,
76 * rather than using a stand-alone <code>ChoiceFormat</code>.</p>
77 *
78 * <h5>Patterns and Their Interpretation</h5>
79 *
80 * <p>The pattern string defines the range boundaries and the strings for each number range.
81 * Syntax:
82 * <pre>
83 * choiceStyle = number separator message ('|' number separator message)*
84 * number = normal_number | ['-'] \htmlonly∞\endhtmlonly (U+221E, infinity)
85 * normal_number = double value (unlocalized ASCII string)
86 * separator = less_than | less_than_or_equal
87 * less_than = '<'
88 * less_than_or_equal = '#' | \htmlonly≤\endhtmlonly (U+2264)
89 * message: see {@link MessageFormat}
90 * </pre>
91 * Pattern_White_Space between syntax elements is ignored, except
92 * around each range's sub-message.</p>
93 *
94 * <p>Each numeric sub-range extends from the current range's number
95 * to the next range's number.
96 * The number itself is included in its range if a <code>less_than_or_equal</code> sign is used,
97 * and excluded from its range (and instead included in the previous range)
98 * if a <code>less_than</code> sign is used.</p>
99 *
100 * <p>When a <code>ChoiceFormat</code> is constructed from
101 * arrays of numbers, closure flags and strings,
102 * they are interpreted just like
103 * the sequence of <code>(number separator string)</code> in an equivalent pattern string.
104 * <code>closure[i]==TRUE</code> corresponds to a <code>less_than</code> separator sign.
105 * The equivalent pattern string will be constructed automatically.</p>
106 *
107 * <p>During formatting, a number is mapped to the first range
108 * where the number is not greater than the range's upper limit.
109 * That range's message string is returned. A NaN maps to the very first range.</p>
110 *
111 * <p>During parsing, a range is selected for the longest match of
112 * any range's message. That range's number is returned, ignoring the separator/closure.
113 * Only a simple string match is performed, without parsing of arguments that
114 * might be specified in the message strings.</p>
115 *
116 * <p>Note that the first range's number is ignored in formatting
117 * but may be returned from parsing.</p>
118 *
119 * <h5>Examples</h5>
120 *
121 * <p>Here is an example of two arrays that map the number
122 * <code>1..7</code> to the English day of the week abbreviations
123 * <code>Sun..Sat</code>. No closures array is given; this is the same as
124 * specifying all closures to be <code>FALSE</code>.</p>
125 *
126 * <pre> {1,2,3,4,5,6,7},
127 * {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}</pre>
128 *
129 * <p>Here is an example that maps the ranges [-Inf, 1), [1, 1], and (1,
130 * +Inf] to three strings. That is, the number line is split into three
131 * ranges: x < 1.0, x = 1.0, and x > 1.0.
132 * (The round parentheses in the notation above indicate an exclusive boundary,
133 * like the turned bracket in European notation: [-Inf, 1) == [-Inf, 1[ )</p>
134 *
135 * <pre> {0, 1, 1},
136 * {FALSE, FALSE, TRUE},
137 * {"no files", "one file", "many files"}</pre>
138 *
139 * <p>Here is an example that shows formatting and parsing: </p>
140 *
141 * \code
142 * #include <unicode/choicfmt.h>
143 * #include <unicode/unistr.h>
144 * #include <iostream.h>
145 *
146 * int main(int argc, char *argv[]) {
147 * double limits[] = {1,2,3,4,5,6,7};
148 * UnicodeString monthNames[] = {
149 * "Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
150 * ChoiceFormat fmt(limits, monthNames, 7);
151 * UnicodeString str;
152 * char buf[256];
153 * for (double x = 1.0; x <= 8.0; x += 1.0) {
154 * fmt.format(x, str);
155 * str.extract(0, str.length(), buf, 256, "");
156 * str.truncate(0);
157 * cout << x << " -> "
158 * << buf << endl;
159 * }
160 * cout << endl;
161 * return 0;
162 * }
163 * \endcode
164 *
165 * <p><em>User subclasses are not supported.</em> While clients may write
166 * subclasses, such code will not necessarily work and will not be
167 * guaranteed to work stably from release to release.
168 *
169 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
170 */
171 class U_I18N_API ChoiceFormat: public NumberFormat {
172 public:
173 /**
174 * Constructs a new ChoiceFormat from the pattern string.
175 *
176 * @param pattern Pattern used to construct object.
177 * @param status Output param to receive success code. If the
178 * pattern cannot be parsed, set to failure code.
179 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
180 */
181 ChoiceFormat(const UnicodeString& pattern,
182 UErrorCode& status);
183
184
185 /**
186 * Constructs a new ChoiceFormat with the given limits and message strings.
187 * All closure flags default to <code>FALSE</code>,
188 * equivalent to <code>less_than_or_equal</code> separators.
189 *
190 * Copies the limits and formats instead of adopting them.
191 *
192 * @param limits Array of limit values.
193 * @param formats Array of formats.
194 * @param count Size of 'limits' and 'formats' arrays.
195 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
196 */
197 ChoiceFormat(const double* limits,
198 const UnicodeString* formats,
199 int32_t count );
200
201 /**
202 * Constructs a new ChoiceFormat with the given limits, closure flags and message strings.
203 *
204 * Copies the limits and formats instead of adopting them.
205 *
206 * @param limits Array of limit values
207 * @param closures Array of booleans specifying whether each
208 * element of 'limits' is open or closed. If FALSE, then the
209 * corresponding limit number is a member of its range.
210 * If TRUE, then the limit number belongs to the previous range it.
211 * @param formats Array of formats
212 * @param count Size of 'limits', 'closures', and 'formats' arrays
213 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
214 */
215 ChoiceFormat(const double* limits,
216 const UBool* closures,
217 const UnicodeString* formats,
218 int32_t count);
219
220 /**
221 * Copy constructor.
222 *
223 * @param that ChoiceFormat object to be copied from
224 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
225 */
226 ChoiceFormat(const ChoiceFormat& that);
227
228 /**
229 * Assignment operator.
230 *
231 * @param that ChoiceFormat object to be copied
232 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
233 */
234 const ChoiceFormat& operator=(const ChoiceFormat& that);
235
236 /**
237 * Destructor.
238 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
239 */
240 virtual ~ChoiceFormat();
241
242 /**
243 * Clones this Format object. The caller owns the
244 * result and must delete it when done.
245 *
246 * @return a copy of this object
247 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
248 */
249 virtual Format* clone(void) const;
250
251 /**
252 * Returns true if the given Format objects are semantically equal.
253 * Objects of different subclasses are considered unequal.
254 *
255 * @param other ChoiceFormat object to be compared
256 * @return true if other is the same as this.
257 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
258 */
259 virtual UBool operator==(const Format& other) const;
260
261 /**
262 * Sets the pattern.
263 * @param pattern The pattern to be applied.
264 * @param status Output param set to success/failure code on
265 * exit. If the pattern is invalid, this will be
266 * set to a failure result.
267 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
268 */
269 virtual void applyPattern(const UnicodeString& pattern,
270 UErrorCode& status);
271
272 /**
273 * Sets the pattern.
274 * @param pattern The pattern to be applied.
275 * @param parseError Struct to receive information on position
276 * of error if an error is encountered
277 * @param status Output param set to success/failure code on
278 * exit. If the pattern is invalid, this will be
279 * set to a failure result.
280 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
281 */
282 virtual void applyPattern(const UnicodeString& pattern,
283 UParseError& parseError,
284 UErrorCode& status);
285 /**
286 * Gets the pattern.
287 *
288 * @param pattern Output param which will receive the pattern
289 * Previous contents are deleted.
290 * @return A reference to 'pattern'
291 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
292 */
293 virtual UnicodeString& toPattern(UnicodeString &pattern) const;
294
295 /**
296 * Sets the choices to be used in formatting.
297 * For details see the constructor with the same parameter list.
298 *
299 * @param limitsToCopy Contains the top value that you want
300 * parsed with that format,and should be in
301 * ascending sorted order. When formatting X,
302 * the choice will be the i, where limit[i]
303 * <= X < limit[i+1].
304 * @param formatsToCopy The format strings you want to use for each limit.
305 * @param count The size of the above arrays.
306 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
307 */
308 virtual void setChoices(const double* limitsToCopy,
309 const UnicodeString* formatsToCopy,
310 int32_t count );
311
312 /**
313 * Sets the choices to be used in formatting.
314 * For details see the constructor with the same parameter list.
315 *
316 * @param limits Array of limits
317 * @param closures Array of limit booleans
318 * @param formats Array of format string
319 * @param count The size of the above arrays
320 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
321 */
322 virtual void setChoices(const double* limits,
323 const UBool* closures,
324 const UnicodeString* formats,
325 int32_t count);
326
327 /**
328 * Returns NULL and 0.
329 * Before ICU 4.8, this used to return the choice limits array.
330 *
331 * @param count Will be set to 0.
332 * @return NULL
333 * @deprecated ICU 4.8 Use the MessagePattern class to analyze a ChoiceFormat pattern.
334 */
335 virtual const double* getLimits(int32_t& count) const;
336
337 /**
338 * Returns NULL and 0.
339 * Before ICU 4.8, this used to return the limit booleans array.
340 *
341 * @param count Will be set to 0.
342 * @return NULL
343 * @deprecated ICU 4.8 Use the MessagePattern class to analyze a ChoiceFormat pattern.
344 */
345 virtual const UBool* getClosures(int32_t& count) const;
346
347 /**
348 * Returns NULL and 0.
349 * Before ICU 4.8, this used to return the array of choice strings.
350 *
351 * @param count Will be set to 0.
352 * @return NULL
353 * @deprecated ICU 4.8 Use the MessagePattern class to analyze a ChoiceFormat pattern.
354 */
355 virtual const UnicodeString* getFormats(int32_t& count) const;
356
357
358 using NumberFormat::format;
359
360 /**
361 * Formats a double number using this object's choices.
362 *
363 * @param number The value to be formatted.
364 * @param appendTo Output parameter to receive result.
365 * Result is appended to existing contents.
366 * @param pos On input: an alignment field, if desired.
367 * On output: the offsets of the alignment field.
368 * @return Reference to 'appendTo' parameter.
369 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
370 */
371 virtual UnicodeString& format(double number,
372 UnicodeString& appendTo,
373 FieldPosition& pos) const;
374 /**
375 * Formats an int32_t number using this object's choices.
376 *
377 * @param number The value to be formatted.
378 * @param appendTo Output parameter to receive result.
379 * Result is appended to existing contents.
380 * @param pos On input: an alignment field, if desired.
381 * On output: the offsets of the alignment field.
382 * @return Reference to 'appendTo' parameter.
383 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
384 */
385 virtual UnicodeString& format(int32_t number,
386 UnicodeString& appendTo,
387 FieldPosition& pos) const;
388
389 /**
390 * Formats an int64_t number using this object's choices.
391 *
392 * @param number The value to be formatted.
393 * @param appendTo Output parameter to receive result.
394 * Result is appended to existing contents.
395 * @param pos On input: an alignment field, if desired.
396 * On output: the offsets of the alignment field.
397 * @return Reference to 'appendTo' parameter.
398 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
399 */
400 virtual UnicodeString& format(int64_t number,
401 UnicodeString& appendTo,
402 FieldPosition& pos) const;
403
404 /**
405 * Formats an array of objects using this object's choices.
406 *
407 * @param objs The array of objects to be formatted.
408 * @param cnt The size of objs.
409 * @param appendTo Output parameter to receive result.
410 * Result is appended to existing contents.
411 * @param pos On input: an alignment field, if desired.
412 * On output: the offsets of the alignment field.
413 * @param success Output param set to success/failure code on
414 * exit.
415 * @return Reference to 'appendTo' parameter.
416 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
417 */
418 virtual UnicodeString& format(const Formattable* objs,
419 int32_t cnt,
420 UnicodeString& appendTo,
421 FieldPosition& pos,
422 UErrorCode& success) const;
423 /**
424 * Formats an object using this object's choices.
425 *
426 *
427 * @param obj The object to be formatted.
428 * @param appendTo Output parameter to receive result.
429 * Result is appended to existing contents.
430 * @param pos On input: an alignment field, if desired.
431 * On output: the offsets of the alignment field.
432 * @param status Output param set to success/failure code on
433 * exit.
434 * @return Reference to 'appendTo' parameter.
435 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
436 */
437 virtual UnicodeString& format(const Formattable& obj,
438 UnicodeString& appendTo,
439 FieldPosition& pos,
440 UErrorCode& status) const;
441
442 /**
443 * Redeclared NumberFormat method.
444 *
445 * @param obj The object to be formatted.
446 * @param appendTo Output parameter to receive result.
447 * Result is appended to existing contents.
448 * @param status Output param set to success/failure code on
449 * exit.
450 * @return Reference to 'appendTo' parameter.
451 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
452 */
453 UnicodeString& format(const Formattable& obj,
454 UnicodeString& appendTo,
455 UErrorCode& status) const;
456
457 /**
458 * Redeclared NumberFormat method.
459 * Formats a double number. These methods call the NumberFormat
460 * pure virtual format() methods with the default FieldPosition.
461 *
462 * @param number The value to be formatted.
463 * @param appendTo Output parameter to receive result.
464 * Result is appended to existing contents.
465 * @return Reference to 'appendTo' parameter.
466 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
467 */
468 UnicodeString& format( double number,
469 UnicodeString& appendTo) const;
470
471 /**
472 * Redeclared NumberFormat method.
473 * Formats an int32_t number. These methods call the NumberFormat
474 * pure virtual format() methods with the default FieldPosition.
475 *
476 * @param number The value to be formatted.
477 * @param appendTo Output parameter to receive result.
478 * Result is appended to existing contents.
479 * @return Reference to 'appendTo' parameter.
480 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
481 */
482 UnicodeString& format( int32_t number,
483 UnicodeString& appendTo) const;
484
485 /**
486 * Looks for the longest match of any message string on the input text and,
487 * if there is a match, sets the result object to the corresponding range's number.
488 *
489 * If no string matches, then the parsePosition is unchanged.
490 *
491 * @param text The text to be parsed.
492 * @param result Formattable to be set to the parse result.
493 * If parse fails, return contents are undefined.
494 * @param parsePosition The position to start parsing at on input.
495 * On output, moved to after the last successfully
496 * parse character. On parse failure, does not change.
497 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
498 */
499 virtual void parse(const UnicodeString& text,
500 Formattable& result,
501 ParsePosition& parsePosition) const;
502
503 /**
504 * Looks for the longest match of any message string on the input text and,
505 * if there is a match, sets the result object to the corresponding range's number.
506 *
507 * If no string matches, then the UErrorCode is set to U_INVALID_FORMAT_ERROR.
508 *
509 * @param text The text to be parsed.
510 * @param result Formattable to be set to the parse result.
511 * If parse fails, return contents are undefined.
512 * @param status Output param with the formatted string.
513 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
514 */
515 virtual void parse(const UnicodeString& text,
516 Formattable& result,
517 UErrorCode& status) const;
518
519 /**
520 * Returns a unique class ID POLYMORPHICALLY. Part of ICU's "poor man's RTTI".
521 *
522 * @return The class ID for this object. All objects of a
523 * given class have the same class ID. Objects of
524 * other classes have different class IDs.
525 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
526 */
527 virtual UClassID getDynamicClassID(void) const;
528
529 /**
530 * Returns the class ID for this class. This is useful only for
531 * comparing to a return value from getDynamicClassID(). For example:
532 * <pre>
533 * . Base* polymorphic_pointer = createPolymorphicObject();
534 * . if (polymorphic_pointer->getDynamicClassID() ==
535 * . Derived::getStaticClassID()) ...
536 * </pre>
537 * @return The class ID for all objects of this class.
538 * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments.
539 */
540 static UClassID U_EXPORT2 getStaticClassID(void);
541
542 private:
543 /**
544 * Converts a double value to a string.
545 * @param value the double number to be converted.
546 * @param string the result string.
547 * @return the converted string.
548 */
549 static UnicodeString& dtos(double value, UnicodeString& string);
550
551 ChoiceFormat(); // default constructor not implemented
552
553 /**
554 * Construct a new ChoiceFormat with the limits and the corresponding formats
555 * based on the pattern.
556 *
557 * @param newPattern Pattern used to construct object.
558 * @param parseError Struct to receive information on position
559 * of error if an error is encountered.
560 * @param status Output param to receive success code. If the
561 * pattern cannot be parsed, set to failure code.
562 */
563 ChoiceFormat(const UnicodeString& newPattern,
564 UParseError& parseError,
565 UErrorCode& status);
566
567 friend class MessageFormat;
568
569 virtual void setChoices(const double* limits,
570 const UBool* closures,
571 const UnicodeString* formats,
572 int32_t count,
573 UErrorCode &errorCode);
574
575 /**
576 * Finds the ChoiceFormat sub-message for the given number.
577 * @param pattern A MessagePattern.
578 * @param partIndex the index of the first ChoiceFormat argument style part.
579 * @param number a number to be mapped to one of the ChoiceFormat argument's intervals
580 * @return the sub-message start part index.
581 */
582 static int32_t findSubMessage(const MessagePattern &pattern, int32_t partIndex, double number);
583
584 static double parseArgument(
585 const MessagePattern &pattern, int32_t partIndex,
586 const UnicodeString &source, ParsePosition &pos);
587
588 /**
589 * Matches the pattern string from the end of the partIndex to
590 * the beginning of the limitPartIndex,
591 * including all syntax except SKIP_SYNTAX,
592 * against the source string starting at sourceOffset.
593 * If they match, returns the length of the source string match.
594 * Otherwise returns -1.
595 */
596 static int32_t matchStringUntilLimitPart(
597 const MessagePattern &pattern, int32_t partIndex, int32_t limitPartIndex,
598 const UnicodeString &source, int32_t sourceOffset);
599
600 /**
601 * Some of the ChoiceFormat constructors do not have a UErrorCode paramater.
602 * We need _some_ way to provide one for the MessagePattern constructor.
603 * Alternatively, the MessagePattern could be a pointer field, but that is
604 * not nice either.
605 */
606 UErrorCode constructorErrorCode;
607
608 /**
609 * The MessagePattern which contains the parsed structure of the pattern string.
610 *
611 * Starting with ICU 4.8, the MessagePattern contains a sequence of
612 * numeric/selector/message parts corresponding to the parsed pattern.
613 * For details see the MessagePattern class API docs.
614 */
615 MessagePattern msgPattern;
616
617 /**
618 * Docs & fields from before ICU 4.8, before MessagePattern was used.
619 * Commented out, and left only for explanation of semantics.
620 * --------
621 * Each ChoiceFormat divides the range -Inf..+Inf into fCount
622 * intervals. The intervals are:
623 *
624 * 0: fChoiceLimits[0]..fChoiceLimits[1]
625 * 1: fChoiceLimits[1]..fChoiceLimits[2]
626 * ...
627 * fCount-2: fChoiceLimits[fCount-2]..fChoiceLimits[fCount-1]
628 * fCount-1: fChoiceLimits[fCount-1]..+Inf
629 *
630 * Interval 0 is special; during formatting (mapping numbers to
631 * strings), it also contains all numbers less than
632 * fChoiceLimits[0], as well as NaN values.
633 *
634 * Interval i maps to and from string fChoiceFormats[i]. When
635 * parsing (mapping strings to numbers), then intervals map to
636 * their lower limit, that is, interval i maps to fChoiceLimit[i].
637 *
638 * The intervals may be closed, half open, or open. This affects
639 * formatting but does not affect parsing. Interval i is affected
640 * by fClosures[i] and fClosures[i+1]. If fClosures[i]
641 * is FALSE, then the value fChoiceLimits[i] is in interval i.
642 * That is, intervals i and i are:
643 *
644 * i-1: ... x < fChoiceLimits[i]
645 * i: fChoiceLimits[i] <= x ...
646 *
647 * If fClosures[i] is TRUE, then the value fChoiceLimits[i] is
648 * in interval i-1. That is, intervals i-1 and i are:
649 *
650 * i-1: ... x <= fChoiceLimits[i]
651 * i: fChoiceLimits[i] < x ...
652 *
653 * Because of the nature of interval 0, fClosures[0] has no
654 * effect.
655 */
656 // double* fChoiceLimits;
657 // UBool* fClosures;
658 // UnicodeString* fChoiceFormats;
659 // int32_t fCount;
660 };
661
662 inline UnicodeString&
format(const Formattable & obj,UnicodeString & appendTo,UErrorCode & status)663 ChoiceFormat::format(const Formattable& obj,
664 UnicodeString& appendTo,
665 UErrorCode& status) const {
666 // Don't use Format:: - use immediate base class only,
667 // in case immediate base modifies behavior later.
668 return NumberFormat::format(obj, appendTo, status);
669 }
670
671 inline UnicodeString&
format(double number,UnicodeString & appendTo)672 ChoiceFormat::format(double number,
673 UnicodeString& appendTo) const {
674 return NumberFormat::format(number, appendTo);
675 }
676
677 inline UnicodeString&
format(int32_t number,UnicodeString & appendTo)678 ChoiceFormat::format(int32_t number,
679 UnicodeString& appendTo) const {
680 return NumberFormat::format(number, appendTo);
681 }
682 U_NAMESPACE_END
683
684 #endif // U_HIDE_DEPRECATED_API
685 #endif /* #if !UCONFIG_NO_FORMATTING */
686
687 #endif // CHOICFMT_H
688 //eof
689