| OLD | NEW |
|---|
| (Empty) |
| 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 "There are 2 files."</p> | |
| 51 * | |
| 52 * <p>There are two methods of defining a <code>ChoiceFormat</code>; both | |
| 53 * are equivalent. The first is by using a string pattern. This is the | |
| 54 * preferred method in most cases. The second method is through direct | |
| 55 * specification of the arrays that make up the | |
| 56 * <code>ChoiceFormat</code>.</p> | |
| 57 * | |
| 58 * <p><strong>Patterns</strong></p> | |
| 59 * | |
| 60 * <p>In most cases, the preferred way to define a | |
| 61 * <code>ChoiceFormat</code> is with a pattern. Here is an example of a | |
| 62 * <code>ChoiceFormat</code> pattern:</p> | |
| 63 * | |
| 64 * \htmlonly<pre> 0≤are no files|1≤is one file|1<are many fi
les</pre>\endhtmlonly | |
| 65 * | |
| 66 * <p>or equivalently,</p> | |
| 67 * | |
| 68 * \htmlonly<pre> 0#are no files|1#is one file|1<are many files</pre>\endh
tmlonly | |
| 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>\endhtmlonl
y | |
| 76 * | |
| 77 * <p><em>Number</em> is a floating point number that can be parsed by a | |
| 78 * default <code>NumberFormat</code> for the US locale. It gives the | |
| 79 * lower limit of this range. The lower limit is either inclusive or | |
| 80 * exclusive, depending on the <em>separator</em>. The upper limit is | |
| 81 * given by the lower limit of the next range. The Unicode infinity | |
| 82 * sign \htmlonly∞ \endhtmlonly (U+221E) is recognized for positive infini
ty. It may be preceded by | |
| 83 * '-' (U+002D) to indicate negative infinity.</p> | |
| 84 * | |
| 85 * <p><em>String</em> is the format string for this range, with special | |
| 86 * characters enclosed in single quotes (<code>'The # | |
| 87 * sign'</code>). Single quotes themselves are indicated by two single | |
| 88 * quotes in a row (<code>'o''clock'</code>).</p> | |
| 89 * | |
| 90 * <p><em>Separator</em> is one of the following single characters: | |
| 91 * | |
| 92 * <ul> | |
| 93 * <li>\htmlonly'≤' \endhtmlonly (U+2264) or '#' (U+0023) | |
| 94 * indicates that the lower limit given by <em>Number</em> is | |
| 95 * inclusive. (The two characters are equivalent to ChoiceFormat.) | |
| 96 * This means that the limit value <em>Number</em> belongs to this | |
| 97 * range. Another way of saying this is that the corresponding | |
| 98 * closure is <code>FALSE</code>.</li> | |
| 99 * | |
| 100 * <li>'<' (U+003C) indicates that the lower limit given by | |
| 101 * <em>Number</em> is exclusive. This means that the value | |
| 102 * <em>Number</em> belongs to the prior range.</li> Another way of | |
| 103 * saying this is that the corresponding closure is | |
| 104 * <code>TRUE</code>. | |
| 105 * </ul> | |
| 106 * | |
| 107 * <p>See below for more information about closures.</p> | |
| 108 * | |
| 109 * <p><strong>Arrays</strong></p> | |
| 110 * | |
| 111 * <p>A <code>ChoiceFormat</code> defining <code>n</code> intervals | |
| 112 * (<code>n</code> >= 2) is specified by three arrays of | |
| 113 * <code>n</code> items: | |
| 114 * | |
| 115 * <ul> | |
| 116 * <li><code>double limits[]</code> gives the start of each | |
| 117 * interval. This must be a non-decreasing list of values, none of | |
| 118 * which may be <code>NaN</code>.</li> | |
| 119 * <li><code>UBool closures[]</code> determines whether each limit | |
| 120 * value is contained in the interval below it or in the interval | |
| 121 * above it. If <code>closures[i]</code> is <code>FALSE</code>, then | |
| 122 * <code>limits[i]</code> is a member of interval | |
| 123 * <code>i</code>. Otherwise it is a member of interval | |
| 124 * <code>i+1</code>. If no closures array is specified, this is | |
| 125 * equivalent to having all closures be <code>FALSE</code>. Closures | |
| 126 * allow one to specify half-open, open, or closed intervals.</li> | |
| 127 * <li><code>UnicodeString formats[]</code> gives the string label | |
| 128 * associated with each interval.</li> | |
| 129 * </ul> | |
| 130 * | |
| 131 * <p><strong>Formatting and Parsing</strong></p> | |
| 132 * | |
| 133 * <p>During formatting, a number is converted to a | |
| 134 * string. <code>ChoiceFormat</code> accomplishes this by mapping the | |
| 135 * number to an interval using the following rule. Given a number | |
| 136 * <code>X</code> and and index value <code>j</code> in the range | |
| 137 * <code>0..n-1</code>, where <code>n</code> is the number of ranges:</p> | |
| 138 * | |
| 139 * \htmlonly<blockquote>\endhtmlonly<code>X</code> matches <code>j</code> if and
only if | |
| 140 * <code>limit[j] <= X < limit[j+1]</code> | |
| 141 * \htmlonly</blockquote>\endhtmlonly | |
| 142 * | |
| 143 * <p>(This assumes that all closures are <code>FALSE</code>. If some | |
| 144 * closures are <code>TRUE</code> then the relations must be changed to | |
| 145 * <code><=</code> or <code><</code> as appropriate.) If there is | |
| 146 * no match, then either the first or last index is used, depending on | |
| 147 * whether the number is too low or too high. Once a number is mapped to | |
| 148 * an interval <code>j</code>, the string <code>formats[j]</code> is | |
| 149 * output.</p> | |
| 150 * | |
| 151 * <p>During parsing, a string is converted to a | |
| 152 * number. <code>ChoiceFormat</code> finds the element | |
| 153 * <code>formats[j]</code> equal to the string, and returns | |
| 154 * <code>limits[j]</code> as the parsed value.</p> | |
| 155 * | |
| 156 * <p><strong>Notes</strong></p> | |
| 157 * | |
| 158 * <p>The first limit value does not define a range boundary. For | |
| 159 * example, in the pattern \htmlonly"<code>1.0#a|2.0#b</code>"\endhtml
only, the | |
| 160 * intervals are [-Inf, 2.0) and [2.0, +Inf]. It appears that the first | |
| 161 * interval should be [1.0, 2.0). However, since all values that are too | |
| 162 * small are mapped to range zero, the first interval is effectively | |
| 163 * [-Inf, 2.0). However, the first limit value <em>is</em> used during | |
| 164 * formatting. In this example, <code>parse("a")</code> returns | |
| 165 * 1.0.</p> | |
| 166 * | |
| 167 * <p>There are no gaps between intervals and the entire number line is | |
| 168 * covered. A <code>ChoiceFormat</code> maps <em>all</em> possible | |
| 169 * double values to a finite set of intervals.</p> | |
| 170 * | |
| 171 * <p>The non-number <code>NaN</code> is mapped to interval zero during | |
| 172 * formatting.</p> | |
| 173 * | |
| 174 * <p><strong>Examples</strong></p> | |
| 175 * | |
| 176 * <p>Here is an example of two arrays that map the number | |
| 177 * <code>1..7</code> to the English day of the week abbreviations | |
| 178 * <code>Sun..Sat</code>. No closures array is given; this is the same as | |
| 179 * specifying all closures to be <code>FALSE</code>.</p> | |
| 180 * | |
| 181 * <pre> {1,2,3,4,5,6,7}, | |
| 182 * {"Sun","Mon","Tue","Wed","Th
ur","Fri","Sat"}</pre> | |
| 183 * | |
| 184 * <p>Here is an example that maps the ranges [-Inf, 1), [1, 1], and (1, | |
| 185 * +Inf] to three strings. That is, the number line is split into three | |
| 186 * ranges: x < 1.0, x = 1.0, and x > 1.0.</p> | |
| 187 * | |
| 188 * <pre> {0, 1, 1}, | |
| 189 * {FALSE, FALSE, TRUE}, | |
| 190 * {"no files", "one file", "many files"}</pre
> | |
| 191 * | |
| 192 * <p>Here is a simple example that shows formatting and parsing: </p> | |
| 193 * | |
| 194 * \code | |
| 195 * #include <unicode/choicfmt.h> | |
| 196 * #include <unicode/unistr.h> | |
| 197 * #include <iostream.h> | |
| 198 * | |
| 199 * int main(int argc, char *argv[]) { | |
| 200 * double limits[] = {1,2,3,4,5,6,7}; | |
| 201 * UnicodeString monthNames[] = { | |
| 202 * "Sun","Mon","Tue","Wed","Thu","Fri","Sat"}; | |
| 203 * ChoiceFormat fmt(limits, monthNames, 7); | |
| 204 * UnicodeString str; | |
| 205 * char buf[256]; | |
| 206 * for (double x = 1.0; x <= 8.0; x += 1.0) { | |
| 207 * fmt.format(x, str); | |
| 208 * str.extract(0, str.length(), buf, 256, ""); | |
| 209 * str.truncate(0); | |
| 210 * cout << x << " -> " | |
| 211 * << buf << endl; | |
| 212 * } | |
| 213 * cout << endl; | |
| 214 * return 0; | |
| 215 * } | |
| 216 * \endcode | |
| 217 * | |
| 218 * <p>Here is a more complex example using a <code>ChoiceFormat</code> | |
| 219 * constructed from a pattern together with a | |
| 220 * <code>MessageFormat</code>.</p> | |
| 221 * | |
| 222 * \code | |
| 223 * #include <unicode/choicfmt.h> | |
| 224 * #include <unicode/msgfmt.h> | |
| 225 * #include <unicode/unistr.h> | |
| 226 * #include <iostream.h> | |
| 227 * | |
| 228 * int main(int argc, char *argv[]) { | |
| 229 * UErrorCode status = U_ZERO_ERROR; | |
| 230 * double filelimits[] = {0,1,2}; | |
| 231 * UnicodeString filepart[] = | |
| 232 * {"are no files","is one file","are {0} files"}; | |
| 233 * ChoiceFormat* fileform = new ChoiceFormat(filelimits, filepart, 3 ); | |
| 234 * Format* testFormats[] = | |
| 235 * {fileform, NULL, NumberFormat::createInstance(status)}; | |
| 236 * MessageFormat pattform("There {0} on {1}", status ); | |
| 237 * pattform.adoptFormats(testFormats, 3); | |
| 238 * Formattable testArgs[] = {0L, "Disk A"}; | |
| 239 * FieldPosition fp(0); | |
| 240 * UnicodeString str; | |
| 241 * char buf[256]; | |
| 242 * for (int32_t i = 0; i < 4; ++i) { | |
| 243 * Formattable fInt(i); | |
| 244 * testArgs[0] = fInt; | |
| 245 * pattform.format(testArgs, 2, str, fp, status ); | |
| 246 * str.extract(0, str.length(), buf, ""); | |
| 247 * str.truncate(0); | |
| 248 * cout << "Output for i=" << i << " : " << buf << endl; | |
| 249 * } | |
| 250 * cout << endl; | |
| 251 * return 0; | |
| 252 * } | |
| 253 * \endcode | |
| 254 * | |
| 255 * <p><em>User subclasses are not supported.</em> While clients may write | |
| 256 * subclasses, such code will not necessarily work and will not be | |
| 257 * guaranteed to work stably from release to release. | |
| 258 */ | |
| 259 class U_I18N_API ChoiceFormat: public NumberFormat { | |
| 260 public: | |
| 261 /** | |
| 262 * Construct a new ChoiceFormat with the limits and the corresponding format
s | |
| 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 * <= X < limit[i+1]. | |
| 393 * @param formatsToCopy The format strings you want to use for each limi
t. | |
| 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 fun
ction to 'check out' a numberformat from the cache. | |
| 644 // static void releaseNumberFormat(NumberFormat *adopt); // call thi
s 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 format
s | |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 18836004:
Move ICU headers from public/{common,i18n} to source/{common,i18n} (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/icu46.git@master