icuSources/i18n/unicode/choicfmt.h

   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 &quot;There are 2 files.&quot;</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&#x2264;are no files|1&#x2264;is one file|1&lt;are many files</pre>\endhtmlonly
  65  *
  66  * <p>or equivalently,</p>
  67  *
  68  * \htmlonly<pre>    0#are no files|1#is one file|1&lt;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&#x221E \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'&#x2264;' \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> &gt;= 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] &lt;= X &lt; 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>&lt;=</code> or <code>&lt;</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&quot;<code>1.0#a|2.0#b</code>&quot;\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(&quot;a&quot;)</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  *     {&quot;Sun&quot;,&quot;Mon&quot;,&quot;Tue&quot;,&quot;Wed&quot;,&quot;Thur&quot;,&quot;Fri&quot;,&quot;Sat&quot;}</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 &lt; 1.0, x = 1.0, and x &gt; 1.0.</p>
 187  *
 188  * <pre>    {0, 1, 1},
 189  *     {FALSE, FALSE, TRUE},
 190  *     {&quot;no files&quot;, &quot;one file&quot;, &quot;many files&quot;}</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      *                          &lt;= X &lt; 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      *                          &lt;= X &lt; 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&
 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&
 765 ChoiceFormat::format(double number,
 766                      UnicodeString& appendTo) const {
 767     return NumberFormat::format(number, appendTo);
 768 }
 769
 770 inline UnicodeString&
 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