icuSources/i18n/tmutfmt.cpp

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