icuSources/i18n/tmutfmt.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4  *******************************************************************************
   5  * Copyright (C) 2008-2015, Google, International Business Machines Corporation
   6  * and others. All Rights Reserved.
   7  *******************************************************************************
   8  */
   9
  10 #include "unicode/tmutfmt.h"
  11
  12 #if !UCONFIG_NO_FORMATTING
  13
  14 #include "unicode/decimfmt.h"
  15 #include "unicode/localpointer.h"
  16 #include "plurrule_impl.h"
  17 #include "uvector.h"
  18 #include "charstr.h"
  19 #include "cmemory.h"
  20 #include "cstring.h"
  21 #include "hash.h"
  22 #include "uresimp.h"
  23 #include "ureslocs.h"
  24 #include "unicode/msgfmt.h"
  25 #include "uassert.h"
  26
  27 #define LEFT_CURLY_BRACKET  ((UChar)0x007B)
  28 #define RIGHT_CURLY_BRACKET ((UChar)0x007D)
  29 #define SPACE             ((UChar)0x0020)
  30 #define DIGIT_ZERO        ((UChar)0x0030)
  31 #define LOW_S             ((UChar)0x0073)
  32 #define LOW_M             ((UChar)0x006D)
  33 #define LOW_I             ((UChar)0x0069)
  34 #define LOW_N             ((UChar)0x006E)
  35 #define LOW_H             ((UChar)0x0068)
  36 #define LOW_W             ((UChar)0x0077)
  37 #define LOW_D             ((UChar)0x0064)
  38 #define LOW_Y             ((UChar)0x0079)
  39 #define LOW_Z             ((UChar)0x007A)
  40 #define LOW_E             ((UChar)0x0065)
  41 #define LOW_R             ((UChar)0x0072)
  42 #define LOW_O             ((UChar)0x006F)
  43 #define LOW_N             ((UChar)0x006E)
  44 #define LOW_T             ((UChar)0x0074)
  45
  46
  47 //TODO: define in compile time
  48 //#define TMUTFMT_DEBUG 1
  49
  50 #ifdef TMUTFMT_DEBUG
  51 #include <iostream>
  52 #endif
  53
  54 U_NAMESPACE_BEGIN
  55
  56
  57
  58 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeUnitFormat)
  59
  60 static const char gUnitsTag[] = "units";
  61 static const char gShortUnitsTag[] = "unitsShort";
  62 static const char gTimeUnitYear[] = "year";
  63 static const char gTimeUnitMonth[] = "month";
  64 static const char gTimeUnitDay[] = "day";
  65 static const char gTimeUnitWeek[] = "week";
  66 static const char gTimeUnitHour[] = "hour";
  67 static const char gTimeUnitMinute[] = "minute";
  68 static const char gTimeUnitSecond[] = "second";
  69 static const char gPluralCountOther[] = "other";
  70
  71 static const UChar DEFAULT_PATTERN_FOR_SECOND[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_S, 0};
  72 static const UChar DEFAULT_PATTERN_FOR_MINUTE[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_M, LOW_I, LOW_N, 0};
  73 static const UChar DEFAULT_PATTERN_FOR_HOUR[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_H, 0};
  74 static const UChar DEFAULT_PATTERN_FOR_WEEK[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_W, 0};
  75 static const UChar DEFAULT_PATTERN_FOR_DAY[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_D, 0};
  76 static const UChar DEFAULT_PATTERN_FOR_MONTH[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_M, 0};
  77 static const UChar DEFAULT_PATTERN_FOR_YEAR[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_Y, 0};
  78
  79 static const UChar PLURAL_COUNT_ZERO[] = {LOW_Z, LOW_E, LOW_R, LOW_O, 0};
  80 static const UChar PLURAL_COUNT_ONE[] = {LOW_O, LOW_N, LOW_E, 0};
  81 static const UChar PLURAL_COUNT_TWO[] = {LOW_T, LOW_W, LOW_O, 0};
  82
  83 TimeUnitFormat::TimeUnitFormat(UErrorCode& status) {
  84     initMeasureFormat(Locale::getDefault(), UMEASFMT_WIDTH_WIDE, NULL, status);
  85     create(UTMUTFMT_FULL_STYLE, status);
  86 }
  87
  88
  89 TimeUnitFormat::TimeUnitFormat(const Locale& locale, UErrorCode& status) {
  90     initMeasureFormat(locale, UMEASFMT_WIDTH_WIDE, NULL, status);
  91     create(UTMUTFMT_FULL_STYLE, status);
  92 }
  93
  94
  95 TimeUnitFormat::TimeUnitFormat(const Locale& locale, UTimeUnitFormatStyle style, UErrorCode& status) {
  96     switch (style) {
  97     case UTMUTFMT_FULL_STYLE:
  98         initMeasureFormat(locale, UMEASFMT_WIDTH_WIDE, NULL, status);
  99         break;
 100     case UTMUTFMT_ABBREVIATED_STYLE:
 101         initMeasureFormat(locale, UMEASFMT_WIDTH_SHORT, NULL, status);
 102         break;
 103     default:
 104         initMeasureFormat(locale, UMEASFMT_WIDTH_WIDE, NULL, status);
 105         break;
 106     }
 107     create(style, status);
 108 }
 109
 110 TimeUnitFormat::TimeUnitFormat(const TimeUnitFormat& other)
 111 :   MeasureFormat(other),
 112     fStyle(other.fStyle)
 113 {
 114     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
 115          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
 116          i = (TimeUnit::UTimeUnitFields)(i+1)) {
 117         UErrorCode status = U_ZERO_ERROR;
 118         fTimeUnitToCountToPatterns[i] = initHash(status);
 119         if (U_SUCCESS(status)) {
 120             copyHash(other.fTimeUnitToCountToPatterns[i], fTimeUnitToCountToPatterns[i], status);
 121         } else {
 122             delete fTimeUnitToCountToPatterns[i];
 123             fTimeUnitToCountToPatterns[i] = NULL;
 124         }
 125     }
 126 }
 127
 128
 129 TimeUnitFormat::~TimeUnitFormat() {
 130     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
 131          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
 132          i = (TimeUnit::UTimeUnitFields)(i+1)) {
 133         deleteHash(fTimeUnitToCountToPatterns[i]);
 134         fTimeUnitToCountToPatterns[i] = NULL;
 135     }
 136 }
 137
 138
 139 Format*
 140 TimeUnitFormat::clone(void) const {
 141     return new TimeUnitFormat(*this);
 142 }
 143
 144
 145 TimeUnitFormat&
 146 TimeUnitFormat::operator=(const TimeUnitFormat& other) {
 147     if (this == &other) {
 148         return *this;
 149     }
 150     MeasureFormat::operator=(other);
 151     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
 152          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
 153          i = (TimeUnit::UTimeUnitFields)(i+1)) {
 154         deleteHash(fTimeUnitToCountToPatterns[i]);
 155         fTimeUnitToCountToPatterns[i] = NULL;
 156     }
 157     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
 158          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
 159          i = (TimeUnit::UTimeUnitFields)(i+1)) {
 160         UErrorCode status = U_ZERO_ERROR;
 161         fTimeUnitToCountToPatterns[i] = initHash(status);
 162         if (U_SUCCESS(status)) {
 163             copyHash(other.fTimeUnitToCountToPatterns[i], fTimeUnitToCountToPatterns[i], status);
 164         } else {
 165             delete fTimeUnitToCountToPatterns[i];
 166             fTimeUnitToCountToPatterns[i] = NULL;
 167         }
 168     }
 169     fStyle = other.fStyle;
 170     return *this;
 171 }
 172
 173 void
 174 TimeUnitFormat::parseObject(const UnicodeString& source,
 175                             Formattable& result,
 176                             ParsePosition& pos) const {
 177     Formattable resultNumber(0.0);
 178     UBool withNumberFormat = false;
 179     TimeUnit::UTimeUnitFields resultTimeUnit = TimeUnit::UTIMEUNIT_FIELD_COUNT;
 180     int32_t oldPos = pos.getIndex();
 181     int32_t newPos = -1;
 182     int32_t longestParseDistance = 0;
 183     UnicodeString* countOfLongestMatch = NULL;
 184 #ifdef TMUTFMT_DEBUG
 185     char res[1000];
 186     source.extract(0, source.length(), res, "UTF-8");
 187     std::cout << "parse source: " << res << "\n";
 188 #endif
 189     // parse by iterating through all available patterns
 190     // and looking for the longest match.
 191     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
 192          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
 193          i = (TimeUnit::UTimeUnitFields)(i+1)) {
 194         Hashtable* countToPatterns = fTimeUnitToCountToPatterns[i];
 195         int32_t elemPos = UHASH_FIRST;
 196         const UHashElement* elem = NULL;
 197         while ((elem = countToPatterns->nextElement(elemPos)) != NULL){
 198             const UHashTok keyTok = elem->key;
 199             UnicodeString* count = (UnicodeString*)keyTok.pointer;
 200 #ifdef TMUTFMT_DEBUG
 201             count->extract(0, count->length(), res, "UTF-8");
 202             std::cout << "parse plural count: " << res << "\n";
 203 #endif
 204             const UHashTok valueTok = elem->value;
 205             // the value is a pair of MessageFormat*
 206             MessageFormat** patterns = (MessageFormat**)valueTok.pointer;
 207             for (UTimeUnitFormatStyle style = UTMUTFMT_FULL_STYLE; style < UTMUTFMT_FORMAT_STYLE_COUNT;
 208                  style = (UTimeUnitFormatStyle)(style + 1)) {
 209                 MessageFormat* pattern = patterns[style];
 210                 pos.setErrorIndex(-1);
 211                 pos.setIndex(oldPos);
 212                 // see if we can parse
 213                 Formattable parsed;
 214                 pattern->parseObject(source, parsed, pos);
 215                 if (pos.getErrorIndex() != -1 || pos.getIndex() == oldPos) {
 216                     continue;
 217                 }
 218     #ifdef TMUTFMT_DEBUG
 219                 std::cout << "parsed.getType: " << parsed.getType() << "\n";
 220     #endif
 221                 Formattable tmpNumber(0.0);
 222                 if (pattern->getArgTypeCount() != 0) {
 223                     Formattable& temp = parsed[0];
 224                     if (temp.getType() == Formattable::kString) {
 225                         UnicodeString tmpString;
 226                         UErrorCode pStatus = U_ZERO_ERROR;
 227                         getNumberFormat().parse(temp.getString(tmpString), tmpNumber, pStatus);
 228                         if (U_FAILURE(pStatus)) {
 229                             continue;
 230                         }
 231                     } else if (temp.isNumeric()) {
 232                         tmpNumber = temp;
 233                     } else {
 234                         continue;
 235                     }
 236                 }
 237                 int32_t parseDistance = pos.getIndex() - oldPos;
 238                 if (parseDistance > longestParseDistance) {
 239                     if (pattern->getArgTypeCount() != 0) {
 240                         resultNumber = tmpNumber;
 241                         withNumberFormat = true;
 242                     } else {
 243                         withNumberFormat = false;
 244                     }
 245                     resultTimeUnit = i;
 246                     newPos = pos.getIndex();
 247                     longestParseDistance = parseDistance;
 248                     countOfLongestMatch = count;
 249                 }
 250             }
 251         }
 252     }
 253     /* After find the longest match, parse the number.
 254      * Result number could be null for the pattern without number pattern.
 255      * such as unit pattern in Arabic.
 256      * When result number is null, use plural rule to set the number.
 257      */
 258     if (withNumberFormat == false && longestParseDistance != 0) {
 259         // set the number using plurrual count
 260         if (0 == countOfLongestMatch->compare(PLURAL_COUNT_ZERO, 4)) {
 261             resultNumber = Formattable(0.0);
 262         } else if (0 == countOfLongestMatch->compare(PLURAL_COUNT_ONE, 3)) {
 263             resultNumber = Formattable(1.0);
 264         } else if (0 == countOfLongestMatch->compare(PLURAL_COUNT_TWO, 3)) {
 265             resultNumber = Formattable(2.0);
 266         } else {
 267             // should not happen.
 268             // TODO: how to handle?
 269             resultNumber = Formattable(3.0);
 270         }
 271     }
 272     if (longestParseDistance == 0) {
 273         pos.setIndex(oldPos);
 274         pos.setErrorIndex(0);
 275     } else {
 276         UErrorCode status = U_ZERO_ERROR;
 277         LocalPointer<TimeUnitAmount> tmutamt(new TimeUnitAmount(resultNumber, resultTimeUnit, status), status);
 278         if (U_SUCCESS(status)) {
 279             result.adoptObject(tmutamt.orphan());
 280             pos.setIndex(newPos);
 281             pos.setErrorIndex(-1);
 282         } else {
 283             pos.setIndex(oldPos);
 284             pos.setErrorIndex(0);
 285         }
 286     }
 287 }
 288
 289 void
 290 TimeUnitFormat::create(UTimeUnitFormatStyle style, UErrorCode& status) {
 291     // fTimeUnitToCountToPatterns[] must have its elements initialized to NULL first
 292     // before checking for failure status.
 293     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
 294          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
 295          i = (TimeUnit::UTimeUnitFields)(i+1)) {
 296         fTimeUnitToCountToPatterns[i] = NULL;
 297     }
 298
 299     if (U_FAILURE(status)) {
 300         return;
 301     }
 302     if (style < UTMUTFMT_FULL_STYLE || style >= UTMUTFMT_FORMAT_STYLE_COUNT) {
 303         status = U_ILLEGAL_ARGUMENT_ERROR;
 304         return;
 305     }
 306     fStyle = style;
 307
 308     //TODO: format() and parseObj() are const member functions,
 309     //so, can not do lazy initialization in C++.
 310     //setup has to be done in constructors.
 311     //and here, the behavior is not consistent with Java.
 312     //In Java, create an empty instance does not setup locale as
 313     //default locale. If it followed by setNumberFormat(),
 314     //in format(), the locale will set up as the locale in fNumberFormat.
 315     //But in C++, this sets the locale as the default locale.
 316     setup(status);
 317 }
 318
 319 void
 320 TimeUnitFormat::setup(UErrorCode& err) {
 321     initDataMembers(err);
 322
 323     UVector pluralCounts(0, uhash_compareUnicodeString, 6, err);
 324     LocalPointer<StringEnumeration> keywords(getPluralRules().getKeywords(err), err);
 325     if (U_FAILURE(err)) {
 326         return;
 327     }
 328     UnicodeString* pluralCount;
 329     while ((pluralCount = const_cast<UnicodeString*>(keywords->snext(err))) != NULL) {
 330       pluralCounts.addElement(pluralCount, err);
 331     }
 332     readFromCurrentLocale(UTMUTFMT_FULL_STYLE, gUnitsTag, pluralCounts, err);
 333     checkConsistency(UTMUTFMT_FULL_STYLE, gUnitsTag, err);
 334     readFromCurrentLocale(UTMUTFMT_ABBREVIATED_STYLE, gShortUnitsTag, pluralCounts, err);
 335     checkConsistency(UTMUTFMT_ABBREVIATED_STYLE, gShortUnitsTag, err);
 336 }
 337
 338
 339 void
 340 TimeUnitFormat::initDataMembers(UErrorCode& err){
 341     if (U_FAILURE(err)) {
 342         return;
 343     }
 344     for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR;
 345          i < TimeUnit::UTIMEUNIT_FIELD_COUNT;
 346          i = (TimeUnit::UTimeUnitFields)(i+1)) {
 347         deleteHash(fTimeUnitToCountToPatterns[i]);
 348         fTimeUnitToCountToPatterns[i] = NULL;
 349     }
 350 }
 351
 352 struct TimeUnitFormatReadSink : public ResourceSink {
 353     TimeUnitFormat *timeUnitFormatObj;
 354     const UVector &pluralCounts;
 355     UTimeUnitFormatStyle style;
 356     UBool beenHere;
 357
 358     TimeUnitFormatReadSink(TimeUnitFormat *timeUnitFormatObj,
 359             const UVector &pluralCounts, UTimeUnitFormatStyle style) :
 360             timeUnitFormatObj(timeUnitFormatObj), pluralCounts(pluralCounts),
 361             style(style), beenHere(FALSE){}
 362
 363     virtual ~TimeUnitFormatReadSink();
 364
 365     virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) {
 366         // Skip all put() calls except the first one -- discard all fallback data.
 367         if (beenHere) {
 368             return;
 369         } else {
 370             beenHere = TRUE;
 371         }
 372
 373         ResourceTable units = value.getTable(errorCode);
 374         if (U_FAILURE(errorCode)) { return; }
 375
 376         for (int32_t i = 0; units.getKeyAndValue(i, key, value); ++i) {
 377             const char* timeUnitName = key;
 378             if (timeUnitName == NULL) {
 379                 continue;
 380             }
 381
 382             TimeUnit::UTimeUnitFields timeUnitField = TimeUnit::UTIMEUNIT_FIELD_COUNT;
 383             if ( uprv_strcmp(timeUnitName, gTimeUnitYear) == 0 ) {
 384                 timeUnitField = TimeUnit::UTIMEUNIT_YEAR;
 385             } else if ( uprv_strcmp(timeUnitName, gTimeUnitMonth) == 0 ) {
 386                 timeUnitField = TimeUnit::UTIMEUNIT_MONTH;
 387             } else if ( uprv_strcmp(timeUnitName, gTimeUnitDay) == 0 ) {
 388                 timeUnitField = TimeUnit::UTIMEUNIT_DAY;
 389             } else if ( uprv_strcmp(timeUnitName, gTimeUnitHour) == 0 ) {
 390                 timeUnitField = TimeUnit::UTIMEUNIT_HOUR;
 391             } else if ( uprv_strcmp(timeUnitName, gTimeUnitMinute) == 0 ) {
 392                 timeUnitField = TimeUnit::UTIMEUNIT_MINUTE;
 393             } else if ( uprv_strcmp(timeUnitName, gTimeUnitSecond) == 0 ) {
 394                 timeUnitField = TimeUnit::UTIMEUNIT_SECOND;
 395             } else if ( uprv_strcmp(timeUnitName, gTimeUnitWeek) == 0 ) {
 396                 timeUnitField = TimeUnit::UTIMEUNIT_WEEK;
 397             } else {
 398                 continue;
 399             }
 400             LocalPointer<Hashtable> localCountToPatterns;
 401             Hashtable *countToPatterns =
 402                 timeUnitFormatObj->fTimeUnitToCountToPatterns[timeUnitField];
 403             if (countToPatterns == NULL) {
 404                 localCountToPatterns.adoptInsteadAndCheckErrorCode(
 405                     timeUnitFormatObj->initHash(errorCode), errorCode);
 406                 countToPatterns = localCountToPatterns.getAlias();
 407                 if (U_FAILURE(errorCode)) {
 408                     return;
 409                 }
 410             }
 411
 412             ResourceTable countsToPatternTable = value.getTable(errorCode);
 413             if (U_FAILURE(errorCode)) {
 414                 continue;
 415             }
 416             for (int32_t j = 0; countsToPatternTable.getKeyAndValue(j, key, value); ++j) {
 417                 errorCode = U_ZERO_ERROR;
 418                 UnicodeString pattern = value.getUnicodeString(errorCode);
 419                 if (U_FAILURE(errorCode)) {
 420                     continue;
 421                 }
 422                 UnicodeString pluralCountUniStr(key, -1, US_INV);
 423                 if (!pluralCounts.contains(&pluralCountUniStr)) {
 424                     continue;
 425                 }
 426                 LocalPointer<MessageFormat> messageFormat(new MessageFormat(
 427                     pattern, timeUnitFormatObj->getLocale(errorCode), errorCode), errorCode);
 428                 if (U_FAILURE(errorCode)) {
 429                     return;
 430                 }
 431                 MessageFormat** formatters =
 432                     (MessageFormat**)countToPatterns->get(pluralCountUniStr);
 433                 if (formatters == NULL) {
 434                     LocalMemory<MessageFormat *> localFormatters(
 435                         (MessageFormat **)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*)));
 436                     if (localFormatters.isNull()) {
 437                         errorCode = U_MEMORY_ALLOCATION_ERROR;
 438                         return;
 439                     }
 440                     localFormatters[UTMUTFMT_FULL_STYLE] = NULL;
 441                     localFormatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL;
 442                     countToPatterns->put(pluralCountUniStr, localFormatters.getAlias(), errorCode);
 443                     if (U_FAILURE(errorCode)) {
 444                         return;
 445                     }
 446                     formatters = localFormatters.orphan();
 447                 }
 448                 formatters[style] = messageFormat.orphan();
 449             }
 450
 451             if (timeUnitFormatObj->fTimeUnitToCountToPatterns[timeUnitField] == NULL) {
 452                 timeUnitFormatObj->fTimeUnitToCountToPatterns[timeUnitField] = localCountToPatterns.orphan();
 453             }
 454         }
 455     }
 456
 457 };
 458
 459 TimeUnitFormatReadSink::~TimeUnitFormatReadSink() {}
 460
 461 void
 462 TimeUnitFormat::readFromCurrentLocale(UTimeUnitFormatStyle style, const char* key,
 463                                       const UVector& pluralCounts, UErrorCode& err) {
 464     if (U_FAILURE(err)) {
 465         return;
 466     }
 467     // fill timeUnitToCountToPatterns from resource file
 468     // err is used to indicate wrong status except missing resource.
 469     // status is an error code used in resource lookup.
 470     // status does not affect "err".
 471     UErrorCode status = U_ZERO_ERROR;
 472     LocalUResourceBundlePointer rb(ures_open(U_ICUDATA_UNIT, getLocaleID(status), &status));
 473
 474     LocalUResourceBundlePointer unitsRes(ures_getByKey(rb.getAlias(), key, NULL, &status));
 475     ures_getByKey(unitsRes.getAlias(), "duration", unitsRes.getAlias(), &status);
 476     if (U_FAILURE(status)) {
 477         return;
 478     }
 479
 480     TimeUnitFormatReadSink sink(this, pluralCounts, style);
 481     ures_getAllItemsWithFallback(unitsRes.getAlias(), "", sink, status);
 482 }
 483
 484 void
 485 TimeUnitFormat::checkConsistency(UTimeUnitFormatStyle style, const char* key, UErrorCode& err) {
 486     if (U_FAILURE(err)) {
 487         return;
 488     }
 489     // there should be patterns for each plural rule in each time unit.
 490     // For each time unit,
 491     //     for each plural rule, following is unit pattern fall-back rule:
 492     //         ( for example: "one" hour )
 493     //         look for its unit pattern in its locale tree.
 494     //         if pattern is not found in its own locale, such as de_DE,
 495     //         look for the pattern in its parent, such as de,
 496     //         keep looking till found or till root.
 497     //         if the pattern is not found in root either,
 498     //         fallback to plural count "other",
 499     //         look for the pattern of "other" in the locale tree:
 500     //         "de_DE" to "de" to "root".
 501     //         If not found, fall back to value of
 502     //         static variable DEFAULT_PATTERN_FOR_xxx, such as "{0} h".
 503     //
 504     // Following is consistency check to create pattern for each
 505     // plural rule in each time unit using above fall-back rule.
 506     //
 507     LocalPointer<StringEnumeration> keywords(
 508             getPluralRules().getKeywords(err), err);
 509     const UnicodeString* pluralCount;
 510     while (U_SUCCESS(err) && (pluralCount = keywords->snext(err)) != NULL) {
 511         for (int32_t i = 0; i < TimeUnit::UTIMEUNIT_FIELD_COUNT; ++i) {
 512             // for each time unit,
 513             // get all the patterns for each plural rule in this locale.
 514             Hashtable* countToPatterns = fTimeUnitToCountToPatterns[i];
 515             if ( countToPatterns == NULL ) {
 516                 fTimeUnitToCountToPatterns[i] = countToPatterns = initHash(err);
 517                 if (U_FAILURE(err)) {
 518                     return;
 519                 }
 520             }
 521             MessageFormat** formatters = (MessageFormat**)countToPatterns->get(*pluralCount);
 522             if( formatters == NULL || formatters[style] == NULL ) {
 523                 // look through parents
 524                 const char* localeName = getLocaleID(err);
 525                 CharString pluralCountChars;
 526                 pluralCountChars.appendInvariantChars(*pluralCount, err);
 527                 searchInLocaleChain(style, key, localeName,
 528                                     (TimeUnit::UTimeUnitFields)i,
 529                                     *pluralCount, pluralCountChars.data(),
 530                                     countToPatterns, err);
 531             }
 532             // TODO: what to do with U_FAILURE(err) at this point.
 533             //       As is, the outer loop continues to run, but does nothing.
 534         }
 535     }
 536 }
 537
 538
 539
 540 // srcPluralCount is the original plural count on which the pattern is
 541 // searched for.
 542 // searchPluralCount is the fallback plural count.
 543 // For example, to search for pattern for ""one" hour",
 544 // "one" is the srcPluralCount,
 545 // if the pattern is not found even in root, fallback to
 546 // using patterns of plural count "other",
 547 // then, "other" is the searchPluralCount.
 548 void
 549 TimeUnitFormat::searchInLocaleChain(UTimeUnitFormatStyle style, const char* key, const char* localeName,
 550                                 TimeUnit::UTimeUnitFields srcTimeUnitField,
 551                                 const UnicodeString& srcPluralCount,
 552                                 const char* searchPluralCount,
 553                                 Hashtable* countToPatterns,
 554                                 UErrorCode& err) {
 555     if (U_FAILURE(err)) {
 556         return;
 557     }
 558     UErrorCode status = U_ZERO_ERROR;
 559     char parentLocale[ULOC_FULLNAME_CAPACITY];
 560     uprv_strcpy(parentLocale, localeName);
 561     int32_t locNameLen;
 562     U_ASSERT(countToPatterns != NULL);
 563     while ((locNameLen = uloc_getParent(parentLocale, parentLocale,
 564                                         ULOC_FULLNAME_CAPACITY, &status)) >= 0){
 565         // look for pattern for srcPluralCount in locale tree
 566         LocalUResourceBundlePointer rb(ures_open(U_ICUDATA_UNIT, parentLocale, &status));
 567         LocalUResourceBundlePointer unitsRes(ures_getByKey(rb.getAlias(), key, NULL, &status));
 568         const char* timeUnitName = getTimeUnitName(srcTimeUnitField, status);
 569         LocalUResourceBundlePointer countsToPatternRB(ures_getByKey(unitsRes.getAlias(), timeUnitName, NULL, &status));
 570         const UChar* pattern;
 571         int32_t      ptLength;
 572         pattern = ures_getStringByKeyWithFallback(countsToPatternRB.getAlias(), searchPluralCount, &ptLength, &status);
 573         if (U_SUCCESS(status)) {
 574             //found
 575             LocalPointer<MessageFormat> messageFormat(
 576                 new MessageFormat(UnicodeString(TRUE, pattern, ptLength), getLocale(err), err), err);
 577             if (U_FAILURE(err)) {
 578                 return;
 579             }
 580             MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount);
 581             if (formatters == NULL) {
 582                 LocalMemory<MessageFormat *> localFormatters(
 583                         (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*)));
 584                 formatters = localFormatters.getAlias();
 585                 localFormatters[UTMUTFMT_FULL_STYLE] = NULL;
 586                 localFormatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL;
 587                 countToPatterns->put(srcPluralCount, localFormatters.orphan(), err);
 588                 if (U_FAILURE(err)) {
 589                     return;
 590                 }
 591             }
 592             //delete formatters[style];
 593             formatters[style] = messageFormat.orphan();
 594             return;
 595         }
 596         status = U_ZERO_ERROR;
 597         if (locNameLen == 0) {
 598             break;
 599         }
 600     }
 601
 602     // if no unitsShort resource was found even after fallback to root locale
 603     // then search the units resource fallback from the current level to root
 604     if ( locNameLen == 0 && uprv_strcmp(key, gShortUnitsTag) == 0) {
 605 #ifdef TMUTFMT_DEBUG
 606         std::cout << "loop into searchInLocaleChain since Short-Long-Alternative \n";
 607 #endif
 608         CharString pLocale(localeName, -1, err);
 609         // Add an underscore at the tail of locale name,
 610         // so that searchInLocaleChain will check the current locale before falling back
 611         pLocale.append('_', err);
 612         searchInLocaleChain(style, gUnitsTag, pLocale.data(), srcTimeUnitField, srcPluralCount,
 613                              searchPluralCount, countToPatterns, err);
 614         if (U_FAILURE(err)) {
 615             return;
 616         }
 617         MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount);
 618         if (formatters != NULL && formatters[style] != NULL) {
 619             return;
 620         }
 621     }
 622
 623     // if not found the pattern for this plural count at all,
 624     // fall-back to plural count "other"
 625     if ( uprv_strcmp(searchPluralCount, gPluralCountOther) == 0 ) {
 626         // set default fall back the same as the resource in root
 627         LocalPointer<MessageFormat> messageFormat;
 628         const UChar *pattern = NULL;
 629         if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_SECOND ) {
 630             pattern = DEFAULT_PATTERN_FOR_SECOND;
 631         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_MINUTE ) {
 632             pattern = DEFAULT_PATTERN_FOR_MINUTE;
 633         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_HOUR ) {
 634             pattern = DEFAULT_PATTERN_FOR_HOUR;
 635         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_WEEK ) {
 636             pattern = DEFAULT_PATTERN_FOR_WEEK;
 637         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_DAY ) {
 638             pattern = DEFAULT_PATTERN_FOR_DAY;
 639         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_MONTH ) {
 640             pattern = DEFAULT_PATTERN_FOR_MONTH;
 641         } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_YEAR ) {
 642             pattern = DEFAULT_PATTERN_FOR_YEAR;
 643         }
 644         if (pattern != NULL) {
 645             messageFormat.adoptInsteadAndCheckErrorCode(
 646                      new MessageFormat(UnicodeString(TRUE, pattern, -1), getLocale(err), err), err);
 647         }
 648         if (U_FAILURE(err)) {
 649             return;
 650         }
 651         MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount);
 652         if (formatters == NULL) {
 653             LocalMemory<MessageFormat *> localFormatters (
 654                     (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*)));
 655             if (localFormatters.isNull()) {
 656                 err = U_MEMORY_ALLOCATION_ERROR;
 657                 return;
 658             }
 659             formatters = localFormatters.getAlias();
 660             formatters[UTMUTFMT_FULL_STYLE] = NULL;
 661             formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL;
 662             countToPatterns->put(srcPluralCount, localFormatters.orphan(), err);
 663         }
 664         if (U_SUCCESS(err)) {
 665             //delete formatters[style];
 666             formatters[style] = messageFormat.orphan();
 667         }
 668     } else {
 669         // fall back to rule "other", and search in parents
 670         searchInLocaleChain(style, key, localeName, srcTimeUnitField, srcPluralCount,
 671                             gPluralCountOther, countToPatterns, err);
 672     }
 673 }
 674
 675 void
 676 TimeUnitFormat::setLocale(const Locale& locale, UErrorCode& status) {
 677     if (setMeasureFormatLocale(locale, status)) {
 678         setup(status);
 679     }
 680 }
 681
 682
 683 void
 684 TimeUnitFormat::setNumberFormat(const NumberFormat& format, UErrorCode& status){
 685     if (U_FAILURE(status)) {
 686         return;
 687     }
 688     adoptNumberFormat((NumberFormat *)format.clone(), status);
 689 }
 690
 691
 692 void
 693 TimeUnitFormat::deleteHash(Hashtable* htable) {
 694     int32_t pos = UHASH_FIRST;
 695     const UHashElement* element = NULL;
 696     if ( htable ) {
 697         while ( (element = htable->nextElement(pos)) != NULL ) {
 698             const UHashTok valueTok = element->value;
 699             const MessageFormat** value = (const MessageFormat**)valueTok.pointer;
 700             delete value[UTMUTFMT_FULL_STYLE];
 701             delete value[UTMUTFMT_ABBREVIATED_STYLE];
 702             //delete[] value;
 703             uprv_free(value);
 704         }
 705     }
 706     delete htable;
 707 }
 708
 709
 710 void
 711 TimeUnitFormat::copyHash(const Hashtable* source, Hashtable* target, UErrorCode& status) {
 712     if ( U_FAILURE(status) ) {
 713         return;
 714     }
 715     int32_t pos = UHASH_FIRST;
 716     const UHashElement* element = NULL;
 717     if ( source ) {
 718         while ( (element = source->nextElement(pos)) != NULL ) {
 719             const UHashTok keyTok = element->key;
 720             const UnicodeString* key = (UnicodeString*)keyTok.pointer;
 721             const UHashTok valueTok = element->value;
 722             const MessageFormat** value = (const MessageFormat**)valueTok.pointer;
 723             MessageFormat** newVal = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*));
 724             newVal[0] = (MessageFormat*)value[0]->clone();
 725             newVal[1] = (MessageFormat*)value[1]->clone();
 726             target->put(UnicodeString(*key), newVal, status);
 727             if ( U_FAILURE(status) ) {
 728                 delete newVal[0];
 729                 delete newVal[1];
 730                 uprv_free(newVal);
 731                 return;
 732             }
 733         }
 734     }
 735 }
 736
 737
 738 U_CDECL_BEGIN
 739
 740 /**
 741  * set hash table value comparator
 742  *
 743  * @param val1  one value in comparison
 744  * @param val2  the other value in comparison
 745  * @return      TRUE if 2 values are the same, FALSE otherwise
 746  */
 747 static UBool U_CALLCONV tmutfmtHashTableValueComparator(UHashTok val1, UHashTok val2);
 748
 749 static UBool
 750 U_CALLCONV tmutfmtHashTableValueComparator(UHashTok val1, UHashTok val2) {
 751     const MessageFormat** pattern1 = (const MessageFormat**)val1.pointer;
 752     const MessageFormat** pattern2 = (const MessageFormat**)val2.pointer;
 753     return *pattern1[0] == *pattern2[0] && *pattern1[1] == *pattern2[1];
 754 }
 755
 756 U_CDECL_END
 757
 758 Hashtable*
 759 TimeUnitFormat::initHash(UErrorCode& status) {
 760     if ( U_FAILURE(status) ) {
 761         return NULL;
 762     }
 763     Hashtable* hTable;
 764     if ( (hTable = new Hashtable(TRUE, status)) == NULL ) {
 765         status = U_MEMORY_ALLOCATION_ERROR;
 766         return NULL;
 767     }
 768     if ( U_FAILURE(status) ) {
 769         delete hTable;
 770         return NULL;
 771     }
 772     hTable->setValueComparator(tmutfmtHashTableValueComparator);
 773     return hTable;
 774 }
 775
 776
 777 const char*
 778 TimeUnitFormat::getTimeUnitName(TimeUnit::UTimeUnitFields unitField,
 779                                 UErrorCode& status) {
 780     if (U_FAILURE(status)) {
 781         return NULL;
 782     }
 783     switch (unitField) {
 784       case TimeUnit::UTIMEUNIT_YEAR:
 785         return gTimeUnitYear;
 786       case TimeUnit::UTIMEUNIT_MONTH:
 787         return gTimeUnitMonth;
 788       case TimeUnit::UTIMEUNIT_DAY:
 789         return gTimeUnitDay;
 790       case TimeUnit::UTIMEUNIT_WEEK:
 791         return gTimeUnitWeek;
 792       case TimeUnit::UTIMEUNIT_HOUR:
 793         return gTimeUnitHour;
 794       case TimeUnit::UTIMEUNIT_MINUTE:
 795         return gTimeUnitMinute;
 796       case TimeUnit::UTIMEUNIT_SECOND:
 797         return gTimeUnitSecond;
 798       default:
 799         status = U_ILLEGAL_ARGUMENT_ERROR;
 800         return NULL;
 801     }
 802 }
 803
 804 U_NAMESPACE_END
 805
 806 #endif