ICU 56 update step 1

source/i18n/dtitvinf.cpp

 /*******************************************************************************
-* Copyright (C) 2008-2012, International Business Machines Corporation and
+* Copyright (C) 2008-2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 *******************************************************************************
 *
 * File DTITVINF.CPP 
 *
 *******************************************************************************
 */
 
 #include "unicode/dtitvinf.h"
 
@@ skipping 203 matching lines @@
 DateIntervalInfo::initializeData(const Locale& locale, UErrorCode& err)
 {
   fIntervalPatterns = initHash(err);
   if ( U_FAILURE(err) ) {
       return;
   }
   const char *locName = locale.getName();
   char parentLocale[ULOC_FULLNAME_CAPACITY];
   uprv_strcpy(parentLocale, locName);
   UErrorCode status = U_ZERO_ERROR;
-  Hashtable skeletonSet(FALSE, status);
+  Hashtable skeletonKeyPairs(FALSE, status);
   if ( U_FAILURE(status) ) {
       return;
   }
 
   // determine calendar type
   const char * calendarTypeToUse = gGregorianTag; // initial default
   char         calendarType[ULOC_KEYWORDS_CAPACITY]; // to be filled in with the type to use, if all goes well
   char         localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY];
   // obtain a locale that always has the calendar key value that should be used
   (void)ures_getFunctionalEquivalent(localeWithCalendarKey, ULOC_LOCALE_IDENTIFIER_CAPACITY, NULL,
@@ skipping 33 matching lines @@
         int32_t index;
         for ( index = 0; index < size; ++index ) {
             LocalUResourceBundlePointer oneRes(ures_getByIndex(itvDtPtnResource, index, 
                                                      NULL, &status));
             if ( U_SUCCESS(status) ) {
                 const char* skeleton = ures_getKey(oneRes.getAlias());
                 if (skeleton == NULL) {
                     continue;
                 }
                 UnicodeString skeletonUniStr(skeleton, -1, US_INV);
-                if ( skeletonSet.geti(skeletonUniStr) == 1 ) {
-                    continue;
-                }
-                skeletonSet.puti(skeletonUniStr, 1, status);
                 if ( uprv_strcmp(skeleton, gFallbackPatternTag) == 0 ) {
                     continue;  // fallback
                 }
 
                 LocalUResourceBundlePointer intervalPatterns(ures_getByKey(
                                      itvDtPtnResource, skeleton, NULL, &status));
 
                 if ( U_FAILURE(status) ) {
                     break;
                 }
                 if ( intervalPatterns == NULL ) {
                     continue;
                 }
 
                 const char* key;
                 int32_t ptnNum = ures_getSize(intervalPatterns.getAlias());
                 int32_t ptnIndex;
                 for ( ptnIndex = 0; ptnIndex < ptnNum; ++ptnIndex ) {
                     UnicodeString pattern =
                         ures_getNextUnicodeString(intervalPatterns.getAlias(), &key, &status);
                     if ( U_FAILURE(status) ) {
                         break;
                     }
+                    UnicodeString keyUniStr(key, -1, US_INV);
+                    UnicodeString skeletonKeyPair(skeletonUniStr + keyUniStr);
+                    if ( skeletonKeyPairs.geti(skeletonKeyPair) == 1 ) {
+                        continue;
+                    }
+                    skeletonKeyPairs.puti(skeletonKeyPair, 1, status);
         
                     UCalendarDateFields calendarField = UCAL_FIELD_COUNT;
                     if ( !uprv_strcmp(key, "y") ) {
                         calendarField = UCAL_YEAR;
                     } else if ( !uprv_strcmp(key, "M") ) {
                         calendarField = UCAL_MONTH;
                     } else if ( !uprv_strcmp(key, "d") ) {
                         calendarField = UCAL_DATE;
                     } else if ( !uprv_strcmp(key, "a") ) {
                         calendarField = UCAL_AM_PM;
@@ skipping 157 matching lines @@
     int32_t bestDistance = MAX_POSITIVE_INT;
     const UnicodeString* bestSkeleton = NULL;
 
     // 0 means exact the same skeletons;
     // 1 means having the same field, but with different length,
     // 2 means only z/v differs
     // -1 means having different field.
     bestMatchDistanceInfo = 0;
     int8_t fieldLength = sizeof(skeletonFieldWidth)/sizeof(skeletonFieldWidth[0]);
 
-    int32_t pos = -1;
+    int32_t pos = UHASH_FIRST;
     const UHashElement* elem = NULL;
     while ( (elem = fIntervalPatterns->nextElement(pos)) != NULL ) {
         const UHashTok keyTok = elem->key;
         UnicodeString* skeleton = (UnicodeString*)keyTok.pointer;
 #ifdef DTITVINF_DEBUG
     skeleton->extract(0,  skeleton->length(), result, "UTF-8");
     sprintf(mesg, "available skeletons: skeleton: %s; \n", result);
     PRINTMESG(mesg)
 #endif
 
@@ skipping 70 matching lines @@
       case UCAL_AM_PM:
         index = kIPI_AM_PM;
         break;
       case UCAL_HOUR:
       case UCAL_HOUR_OF_DAY:
         index = kIPI_HOUR;
         break;
       case UCAL_MINUTE:
         index = kIPI_MINUTE;
         break;
+      case UCAL_SECOND:
+        index = kIPI_SECOND;
+        break;
       default:
         status = U_ILLEGAL_ARGUMENT_ERROR;
     }
     return index;
 }
 
 
 
 void
 DateIntervalInfo::deleteHash(Hashtable* hTable) 
 {
     if ( hTable == NULL ) {
         return;
     }
-    int32_t pos = -1;
+    int32_t pos = UHASH_FIRST;
     const UHashElement* element = NULL;
     while ( (element = hTable->nextElement(pos)) != NULL ) {
         const UHashTok valueTok = element->value;
         const UnicodeString* value = (UnicodeString*)valueTok.pointer;
         delete[] value;
     }
     delete fIntervalPatterns;
 }
 
 
@@ skipping 42 matching lines @@
 }
 
 
 void
 DateIntervalInfo::copyHash(const Hashtable* source,
                            Hashtable* target,
                            UErrorCode& status) {
     if ( U_FAILURE(status) ) {
         return;
     }
-    int32_t pos = -1;
+    int32_t pos = UHASH_FIRST;
     const UHashElement* element = NULL;
     if ( source ) {
         while ( (element = source->nextElement(pos)) != NULL ) {
             const UHashTok keyTok = element->key;
             const UnicodeString* key = (UnicodeString*)keyTok.pointer;
             const UHashTok valueTok = element->value;
             const UnicodeString* value = (UnicodeString*)valueTok.pointer;
             UnicodeString* copy = new UnicodeString[kIPI_MAX_INDEX];
             int8_t i;
             for ( i = 0; i < kIPI_MAX_INDEX; ++i ) {
                 copy[i] = value[i];
             }
             target->put(UnicodeString(*key), copy, status);
             if ( U_FAILURE(status) ) {
                 return;
             }
         }
     }
 }
 
 
 U_NAMESPACE_END
 
 #endif