| /******************************************************************************* | |
| * Copyright (C) 2008-2015, International Business Machines Corporation and | |
| * others. All Rights Reserved. | |
| ******************************************************************************* | |
| * | |
| * File DTITVINF.CPP | |
| * | |
| ******************************************************************************* | |
| */ | |
| #include "unicode/dtitvinf.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| //TODO: define it in compiler time | |
| //#define DTITVINF_DEBUG 1 | |
| #ifdef DTITVINF_DEBUG | |
| #include <iostream> | |
| #endif | |
| #include "cstring.h" | |
| #include "unicode/msgfmt.h" | |
| #include "unicode/uloc.h" | |
| #include "unicode/ures.h" | |
| #include "dtitv_impl.h" | |
| #include "hash.h" | |
| #include "gregoimp.h" | |
| #include "uresimp.h" | |
| #include "hash.h" | |
| #include "gregoimp.h" | |
| #include "uresimp.h" | |
| U_NAMESPACE_BEGIN | |
| #ifdef DTITVINF_DEBUG | |
| #define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; } | |
| #endif | |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalInfo) | |
| static const char gCalendarTag[]="calendar"; | |
| static const char gGregorianTag[]="gregorian"; | |
| static const char gIntervalDateTimePatternTag[]="intervalFormats"; | |
| static const char gFallbackPatternTag[]="fallback"; | |
| // {0} | |
| static const UChar gFirstPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET}; | |
| // {1} | |
| static const UChar gSecondPattern[] = {LEFT_CURLY_BRACKET, DIGIT_ONE, RIGHT_CURLY_BRACKET}; | |
| // default fall-back | |
| 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}; | |
| DateIntervalInfo::DateIntervalInfo(UErrorCode& status) | |
| : fFallbackIntervalPattern(gDefaultFallbackPattern), | |
| fFirstDateInPtnIsLaterDate(false), | |
| fIntervalPatterns(NULL) | |
| { | |
| fIntervalPatterns = initHash(status); | |
| } | |
| DateIntervalInfo::DateIntervalInfo(const Locale& locale, UErrorCode& status) | |
| : fFallbackIntervalPattern(gDefaultFallbackPattern), | |
| fFirstDateInPtnIsLaterDate(false), | |
| fIntervalPatterns(NULL) | |
| { | |
| initializeData(locale, status); | |
| } | |
| void | |
| DateIntervalInfo::setIntervalPattern(const UnicodeString& skeleton, | |
| UCalendarDateFields lrgDiffCalUnit, | |
| const UnicodeString& intervalPattern, | |
| UErrorCode& status) { | |
| if ( lrgDiffCalUnit == UCAL_HOUR_OF_DAY ) { | |
| setIntervalPatternInternally(skeleton, UCAL_AM_PM, intervalPattern, status); | |
| setIntervalPatternInternally(skeleton, UCAL_HOUR, intervalPattern, status); | |
| } else if ( lrgDiffCalUnit == UCAL_DAY_OF_MONTH || | |
| lrgDiffCalUnit == UCAL_DAY_OF_WEEK ) { | |
| setIntervalPatternInternally(skeleton, UCAL_DATE, intervalPattern, status); | |
| } else { | |
| setIntervalPatternInternally(skeleton, lrgDiffCalUnit, intervalPattern, status); | |
| } | |
| } | |
| void | |
| DateIntervalInfo::setFallbackIntervalPattern( | |
| const UnicodeString& fallbackPattern, | |
| UErrorCode& status) { | |
| if ( U_FAILURE(status) ) { | |
| return; | |
| } | |
| int32_t firstPatternIndex = fallbackPattern.indexOf(gFirstPattern, | |
| sizeof(gFirstPattern)/sizeof(gFirstPattern[0]), 0); | |
| int32_t secondPatternIndex = fallbackPattern.indexOf(gSecondPattern, | |
| sizeof(gSecondPattern)/sizeof(gSecondPattern[0]), 0); | |
| if ( firstPatternIndex == -1 || secondPatternIndex == -1 ) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| if ( firstPatternIndex > secondPatternIndex ) { | |
| fFirstDateInPtnIsLaterDate = true; | |
| } | |
| fFallbackIntervalPattern = fallbackPattern; | |
| } | |
| DateIntervalInfo::DateIntervalInfo(const DateIntervalInfo& dtitvinf) | |
| : UObject(dtitvinf), | |
| fIntervalPatterns(NULL) | |
| { | |
| *this = dtitvinf; | |
| } | |
| DateIntervalInfo& | |
| DateIntervalInfo::operator=(const DateIntervalInfo& dtitvinf) { | |
| if ( this == &dtitvinf ) { | |
| return *this; | |
| } | |
| UErrorCode status = U_ZERO_ERROR; | |
| deleteHash(fIntervalPatterns); | |
| fIntervalPatterns = initHash(status); | |
| copyHash(dtitvinf.fIntervalPatterns, fIntervalPatterns, status); | |
| if ( U_FAILURE(status) ) { | |
| return *this; | |
| } | |
| fFallbackIntervalPattern = dtitvinf.fFallbackIntervalPattern; | |
| fFirstDateInPtnIsLaterDate = dtitvinf.fFirstDateInPtnIsLaterDate; | |
| return *this; | |
| } | |
| DateIntervalInfo* | |
| DateIntervalInfo::clone() const { | |
| return new DateIntervalInfo(*this); | |
| } | |
| DateIntervalInfo::~DateIntervalInfo() { | |
| deleteHash(fIntervalPatterns); | |
| fIntervalPatterns = NULL; | |
| } | |
| UBool | |
| DateIntervalInfo::operator==(const DateIntervalInfo& other) const { | |
| UBool equal = ( | |
| fFallbackIntervalPattern == other.fFallbackIntervalPattern && | |
| fFirstDateInPtnIsLaterDate == other.fFirstDateInPtnIsLaterDate ); | |
| if ( equal == TRUE ) { | |
| equal = fIntervalPatterns->equals(*(other.fIntervalPatterns)); | |
| } | |
| return equal; | |
| } | |
| UnicodeString& | |
| DateIntervalInfo::getIntervalPattern(const UnicodeString& skeleton, | |
| UCalendarDateFields field, | |
| UnicodeString& result, | |
| UErrorCode& status) const { | |
| if ( U_FAILURE(status) ) { | |
| return result; | |
| } | |
| const UnicodeString* patternsOfOneSkeleton = (UnicodeString*) fIntervalPatterns->get(skeleton); | |
| if ( patternsOfOneSkeleton != NULL ) { | |
| IntervalPatternIndex index = calendarFieldToIntervalIndex(field, status); | |
| if ( U_FAILURE(status) ) { | |
| return result; | |
| } | |
| const UnicodeString& intervalPattern = patternsOfOneSkeleton[index]; | |
| if ( !intervalPattern.isEmpty() ) { | |
| result = intervalPattern; | |
| } | |
| } | |
| return result; | |
| } | |
| UBool | |
| DateIntervalInfo::getDefaultOrder() const { | |
| return fFirstDateInPtnIsLaterDate; | |
| } | |
| UnicodeString& | |
| DateIntervalInfo::getFallbackIntervalPattern(UnicodeString& result) const { | |
| result = fFallbackIntervalPattern; | |
| return result; | |
| } | |
| #define ULOC_LOCALE_IDENTIFIER_CAPACITY (ULOC_FULLNAME_CAPACITY + 1 + ULOC_KEYWORD_AND_VALUES_CAPACITY) | |
| void | |
| 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 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, | |
| "calendar", "calendar", locName, NULL, FALSE, &status); | |
| localeWithCalendarKey[ULOC_LOCALE_IDENTIFIER_CAPACITY-1] = 0; // ensure null termination | |
| // now get the calendar key value from that locale | |
| int32_t calendarTypeLen = uloc_getKeywordValue(localeWithCalendarKey, "calendar", calendarType, ULOC_KEYWORDS_CAPACITY, &status); | |
| if (U_SUCCESS(status) && calendarTypeLen < ULOC_KEYWORDS_CAPACITY) { | |
| calendarTypeToUse = calendarType; | |
| } | |
| status = U_ZERO_ERROR; | |
| do { | |
| UResourceBundle *rb, *calBundle, *calTypeBundle, *itvDtPtnResource; | |
| rb = ures_open(NULL, parentLocale, &status); | |
| if ( U_FAILURE(status) ) { | |
| break; | |
| } | |
| calBundle = ures_getByKey(rb, gCalendarTag, NULL, &status); | |
| calTypeBundle = ures_getByKey(calBundle, calendarTypeToUse, NULL, &status); | |
| itvDtPtnResource = ures_getByKeyWithFallback(calTypeBundle, | |
| gIntervalDateTimePatternTag, NULL, &status); | |
| if ( U_SUCCESS(status) ) { | |
| // look for fallback first, since it establishes the default order | |
| const UChar* resStr; | |
| int32_t resStrLen = 0; | |
| resStr = ures_getStringByKeyWithFallback(itvDtPtnResource, | |
| gFallbackPatternTag, | |
| &resStrLen, &status); | |
| if ( U_SUCCESS(status) ) { | |
| UnicodeString pattern = UnicodeString(TRUE, resStr, resStrLen); | |
| setFallbackIntervalPattern(pattern, status); | |
| } | |
| int32_t size = ures_getSize(itvDtPtnResource); | |
| 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 ( 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; | |
| } else if ( !uprv_strcmp(key, "h") || !uprv_strcmp(key, "H") ) { | |
| calendarField = UCAL_HOUR; | |
| } else if ( !uprv_strcmp(key, "m") ) { | |
| calendarField = UCAL_MINUTE; | |
| } | |
| if ( calendarField != UCAL_FIELD_COUNT ) { | |
| setIntervalPatternInternally(skeletonUniStr, calendarField, pattern,status); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| ures_close(itvDtPtnResource); | |
| ures_close(calTypeBundle); | |
| ures_close(calBundle); | |
| status = U_ZERO_ERROR; | |
| // Find the name of the appropriate parent locale (from %%Parent if present, else | |
| // uloc_getParent on the actual locale name) | |
| // (It would be nice to have a ures function that did this...) | |
| int32_t locNameLen; | |
| const UChar * parentUName = ures_getStringByKey(rb, "%%Parent", &locNameLen, &status); | |
| if (U_SUCCESS(status) && status != U_USING_FALLBACK_WARNING && locNameLen < ULOC_FULLNAME_CAPACITY) { | |
| u_UCharsToChars(parentUName, parentLocale, locNameLen + 1); | |
| } else { | |
| status = U_ZERO_ERROR; | |
| // Get the actual name of the current locale being used | |
| const char *curLocaleName=ures_getLocaleByType(rb, ULOC_ACTUAL_LOCALE, &status); | |
| if ( U_FAILURE(status) ) { | |
| curLocaleName = parentLocale; | |
| status = U_ZERO_ERROR; | |
| } | |
| uloc_getParent(curLocaleName, parentLocale, ULOC_FULLNAME_CAPACITY, &status); | |
| if (U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) { | |
| parentLocale[0] = 0; // just fallback to root, will cause us to stop | |
| status = U_ZERO_ERROR; | |
| } | |
| } | |
| // Now we can close the current locale bundle | |
| ures_close(rb); | |
| // If the new current locale is root, then stop | |
| // (unlike for DateTimePatternGenerator, DateIntervalFormat does not go all the way up | |
| // to root to find additional data for non-root locales) | |
| } while ( parentLocale[0] != 0 && uprv_strcmp(parentLocale,"root")!=0 ); | |
| } | |
| void | |
| DateIntervalInfo::setIntervalPatternInternally(const UnicodeString& skeleton, | |
| UCalendarDateFields lrgDiffCalUnit, | |
| const UnicodeString& intervalPattern, | |
| UErrorCode& status) { | |
| IntervalPatternIndex index = calendarFieldToIntervalIndex(lrgDiffCalUnit,status); | |
| if ( U_FAILURE(status) ) { | |
| return; | |
| } | |
| UnicodeString* patternsOfOneSkeleton = (UnicodeString*)(fIntervalPatterns->get(skeleton)); | |
| UBool emptyHash = false; | |
| if ( patternsOfOneSkeleton == NULL ) { | |
| patternsOfOneSkeleton = new UnicodeString[kIPI_MAX_INDEX]; | |
| emptyHash = true; | |
| } | |
| patternsOfOneSkeleton[index] = intervalPattern; | |
| if ( emptyHash == TRUE ) { | |
| fIntervalPatterns->put(skeleton, patternsOfOneSkeleton, status); | |
| } | |
| } | |
| void | |
| DateIntervalInfo::parseSkeleton(const UnicodeString& skeleton, | |
| int32_t* skeletonFieldWidth) { | |
| const int8_t PATTERN_CHAR_BASE = 0x41; | |
| int32_t i; | |
| for ( i = 0; i < skeleton.length(); ++i ) { | |
| // it is an ASCII char in skeleton | |
| int8_t ch = (int8_t)skeleton.charAt(i); | |
| ++skeletonFieldWidth[ch - PATTERN_CHAR_BASE]; | |
| } | |
| } | |
| UBool | |
| DateIntervalInfo::stringNumeric(int32_t fieldWidth, int32_t anotherFieldWidth, | |
| char patternLetter) { | |
| if ( patternLetter == 'M' ) { | |
| if ( (fieldWidth <= 2 && anotherFieldWidth > 2) || | |
| (fieldWidth > 2 && anotherFieldWidth <= 2 )) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| const UnicodeString* | |
| DateIntervalInfo::getBestSkeleton(const UnicodeString& skeleton, | |
| int8_t& bestMatchDistanceInfo) const { | |
| #ifdef DTITVINF_DEBUG | |
| char result[1000]; | |
| char result_1[1000]; | |
| char mesg[2000]; | |
| skeleton.extract(0, skeleton.length(), result, "UTF-8"); | |
| sprintf(mesg, "in getBestSkeleton: skeleton: %s; \n", result); | |
| PRINTMESG(mesg) | |
| #endif | |
| int32_t inputSkeletonFieldWidth[] = | |
| { | |
| // A B C D E F G H I J K L M N O | |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| // P Q R S T U V W X Y Z | |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| // a b c d e f g h i j k l m n o | |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| // p q r s t u v w x y z | |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 | |
| }; | |
| int32_t skeletonFieldWidth[] = | |
| { | |
| // A B C D E F G H I J K L M N O | |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| // P Q R S T U V W X Y Z | |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| // a b c d e f g h i j k l m n o | |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | |
| // p q r s t u v w x y z | |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 | |
| }; | |
| const int32_t DIFFERENT_FIELD = 0x1000; | |
| const int32_t STRING_NUMERIC_DIFFERENCE = 0x100; | |
| const int32_t BASE = 0x41; | |
| const UChar CHAR_V = 0x0076; | |
| const UChar CHAR_Z = 0x007A; | |
| // hack for 'v' and 'z'. | |
| // resource bundle only have time skeletons ending with 'v', | |
| // but not for time skeletons ending with 'z'. | |
| UBool replaceZWithV = false; | |
| const UnicodeString* inputSkeleton = &skeleton; | |
| UnicodeString copySkeleton; | |
| if ( skeleton.indexOf(CHAR_Z) != -1 ) { | |
| copySkeleton = skeleton; | |
| copySkeleton.findAndReplace(UnicodeString(CHAR_Z), UnicodeString(CHAR_V)); | |
| inputSkeleton = ©Skeleton; | |
| replaceZWithV = true; | |
| } | |
| parseSkeleton(*inputSkeleton, inputSkeletonFieldWidth); | |
| 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 = 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 | |
| // clear skeleton field width | |
| int8_t i; | |
| for ( i = 0; i < fieldLength; ++i ) { | |
| skeletonFieldWidth[i] = 0; | |
| } | |
| parseSkeleton(*skeleton, skeletonFieldWidth); | |
| // calculate distance | |
| int32_t distance = 0; | |
| int8_t fieldDifference = 1; | |
| for ( i = 0; i < fieldLength; ++i ) { | |
| int32_t inputFieldWidth = inputSkeletonFieldWidth[i]; | |
| int32_t fieldWidth = skeletonFieldWidth[i]; | |
| if ( inputFieldWidth == fieldWidth ) { | |
| continue; | |
| } | |
| if ( inputFieldWidth == 0 ) { | |
| fieldDifference = -1; | |
| distance += DIFFERENT_FIELD; | |
| } else if ( fieldWidth == 0 ) { | |
| fieldDifference = -1; | |
| distance += DIFFERENT_FIELD; | |
| } else if (stringNumeric(inputFieldWidth, fieldWidth, | |
| (char)(i+BASE) ) ) { | |
| distance += STRING_NUMERIC_DIFFERENCE; | |
| } else { | |
| distance += (inputFieldWidth > fieldWidth) ? | |
| (inputFieldWidth - fieldWidth) : | |
| (fieldWidth - inputFieldWidth); | |
| } | |
| } | |
| if ( distance < bestDistance ) { | |
| bestSkeleton = skeleton; | |
| bestDistance = distance; | |
| bestMatchDistanceInfo = fieldDifference; | |
| } | |
| if ( distance == 0 ) { | |
| bestMatchDistanceInfo = 0; | |
| break; | |
| } | |
| } | |
| if ( replaceZWithV && bestMatchDistanceInfo != -1 ) { | |
| bestMatchDistanceInfo = 2; | |
| } | |
| return bestSkeleton; | |
| } | |
| DateIntervalInfo::IntervalPatternIndex | |
| DateIntervalInfo::calendarFieldToIntervalIndex(UCalendarDateFields field, | |
| UErrorCode& status) { | |
| if ( U_FAILURE(status) ) { | |
| return kIPI_MAX_INDEX; | |
| } | |
| IntervalPatternIndex index = kIPI_MAX_INDEX; | |
| switch ( field ) { | |
| case UCAL_ERA: | |
| index = kIPI_ERA; | |
| break; | |
| case UCAL_YEAR: | |
| index = kIPI_YEAR; | |
| break; | |
| case UCAL_MONTH: | |
| index = kIPI_MONTH; | |
| break; | |
| case UCAL_DATE: | |
| case UCAL_DAY_OF_WEEK: | |
| //case UCAL_DAY_OF_MONTH: | |
| index = kIPI_DATE; | |
| break; | |
| 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 = 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; | |
| } | |
| U_CDECL_BEGIN | |
| /** | |
| * set hash table value comparator | |
| * | |
| * @param val1 one value in comparison | |
| * @param val2 the other value in comparison | |
| * @return TRUE if 2 values are the same, FALSE otherwise | |
| */ | |
| static UBool U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2); | |
| static UBool | |
| U_CALLCONV dtitvinfHashTableValueComparator(UHashTok val1, UHashTok val2) { | |
| const UnicodeString* pattern1 = (UnicodeString*)val1.pointer; | |
| const UnicodeString* pattern2 = (UnicodeString*)val2.pointer; | |
| UBool ret = TRUE; | |
| int8_t i; | |
| for ( i = 0; i < DateIntervalInfo::kMaxIntervalPatternIndex && ret == TRUE; ++i ) { | |
| ret = (pattern1[i] == pattern2[i]); | |
| } | |
| return ret; | |
| } | |
| U_CDECL_END | |
| Hashtable* | |
| DateIntervalInfo::initHash(UErrorCode& status) { | |
| if ( U_FAILURE(status) ) { | |
| return NULL; | |
| } | |
| Hashtable* hTable; | |
| if ( (hTable = new Hashtable(FALSE, status)) == NULL ) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return NULL; | |
| } | |
| if ( U_FAILURE(status) ) { | |
| delete hTable; | |
| return NULL; | |
| } | |
| hTable->setValueComparator(dtitvinfHashTableValueComparator); | |
| return hTable; | |
| } | |
| void | |
| DateIntervalInfo::copyHash(const Hashtable* source, | |
| Hashtable* target, | |
| UErrorCode& status) { | |
| if ( U_FAILURE(status) ) { | |
| return; | |
| } | |
| 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 |