icuSources/i18n/tmutfmt.cpp

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