icuSources/i18n/unicode/choicfmt.h

   1 /*
   2 ********************************************************************************
   3 *   Copyright (C) 1997-2010, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 ********************************************************************************
   6 *
   7 * File CHOICFMT.H
   8 *
   9 * Modification History:
  10 *
  11 *   Date        Name        Description
  12 *   02/19/97    aliu        Converted from java.
  13 *   03/20/97    helena      Finished first cut of implementation and got rid
  14 *                           of nextDouble/previousDouble and replaced with
  15 *                           boolean array.
  16 *   4/10/97     aliu        Clean up.  Modified to work on AIX.
  17 *   8/6/97      nos         Removed overloaded constructor, member var 'buffer'.
  18 *   07/22/98    stephen     Removed operator!= (implemented in Format)
  19 ********************************************************************************
  20 */
  21
  22 #ifndef CHOICFMT_H
  23 #define CHOICFMT_H
  24
  25 #include "unicode/utypes.h"
  26
  27 /**
  28  * \file
  29  * \brief C++ API: Choice Format.
  30  */
  31
  32 #if !UCONFIG_NO_FORMATTING
  33
  34 #include "unicode/unistr.h"
  35 #include "unicode/numfmt.h"
  36 #include "unicode/fieldpos.h"
  37 #include "unicode/format.h"
  38
  39 U_NAMESPACE_BEGIN
  40
  41 class MessageFormat;
  42
  43 /**
  44  * ChoiceFormat converts between ranges of numeric values
  45  * and string names for those ranges. A <code>ChoiceFormat</code> splits
  46  * the real number line <code>-Inf</code> to <code>+Inf</code> into two
  47  * or more contiguous ranges. Each range is mapped to a
  48  * string. <code>ChoiceFormat</code> is generally used in a
  49  * <code>MessageFormat</code> for displaying grammatically correct
  50  * plurals such as &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     /**
 386      * Set the choices to be used in formatting.
 387      *
 388      * @param limitsToCopy      Contains the top value that you want
 389      *                          parsed with that format,and should be in
 390      *                          ascending sorted order. When formatting X,
 391      *                          the choice will be the i, where limit[i]
 392      *                          &lt;= X &lt; limit[i+1].
 393      * @param formatsToCopy     The format strings you want to use for each limit.
 394      * @param count             The size of the above arrays.
 395      * @stable ICU 2.0
 396      */
 397     virtual void setChoices(const double* limitsToCopy,
 398                             const UnicodeString* formatsToCopy,
 399                             int32_t count );
 400
 401     /**
 402      * Set the choices to be used in formatting.  See class description
 403      * for documenatation of the limits, closures, and formats arrays.
 404      * @param limits Array of limits
 405      * @param closures Array of limit booleans
 406      * @param formats Array of format string
 407      * @param count The size of the above arrays
 408      * @stable ICU 2.4
 409      */
 410     virtual void setChoices(const double* limits,
 411                             const UBool* closures,
 412                             const UnicodeString* formats,
 413                             int32_t count);
 414
 415     /**
 416      * Get the limits passed in the constructor.
 417      *
 418      * @param count    The size of the limits arrays
 419      * @return the limits.
 420      * @stable ICU 2.0
 421      */
 422     virtual const double* getLimits(int32_t& count) const;
 423
 424     /**
 425      * Get the limit booleans passed in the constructor.  The caller
 426      * must not delete the result.
 427      *
 428      * @param count   The size of the arrays
 429      * @return the closures
 430      * @stable ICU 2.4
 431      */
 432     virtual const UBool* getClosures(int32_t& count) const;
 433
 434     /**
 435      * Get the formats passed in the constructor.
 436      *
 437      * @param count   The size of the arrays
 438      * @return the formats.
 439      * @stable ICU 2.0
 440      */
 441     virtual const UnicodeString* getFormats(int32_t& count) const;
 442
 443
 444     using NumberFormat::format;
 445
 446     /**
 447      * Format a double or long number using this object's choices.
 448      *
 449      * @param number    The value to be formatted.
 450      * @param appendTo  Output parameter to receive result.
 451      *                  Result is appended to existing contents.
 452      * @param pos       On input: an alignment field, if desired.
 453      *                  On output: the offsets of the alignment field.
 454      * @return          Reference to 'appendTo' parameter.
 455      * @stable ICU 2.0
 456      */
 457     virtual UnicodeString& format(double number,
 458                                   UnicodeString& appendTo,
 459                                   FieldPosition& pos) const;
 460     /**
 461      * Format a int_32t number using this object's choices.
 462      *
 463      * @param number    The value to be formatted.
 464      * @param appendTo  Output parameter to receive result.
 465      *                  Result is appended to existing contents.
 466      * @param pos       On input: an alignment field, if desired.
 467      *                  On output: the offsets of the alignment field.
 468      * @return          Reference to 'appendTo' parameter.
 469      * @stable ICU 2.0
 470      */
 471     virtual UnicodeString& format(int32_t number,
 472                                   UnicodeString& appendTo,
 473                                   FieldPosition& pos) const;
 474
 475     /**
 476      * Format an int64_t number using this object's choices.
 477      *
 478      * @param number    The value to be formatted.
 479      * @param appendTo  Output parameter to receive result.
 480      *                  Result is appended to existing contents.
 481      * @param pos       On input: an alignment field, if desired.
 482      *                  On output: the offsets of the alignment field.
 483      * @return          Reference to 'appendTo' parameter.
 484      * @stable ICU 2.8
 485      */
 486     virtual UnicodeString& format(int64_t number,
 487                                   UnicodeString& appendTo,
 488                                   FieldPosition& pos) const;
 489
 490     /**
 491      * Format an array of objects using this object's choices.
 492      *
 493      * @param objs      The array of objects to be formatted.
 494      * @param cnt       The size of objs.
 495      * @param appendTo  Output parameter to receive result.
 496      *                  Result is appended to existing contents.
 497      * @param pos       On input: an alignment field, if desired.
 498      *                  On output: the offsets of the alignment field.
 499      * @param success   Output param set to success/failure code on
 500      *                  exit.
 501      * @return          Reference to 'appendTo' parameter.
 502      * @stable ICU 2.0
 503      */
 504     virtual UnicodeString& format(const Formattable* objs,
 505                                   int32_t cnt,
 506                                   UnicodeString& appendTo,
 507                                   FieldPosition& pos,
 508                                   UErrorCode& success) const;
 509     /**
 510      * Format an object using this object's choices.
 511      *
 512      *
 513      * @param obj       The object to be formatted.
 514      * @param appendTo  Output parameter to receive result.
 515      *                  Result is appended to existing contents.
 516      * @param pos       On input: an alignment field, if desired.
 517      *                  On output: the offsets of the alignment field.
 518      * @param status    Output param set to success/failure code on
 519      *                  exit.
 520      * @return          Reference to 'appendTo' parameter.
 521      * @stable ICU 2.0
 522      */
 523     virtual UnicodeString& format(const Formattable& obj,
 524                                   UnicodeString& appendTo,
 525                                   FieldPosition& pos,
 526                                   UErrorCode& status) const;
 527
 528     /**
 529      * Redeclared NumberFormat method.
 530      *
 531      * @param obj       The object to be formatted.
 532      * @param appendTo  Output parameter to receive result.
 533      *                  Result is appended to existing contents.
 534      * @param status    Output param set to success/failure code on
 535      *                  exit.
 536      * @return          Reference to 'appendTo' parameter.
 537      * @stable ICU 2.0
 538      */
 539     UnicodeString& format(const Formattable& obj,
 540                           UnicodeString& appendTo,
 541                           UErrorCode& status) const;
 542
 543     /**
 544      * Redeclared NumberFormat method.
 545      * Format a double number. These methods call the NumberFormat
 546      * pure virtual format() methods with the default FieldPosition.
 547      *
 548      * @param number    The value to be formatted.
 549      * @param appendTo  Output parameter to receive result.
 550      *                  Result is appended to existing contents.
 551      * @return          Reference to 'appendTo' parameter.
 552      * @stable ICU 2.0
 553      */
 554     UnicodeString& format(  double number,
 555                             UnicodeString& appendTo) const;
 556
 557     /**
 558      * Redeclared NumberFormat method.
 559      * Format a long number. These methods call the NumberFormat
 560      * pure virtual format() methods with the default FieldPosition.
 561      *
 562      * @param number    The value to be formatted.
 563      * @param appendTo  Output parameter to receive result.
 564      *                  Result is appended to existing contents.
 565      * @return          Reference to 'appendTo' parameter.
 566      * @stable ICU 2.0
 567      */
 568     UnicodeString& format(  int32_t number,
 569                             UnicodeString& appendTo) const;
 570
 571    /**
 572     * Return a long if possible (e.g. within range LONG_MAX,
 573     * LONG_MAX], and with no decimals), otherwise a double.  If
 574     * IntegerOnly is set, will stop at a decimal point (or equivalent;
 575     * e.g. for rational numbers "1 2/3", will stop after the 1).
 576     * <P>
 577     * If no object can be parsed, parsePosition is unchanged, and NULL is
 578     * returned.
 579     *
 580     * @param text           The text to be parsed.
 581     * @param result         Formattable to be set to the parse result.
 582     *                       If parse fails, return contents are undefined.
 583     * @param parsePosition  The position to start parsing at on input.
 584     *                       On output, moved to after the last successfully
 585     *                       parse character. On parse failure, does not change.
 586     * @see                  NumberFormat::isParseIntegerOnly
 587     * @stable ICU 2.0
 588     */
 589     virtual void parse(const UnicodeString& text,
 590                        Formattable& result,
 591                        ParsePosition& parsePosition) const;
 592
 593     /**
 594     * Return a long if possible (e.g. within range LONG_MAX,
 595     * LONG_MAX], and with no decimals), otherwise a double.  If
 596     * IntegerOnly is set, will stop at a decimal point (or equivalent;
 597     * e.g. for rational numbers "1 2/3", will stop after the 1).
 598     * <P>
 599     * If no object can be parsed, parsePosition is unchanged, and NULL is
 600     * returned.
 601     *
 602     * @param text           The text to be parsed.
 603     * @param result         Formattable to be set to the parse result.
 604     *                       If parse fails, return contents are undefined.
 605     * @param status         Output param with the formatted string.
 606     * @see                  NumberFormat::isParseIntegerOnly
 607     * @stable ICU 2.0
 608     */
 609     virtual void parse(const UnicodeString& text,
 610                        Formattable& result,
 611                        UErrorCode& status) const;
 612
 613
 614 public:
 615     /**
 616      * Returns a unique class ID POLYMORPHICALLY.  Pure virtual override.
 617      * This method is to implement a simple version of RTTI, since not all
 618      * C++ compilers support genuine RTTI.  Polymorphic operator==() and
 619      * clone() methods call this method.
 620      *
 621      * @return          The class ID for this object. All objects of a
 622      *                  given class have the same class ID.  Objects of
 623      *                  other classes have different class IDs.
 624      * @stable ICU 2.0
 625      */
 626     virtual UClassID getDynamicClassID(void) const;
 627
 628     /**
 629      * Return the class ID for this class.  This is useful only for
 630      * comparing to a return value from getDynamicClassID().  For example:
 631      * <pre>
 632      * .       Base* polymorphic_pointer = createPolymorphicObject();
 633      * .       if (polymorphic_pointer->getDynamicClassID() ==
 634      * .           Derived::getStaticClassID()) ...
 635      * </pre>
 636      * @return          The class ID for all objects of this class.
 637      * @stable ICU 2.0
 638      */
 639     static UClassID U_EXPORT2 getStaticClassID(void);
 640
 641 private:
 642     // static cache management (thread-safe)
 643   //  static NumberFormat* getNumberFormat(UErrorCode &status); // call this function to 'check out' a numberformat from the cache.
 644   //  static void          releaseNumberFormat(NumberFormat *adopt); // call this function to 'return' the number format to the cache.
 645
 646     /**
 647      * Converts a string to a double value using a default NumberFormat object
 648      * which is static (shared by all ChoiceFormat instances).
 649      * @param string the string to be converted with.
 650      * @return the converted double number.
 651      */
 652     static double stod(const UnicodeString& string);
 653
 654     /**
 655      * Converts a double value to a string using a default NumberFormat object
 656      * which is static (shared by all ChoiceFormat instances).
 657      * @param value the double number to be converted with.
 658      * @param string the result string.
 659      * @return the converted string.
 660      */
 661     static UnicodeString& dtos(double value, UnicodeString& string);
 662
 663     ChoiceFormat(); // default constructor not implemented
 664
 665     /**
 666      * Construct a new ChoiceFormat with the limits and the corresponding formats
 667      * based on the pattern.
 668      *
 669      * @param newPattern   Pattern used to construct object.
 670      * @param parseError   Struct to recieve information on position
 671      *                     of error if an error is encountered.
 672      * @param status       Output param to receive success code.  If the
 673      *                     pattern cannot be parsed, set to failure code.
 674      * @stable ICU 2.0
 675      */
 676     ChoiceFormat(const UnicodeString& newPattern,
 677                  UParseError& parseError,
 678                  UErrorCode& status);
 679
 680     friend class MessageFormat;
 681     /**
 682      * Each ChoiceFormat divides the range -Inf..+Inf into fCount
 683      * intervals.  The intervals are:
 684      *
 685      *         0: fChoiceLimits[0]..fChoiceLimits[1]
 686      *         1: fChoiceLimits[1]..fChoiceLimits[2]
 687      *        ...
 688      *  fCount-2: fChoiceLimits[fCount-2]..fChoiceLimits[fCount-1]
 689      *  fCount-1: fChoiceLimits[fCount-1]..+Inf
 690      *
 691      * Interval 0 is special; during formatting (mapping numbers to
 692      * strings), it also contains all numbers less than
 693      * fChoiceLimits[0], as well as NaN values.
 694      *
 695      * Interval i maps to and from string fChoiceFormats[i].  When
 696      * parsing (mapping strings to numbers), then intervals map to
 697      * their lower limit, that is, interval i maps to fChoiceLimit[i].
 698      *
 699      * The intervals may be closed, half open, or open.  This affects
 700      * formatting but does not affect parsing.  Interval i is affected
 701      * by fClosures[i] and fClosures[i+1].  If fClosures[i]
 702      * is FALSE, then the value fChoiceLimits[i] is in interval i.
 703      * That is, intervals i and i are:
 704      *
 705      *  i-1:                 ... x < fChoiceLimits[i]
 706      *    i: fChoiceLimits[i] <= x ...
 707      *
 708      * If fClosures[i] is TRUE, then the value fChoiceLimits[i] is
 709      * in interval i-1.  That is, intervals i-1 and i are:
 710      *
 711      *  i-1:                ... x <= fChoiceLimits[i]
 712      *    i: fChoiceLimits[i] < x ...
 713      *
 714      * Because of the nature of interval 0, fClosures[0] has no
 715      * effect.
 716
 717      */
 718     double*         fChoiceLimits;
 719     UBool*          fClosures;
 720     UnicodeString*  fChoiceFormats;
 721     int32_t         fCount;
 722 };
 723
 724 inline UnicodeString&
 725 ChoiceFormat::format(const Formattable& obj,
 726                      UnicodeString& appendTo,
 727                      UErrorCode& status) const {
 728     // Don't use Format:: - use immediate base class only,
 729     // in case immediate base modifies behavior later.
 730     return NumberFormat::format(obj, appendTo, status);
 731 }
 732
 733 inline UnicodeString&
 734 ChoiceFormat::format(double number,
 735                      UnicodeString& appendTo) const {
 736     return NumberFormat::format(number, appendTo);
 737 }
 738
 739 inline UnicodeString&
 740 ChoiceFormat::format(int32_t number,
 741                      UnicodeString& appendTo) const {
 742     return NumberFormat::format(number, appendTo);
 743 }
 744 U_NAMESPACE_END
 745
 746 #endif /* #if !UCONFIG_NO_FORMATTING */
 747
 748 #endif // _CHOICFMT
 749 //eof