icuSources/i18n/unicode/choicfmt.h

   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>-&#x221E;</code> to
  56  * <code>+&#x221E;</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 &quot;There is one file.&quot; vs. &quot;There are 2 files.&quot;
  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&#x221E;\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&#x2264;\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  *     {&quot;Sun&quot;,&quot;Mon&quot;,&quot;Tue&quot;,&quot;Wed&quot;,&quot;Thur&quot;,&quot;Fri&quot;,&quot;Sat&quot;}</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 &lt; 1.0, x = 1.0, and x &gt; 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  *     {&quot;no files&quot;, &quot;one file&quot;, &quot;many files&quot;}</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      *                          &lt;= X &lt; 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&
 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&
 672 ChoiceFormat::format(double number,
 673                      UnicodeString& appendTo) const {
 674     return NumberFormat::format(number, appendTo);
 675 }
 676
 677 inline UnicodeString&
 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