icuSources/i18n/dtitvinf.cpp

   1 /*******************************************************************************
   2 * Copyright (C) 2008-2012, International Business Machines Corporation and
   3 * others. All Rights Reserved.
   4 *******************************************************************************
   5 *
   6 * File DTITVINF.CPP
   7 *
   8 *******************************************************************************
   9 */
  10
  11 #include "unicode/dtitvinf.h"
  12
  13
  14 #if !UCONFIG_NO_FORMATTING
  15
  16 //TODO: define it in compiler time
  17 //#define DTITVINF_DEBUG 1
  18
  19
  20 #ifdef DTITVINF_DEBUG
  21 #include <iostream>
  22 #endif
  23
  24 #include "cstring.h"
  25 #include "unicode/msgfmt.h"
  26 #include "unicode/uloc.h"
  27 #include "unicode/ures.h"
  28 #include "dtitv_impl.h"
  29 #include "hash.h"
  30 #include "gregoimp.h"
  31 #include "uresimp.h"
  32 #include "hash.h"
  33 #include "gregoimp.h"
  34 #include "uresimp.h"
  35
  36
  37 U_NAMESPACE_BEGIN
  38
  39
  40 #ifdef DTITVINF_DEBUG
  41 #define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
  42 #endif
  43
  44 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalInfo)
  45
  46 static const char gCalendarTag[]="calendar";
  47 static const char gGregorianTag[]="gregorian";
  48 static const char gIntervalDateTimePatternTag[]="intervalFormats";
  49 static const char gFallbackPatternTag[]="fallback";
  50
  51 // {0}
  52 static const UChar gFirstPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET};
  53 // {1}
  54 static const UChar gSecondPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ONE, RIGHT_CURLY_BRACKET};
  55
  56 // default fall-back
  57 static const UChar gDefaultFallbackPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, EN_DASH, SPACE, LEFT_CURLY_BRACKET, DIGIT_ONE, RIGHT_CURLY_BRACKET, 0};
  58
  59
  60
  61 DateIntervalInfo::DateIntervalInfo(UErrorCode& status)
  62 :   fFallbackIntervalPattern(gDefaultFallbackPattern),
  63     fFirstDateInPtnIsLaterDate(false),
  64     fIntervalPatterns(NULL)
  65 {
  66     fIntervalPatterns = initHash(status);
  67 }
  68
  69
  70
  71 DateIntervalInfo::DateIntervalInfo(const Locale& locale, UErrorCode& status)
  72 :   fFallbackIntervalPattern(gDefaultFallbackPattern),
  73     fFirstDateInPtnIsLaterDate(false),
  74     fIntervalPatterns(NULL)
  75 {
  76     initializeData(locale, status);
  77 }
  78
  79
  80
  81 void
  82 DateIntervalInfo::setIntervalPattern(const UnicodeString& skeleton,
  83                                      UCalendarDateFields lrgDiffCalUnit,
  84                                      const UnicodeString& intervalPattern,
  85                                      UErrorCode& status) {
  86
  87     if ( lrgDiffCalUnit == UCAL_HOUR_OF_DAY ) {
  88         setIntervalPatternInternally(skeleton, UCAL_AM_PM, intervalPattern, status);
  89         setIntervalPatternInternally(skeleton, UCAL_HOUR, intervalPattern, status);
  90     } else if ( lrgDiffCalUnit == UCAL_DAY_OF_MONTH ||
  91                 lrgDiffCalUnit == UCAL_DAY_OF_WEEK ) {
  92         setIntervalPatternInternally(skeleton, UCAL_DATE, intervalPattern, status);
  93     } else {
  94         setIntervalPatternInternally(skeleton, lrgDiffCalUnit, intervalPattern, status);
  95     }
  96 }
  97
  98
  99 void
 100 DateIntervalInfo::setFallbackIntervalPattern(
 101                                     const UnicodeString& fallbackPattern,
 102                                     UErrorCode& status) {
 103     if ( U_FAILURE(status) ) {
 104         return;
 105     }
 106     int32_t firstPatternIndex = fallbackPattern.indexOf(gFirstPattern,
 107                         sizeof(gFirstPattern)/sizeof(gFirstPattern[0]), 0);
 108     int32_t secondPatternIndex = fallbackPattern.indexOf(gSecondPattern,
 109                         sizeof(gSecondPattern)/sizeof(gSecondPattern[0]), 0);
 110     if ( firstPatternIndex == -1 || secondPatternIndex == -1 ) {
 111         status = U_ILLEGAL_ARGUMENT_ERROR;
 112         return;
 113     }
 114     if ( firstPatternIndex > secondPatternIndex ) {
 115         fFirstDateInPtnIsLaterDate = true;
 116     }
 117     fFallbackIntervalPattern = fallbackPattern;
 118 }
 119
 120
 121
 122 DateIntervalInfo::DateIntervalInfo(const DateIntervalInfo& dtitvinf)
 123 :   UObject(dtitvinf),
 124     fIntervalPatterns(NULL)
 125 {
 126     *this = dtitvinf;
 127 }
 128
 129
 130
 131 DateIntervalInfo&
 132 DateIntervalInfo::operator=(const DateIntervalInfo& dtitvinf) {
 133     if ( this == &dtitvinf ) {
 134         return *this;
 135     }
 136
 137     UErrorCode status = U_ZERO_ERROR;
 138     deleteHash(fIntervalPatterns);
 139     fIntervalPatterns = initHash(status);
 140     copyHash(dtitvinf.fIntervalPatterns, fIntervalPatterns, status);
 141     if ( U_FAILURE(status) ) {
 142         return *this;
 143     }
 144
 145     fFallbackIntervalPattern = dtitvinf.fFallbackIntervalPattern;
 146     fFirstDateInPtnIsLaterDate = dtitvinf.fFirstDateInPtnIsLaterDate;
 147     return *this;
 148 }
 149
 150
 151 DateIntervalInfo*
 152 DateIntervalInfo::clone() const {
 153     return new DateIntervalInfo(*this);
 154 }
 155
 156
 157 DateIntervalInfo::~DateIntervalInfo() {
 158     deleteHash(fIntervalPatterns);
 159     fIntervalPatterns = NULL;
 160 }
 161
 162
 163 UBool
 164 DateIntervalInfo::operator==(const DateIntervalInfo& other) const {
 165     UBool equal = (
 166       fFallbackIntervalPattern == other.fFallbackIntervalPattern &&
 167       fFirstDateInPtnIsLaterDate == other.fFirstDateInPtnIsLaterDate );
 168
 169     if ( equal == TRUE ) {
 170         equal = fIntervalPatterns->equals(*(other.fIntervalPatterns));
 171     }
 172
 173     return equal;
 174 }
 175
 176
 177 UnicodeString&
 178 DateIntervalInfo::getIntervalPattern(const UnicodeString& skeleton,
 179                                      UCalendarDateFields field,
 180                                      UnicodeString& result,
 181                                      UErrorCode& status) const {
 182     if ( U_FAILURE(status) ) {
 183         return result;
 184     }
 185
 186     const UnicodeString* patternsOfOneSkeleton = (UnicodeString*) fIntervalPatterns->get(skeleton);
 187     if ( patternsOfOneSkeleton != NULL ) {
 188         IntervalPatternIndex index = calendarFieldToIntervalIndex(field, status);
 189         if ( U_FAILURE(status) ) {
 190             return result;
 191         }
 192         const UnicodeString& intervalPattern =  patternsOfOneSkeleton[index];
 193         if ( !intervalPattern.isEmpty() ) {
 194             result = intervalPattern;
 195         }
 196     }
 197     return result;
 198 }
 199
 200
 201 UBool
 202 DateIntervalInfo::getDefaultOrder() const {
 203     return fFirstDateInPtnIsLaterDate;
 204 }
 205
 206
 207 UnicodeString&
 208 DateIntervalInfo::getFallbackIntervalPattern(UnicodeString& result) const {
 209     result = fFallbackIntervalPattern;
 210     return result;
 211 }
 212
 213 #define ULOC_LOCALE_IDENTIFIER_CAPACITY (ULOC_FULLNAME_CAPACITY + 1 + ULOC_KEYWORD_AND_VALUES_CAPACITY)
 214
 215 void
 216 DateIntervalInfo::initializeData(const Locale& locale, UErrorCode& err)
 217 {
 218   fIntervalPatterns = initHash(err);
 219   if ( U_FAILURE(err) ) {
 220       return;
 221   }
 222   const char *locName = locale.getName();
 223   char parentLocale[ULOC_FULLNAME_CAPACITY];
 224   uprv_strcpy(parentLocale, locName);
 225   UErrorCode status = U_ZERO_ERROR;
 226   Hashtable skeletonSet(FALSE, status);
 227   if ( U_FAILURE(status) ) {
 228       return;
 229   }
 230
 231   // determine calendar type
 232   const char * calendarTypeToUse = gGregorianTag; // initial default
 233   char         calendarType[ULOC_KEYWORDS_CAPACITY]; // to be filled in with the type to use, if all goes well
 234   char         localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY];
 235   // obtain a locale that always has the calendar key value that should be used
 236   (void)ures_getFunctionalEquivalent(localeWithCalendarKey, ULOC_LOCALE_IDENTIFIER_CAPACITY, NULL,
 237                                      "calendar", "calendar", locName, NULL, FALSE, &status);
 238   localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY-1] = 0; // ensure null termination
 239   // now get the calendar key value from that locale
 240   int32_t calendarTypeLen = uloc_getKeywordValue(localeWithCalendarKey, "calendar", calendarType, ULOC_KEYWORDS_CAPACITY, &status);
 241   if (U_SUCCESS(status) && calendarTypeLen < ULOC_KEYWORDS_CAPACITY) {
 242     calendarTypeToUse = calendarType;
 243   }
 244   status = U_ZERO_ERROR;
 245
 246   do {
 247     UResourceBundle *rb, *calBundle, *calTypeBundle, *itvDtPtnResource;
 248     rb = ures_open(NULL, parentLocale, &status);
 249     if ( U_FAILURE(status) ) {
 250         break;
 251     }
 252     calBundle = ures_getByKey(rb, gCalendarTag, NULL, &status);
 253     calTypeBundle = ures_getByKey(calBundle, calendarTypeToUse, NULL, &status);
 254     itvDtPtnResource = ures_getByKeyWithFallback(calTypeBundle,
 255                          gIntervalDateTimePatternTag, NULL, &status);
 256
 257     if ( U_SUCCESS(status) ) {
 258         // look for fallback first, since it establishes the default order
 259         const UChar* resStr;
 260         int32_t resStrLen = 0;
 261         resStr = ures_getStringByKeyWithFallback(itvDtPtnResource,
 262                                              gFallbackPatternTag,
 263                                              &resStrLen, &status);
 264         if ( U_SUCCESS(status) ) {
 265             UnicodeString pattern = UnicodeString(TRUE, resStr, resStrLen);
 266             setFallbackIntervalPattern(pattern, status);
 267         }
 268
 269         int32_t size = ures_getSize(itvDtPtnResource);
 270         int32_t index;
 271         for ( index = 0; index < size; ++index ) {
 272             LocalUResourceBundlePointer oneRes(ures_getByIndex(itvDtPtnResource, index,
 273                                                      NULL, &status));
 274             if ( U_SUCCESS(status) ) {
 275                 const char* skeleton = ures_getKey(oneRes.getAlias());
 276                 if (skeleton == NULL) {
 277                     continue;
 278                 }
 279                 UnicodeString skeletonUniStr(skeleton, -1, US_INV);
 280                 if ( skeletonSet.geti(skeletonUniStr) == 1 ) {
 281                     continue;
 282                 }
 283                 skeletonSet.puti(skeletonUniStr, 1, status);
 284                 if ( uprv_strcmp(skeleton, gFallbackPatternTag) == 0 ) {
 285                     continue;  // fallback
 286                 }
 287
 288                 LocalUResourceBundlePointer intervalPatterns(ures_getByKey(
 289                                      itvDtPtnResource, skeleton, NULL, &status));
 290
 291                 if ( U_FAILURE(status) ) {
 292                     break;
 293                 }
 294                 if ( intervalPatterns == NULL ) {
 295                     continue;
 296                 }
 297
 298                 const char* key;
 299                 int32_t ptnNum = ures_getSize(intervalPatterns.getAlias());
 300                 int32_t ptnIndex;
 301                 for ( ptnIndex = 0; ptnIndex < ptnNum; ++ptnIndex ) {
 302                     UnicodeString pattern =
 303                         ures_getNextUnicodeString(intervalPatterns.getAlias(), &key, &status);
 304                     if ( U_FAILURE(status) ) {
 305                         break;
 306                     }
 307
 308                     UCalendarDateFields calendarField = UCAL_FIELD_COUNT;
 309                     if ( !uprv_strcmp(key, "y") ) {
 310                         calendarField = UCAL_YEAR;
 311                     } else if ( !uprv_strcmp(key, "M") ) {
 312                         calendarField = UCAL_MONTH;
 313                     } else if ( !uprv_strcmp(key, "d") ) {
 314                         calendarField = UCAL_DATE;
 315                     } else if ( !uprv_strcmp(key, "a") ) {
 316                         calendarField = UCAL_AM_PM;
 317                     } else if ( !uprv_strcmp(key, "h") || !uprv_strcmp(key, "H") ) {
 318                         calendarField = UCAL_HOUR;
 319                     } else if ( !uprv_strcmp(key, "m") ) {
 320                         calendarField = UCAL_MINUTE;
 321                     }
 322                     if ( calendarField != UCAL_FIELD_COUNT ) {
 323                         setIntervalPatternInternally(skeletonUniStr, calendarField, pattern,status);
 324                     }
 325                 }
 326             }
 327         }
 328     }
 329     ures_close(itvDtPtnResource);
 330     ures_close(calTypeBundle);
 331     ures_close(calBundle);
 332
 333     status = U_ZERO_ERROR;
 334     // Find the name of the appropriate parent locale (from %%Parent if present, else
 335     // uloc_getParent on the actual locale name)
 336     // (It would be nice to have a ures function that did this...)
 337     int32_t locNameLen;
 338     const UChar * parentUName = ures_getStringByKey(rb, "%%Parent", &locNameLen, &status);
 339     if (U_SUCCESS(status) && status != U_USING_FALLBACK_WARNING && locNameLen < ULOC_FULLNAME_CAPACITY) {
 340         u_UCharsToChars(parentUName, parentLocale, locNameLen + 1);
 341     } else {
 342         status = U_ZERO_ERROR;
 343         // Get the actual name of the current locale being used
 344         const char *curLocaleName=ures_getLocaleByType(rb, ULOC_ACTUAL_LOCALE, &status);
 345         if ( U_FAILURE(status) ) {
 346             curLocaleName = parentLocale;
 347             status = U_ZERO_ERROR;
 348         }
 349         uloc_getParent(curLocaleName, parentLocale, ULOC_FULLNAME_CAPACITY, &status);
 350         if (U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) {
 351             parentLocale[0] = 0; // just fallback to root, will cause us to stop
 352             status = U_ZERO_ERROR;
 353         }
 354     }
 355     // Now we can close the current locale bundle
 356     ures_close(rb);
 357     // If the new current locale is root, then stop
 358     // (unlike for DateTimePatternGenerator, DateIntervalFormat does not go all the way up
 359     // to root to find additional data for non-root locales)
 360   } while ( parentLocale[0] != 0 && uprv_strcmp(parentLocale,"root")!=0 );
 361 }
 362
 363
 364
 365 void
 366 DateIntervalInfo::setIntervalPatternInternally(const UnicodeString& skeleton,
 367                                       UCalendarDateFields lrgDiffCalUnit,
 368                                       const UnicodeString& intervalPattern,
 369                                       UErrorCode& status) {
 370     IntervalPatternIndex index = calendarFieldToIntervalIndex(lrgDiffCalUnit,status);
 371     if ( U_FAILURE(status) ) {
 372         return;
 373     }
 374     UnicodeString* patternsOfOneSkeleton = (UnicodeString*)(fIntervalPatterns->get(skeleton));
 375     UBool emptyHash = false;
 376     if ( patternsOfOneSkeleton == NULL ) {
 377         patternsOfOneSkeleton = new UnicodeString[kIPI_MAX_INDEX];
 378         emptyHash = true;
 379     }
 380
 381     patternsOfOneSkeleton[index] = intervalPattern;
 382     if ( emptyHash == TRUE ) {
 383         fIntervalPatterns->put(skeleton, patternsOfOneSkeleton, status);
 384     }
 385 }
 386
 387
 388
 389 void
 390 DateIntervalInfo::parseSkeleton(const UnicodeString& skeleton,
 391                                 int32_t* skeletonFieldWidth) {
 392     const int8_t PATTERN_CHAR_BASE = 0x41;
 393     int32_t i;
 394     for ( i = 0; i < skeleton.length(); ++i ) {
 395         // it is an ASCII char in skeleton
 396         int8_t ch = (int8_t)skeleton.charAt(i);
 397         ++skeletonFieldWidth[ch - PATTERN_CHAR_BASE];
 398     }
 399 }
 400
 401
 402
 403 UBool
 404 DateIntervalInfo::stringNumeric(int32_t fieldWidth, int32_t anotherFieldWidth,
 405                                 char patternLetter) {
 406     if ( patternLetter == 'M' ) {
 407         if ( (fieldWidth <= 2 && anotherFieldWidth > 2) ||
 408              (fieldWidth > 2 && anotherFieldWidth <= 2 )) {
 409             return true;
 410         }
 411     }
 412     return false;
 413 }
 414
 415
 416
 417 const UnicodeString*
 418 DateIntervalInfo::getBestSkeleton(const UnicodeString& skeleton,
 419                                   int8_t& bestMatchDistanceInfo) const {
 420 #ifdef DTITVINF_DEBUG
 421     char result[1000];
 422     char result_1[1000];
 423     char mesg[2000];
 424     skeleton.extract(0,  skeleton.length(), result, "UTF-8");
 425     sprintf(mesg, "in getBestSkeleton: skeleton: %s; \n", result);
 426     PRINTMESG(mesg)
 427 #endif
 428
 429
 430     int32_t inputSkeletonFieldWidth[] =
 431     {
 432     //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
 433              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 434     //   P   Q   R   S   T   U   V   W   X   Y   Z
 435          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
 436     //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
 437          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 438     //   p   q   r   s   t   u   v   w   x   y   z
 439          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
 440     };
 441
 442     int32_t skeletonFieldWidth[] =
 443     {
 444     //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
 445              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 446     //   P   Q   R   S   T   U   V   W   X   Y   Z
 447          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
 448     //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
 449          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 450     //   p   q   r   s   t   u   v   w   x   y   z
 451          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
 452     };
 453
 454     const int32_t DIFFERENT_FIELD = 0x1000;
 455     const int32_t STRING_NUMERIC_DIFFERENCE = 0x100;
 456     const int32_t BASE = 0x41;
 457     const UChar CHAR_V = 0x0076;
 458     const UChar CHAR_Z = 0x007A;
 459
 460     // hack for 'v' and 'z'.
 461     // resource bundle only have time skeletons ending with 'v',
 462     // but not for time skeletons ending with 'z'.
 463     UBool replaceZWithV = false;
 464     const UnicodeString* inputSkeleton = &skeleton;
 465     UnicodeString copySkeleton;
 466     if ( skeleton.indexOf(CHAR_Z) != -1 ) {
 467         copySkeleton = skeleton;
 468         copySkeleton.findAndReplace(UnicodeString(CHAR_Z), UnicodeString(CHAR_V));
 469         inputSkeleton = &copySkeleton;
 470         replaceZWithV = true;
 471     }
 472
 473     parseSkeleton(*inputSkeleton, inputSkeletonFieldWidth);
 474     int32_t bestDistance = MAX_POSITIVE_INT;
 475     const UnicodeString* bestSkeleton = NULL;
 476
 477     // 0 means exact the same skeletons;
 478     // 1 means having the same field, but with different length,
 479     // 2 means only z/v differs
 480     // -1 means having different field.
 481     bestMatchDistanceInfo = 0;
 482     int8_t fieldLength = sizeof(skeletonFieldWidth)/sizeof(skeletonFieldWidth[0]);
 483
 484     int32_t pos = -1;
 485     const UHashElement* elem = NULL;
 486     while ( (elem = fIntervalPatterns->nextElement(pos)) != NULL ) {
 487         const UHashTok keyTok = elem->key;
 488         UnicodeString* skeleton = (UnicodeString*)keyTok.pointer;
 489 #ifdef DTITVINF_DEBUG
 490     skeleton->extract(0,  skeleton->length(), result, "UTF-8");
 491     sprintf(mesg, "available skeletons: skeleton: %s; \n", result);
 492     PRINTMESG(mesg)
 493 #endif
 494
 495         // clear skeleton field width
 496         int8_t i;
 497         for ( i = 0; i < fieldLength; ++i ) {
 498             skeletonFieldWidth[i] = 0;
 499         }
 500         parseSkeleton(*skeleton, skeletonFieldWidth);
 501         // calculate distance
 502         int32_t distance = 0;
 503         int8_t fieldDifference = 1;
 504         for ( i = 0; i < fieldLength; ++i ) {
 505             int32_t inputFieldWidth = inputSkeletonFieldWidth[i];
 506             int32_t fieldWidth = skeletonFieldWidth[i];
 507             if ( inputFieldWidth == fieldWidth ) {
 508                 continue;
 509             }
 510             if ( inputFieldWidth == 0 ) {
 511                 fieldDifference = -1;
 512                 distance += DIFFERENT_FIELD;
 513             } else if ( fieldWidth == 0 ) {
 514                 fieldDifference = -1;
 515                 distance += DIFFERENT_FIELD;
 516             } else if (stringNumeric(inputFieldWidth, fieldWidth,
 517                                      (char)(i+BASE) ) ) {
 518                 distance += STRING_NUMERIC_DIFFERENCE;
 519             } else {
 520                 distance += (inputFieldWidth > fieldWidth) ?
 521                             (inputFieldWidth - fieldWidth) :
 522                             (fieldWidth - inputFieldWidth);
 523             }
 524         }
 525         if ( distance < bestDistance ) {
 526             bestSkeleton = skeleton;
 527             bestDistance = distance;
 528             bestMatchDistanceInfo = fieldDifference;
 529         }
 530         if ( distance == 0 ) {
 531             bestMatchDistanceInfo = 0;
 532             break;
 533         }
 534     }
 535     if ( replaceZWithV && bestMatchDistanceInfo != -1 ) {
 536         bestMatchDistanceInfo = 2;
 537     }
 538     return bestSkeleton;
 539 }
 540
 541
 542
 543 DateIntervalInfo::IntervalPatternIndex
 544 DateIntervalInfo::calendarFieldToIntervalIndex(UCalendarDateFields field,
 545                                                UErrorCode& status) {
 546     if ( U_FAILURE(status) ) {
 547         return kIPI_MAX_INDEX;
 548     }
 549     IntervalPatternIndex index = kIPI_MAX_INDEX;
 550     switch ( field ) {
 551       case UCAL_ERA:
 552         index = kIPI_ERA;
 553         break;
 554       case UCAL_YEAR:
 555         index = kIPI_YEAR;
 556         break;
 557       case UCAL_MONTH:
 558         index = kIPI_MONTH;
 559         break;
 560       case UCAL_DATE:
 561       case UCAL_DAY_OF_WEEK:
 562       //case UCAL_DAY_OF_MONTH:
 563         index = kIPI_DATE;
 564         break;
 565       case UCAL_AM_PM:
 566         index = kIPI_AM_PM;
 567         break;
 568       case UCAL_HOUR:
 569       case UCAL_HOUR_OF_DAY:
 570         index = kIPI_HOUR;
 571         break;
 572       case UCAL_MINUTE:
 573         index = kIPI_MINUTE;
 574         break;
 575       default:
 576         status = U_ILLEGAL_ARGUMENT_ERROR;
 577     }
 578     return index;
 579 }
 580
 581
 582
 583 void
 584 DateIntervalInfo::deleteHash(Hashtable* hTable)
 585 {
 586     if ( hTable == NULL ) {
 587         return;
 588     }
 589     int32_t pos = -1;
 590     const UHashElement* element = NULL;
 591     while ( (element = hTable->nextElement(pos)) != NULL ) {
 592         const UHashTok valueTok = element->value;
 593         const UnicodeString* value = (UnicodeString*)valueTok.pointer;
 594         delete[] value;
 595     }
 596     delete fIntervalPatterns;
 597 }
 598
 599
 600 U_CDECL_BEGIN
 601
 602 /**
 603  * set hash table value comparator
 604  *
 605  * @param val1  one value in comparison
 606  * @param val2  the other value in comparison
 607  * @return      TRUE if 2 values are the same, FALSE otherwise
 608  */
 609 static UBool U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2);
 610
 611 static UBool
 612 U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2) {
 613     const UnicodeString* pattern1 = (UnicodeString*)val1.pointer;
 614     const UnicodeString* pattern2 = (UnicodeString*)val2.pointer;
 615     UBool ret = TRUE;
 616     int8_t i;
 617     for ( i = 0; i < DateIntervalInfo::kMaxIntervalPatternIndex && ret == TRUE; ++i ) {
 618         ret = (pattern1[i] == pattern2[i]);
 619     }
 620     return ret;
 621 }
 622
 623 U_CDECL_END
 624
 625
 626 Hashtable*
 627 DateIntervalInfo::initHash(UErrorCode& status) {
 628     if ( U_FAILURE(status) ) {
 629         return NULL;
 630     }
 631     Hashtable* hTable;
 632     if ( (hTable = new Hashtable(FALSE, status)) == NULL ) {
 633         status = U_MEMORY_ALLOCATION_ERROR;
 634         return NULL;
 635     }
 636     if ( U_FAILURE(status) ) {
 637         delete hTable;
 638         return NULL;
 639     }
 640     hTable->setValueComparator(dtitvinfHashTableValueComparator);
 641     return hTable;
 642 }
 643
 644
 645 void
 646 DateIntervalInfo::copyHash(const Hashtable* source,
 647                            Hashtable* target,
 648                            UErrorCode& status) {
 649     if ( U_FAILURE(status) ) {
 650         return;
 651     }
 652     int32_t pos = -1;
 653     const UHashElement* element = NULL;
 654     if ( source ) {
 655         while ( (element = source->nextElement(pos)) != NULL ) {
 656             const UHashTok keyTok = element->key;
 657             const UnicodeString* key = (UnicodeString*)keyTok.pointer;
 658             const UHashTok valueTok = element->value;
 659             const UnicodeString* value = (UnicodeString*)valueTok.pointer;
 660             UnicodeString* copy = new UnicodeString[kIPI_MAX_INDEX];
 661             int8_t i;
 662             for ( i = 0; i < kIPI_MAX_INDEX; ++i ) {
 663                 copy[i] = value[i];
 664             }
 665             target->put(UnicodeString(*key), copy, status);
 666             if ( U_FAILURE(status) ) {
 667                 return;
 668             }
 669         }
 670     }
 671 }
 672
 673
 674 U_NAMESPACE_END
 675
 676 #endif