1 // Copyright (C) 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ********************************************************************** 5 * Copyright (c) 2004-2016, International Business Machines 6 * Corporation and others. All Rights Reserved. 7 ********************************************************************** 8 * Author: Alan Liu 9 * Created: April 20, 2004 10 * Since: ICU 3.0 11 ********************************************************************** 12 */ 13 #include "utypeinfo.h" // for 'typeid' to work 14 #include "unicode/utypes.h" 15 16 #if !UCONFIG_NO_FORMATTING 17 18 #include "unicode/measfmt.h" 19 #include "unicode/numfmt.h" 20 #include "currfmt.h" 21 #include "unicode/localpointer.h" 22 #include "resource.h" 23 #include "unicode/simpleformatter.h" 24 #include "quantityformatter.h" 25 #include "unicode/plurrule.h" 26 #include "unicode/decimfmt.h" 27 #include "uresimp.h" 28 #include "unicode/ures.h" 29 #include "ureslocs.h" 30 #include "cstring.h" 31 #include "mutex.h" 32 #include "ucln_in.h" 33 #include "unicode/listformatter.h" 34 #include "charstr.h" 35 #include "unicode/putil.h" 36 #include "unicode/smpdtfmt.h" 37 #include "uassert.h" 38 39 #include "sharednumberformat.h" 40 #include "sharedpluralrules.h" 41 #include "standardplural.h" 42 #include "unifiedcache.h" 43 44 #define MEAS_UNIT_COUNT 138 45 #define WIDTH_INDEX_COUNT (UMEASFMT_WIDTH_NARROW + 1) 46 47 U_NAMESPACE_BEGIN 48 49 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MeasureFormat) 50 51 // Used to format durations like 5:47 or 21:35:42. 52 class NumericDateFormatters : public UMemory { 53 public: 54 // Formats like H:mm 55 SimpleDateFormat hourMinute; 56 57 // formats like M:ss 58 SimpleDateFormat minuteSecond; 59 60 // formats like H:mm:ss 61 SimpleDateFormat hourMinuteSecond; 62 63 // Constructor that takes the actual patterns for hour-minute, 64 // minute-second, and hour-minute-second respectively. 65 NumericDateFormatters( 66 const UnicodeString &hm, 67 const UnicodeString &ms, 68 const UnicodeString &hms, 69 UErrorCode &status) : 70 hourMinute(hm, status), 71 minuteSecond(ms, status), 72 hourMinuteSecond(hms, status) { 73 const TimeZone *gmt = TimeZone::getGMT(); 74 hourMinute.setTimeZone(*gmt); 75 minuteSecond.setTimeZone(*gmt); 76 hourMinuteSecond.setTimeZone(*gmt); 77 } 78 private: 79 NumericDateFormatters(const NumericDateFormatters &other); 80 NumericDateFormatters &operator=(const NumericDateFormatters &other); 81 }; 82 83 static UMeasureFormatWidth getRegularWidth(UMeasureFormatWidth width) { 84 if (width >= WIDTH_INDEX_COUNT) { 85 return UMEASFMT_WIDTH_NARROW; 86 } 87 return width; 88 } 89 90 /** 91 * Instances contain all MeasureFormat specific data for a particular locale. 92 * This data is cached. It is never copied, but is shared via shared pointers. 93 * 94 * Note: We might change the cache data to have an array[WIDTH_INDEX_COUNT] of 95 * complete sets of unit & per patterns, 96 * to correspond to the resource data and its aliases. 97 * 98 * TODO: Maybe store more sparsely in general, with pointers rather than potentially-empty objects. 99 */ 100 class MeasureFormatCacheData : public SharedObject { 101 public: 102 static const int32_t PER_UNIT_INDEX = StandardPlural::COUNT; 103 static const int32_t PATTERN_COUNT = PER_UNIT_INDEX + 1; 104 105 /** 106 * Redirection data from root-bundle, top-level sideways aliases. 107 * - UMEASFMT_WIDTH_COUNT: initial value, just fall back to root 108 * - UMEASFMT_WIDTH_WIDE/SHORT/NARROW: sideways alias for missing data 109 */ 110 UMeasureFormatWidth widthFallback[WIDTH_INDEX_COUNT]; 111 /** Measure unit -> format width -> array of patterns ("{0} meters") (plurals + PER_UNIT_INDEX) */ 112 SimpleFormatter *patterns[MEAS_UNIT_COUNT][WIDTH_INDEX_COUNT][PATTERN_COUNT]; 113 const UChar* dnams[MEAS_UNIT_COUNT][WIDTH_INDEX_COUNT]; 114 SimpleFormatter perFormatters[WIDTH_INDEX_COUNT]; 115 116 MeasureFormatCacheData(); 117 virtual ~MeasureFormatCacheData(); 118 119 UBool hasPerFormatter(int32_t width) const { 120 // TODO: Create a more obvious way to test if the per-formatter has been set? 121 // Use pointers, check for NULL? Or add an isValid() method? 122 return perFormatters[width].getArgumentLimit() == 2; 123 } 124 125 void adoptCurrencyFormat(int32_t widthIndex, NumberFormat *nfToAdopt) { 126 delete currencyFormats[widthIndex]; 127 currencyFormats[widthIndex] = nfToAdopt; 128 } 129 const NumberFormat *getCurrencyFormat(UMeasureFormatWidth width) const { 130 return currencyFormats[getRegularWidth(width)]; 131 } 132 void adoptIntegerFormat(NumberFormat *nfToAdopt) { 133 delete integerFormat; 134 integerFormat = nfToAdopt; 135 } 136 const NumberFormat *getIntegerFormat() const { 137 return integerFormat; 138 } 139 void adoptNumericDateFormatters(NumericDateFormatters *formattersToAdopt) { 140 delete numericDateFormatters; 141 numericDateFormatters = formattersToAdopt; 142 } 143 const NumericDateFormatters *getNumericDateFormatters() const { 144 return numericDateFormatters; 145 } 146 147 private: 148 NumberFormat *currencyFormats[WIDTH_INDEX_COUNT]; 149 NumberFormat *integerFormat; 150 NumericDateFormatters *numericDateFormatters; 151 MeasureFormatCacheData(const MeasureFormatCacheData &other); 152 MeasureFormatCacheData &operator=(const MeasureFormatCacheData &other); 153 }; 154 155 MeasureFormatCacheData::MeasureFormatCacheData() { 156 for (int32_t i = 0; i < WIDTH_INDEX_COUNT; ++i) { 157 widthFallback[i] = UMEASFMT_WIDTH_COUNT; 158 } 159 for (int32_t i = 0; i < UPRV_LENGTHOF(currencyFormats); ++i) { 160 currencyFormats[i] = NULL; 161 } 162 uprv_memset(patterns, 0, sizeof(patterns)); 163 uprv_memset(dnams, 0, sizeof(dnams)); 164 integerFormat = NULL; 165 numericDateFormatters = NULL; 166 } 167 168 MeasureFormatCacheData::~MeasureFormatCacheData() { 169 for (int32_t i = 0; i < UPRV_LENGTHOF(currencyFormats); ++i) { 170 delete currencyFormats[i]; 171 } 172 for (int32_t i = 0; i < MEAS_UNIT_COUNT; ++i) { 173 for (int32_t j = 0; j < WIDTH_INDEX_COUNT; ++j) { 174 for (int32_t k = 0; k < PATTERN_COUNT; ++k) { 175 delete patterns[i][j][k]; 176 } 177 } 178 } 179 // Note: the contents of 'dnams' are pointers into the resource bundle 180 delete integerFormat; 181 delete numericDateFormatters; 182 } 183 184 static UBool isCurrency(const MeasureUnit &unit) { 185 return (uprv_strcmp(unit.getType(), "currency") == 0); 186 } 187 188 static UBool getString( 189 const UResourceBundle *resource, 190 UnicodeString &result, 191 UErrorCode &status) { 192 int32_t len = 0; 193 const UChar *resStr = ures_getString(resource, &len, &status); 194 if (U_FAILURE(status)) { 195 return FALSE; 196 } 197 result.setTo(TRUE, resStr, len); 198 return TRUE; 199 } 200 201 namespace { 202 203 static const UChar g_LOCALE_units[] = { 204 0x2F, 0x4C, 0x4F, 0x43, 0x41, 0x4C, 0x45, 0x2F, 205 0x75, 0x6E, 0x69, 0x74, 0x73 206 }; 207 static const UChar gShort[] = { 0x53, 0x68, 0x6F, 0x72, 0x74 }; 208 static const UChar gNarrow[] = { 0x4E, 0x61, 0x72, 0x72, 0x6F, 0x77 }; 209 210 /** 211 * Sink for enumerating all of the measurement unit display names. 212 * Contains inner sink classes, each one corresponding to a type of resource table. 213 * The outer sink handles the top-level units, unitsNarrow, and unitsShort tables. 214 * 215 * More specific bundles (en_GB) are enumerated before their parents (en_001, en, root): 216 * Only store a value if it is still missing, that is, it has not been overridden. 217 * 218 * C++: Each inner sink class has a reference to the main outer sink. 219 * Java: Use non-static inner classes instead. 220 */ 221 struct UnitDataSink : public ResourceSink { 222 223 // Output data. 224 MeasureFormatCacheData &cacheData; 225 226 // Path to current data. 227 UMeasureFormatWidth width; 228 const char *type; 229 int32_t unitIndex; 230 231 UnitDataSink(MeasureFormatCacheData &outputData) 232 : cacheData(outputData), 233 width(UMEASFMT_WIDTH_COUNT), type(NULL), unitIndex(0) {} 234 ~UnitDataSink(); 235 236 void setFormatterIfAbsent(int32_t index, const ResourceValue &value, 237 int32_t minPlaceholders, UErrorCode &errorCode) { 238 SimpleFormatter **patterns = &cacheData.patterns[unitIndex][width][0]; 239 if (U_SUCCESS(errorCode) && patterns[index] == NULL) { 240 if (minPlaceholders >= 0) { 241 patterns[index] = new SimpleFormatter( 242 value.getUnicodeString(errorCode), minPlaceholders, 1, errorCode); 243 } 244 if (U_SUCCESS(errorCode) && patterns[index] == NULL) { 245 errorCode = U_MEMORY_ALLOCATION_ERROR; 246 } 247 } 248 } 249 250 void setDnamIfAbsent(const ResourceValue &value, UErrorCode& errorCode) { 251 if (cacheData.dnams[unitIndex][width] == NULL) { 252 int32_t length; 253 cacheData.dnams[unitIndex][width] = value.getString(length, errorCode); 254 } 255 } 256 257 /** 258 * Consume a display pattern. For example, 259 * unitsShort/duration/hour contains other{"{0} hrs"}. 260 */ 261 void consumePattern(const char *key, const ResourceValue &value, UErrorCode &errorCode) { 262 if (U_FAILURE(errorCode)) { return; } 263 if (uprv_strcmp(key, "dnam") == 0) { 264 // The display name for the unit in the current width. 265 setDnamIfAbsent(value, errorCode); 266 } else if (uprv_strcmp(key, "per") == 0) { 267 // For example, "{0}/h". 268 setFormatterIfAbsent(MeasureFormatCacheData::PER_UNIT_INDEX, value, 1, errorCode); 269 } else { 270 // The key must be one of the plural form strings. For example: 271 // one{"{0} hr"} 272 // other{"{0} hrs"} 273 setFormatterIfAbsent(StandardPlural::indexFromString(key, errorCode), value, 0, 274 errorCode); 275 } 276 } 277 278 /** 279 * Consume a table of per-unit tables. For example, 280 * unitsShort/duration contains tables for duration-unit subtypes day & hour. 281 */ 282 void consumeSubtypeTable(const char *key, ResourceValue &value, UErrorCode &errorCode) { 283 if (U_FAILURE(errorCode)) { return; } 284 unitIndex = MeasureUnit::internalGetIndexForTypeAndSubtype(type, key); 285 if (unitIndex < 0) { 286 // TODO: How to handle unexpected data? 287 // See http://bugs.icu-project.org/trac/ticket/12597 288 return; 289 } 290 291 if (value.getType() == URES_STRING) { 292 // Units like "coordinate" that don't have plural variants 293 setFormatterIfAbsent(StandardPlural::OTHER, value, 0, errorCode); 294 } else if (value.getType() == URES_TABLE) { 295 // Units that have plural variants 296 ResourceTable patternTableTable = value.getTable(errorCode); 297 if (U_FAILURE(errorCode)) { return; } 298 for (int i = 0; patternTableTable.getKeyAndValue(i, key, value); ++i) { 299 consumePattern(key, value, errorCode); 300 } 301 } else { 302 // TODO: How to handle unexpected data? 303 // See http://bugs.icu-project.org/trac/ticket/12597 304 return; 305 } 306 } 307 308 /** 309 * Consume compound x-per-y display pattern. For example, 310 * unitsShort/compound/per may be "{0}/{1}". 311 */ 312 void consumeCompoundPattern(const char *key, const ResourceValue &value, UErrorCode &errorCode) { 313 if (U_SUCCESS(errorCode) && uprv_strcmp(key, "per") == 0) { 314 cacheData.perFormatters[width]. 315 applyPatternMinMaxArguments(value.getUnicodeString(errorCode), 2, 2, errorCode); 316 } 317 } 318 319 /** 320 * Consume a table of unit type tables. For example, 321 * unitsShort contains tables for area & duration. 322 * It also contains a table for the compound/per pattern. 323 */ 324 void consumeUnitTypesTable(const char *key, ResourceValue &value, UErrorCode &errorCode) { 325 if (U_FAILURE(errorCode)) { return; } 326 if (uprv_strcmp(key, "currency") == 0) { 327 // Skip. 328 } else if (uprv_strcmp(key, "compound") == 0) { 329 if (!cacheData.hasPerFormatter(width)) { 330 ResourceTable compoundTable = value.getTable(errorCode); 331 if (U_FAILURE(errorCode)) { return; } 332 for (int i = 0; compoundTable.getKeyAndValue(i, key, value); ++i) { 333 consumeCompoundPattern(key, value, errorCode); 334 } 335 } 336 } else { 337 type = key; 338 ResourceTable subtypeTable = value.getTable(errorCode); 339 if (U_FAILURE(errorCode)) { return; } 340 for (int i = 0; subtypeTable.getKeyAndValue(i, key, value); ++i) { 341 consumeSubtypeTable(key, value, errorCode); 342 } 343 } 344 } 345 346 void consumeAlias(const char *key, const ResourceValue &value, UErrorCode &errorCode) { 347 // Handle aliases like 348 // units:alias{"/LOCALE/unitsShort"} 349 // which should only occur in the root bundle. 350 UMeasureFormatWidth sourceWidth = widthFromKey(key); 351 if (sourceWidth == UMEASFMT_WIDTH_COUNT) { 352 // Alias from something we don't care about. 353 return; 354 } 355 UMeasureFormatWidth targetWidth = widthFromAlias(value, errorCode); 356 if (targetWidth == UMEASFMT_WIDTH_COUNT) { 357 // We do not recognize what to fall back to. 358 errorCode = U_INVALID_FORMAT_ERROR; 359 return; 360 } 361 // Check that we do not fall back to another fallback. 362 if (cacheData.widthFallback[targetWidth] != UMEASFMT_WIDTH_COUNT) { 363 errorCode = U_INVALID_FORMAT_ERROR; 364 return; 365 } 366 cacheData.widthFallback[sourceWidth] = targetWidth; 367 } 368 369 void consumeTable(const char *key, ResourceValue &value, UErrorCode &errorCode) { 370 if (U_SUCCESS(errorCode) && (width = widthFromKey(key)) != UMEASFMT_WIDTH_COUNT) { 371 ResourceTable unitTypesTable = value.getTable(errorCode); 372 if (U_FAILURE(errorCode)) { return; } 373 for (int i = 0; unitTypesTable.getKeyAndValue(i, key, value); ++i) { 374 consumeUnitTypesTable(key, value, errorCode); 375 } 376 } 377 } 378 379 static UMeasureFormatWidth widthFromKey(const char *key) { 380 if (uprv_strncmp(key, "units", 5) == 0) { 381 key += 5; 382 if (*key == 0) { 383 return UMEASFMT_WIDTH_WIDE; 384 } else if (uprv_strcmp(key, "Short") == 0) { 385 return UMEASFMT_WIDTH_SHORT; 386 } else if (uprv_strcmp(key, "Narrow") == 0) { 387 return UMEASFMT_WIDTH_NARROW; 388 } 389 } 390 return UMEASFMT_WIDTH_COUNT; 391 } 392 393 static UMeasureFormatWidth widthFromAlias(const ResourceValue &value, UErrorCode &errorCode) { 394 int32_t length; 395 const UChar *s = value.getAliasString(length, errorCode); 396 // For example: "/LOCALE/unitsShort" 397 if (U_SUCCESS(errorCode) && length >= 13 && u_memcmp(s, g_LOCALE_units, 13) == 0) { 398 s += 13; 399 length -= 13; 400 if (*s == 0) { 401 return UMEASFMT_WIDTH_WIDE; 402 } else if (u_strCompare(s, length, gShort, 5, FALSE) == 0) { 403 return UMEASFMT_WIDTH_SHORT; 404 } else if (u_strCompare(s, length, gNarrow, 6, FALSE) == 0) { 405 return UMEASFMT_WIDTH_NARROW; 406 } 407 } 408 return UMEASFMT_WIDTH_COUNT; 409 } 410 411 virtual void put(const char *key, ResourceValue &value, UBool /*noFallback*/, 412 UErrorCode &errorCode) { 413 // Main entry point to sink 414 ResourceTable widthsTable = value.getTable(errorCode); 415 if (U_FAILURE(errorCode)) { return; } 416 for (int i = 0; widthsTable.getKeyAndValue(i, key, value); ++i) { 417 if (value.getType() == URES_ALIAS) { 418 consumeAlias(key, value, errorCode); 419 } else { 420 consumeTable(key, value, errorCode); 421 } 422 } 423 } 424 }; 425 426 // Virtual destructors must be defined out of line. 427 UnitDataSink::~UnitDataSink() {} 428 429 } // namespace 430 431 static UBool loadMeasureUnitData( 432 const UResourceBundle *resource, 433 MeasureFormatCacheData &cacheData, 434 UErrorCode &status) { 435 UnitDataSink sink(cacheData); 436 ures_getAllItemsWithFallback(resource, "", sink, status); 437 return U_SUCCESS(status); 438 } 439 440 static UnicodeString loadNumericDateFormatterPattern( 441 const UResourceBundle *resource, 442 const char *pattern, 443 UErrorCode &status) { 444 UnicodeString result; 445 if (U_FAILURE(status)) { 446 return result; 447 } 448 CharString chs; 449 chs.append("durationUnits", status) 450 .append("/", status).append(pattern, status); 451 LocalUResourceBundlePointer patternBundle( 452 ures_getByKeyWithFallback( 453 resource, 454 chs.data(), 455 NULL, 456 &status)); 457 if (U_FAILURE(status)) { 458 return result; 459 } 460 getString(patternBundle.getAlias(), result, status); 461 // Replace 'h' with 'H' 462 int32_t len = result.length(); 463 UChar *buffer = result.getBuffer(len); 464 for (int32_t i = 0; i < len; ++i) { 465 if (buffer[i] == 0x68) { // 'h' 466 buffer[i] = 0x48; // 'H' 467 } 468 } 469 result.releaseBuffer(len); 470 return result; 471 } 472 473 static NumericDateFormatters *loadNumericDateFormatters( 474 const UResourceBundle *resource, 475 UErrorCode &status) { 476 if (U_FAILURE(status)) { 477 return NULL; 478 } 479 NumericDateFormatters *result = new NumericDateFormatters( 480 loadNumericDateFormatterPattern(resource, "hm", status), 481 loadNumericDateFormatterPattern(resource, "ms", status), 482 loadNumericDateFormatterPattern(resource, "hms", status), 483 status); 484 if (U_FAILURE(status)) { 485 delete result; 486 return NULL; 487 } 488 return result; 489 } 490 491 template<> U_I18N_API 492 const MeasureFormatCacheData *LocaleCacheKey<MeasureFormatCacheData>::createObject( 493 const void * /*unused*/, UErrorCode &status) const { 494 const char *localeId = fLoc.getName(); 495 LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, localeId, &status)); 496 static UNumberFormatStyle currencyStyles[] = { 497 UNUM_CURRENCY_PLURAL, UNUM_CURRENCY_ISO, UNUM_CURRENCY}; 498 LocalPointer<MeasureFormatCacheData> result(new MeasureFormatCacheData(), status); 499 if (U_FAILURE(status)) { 500 return NULL; 501 } 502 if (!loadMeasureUnitData( 503 unitsBundle.getAlias(), 504 *result, 505 status)) { 506 return NULL; 507 } 508 result->adoptNumericDateFormatters(loadNumericDateFormatters( 509 unitsBundle.getAlias(), status)); 510 if (U_FAILURE(status)) { 511 return NULL; 512 } 513 514 for (int32_t i = 0; i < WIDTH_INDEX_COUNT; ++i) { 515 // NumberFormat::createInstance can erase warning codes from status, so pass it 516 // a separate status instance 517 UErrorCode localStatus = U_ZERO_ERROR; 518 result->adoptCurrencyFormat(i, NumberFormat::createInstance( 519 localeId, currencyStyles[i], localStatus)); 520 if (localStatus != U_ZERO_ERROR) { 521 status = localStatus; 522 } 523 if (U_FAILURE(status)) { 524 return NULL; 525 } 526 } 527 NumberFormat *inf = NumberFormat::createInstance( 528 localeId, UNUM_DECIMAL, status); 529 if (U_FAILURE(status)) { 530 return NULL; 531 } 532 inf->setMaximumFractionDigits(0); 533 DecimalFormat *decfmt = dynamic_cast<DecimalFormat *>(inf); 534 if (decfmt != NULL) { 535 decfmt->setRoundingMode(DecimalFormat::kRoundDown); 536 } 537 result->adoptIntegerFormat(inf); 538 result->addRef(); 539 return result.orphan(); 540 } 541 542 static UBool isTimeUnit(const MeasureUnit &mu, const char *tu) { 543 return uprv_strcmp(mu.getType(), "duration") == 0 && 544 uprv_strcmp(mu.getSubtype(), tu) == 0; 545 } 546 547 // Converts a composite measure into hours-minutes-seconds and stores at hms 548 // array. [0] is hours; [1] is minutes; [2] is seconds. Returns a bit map of 549 // units found: 1=hours, 2=minutes, 4=seconds. For example, if measures 550 // contains hours-minutes, this function would return 3. 551 // 552 // If measures cannot be converted into hours, minutes, seconds or if amounts 553 // are negative, or if hours, minutes, seconds are out of order, returns 0. 554 static int32_t toHMS( 555 const Measure *measures, 556 int32_t measureCount, 557 Formattable *hms, 558 UErrorCode &status) { 559 if (U_FAILURE(status)) { 560 return 0; 561 } 562 int32_t result = 0; 563 if (U_FAILURE(status)) { 564 return 0; 565 } 566 // We use copy constructor to ensure that both sides of equality operator 567 // are instances of MeasureUnit base class and not a subclass. Otherwise, 568 // operator== will immediately return false. 569 for (int32_t i = 0; i < measureCount; ++i) { 570 if (isTimeUnit(measures[i].getUnit(), "hour")) { 571 // hour must come first 572 if (result >= 1) { 573 return 0; 574 } 575 hms[0] = measures[i].getNumber(); 576 if (hms[0].getDouble() < 0.0) { 577 return 0; 578 } 579 result |= 1; 580 } else if (isTimeUnit(measures[i].getUnit(), "minute")) { 581 // minute must come after hour 582 if (result >= 2) { 583 return 0; 584 } 585 hms[1] = measures[i].getNumber(); 586 if (hms[1].getDouble() < 0.0) { 587 return 0; 588 } 589 result |= 2; 590 } else if (isTimeUnit(measures[i].getUnit(), "second")) { 591 // second must come after hour and minute 592 if (result >= 4) { 593 return 0; 594 } 595 hms[2] = measures[i].getNumber(); 596 if (hms[2].getDouble() < 0.0) { 597 return 0; 598 } 599 result |= 4; 600 } else { 601 return 0; 602 } 603 } 604 return result; 605 } 606 607 608 MeasureFormat::MeasureFormat( 609 const Locale &locale, UMeasureFormatWidth w, UErrorCode &status) 610 : cache(NULL), 611 numberFormat(NULL), 612 pluralRules(NULL), 613 width(w), 614 listFormatter(NULL) { 615 initMeasureFormat(locale, w, NULL, status); 616 } 617 618 MeasureFormat::MeasureFormat( 619 const Locale &locale, 620 UMeasureFormatWidth w, 621 NumberFormat *nfToAdopt, 622 UErrorCode &status) 623 : cache(NULL), 624 numberFormat(NULL), 625 pluralRules(NULL), 626 width(w), 627 listFormatter(NULL) { 628 initMeasureFormat(locale, w, nfToAdopt, status); 629 } 630 631 MeasureFormat::MeasureFormat(const MeasureFormat &other) : 632 Format(other), 633 cache(other.cache), 634 numberFormat(other.numberFormat), 635 pluralRules(other.pluralRules), 636 width(other.width), 637 listFormatter(NULL) { 638 cache->addRef(); 639 numberFormat->addRef(); 640 pluralRules->addRef(); 641 if (other.listFormatter != NULL) { 642 listFormatter = new ListFormatter(*other.listFormatter); 643 } 644 } 645 646 MeasureFormat &MeasureFormat::operator=(const MeasureFormat &other) { 647 if (this == &other) { 648 return *this; 649 } 650 Format::operator=(other); 651 SharedObject::copyPtr(other.cache, cache); 652 SharedObject::copyPtr(other.numberFormat, numberFormat); 653 SharedObject::copyPtr(other.pluralRules, pluralRules); 654 width = other.width; 655 delete listFormatter; 656 if (other.listFormatter != NULL) { 657 listFormatter = new ListFormatter(*other.listFormatter); 658 } else { 659 listFormatter = NULL; 660 } 661 return *this; 662 } 663 664 MeasureFormat::MeasureFormat() : 665 cache(NULL), 666 numberFormat(NULL), 667 pluralRules(NULL), 668 width(UMEASFMT_WIDTH_SHORT), 669 listFormatter(NULL) { 670 } 671 672 MeasureFormat::~MeasureFormat() { 673 if (cache != NULL) { 674 cache->removeRef(); 675 } 676 if (numberFormat != NULL) { 677 numberFormat->removeRef(); 678 } 679 if (pluralRules != NULL) { 680 pluralRules->removeRef(); 681 } 682 delete listFormatter; 683 } 684 685 UBool MeasureFormat::operator==(const Format &other) const { 686 if (this == &other) { // Same object, equal 687 return TRUE; 688 } 689 if (!Format::operator==(other)) { 690 return FALSE; 691 } 692 const MeasureFormat &rhs = static_cast<const MeasureFormat &>(other); 693 694 // Note: Since the ListFormatter depends only on Locale and width, we 695 // don't have to check it here. 696 697 // differing widths aren't equivalent 698 if (width != rhs.width) { 699 return FALSE; 700 } 701 // Width the same check locales. 702 // We don't need to check locales if both objects have same cache. 703 if (cache != rhs.cache) { 704 UErrorCode status = U_ZERO_ERROR; 705 const char *localeId = getLocaleID(status); 706 const char *rhsLocaleId = rhs.getLocaleID(status); 707 if (U_FAILURE(status)) { 708 // On failure, assume not equal 709 return FALSE; 710 } 711 if (uprv_strcmp(localeId, rhsLocaleId) != 0) { 712 return FALSE; 713 } 714 } 715 // Locales same, check NumberFormat if shared data differs. 716 return ( 717 numberFormat == rhs.numberFormat || 718 **numberFormat == **rhs.numberFormat); 719 } 720 721 Format *MeasureFormat::clone() const { 722 return new MeasureFormat(*this); 723 } 724 725 UnicodeString &MeasureFormat::format( 726 const Formattable &obj, 727 UnicodeString &appendTo, 728 FieldPosition &pos, 729 UErrorCode &status) const { 730 if (U_FAILURE(status)) return appendTo; 731 if (obj.getType() == Formattable::kObject) { 732 const UObject* formatObj = obj.getObject(); 733 const Measure* amount = dynamic_cast<const Measure*>(formatObj); 734 if (amount != NULL) { 735 return formatMeasure( 736 *amount, **numberFormat, appendTo, pos, status); 737 } 738 } 739 status = U_ILLEGAL_ARGUMENT_ERROR; 740 return appendTo; 741 } 742 743 void MeasureFormat::parseObject( 744 const UnicodeString & /*source*/, 745 Formattable & /*result*/, 746 ParsePosition& /*pos*/) const { 747 return; 748 } 749 750 UnicodeString &MeasureFormat::formatMeasurePerUnit( 751 const Measure &measure, 752 const MeasureUnit &perUnit, 753 UnicodeString &appendTo, 754 FieldPosition &pos, 755 UErrorCode &status) const { 756 if (U_FAILURE(status)) { 757 return appendTo; 758 } 759 MeasureUnit *resolvedUnit = 760 MeasureUnit::resolveUnitPerUnit(measure.getUnit(), perUnit); 761 if (resolvedUnit != NULL) { 762 Measure newMeasure(measure.getNumber(), resolvedUnit, status); 763 return formatMeasure( 764 newMeasure, **numberFormat, appendTo, pos, status); 765 } 766 FieldPosition fpos(pos.getField()); 767 UnicodeString result; 768 int32_t offset = withPerUnitAndAppend( 769 formatMeasure( 770 measure, **numberFormat, result, fpos, status), 771 perUnit, 772 appendTo, 773 status); 774 if (U_FAILURE(status)) { 775 return appendTo; 776 } 777 if (fpos.getBeginIndex() != 0 || fpos.getEndIndex() != 0) { 778 pos.setBeginIndex(fpos.getBeginIndex() + offset); 779 pos.setEndIndex(fpos.getEndIndex() + offset); 780 } 781 return appendTo; 782 } 783 784 UnicodeString &MeasureFormat::formatMeasures( 785 const Measure *measures, 786 int32_t measureCount, 787 UnicodeString &appendTo, 788 FieldPosition &pos, 789 UErrorCode &status) const { 790 if (U_FAILURE(status)) { 791 return appendTo; 792 } 793 if (measureCount == 0) { 794 return appendTo; 795 } 796 if (measureCount == 1) { 797 return formatMeasure(measures[0], **numberFormat, appendTo, pos, status); 798 } 799 if (width == UMEASFMT_WIDTH_NUMERIC) { 800 Formattable hms[3]; 801 int32_t bitMap = toHMS(measures, measureCount, hms, status); 802 if (bitMap > 0) { 803 return formatNumeric(hms, bitMap, appendTo, status); 804 } 805 } 806 if (pos.getField() != FieldPosition::DONT_CARE) { 807 return formatMeasuresSlowTrack( 808 measures, measureCount, appendTo, pos, status); 809 } 810 UnicodeString *results = new UnicodeString[measureCount]; 811 if (results == NULL) { 812 status = U_MEMORY_ALLOCATION_ERROR; 813 return appendTo; 814 } 815 for (int32_t i = 0; i < measureCount; ++i) { 816 const NumberFormat *nf = cache->getIntegerFormat(); 817 if (i == measureCount - 1) { 818 nf = numberFormat->get(); 819 } 820 formatMeasure( 821 measures[i], 822 *nf, 823 results[i], 824 pos, 825 status); 826 } 827 listFormatter->format(results, measureCount, appendTo, status); 828 delete [] results; 829 return appendTo; 830 } 831 832 UnicodeString MeasureFormat::getUnitDisplayName(const MeasureUnit& unit, UErrorCode& /*status*/) const { 833 UMeasureFormatWidth width = getRegularWidth(this->width); 834 const UChar* const* styleToDnam = cache->dnams[unit.getIndex()]; 835 const UChar* dnam = styleToDnam[width]; 836 if (dnam == NULL) { 837 int32_t fallbackWidth = cache->widthFallback[width]; 838 dnam = styleToDnam[fallbackWidth]; 839 } 840 841 UnicodeString result; 842 if (dnam == NULL) { 843 result.setToBogus(); 844 } else { 845 result.setTo(dnam, -1); 846 } 847 return result; 848 } 849 850 void MeasureFormat::initMeasureFormat( 851 const Locale &locale, 852 UMeasureFormatWidth w, 853 NumberFormat *nfToAdopt, 854 UErrorCode &status) { 855 static const char *listStyles[] = {"unit", "unit-short", "unit-narrow"}; 856 LocalPointer<NumberFormat> nf(nfToAdopt); 857 if (U_FAILURE(status)) { 858 return; 859 } 860 const char *name = locale.getName(); 861 setLocaleIDs(name, name); 862 863 UnifiedCache::getByLocale(locale, cache, status); 864 if (U_FAILURE(status)) { 865 return; 866 } 867 868 const SharedPluralRules *pr = PluralRules::createSharedInstance( 869 locale, UPLURAL_TYPE_CARDINAL, status); 870 if (U_FAILURE(status)) { 871 return; 872 } 873 SharedObject::copyPtr(pr, pluralRules); 874 pr->removeRef(); 875 if (nf.isNull()) { 876 const SharedNumberFormat *shared = NumberFormat::createSharedInstance( 877 locale, UNUM_DECIMAL, status); 878 if (U_FAILURE(status)) { 879 return; 880 } 881 SharedObject::copyPtr(shared, numberFormat); 882 shared->removeRef(); 883 } else { 884 adoptNumberFormat(nf.orphan(), status); 885 if (U_FAILURE(status)) { 886 return; 887 } 888 } 889 width = w; 890 delete listFormatter; 891 listFormatter = ListFormatter::createInstance( 892 locale, 893 listStyles[getRegularWidth(width)], 894 status); 895 } 896 897 void MeasureFormat::adoptNumberFormat( 898 NumberFormat *nfToAdopt, UErrorCode &status) { 899 LocalPointer<NumberFormat> nf(nfToAdopt); 900 if (U_FAILURE(status)) { 901 return; 902 } 903 SharedNumberFormat *shared = new SharedNumberFormat(nf.getAlias()); 904 if (shared == NULL) { 905 status = U_MEMORY_ALLOCATION_ERROR; 906 return; 907 } 908 nf.orphan(); 909 SharedObject::copyPtr(shared, numberFormat); 910 } 911 912 UBool MeasureFormat::setMeasureFormatLocale(const Locale &locale, UErrorCode &status) { 913 if (U_FAILURE(status) || locale == getLocale(status)) { 914 return FALSE; 915 } 916 initMeasureFormat(locale, width, NULL, status); 917 return U_SUCCESS(status); 918 } 919 920 const NumberFormat &MeasureFormat::getNumberFormat() const { 921 return **numberFormat; 922 } 923 924 const PluralRules &MeasureFormat::getPluralRules() const { 925 return **pluralRules; 926 } 927 928 Locale MeasureFormat::getLocale(UErrorCode &status) const { 929 return Format::getLocale(ULOC_VALID_LOCALE, status); 930 } 931 932 const char *MeasureFormat::getLocaleID(UErrorCode &status) const { 933 return Format::getLocaleID(ULOC_VALID_LOCALE, status); 934 } 935 936 UnicodeString &MeasureFormat::formatMeasure( 937 const Measure &measure, 938 const NumberFormat &nf, 939 UnicodeString &appendTo, 940 FieldPosition &pos, 941 UErrorCode &status) const { 942 if (U_FAILURE(status)) { 943 return appendTo; 944 } 945 const Formattable& amtNumber = measure.getNumber(); 946 const MeasureUnit& amtUnit = measure.getUnit(); 947 if (isCurrency(amtUnit)) { 948 UChar isoCode[4]; 949 u_charsToUChars(amtUnit.getSubtype(), isoCode, 4); 950 return cache->getCurrencyFormat(width)->format( 951 new CurrencyAmount(amtNumber, isoCode, status), 952 appendTo, 953 pos, 954 status); 955 } 956 UnicodeString formattedNumber; 957 StandardPlural::Form pluralForm = QuantityFormatter::selectPlural( 958 amtNumber, nf, **pluralRules, formattedNumber, pos, status); 959 const SimpleFormatter *formatter = getPluralFormatter(amtUnit, width, pluralForm, status); 960 return QuantityFormatter::format(*formatter, formattedNumber, appendTo, pos, status); 961 } 962 963 // Formats hours-minutes-seconds as 5:37:23 or similar. 964 UnicodeString &MeasureFormat::formatNumeric( 965 const Formattable *hms, // always length 3 966 int32_t bitMap, // 1=hourset, 2=minuteset, 4=secondset 967 UnicodeString &appendTo, 968 UErrorCode &status) const { 969 if (U_FAILURE(status)) { 970 return appendTo; 971 } 972 UDate millis = 973 (UDate) (((uprv_trunc(hms[0].getDouble(status)) * 60.0 974 + uprv_trunc(hms[1].getDouble(status))) * 60.0 975 + uprv_trunc(hms[2].getDouble(status))) * 1000.0); 976 switch (bitMap) { 977 case 5: // hs 978 case 7: // hms 979 return formatNumeric( 980 millis, 981 cache->getNumericDateFormatters()->hourMinuteSecond, 982 UDAT_SECOND_FIELD, 983 hms[2], 984 appendTo, 985 status); 986 break; 987 case 6: // ms 988 return formatNumeric( 989 millis, 990 cache->getNumericDateFormatters()->minuteSecond, 991 UDAT_SECOND_FIELD, 992 hms[2], 993 appendTo, 994 status); 995 break; 996 case 3: // hm 997 return formatNumeric( 998 millis, 999 cache->getNumericDateFormatters()->hourMinute, 1000 UDAT_MINUTE_FIELD, 1001 hms[1], 1002 appendTo, 1003 status); 1004 break; 1005 default: 1006 status = U_INTERNAL_PROGRAM_ERROR; 1007 return appendTo; 1008 break; 1009 } 1010 return appendTo; 1011 } 1012 1013 static void appendRange( 1014 const UnicodeString &src, 1015 int32_t start, 1016 int32_t end, 1017 UnicodeString &dest) { 1018 dest.append(src, start, end - start); 1019 } 1020 1021 static void appendRange( 1022 const UnicodeString &src, 1023 int32_t end, 1024 UnicodeString &dest) { 1025 dest.append(src, end, src.length() - end); 1026 } 1027 1028 // Formats time like 5:37:23 1029 UnicodeString &MeasureFormat::formatNumeric( 1030 UDate date, // Time since epoch 1:30:00 would be 5400000 1031 const DateFormat &dateFmt, // h:mm, m:ss, or h:mm:ss 1032 UDateFormatField smallestField, // seconds in 5:37:23.5 1033 const Formattable &smallestAmount, // 23.5 for 5:37:23.5 1034 UnicodeString &appendTo, 1035 UErrorCode &status) const { 1036 if (U_FAILURE(status)) { 1037 return appendTo; 1038 } 1039 // Format the smallest amount with this object's NumberFormat 1040 UnicodeString smallestAmountFormatted; 1041 1042 // We keep track of the integer part of smallest amount so that 1043 // we can replace it later so that we get '0:00:09.3' instead of 1044 // '0:00:9.3' 1045 FieldPosition intFieldPosition(UNUM_INTEGER_FIELD); 1046 (*numberFormat)->format( 1047 smallestAmount, smallestAmountFormatted, intFieldPosition, status); 1048 if ( 1049 intFieldPosition.getBeginIndex() == 0 && 1050 intFieldPosition.getEndIndex() == 0) { 1051 status = U_INTERNAL_PROGRAM_ERROR; 1052 return appendTo; 1053 } 1054 1055 // Format time. draft becomes something like '5:30:45' 1056 FieldPosition smallestFieldPosition(smallestField); 1057 UnicodeString draft; 1058 dateFmt.format(date, draft, smallestFieldPosition, status); 1059 1060 // If we find field for smallest amount replace it with the formatted 1061 // smallest amount from above taking care to replace the integer part 1062 // with what is in original time. For example, If smallest amount 1063 // is 9.35s and the formatted time is 0:00:09 then 9.35 becomes 09.35 1064 // and replacing yields 0:00:09.35 1065 if (smallestFieldPosition.getBeginIndex() != 0 || 1066 smallestFieldPosition.getEndIndex() != 0) { 1067 appendRange(draft, 0, smallestFieldPosition.getBeginIndex(), appendTo); 1068 appendRange( 1069 smallestAmountFormatted, 1070 0, 1071 intFieldPosition.getBeginIndex(), 1072 appendTo); 1073 appendRange( 1074 draft, 1075 smallestFieldPosition.getBeginIndex(), 1076 smallestFieldPosition.getEndIndex(), 1077 appendTo); 1078 appendRange( 1079 smallestAmountFormatted, 1080 intFieldPosition.getEndIndex(), 1081 appendTo); 1082 appendRange( 1083 draft, 1084 smallestFieldPosition.getEndIndex(), 1085 appendTo); 1086 } else { 1087 appendTo.append(draft); 1088 } 1089 return appendTo; 1090 } 1091 1092 const SimpleFormatter *MeasureFormat::getFormatterOrNull( 1093 const MeasureUnit &unit, UMeasureFormatWidth width, int32_t index) const { 1094 width = getRegularWidth(width); 1095 SimpleFormatter *const (*unitPatterns)[MeasureFormatCacheData::PATTERN_COUNT] = 1096 &cache->patterns[unit.getIndex()][0]; 1097 if (unitPatterns[width][index] != NULL) { 1098 return unitPatterns[width][index]; 1099 } 1100 int32_t fallbackWidth = cache->widthFallback[width]; 1101 if (fallbackWidth != UMEASFMT_WIDTH_COUNT && unitPatterns[fallbackWidth][index] != NULL) { 1102 return unitPatterns[fallbackWidth][index]; 1103 } 1104 return NULL; 1105 } 1106 1107 const SimpleFormatter *MeasureFormat::getFormatter( 1108 const MeasureUnit &unit, UMeasureFormatWidth width, int32_t index, 1109 UErrorCode &errorCode) const { 1110 if (U_FAILURE(errorCode)) { 1111 return NULL; 1112 } 1113 const SimpleFormatter *pattern = getFormatterOrNull(unit, width, index); 1114 if (pattern == NULL) { 1115 errorCode = U_MISSING_RESOURCE_ERROR; 1116 } 1117 return pattern; 1118 } 1119 1120 const SimpleFormatter *MeasureFormat::getPluralFormatter( 1121 const MeasureUnit &unit, UMeasureFormatWidth width, int32_t index, 1122 UErrorCode &errorCode) const { 1123 if (U_FAILURE(errorCode)) { 1124 return NULL; 1125 } 1126 if (index != StandardPlural::OTHER) { 1127 const SimpleFormatter *pattern = getFormatterOrNull(unit, width, index); 1128 if (pattern != NULL) { 1129 return pattern; 1130 } 1131 } 1132 return getFormatter(unit, width, StandardPlural::OTHER, errorCode); 1133 } 1134 1135 const SimpleFormatter *MeasureFormat::getPerFormatter( 1136 UMeasureFormatWidth width, 1137 UErrorCode &status) const { 1138 if (U_FAILURE(status)) { 1139 return NULL; 1140 } 1141 width = getRegularWidth(width); 1142 const SimpleFormatter * perFormatters = cache->perFormatters; 1143 if (perFormatters[width].getArgumentLimit() == 2) { 1144 return &perFormatters[width]; 1145 } 1146 int32_t fallbackWidth = cache->widthFallback[width]; 1147 if (fallbackWidth != UMEASFMT_WIDTH_COUNT && 1148 perFormatters[fallbackWidth].getArgumentLimit() == 2) { 1149 return &perFormatters[fallbackWidth]; 1150 } 1151 status = U_MISSING_RESOURCE_ERROR; 1152 return NULL; 1153 } 1154 1155 int32_t MeasureFormat::withPerUnitAndAppend( 1156 const UnicodeString &formatted, 1157 const MeasureUnit &perUnit, 1158 UnicodeString &appendTo, 1159 UErrorCode &status) const { 1160 int32_t offset = -1; 1161 if (U_FAILURE(status)) { 1162 return offset; 1163 } 1164 const SimpleFormatter *perUnitFormatter = 1165 getFormatterOrNull(perUnit, width, MeasureFormatCacheData::PER_UNIT_INDEX); 1166 if (perUnitFormatter != NULL) { 1167 const UnicodeString *params[] = {&formatted}; 1168 perUnitFormatter->formatAndAppend( 1169 params, 1170 UPRV_LENGTHOF(params), 1171 appendTo, 1172 &offset, 1173 1, 1174 status); 1175 return offset; 1176 } 1177 const SimpleFormatter *perFormatter = getPerFormatter(width, status); 1178 const SimpleFormatter *pattern = 1179 getPluralFormatter(perUnit, width, StandardPlural::ONE, status); 1180 if (U_FAILURE(status)) { 1181 return offset; 1182 } 1183 UnicodeString perUnitString = pattern->getTextWithNoArguments(); 1184 perUnitString.trim(); 1185 const UnicodeString *params[] = {&formatted, &perUnitString}; 1186 perFormatter->formatAndAppend( 1187 params, 1188 UPRV_LENGTHOF(params), 1189 appendTo, 1190 &offset, 1191 1, 1192 status); 1193 return offset; 1194 } 1195 1196 UnicodeString &MeasureFormat::formatMeasuresSlowTrack( 1197 const Measure *measures, 1198 int32_t measureCount, 1199 UnicodeString& appendTo, 1200 FieldPosition& pos, 1201 UErrorCode& status) const { 1202 if (U_FAILURE(status)) { 1203 return appendTo; 1204 } 1205 FieldPosition dontCare(FieldPosition::DONT_CARE); 1206 FieldPosition fpos(pos.getField()); 1207 UnicodeString *results = new UnicodeString[measureCount]; 1208 int32_t fieldPositionFoundIndex = -1; 1209 for (int32_t i = 0; i < measureCount; ++i) { 1210 const NumberFormat *nf = cache->getIntegerFormat(); 1211 if (i == measureCount - 1) { 1212 nf = numberFormat->get(); 1213 } 1214 if (fieldPositionFoundIndex == -1) { 1215 formatMeasure(measures[i], *nf, results[i], fpos, status); 1216 if (U_FAILURE(status)) { 1217 delete [] results; 1218 return appendTo; 1219 } 1220 if (fpos.getBeginIndex() != 0 || fpos.getEndIndex() != 0) { 1221 fieldPositionFoundIndex = i; 1222 } 1223 } else { 1224 formatMeasure(measures[i], *nf, results[i], dontCare, status); 1225 } 1226 } 1227 int32_t offset; 1228 listFormatter->format( 1229 results, 1230 measureCount, 1231 appendTo, 1232 fieldPositionFoundIndex, 1233 offset, 1234 status); 1235 if (U_FAILURE(status)) { 1236 delete [] results; 1237 return appendTo; 1238 } 1239 if (offset != -1) { 1240 pos.setBeginIndex(fpos.getBeginIndex() + offset); 1241 pos.setEndIndex(fpos.getEndIndex() + offset); 1242 } 1243 delete [] results; 1244 return appendTo; 1245 } 1246 1247 MeasureFormat* U_EXPORT2 MeasureFormat::createCurrencyFormat(const Locale& locale, 1248 UErrorCode& ec) { 1249 CurrencyFormat* fmt = NULL; 1250 if (U_SUCCESS(ec)) { 1251 fmt = new CurrencyFormat(locale, ec); 1252 if (U_FAILURE(ec)) { 1253 delete fmt; 1254 fmt = NULL; 1255 } 1256 } 1257 return fmt; 1258 } 1259 1260 MeasureFormat* U_EXPORT2 MeasureFormat::createCurrencyFormat(UErrorCode& ec) { 1261 if (U_FAILURE(ec)) { 1262 return NULL; 1263 } 1264 return MeasureFormat::createCurrencyFormat(Locale::getDefault(), ec); 1265 } 1266 1267 U_NAMESPACE_END 1268 1269 #endif /* #if !UCONFIG_NO_FORMATTING */ 1270
