icuSources/i18n/dtitvinf.cpp

   1 /*******************************************************************************
   2 * Copyright (C) 2008-2015, 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 skeletonKeyPairs(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 ( uprv_strcmp(skeleton, gFallbackPatternTag) == 0 ) {
 281                     continue;  // fallback
 282                 }
 283
 284                 LocalUResourceBundlePointer intervalPatterns(ures_getByKey(
 285                                      itvDtPtnResource, skeleton, NULL, &status));
 286
 287                 if ( U_FAILURE(status) ) {
 288                     break;
 289                 }
 290                 if ( intervalPatterns == NULL ) {
 291                     continue;
 292                 }
 293
 294                 const char* key;
 295                 int32_t ptnNum = ures_getSize(intervalPatterns.getAlias());
 296                 int32_t ptnIndex;
 297                 for ( ptnIndex = 0; ptnIndex < ptnNum; ++ptnIndex ) {
 298                     UnicodeString pattern =
 299                         ures_getNextUnicodeString(intervalPatterns.getAlias(), &key, &status);
 300                     if ( U_FAILURE(status) ) {
 301                         break;
 302                     }
 303                     UnicodeString keyUniStr(key, -1, US_INV);
 304                     UnicodeString skeletonKeyPair(skeletonUniStr + keyUniStr);
 305                     if ( skeletonKeyPairs.geti(skeletonKeyPair) == 1 ) {
 306                         continue;
 307                     }
 308                     skeletonKeyPairs.puti(skeletonKeyPair, 1, status);
 309
 310                     UCalendarDateFields calendarField = UCAL_FIELD_COUNT;
 311                     if ( !uprv_strcmp(key, "y") ) {
 312                         calendarField = UCAL_YEAR;
 313                     } else if ( !uprv_strcmp(key, "M") ) {
 314                         calendarField = UCAL_MONTH;
 315                     } else if ( !uprv_strcmp(key, "d") ) {
 316                         calendarField = UCAL_DATE;
 317                     } else if ( !uprv_strcmp(key, "a") ) {
 318                         calendarField = UCAL_AM_PM;
 319                     } else if ( !uprv_strcmp(key, "h") || !uprv_strcmp(key, "H") ) {
 320                         calendarField = UCAL_HOUR;
 321                     } else if ( !uprv_strcmp(key, "m") ) {
 322                         calendarField = UCAL_MINUTE;
 323                     }
 324                     if ( calendarField != UCAL_FIELD_COUNT ) {
 325                         setIntervalPatternInternally(skeletonUniStr, calendarField, pattern,status);
 326                     }
 327                 }
 328             }
 329         }
 330     }
 331     ures_close(itvDtPtnResource);
 332     ures_close(calTypeBundle);
 333     ures_close(calBundle);
 334
 335     status = U_ZERO_ERROR;
 336     // Find the name of the appropriate parent locale (from %%Parent if present, else
 337     // uloc_getParent on the actual locale name)
 338     // (It would be nice to have a ures function that did this...)
 339     int32_t locNameLen;
 340     const UChar * parentUName = ures_getStringByKey(rb, "%%Parent", &locNameLen, &status);
 341     if (U_SUCCESS(status) && status != U_USING_FALLBACK_WARNING && locNameLen < ULOC_FULLNAME_CAPACITY) {
 342         u_UCharsToChars(parentUName, parentLocale, locNameLen + 1);
 343     } else {
 344         status = U_ZERO_ERROR;
 345         // Get the actual name of the current locale being used
 346         const char *curLocaleName=ures_getLocaleByType(rb, ULOC_ACTUAL_LOCALE, &status);
 347         if ( U_FAILURE(status) ) {
 348             curLocaleName = parentLocale;
 349             status = U_ZERO_ERROR;
 350         }
 351         uloc_getParent(curLocaleName, parentLocale, ULOC_FULLNAME_CAPACITY, &status);
 352         if (U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) {
 353             parentLocale[0] = 0; // just fallback to root, will cause us to stop
 354             status = U_ZERO_ERROR;
 355         }
 356     }
 357     // Now we can close the current locale bundle
 358     ures_close(rb);
 359     // If the new current locale is root, then stop
 360     // (unlike for DateTimePatternGenerator, DateIntervalFormat does not go all the way up
 361     // to root to find additional data for non-root locales)
 362   } while ( parentLocale[0] != 0 && uprv_strcmp(parentLocale,"root")!=0 );
 363 }
 364
 365
 366
 367 void
 368 DateIntervalInfo::setIntervalPatternInternally(const UnicodeString& skeleton,
 369                                       UCalendarDateFields lrgDiffCalUnit,
 370                                       const UnicodeString& intervalPattern,
 371                                       UErrorCode& status) {
 372     IntervalPatternIndex index = calendarFieldToIntervalIndex(lrgDiffCalUnit,status);
 373     if ( U_FAILURE(status) ) {
 374         return;
 375     }
 376     UnicodeString* patternsOfOneSkeleton = (UnicodeString*)(fIntervalPatterns->get(skeleton));
 377     UBool emptyHash = false;
 378     if ( patternsOfOneSkeleton == NULL ) {
 379         patternsOfOneSkeleton = new UnicodeString[kIPI_MAX_INDEX];
 380         emptyHash = true;
 381     }
 382
 383     patternsOfOneSkeleton[index] = intervalPattern;
 384     if ( emptyHash == TRUE ) {
 385         fIntervalPatterns->put(skeleton, patternsOfOneSkeleton, status);
 386     }
 387 }
 388
 389
 390
 391 void
 392 DateIntervalInfo::parseSkeleton(const UnicodeString& skeleton,
 393                                 int32_t* skeletonFieldWidth) {
 394     const int8_t PATTERN_CHAR_BASE = 0x41;
 395     int32_t i;
 396     for ( i = 0; i < skeleton.length(); ++i ) {
 397         // it is an ASCII char in skeleton
 398         int8_t ch = (int8_t)skeleton.charAt(i);
 399         ++skeletonFieldWidth[ch - PATTERN_CHAR_BASE];
 400     }
 401 }
 402
 403
 404
 405 UBool
 406 DateIntervalInfo::stringNumeric(int32_t fieldWidth, int32_t anotherFieldWidth,
 407                                 char patternLetter) {
 408     if ( patternLetter == 'M' ) {
 409         if ( (fieldWidth <= 2 && anotherFieldWidth > 2) ||
 410              (fieldWidth > 2 && anotherFieldWidth <= 2 )) {
 411             return true;
 412         }
 413     }
 414     return false;
 415 }
 416
 417
 418
 419 const UnicodeString*
 420 DateIntervalInfo::getBestSkeleton(const UnicodeString& skeleton,
 421                                   int8_t& bestMatchDistanceInfo) const {
 422 #ifdef DTITVINF_DEBUG
 423     char result[1000];
 424     char result_1[1000];
 425     char mesg[2000];
 426     skeleton.extract(0,  skeleton.length(), result, "UTF-8");
 427     sprintf(mesg, "in getBestSkeleton: skeleton: %s; \n", result);
 428     PRINTMESG(mesg)
 429 #endif
 430
 431
 432     int32_t inputSkeletonFieldWidth[] =
 433     {
 434     //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
 435              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 436     //   P   Q   R   S   T   U   V   W   X   Y   Z
 437          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
 438     //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
 439          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 440     //   p   q   r   s   t   u   v   w   x   y   z
 441          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
 442     };
 443
 444     int32_t skeletonFieldWidth[] =
 445     {
 446     //       A   B   C   D   E   F   G   H   I   J   K   L   M   N   O
 447              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 448     //   P   Q   R   S   T   U   V   W   X   Y   Z
 449          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0,  0, 0, 0,
 450     //       a   b   c   d   e   f   g   h   i   j   k   l   m   n   o
 451          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 452     //   p   q   r   s   t   u   v   w   x   y   z
 453          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
 454     };
 455
 456     const int32_t DIFFERENT_FIELD = 0x1000;
 457     const int32_t STRING_NUMERIC_DIFFERENCE = 0x100;
 458     const int32_t BASE = 0x41;
 459     const UChar CHAR_V = 0x0076;
 460     const UChar CHAR_Z = 0x007A;
 461
 462     // hack for 'v' and 'z'.
 463     // resource bundle only have time skeletons ending with 'v',
 464     // but not for time skeletons ending with 'z'.
 465     UBool replaceZWithV = false;
 466     const UnicodeString* inputSkeleton = &skeleton;
 467     UnicodeString copySkeleton;
 468     if ( skeleton.indexOf(CHAR_Z) != -1 ) {
 469         copySkeleton = skeleton;
 470         copySkeleton.findAndReplace(UnicodeString(CHAR_Z), UnicodeString(CHAR_V));
 471         inputSkeleton = &copySkeleton;
 472         replaceZWithV = true;
 473     }
 474
 475     parseSkeleton(*inputSkeleton, inputSkeletonFieldWidth);
 476     int32_t bestDistance = MAX_POSITIVE_INT;
 477     const UnicodeString* bestSkeleton = NULL;
 478
 479     // 0 means exact the same skeletons;
 480     // 1 means having the same field, but with different length,
 481     // 2 means only z/v differs
 482     // -1 means having different field.
 483     bestMatchDistanceInfo = 0;
 484     int8_t fieldLength = sizeof(skeletonFieldWidth)/sizeof(skeletonFieldWidth[0]);
 485
 486     int32_t pos = UHASH_FIRST;
 487     const UHashElement* elem = NULL;
 488     while ( (elem = fIntervalPatterns->nextElement(pos)) != NULL ) {
 489         const UHashTok keyTok = elem->key;
 490         UnicodeString* skeleton = (UnicodeString*)keyTok.pointer;
 491 #ifdef DTITVINF_DEBUG
 492     skeleton->extract(0,  skeleton->length(), result, "UTF-8");
 493     sprintf(mesg, "available skeletons: skeleton: %s; \n", result);
 494     PRINTMESG(mesg)
 495 #endif
 496
 497         // clear skeleton field width
 498         int8_t i;
 499         for ( i = 0; i < fieldLength; ++i ) {
 500             skeletonFieldWidth[i] = 0;
 501         }
 502         parseSkeleton(*skeleton, skeletonFieldWidth);
 503         // calculate distance
 504         int32_t distance = 0;
 505         int8_t fieldDifference = 1;
 506         for ( i = 0; i < fieldLength; ++i ) {
 507             int32_t inputFieldWidth = inputSkeletonFieldWidth[i];
 508             int32_t fieldWidth = skeletonFieldWidth[i];
 509             if ( inputFieldWidth == fieldWidth ) {
 510                 continue;
 511             }
 512             if ( inputFieldWidth == 0 ) {
 513                 fieldDifference = -1;
 514                 distance += DIFFERENT_FIELD;
 515             } else if ( fieldWidth == 0 ) {
 516                 fieldDifference = -1;
 517                 distance += DIFFERENT_FIELD;
 518             } else if (stringNumeric(inputFieldWidth, fieldWidth,
 519                                      (char)(i+BASE) ) ) {
 520                 distance += STRING_NUMERIC_DIFFERENCE;
 521             } else {
 522                 distance += (inputFieldWidth > fieldWidth) ?
 523                             (inputFieldWidth - fieldWidth) :
 524                             (fieldWidth - inputFieldWidth);
 525             }
 526         }
 527         if ( distance < bestDistance ) {
 528             bestSkeleton = skeleton;
 529             bestDistance = distance;
 530             bestMatchDistanceInfo = fieldDifference;
 531         }
 532         if ( distance == 0 ) {
 533             bestMatchDistanceInfo = 0;
 534             break;
 535         }
 536     }
 537     if ( replaceZWithV && bestMatchDistanceInfo != -1 ) {
 538         bestMatchDistanceInfo = 2;
 539     }
 540     return bestSkeleton;
 541 }
 542
 543
 544
 545 DateIntervalInfo::IntervalPatternIndex
 546 DateIntervalInfo::calendarFieldToIntervalIndex(UCalendarDateFields field,
 547                                                UErrorCode& status) {
 548     if ( U_FAILURE(status) ) {
 549         return kIPI_MAX_INDEX;
 550     }
 551     IntervalPatternIndex index = kIPI_MAX_INDEX;
 552     switch ( field ) {
 553       case UCAL_ERA:
 554         index = kIPI_ERA;
 555         break;
 556       case UCAL_YEAR:
 557         index = kIPI_YEAR;
 558         break;
 559       case UCAL_MONTH:
 560         index = kIPI_MONTH;
 561         break;
 562       case UCAL_DATE:
 563       case UCAL_DAY_OF_WEEK:
 564       //case UCAL_DAY_OF_MONTH:
 565         index = kIPI_DATE;
 566         break;
 567       case UCAL_AM_PM:
 568         index = kIPI_AM_PM;
 569         break;
 570       case UCAL_HOUR:
 571       case UCAL_HOUR_OF_DAY:
 572         index = kIPI_HOUR;
 573         break;
 574       case UCAL_MINUTE:
 575         index = kIPI_MINUTE;
 576         break;
 577       case UCAL_SECOND:
 578         index = kIPI_SECOND;
 579         break;
 580       default:
 581         status = U_ILLEGAL_ARGUMENT_ERROR;
 582     }
 583     return index;
 584 }
 585
 586
 587
 588 void
 589 DateIntervalInfo::deleteHash(Hashtable* hTable)
 590 {
 591     if ( hTable == NULL ) {
 592         return;
 593     }
 594     int32_t pos = UHASH_FIRST;
 595     const UHashElement* element = NULL;
 596     while ( (element = hTable->nextElement(pos)) != NULL ) {
 597         const UHashTok valueTok = element->value;
 598         const UnicodeString* value = (UnicodeString*)valueTok.pointer;
 599         delete[] value;
 600     }
 601     delete fIntervalPatterns;
 602 }
 603
 604
 605 U_CDECL_BEGIN
 606
 607 /**
 608  * set hash table value comparator
 609  *
 610  * @param val1  one value in comparison
 611  * @param val2  the other value in comparison
 612  * @return      TRUE if 2 values are the same, FALSE otherwise
 613  */
 614 static UBool U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2);
 615
 616 static UBool
 617 U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2) {
 618     const UnicodeString* pattern1 = (UnicodeString*)val1.pointer;
 619     const UnicodeString* pattern2 = (UnicodeString*)val2.pointer;
 620     UBool ret = TRUE;
 621     int8_t i;
 622     for ( i = 0; i < DateIntervalInfo::kMaxIntervalPatternIndex && ret == TRUE; ++i ) {
 623         ret = (pattern1[i] == pattern2[i]);
 624     }
 625     return ret;
 626 }
 627
 628 U_CDECL_END
 629
 630
 631 Hashtable*
 632 DateIntervalInfo::initHash(UErrorCode& status) {
 633     if ( U_FAILURE(status) ) {
 634         return NULL;
 635     }
 636     Hashtable* hTable;
 637     if ( (hTable = new Hashtable(FALSE, status)) == NULL ) {
 638         status = U_MEMORY_ALLOCATION_ERROR;
 639         return NULL;
 640     }
 641     if ( U_FAILURE(status) ) {
 642         delete hTable;
 643         return NULL;
 644     }
 645     hTable->setValueComparator(dtitvinfHashTableValueComparator);
 646     return hTable;
 647 }
 648
 649
 650 void
 651 DateIntervalInfo::copyHash(const Hashtable* source,
 652                            Hashtable* target,
 653                            UErrorCode& status) {
 654     if ( U_FAILURE(status) ) {
 655         return;
 656     }
 657     int32_t pos = UHASH_FIRST;
 658     const UHashElement* element = NULL;
 659     if ( source ) {
 660         while ( (element = source->nextElement(pos)) != NULL ) {
 661             const UHashTok keyTok = element->key;
 662             const UnicodeString* key = (UnicodeString*)keyTok.pointer;
 663             const UHashTok valueTok = element->value;
 664             const UnicodeString* value = (UnicodeString*)valueTok.pointer;
 665             UnicodeString* copy = new UnicodeString[kIPI_MAX_INDEX];
 666             int8_t i;
 667             for ( i = 0; i < kIPI_MAX_INDEX; ++i ) {
 668                 copy[i] = value[i];
 669             }
 670             target->put(UnicodeString(*key), copy, status);
 671             if ( U_FAILURE(status) ) {
 672                 return;
 673             }
 674         }
 675     }
 676 }
 677
 678
 679 U_NAMESPACE_END
 680
 681 #endif