| /* |
| ******************************************************************************* |
| * Copyright (C) 2008-2014, Google, International Business Machines Corporation |
| * and others. All Rights Reserved. |
| ******************************************************************************* |
| */ |
| |
| #include "unicode/tmutfmt.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "starboard/client_porting/poem/assert_poem.h" |
| #include "starboard/client_porting/poem/string_poem.h" |
| #include "unicode/decimfmt.h" |
| #include "plurrule_impl.h" |
| #include "uvector.h" |
| #include "charstr.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include "hash.h" |
| #include "uresimp.h" |
| #include "ureslocs.h" |
| #include "unicode/msgfmt.h" |
| #include "uassert.h" |
| |
| #define LEFT_CURLY_BRACKET ((UChar)0x007B) |
| #define RIGHT_CURLY_BRACKET ((UChar)0x007D) |
| #define SPACE ((UChar)0x0020) |
| #define DIGIT_ZERO ((UChar)0x0030) |
| #define LOW_S ((UChar)0x0073) |
| #define LOW_M ((UChar)0x006D) |
| #define LOW_I ((UChar)0x0069) |
| #define LOW_N ((UChar)0x006E) |
| #define LOW_H ((UChar)0x0068) |
| #define LOW_W ((UChar)0x0077) |
| #define LOW_D ((UChar)0x0064) |
| #define LOW_Y ((UChar)0x0079) |
| #define LOW_Z ((UChar)0x007A) |
| #define LOW_E ((UChar)0x0065) |
| #define LOW_R ((UChar)0x0072) |
| #define LOW_O ((UChar)0x006F) |
| #define LOW_N ((UChar)0x006E) |
| #define LOW_T ((UChar)0x0074) |
| |
| |
| //TODO: define in compile time |
| //#define TMUTFMT_DEBUG 1 |
| |
| #ifdef TMUTFMT_DEBUG |
| #include <iostream> |
| #endif |
| |
| U_NAMESPACE_BEGIN |
| |
| |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeUnitFormat) |
| |
| static const char gUnitsTag[] = "units"; |
| static const char gShortUnitsTag[] = "unitsShort"; |
| static const char gTimeUnitYear[] = "year"; |
| static const char gTimeUnitMonth[] = "month"; |
| static const char gTimeUnitDay[] = "day"; |
| static const char gTimeUnitWeek[] = "week"; |
| static const char gTimeUnitHour[] = "hour"; |
| static const char gTimeUnitMinute[] = "minute"; |
| static const char gTimeUnitSecond[] = "second"; |
| static const char gPluralCountOther[] = "other"; |
| |
| static const UChar DEFAULT_PATTERN_FOR_SECOND[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_S, 0}; |
| static const UChar DEFAULT_PATTERN_FOR_MINUTE[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_M, LOW_I, LOW_N, 0}; |
| static const UChar DEFAULT_PATTERN_FOR_HOUR[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_H, 0}; |
| static const UChar DEFAULT_PATTERN_FOR_WEEK[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_W, 0}; |
| static const UChar DEFAULT_PATTERN_FOR_DAY[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_D, 0}; |
| static const UChar DEFAULT_PATTERN_FOR_MONTH[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_M, 0}; |
| static const UChar DEFAULT_PATTERN_FOR_YEAR[] = {LEFT_CURLY_BRACKET, DIGIT_ZERO, RIGHT_CURLY_BRACKET, SPACE, LOW_Y, 0}; |
| |
| static const UChar PLURAL_COUNT_ZERO[] = {LOW_Z, LOW_E, LOW_R, LOW_O, 0}; |
| static const UChar PLURAL_COUNT_ONE[] = {LOW_O, LOW_N, LOW_E, 0}; |
| static const UChar PLURAL_COUNT_TWO[] = {LOW_T, LOW_W, LOW_O, 0}; |
| |
| TimeUnitFormat::TimeUnitFormat(UErrorCode& status) { |
| initMeasureFormat(Locale::getDefault(), UMEASFMT_WIDTH_WIDE, NULL, status); |
| create(UTMUTFMT_FULL_STYLE, status); |
| } |
| |
| |
| TimeUnitFormat::TimeUnitFormat(const Locale& locale, UErrorCode& status) { |
| initMeasureFormat(locale, UMEASFMT_WIDTH_WIDE, NULL, status); |
| create(UTMUTFMT_FULL_STYLE, status); |
| } |
| |
| |
| TimeUnitFormat::TimeUnitFormat(const Locale& locale, UTimeUnitFormatStyle style, UErrorCode& status) { |
| switch (style) { |
| case UTMUTFMT_FULL_STYLE: |
| initMeasureFormat(locale, UMEASFMT_WIDTH_WIDE, NULL, status); |
| break; |
| case UTMUTFMT_ABBREVIATED_STYLE: |
| initMeasureFormat(locale, UMEASFMT_WIDTH_SHORT, NULL, status); |
| break; |
| default: |
| initMeasureFormat(locale, UMEASFMT_WIDTH_WIDE, NULL, status); |
| break; |
| } |
| create(style, status); |
| } |
| |
| TimeUnitFormat::TimeUnitFormat(const TimeUnitFormat& other) |
| : MeasureFormat(other), |
| fStyle(other.fStyle) |
| { |
| for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR; |
| i < TimeUnit::UTIMEUNIT_FIELD_COUNT; |
| i = (TimeUnit::UTimeUnitFields)(i+1)) { |
| UErrorCode status = U_ZERO_ERROR; |
| fTimeUnitToCountToPatterns[i] = initHash(status); |
| if (U_SUCCESS(status)) { |
| copyHash(other.fTimeUnitToCountToPatterns[i], fTimeUnitToCountToPatterns[i], status); |
| } else { |
| delete fTimeUnitToCountToPatterns[i]; |
| fTimeUnitToCountToPatterns[i] = NULL; |
| } |
| } |
| } |
| |
| |
| TimeUnitFormat::~TimeUnitFormat() { |
| for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR; |
| i < TimeUnit::UTIMEUNIT_FIELD_COUNT; |
| i = (TimeUnit::UTimeUnitFields)(i+1)) { |
| deleteHash(fTimeUnitToCountToPatterns[i]); |
| fTimeUnitToCountToPatterns[i] = NULL; |
| } |
| } |
| |
| |
| Format* |
| TimeUnitFormat::clone(void) const { |
| return new TimeUnitFormat(*this); |
| } |
| |
| |
| TimeUnitFormat& |
| TimeUnitFormat::operator=(const TimeUnitFormat& other) { |
| if (this == &other) { |
| return *this; |
| } |
| MeasureFormat::operator=(other); |
| for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR; |
| i < TimeUnit::UTIMEUNIT_FIELD_COUNT; |
| i = (TimeUnit::UTimeUnitFields)(i+1)) { |
| deleteHash(fTimeUnitToCountToPatterns[i]); |
| fTimeUnitToCountToPatterns[i] = NULL; |
| } |
| for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR; |
| i < TimeUnit::UTIMEUNIT_FIELD_COUNT; |
| i = (TimeUnit::UTimeUnitFields)(i+1)) { |
| UErrorCode status = U_ZERO_ERROR; |
| fTimeUnitToCountToPatterns[i] = initHash(status); |
| if (U_SUCCESS(status)) { |
| copyHash(other.fTimeUnitToCountToPatterns[i], fTimeUnitToCountToPatterns[i], status); |
| } else { |
| delete fTimeUnitToCountToPatterns[i]; |
| fTimeUnitToCountToPatterns[i] = NULL; |
| } |
| } |
| fStyle = other.fStyle; |
| return *this; |
| } |
| |
| void |
| TimeUnitFormat::parseObject(const UnicodeString& source, |
| Formattable& result, |
| ParsePosition& pos) const { |
| Formattable resultNumber(0.0); |
| UBool withNumberFormat = false; |
| TimeUnit::UTimeUnitFields resultTimeUnit = TimeUnit::UTIMEUNIT_FIELD_COUNT; |
| int32_t oldPos = pos.getIndex(); |
| int32_t newPos = -1; |
| int32_t longestParseDistance = 0; |
| UnicodeString* countOfLongestMatch = NULL; |
| #ifdef TMUTFMT_DEBUG |
| char res[1000]; |
| source.extract(0, source.length(), res, "UTF-8"); |
| std::cout << "parse source: " << res << "\n"; |
| #endif |
| // parse by iterating through all available patterns |
| // and looking for the longest match. |
| for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR; |
| i < TimeUnit::UTIMEUNIT_FIELD_COUNT; |
| i = (TimeUnit::UTimeUnitFields)(i+1)) { |
| Hashtable* countToPatterns = fTimeUnitToCountToPatterns[i]; |
| int32_t elemPos = UHASH_FIRST; |
| const UHashElement* elem = NULL; |
| while ((elem = countToPatterns->nextElement(elemPos)) != NULL){ |
| const UHashTok keyTok = elem->key; |
| UnicodeString* count = (UnicodeString*)keyTok.pointer; |
| #ifdef TMUTFMT_DEBUG |
| count->extract(0, count->length(), res, "UTF-8"); |
| std::cout << "parse plural count: " << res << "\n"; |
| #endif |
| const UHashTok valueTok = elem->value; |
| // the value is a pair of MessageFormat* |
| MessageFormat** patterns = (MessageFormat**)valueTok.pointer; |
| for (UTimeUnitFormatStyle style = UTMUTFMT_FULL_STYLE; style < UTMUTFMT_FORMAT_STYLE_COUNT; |
| style = (UTimeUnitFormatStyle)(style + 1)) { |
| MessageFormat* pattern = patterns[style]; |
| pos.setErrorIndex(-1); |
| pos.setIndex(oldPos); |
| // see if we can parse |
| Formattable parsed; |
| pattern->parseObject(source, parsed, pos); |
| if (pos.getErrorIndex() != -1 || pos.getIndex() == oldPos) { |
| continue; |
| } |
| #ifdef TMUTFMT_DEBUG |
| std::cout << "parsed.getType: " << parsed.getType() << "\n"; |
| #endif |
| Formattable tmpNumber(0.0); |
| if (pattern->getArgTypeCount() != 0) { |
| Formattable& temp = parsed[0]; |
| if (temp.getType() == Formattable::kString) { |
| UnicodeString tmpString; |
| UErrorCode pStatus = U_ZERO_ERROR; |
| getNumberFormat().parse(temp.getString(tmpString), tmpNumber, pStatus); |
| if (U_FAILURE(pStatus)) { |
| continue; |
| } |
| } else if (temp.isNumeric()) { |
| tmpNumber = temp; |
| } else { |
| continue; |
| } |
| } |
| int32_t parseDistance = pos.getIndex() - oldPos; |
| if (parseDistance > longestParseDistance) { |
| if (pattern->getArgTypeCount() != 0) { |
| resultNumber = tmpNumber; |
| withNumberFormat = true; |
| } else { |
| withNumberFormat = false; |
| } |
| resultTimeUnit = i; |
| newPos = pos.getIndex(); |
| longestParseDistance = parseDistance; |
| countOfLongestMatch = count; |
| } |
| } |
| } |
| } |
| /* After find the longest match, parse the number. |
| * Result number could be null for the pattern without number pattern. |
| * such as unit pattern in Arabic. |
| * When result number is null, use plural rule to set the number. |
| */ |
| if (withNumberFormat == false && longestParseDistance != 0) { |
| // set the number using plurrual count |
| if (0 == countOfLongestMatch->compare(PLURAL_COUNT_ZERO, 4)) { |
| resultNumber = Formattable(0.0); |
| } else if (0 == countOfLongestMatch->compare(PLURAL_COUNT_ONE, 3)) { |
| resultNumber = Formattable(1.0); |
| } else if (0 == countOfLongestMatch->compare(PLURAL_COUNT_TWO, 3)) { |
| resultNumber = Formattable(2.0); |
| } else { |
| // should not happen. |
| // TODO: how to handle? |
| resultNumber = Formattable(3.0); |
| } |
| } |
| if (longestParseDistance == 0) { |
| pos.setIndex(oldPos); |
| pos.setErrorIndex(0); |
| } else { |
| UErrorCode status = U_ZERO_ERROR; |
| TimeUnitAmount* tmutamt = new TimeUnitAmount(resultNumber, resultTimeUnit, status); |
| if (U_SUCCESS(status)) { |
| result.adoptObject(tmutamt); |
| pos.setIndex(newPos); |
| pos.setErrorIndex(-1); |
| } else { |
| pos.setIndex(oldPos); |
| pos.setErrorIndex(0); |
| } |
| } |
| } |
| |
| void |
| TimeUnitFormat::create(UTimeUnitFormatStyle style, UErrorCode& status) { |
| // fTimeUnitToCountToPatterns[] must have its elements initialized to NULL first |
| // before checking for failure status. |
| for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR; |
| i < TimeUnit::UTIMEUNIT_FIELD_COUNT; |
| i = (TimeUnit::UTimeUnitFields)(i+1)) { |
| fTimeUnitToCountToPatterns[i] = NULL; |
| } |
| |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if (style < UTMUTFMT_FULL_STYLE || style >= UTMUTFMT_FORMAT_STYLE_COUNT) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| fStyle = style; |
| |
| //TODO: format() and parseObj() are const member functions, |
| //so, can not do lazy initialization in C++. |
| //setup has to be done in constructors. |
| //and here, the behavior is not consistent with Java. |
| //In Java, create an empty instance does not setup locale as |
| //default locale. If it followed by setNumberFormat(), |
| //in format(), the locale will set up as the locale in fNumberFormat. |
| //But in C++, this sets the locale as the default locale. |
| setup(status); |
| } |
| |
| void |
| TimeUnitFormat::setup(UErrorCode& err) { |
| initDataMembers(err); |
| |
| UVector pluralCounts(0, uhash_compareUnicodeString, 6, err); |
| StringEnumeration* keywords = getPluralRules().getKeywords(err); |
| if (U_FAILURE(err)) { |
| return; |
| } |
| UnicodeString* pluralCount; |
| while ((pluralCount = const_cast<UnicodeString*>(keywords->snext(err))) != NULL) { |
| pluralCounts.addElement(pluralCount, err); |
| } |
| readFromCurrentLocale(UTMUTFMT_FULL_STYLE, gUnitsTag, pluralCounts, err); |
| checkConsistency(UTMUTFMT_FULL_STYLE, gUnitsTag, err); |
| readFromCurrentLocale(UTMUTFMT_ABBREVIATED_STYLE, gShortUnitsTag, pluralCounts, err); |
| checkConsistency(UTMUTFMT_ABBREVIATED_STYLE, gShortUnitsTag, err); |
| delete keywords; |
| } |
| |
| |
| void |
| TimeUnitFormat::initDataMembers(UErrorCode& err){ |
| if (U_FAILURE(err)) { |
| return; |
| } |
| for (TimeUnit::UTimeUnitFields i = TimeUnit::UTIMEUNIT_YEAR; |
| i < TimeUnit::UTIMEUNIT_FIELD_COUNT; |
| i = (TimeUnit::UTimeUnitFields)(i+1)) { |
| deleteHash(fTimeUnitToCountToPatterns[i]); |
| fTimeUnitToCountToPatterns[i] = NULL; |
| } |
| } |
| |
| void |
| TimeUnitFormat::readFromCurrentLocale(UTimeUnitFormatStyle style, const char* key, |
| const UVector& pluralCounts, UErrorCode& err) { |
| if (U_FAILURE(err)) { |
| return; |
| } |
| // fill timeUnitToCountToPatterns from resource file |
| // err is used to indicate wrong status except missing resource. |
| // status is an error code used in resource lookup. |
| // status does not affect "err". |
| UErrorCode status = U_ZERO_ERROR; |
| UResourceBundle *rb, *unitsRes; |
| rb = ures_open(U_ICUDATA_UNIT, getLocaleID(status), &status); |
| unitsRes = ures_getByKey(rb, key, NULL, &status); |
| unitsRes = ures_getByKey(unitsRes, "duration", unitsRes, &status); |
| if (U_FAILURE(status)) { |
| ures_close(unitsRes); |
| ures_close(rb); |
| return; |
| } |
| int32_t size = ures_getSize(unitsRes); |
| for ( int32_t index = 0; index < size; ++index) { |
| // resource of one time unit |
| UResourceBundle* oneTimeUnit = ures_getByIndex(unitsRes, index, |
| NULL, &status); |
| if (U_SUCCESS(status)) { |
| const char* timeUnitName = ures_getKey(oneTimeUnit); |
| if (timeUnitName == NULL) { |
| ures_close(oneTimeUnit); |
| continue; |
| } |
| UResourceBundle* countsToPatternRB = ures_getByKey(unitsRes, |
| timeUnitName, |
| NULL, &status); |
| if (countsToPatternRB == NULL || U_FAILURE(status)) { |
| ures_close(countsToPatternRB); |
| ures_close(oneTimeUnit); |
| continue; |
| } |
| TimeUnit::UTimeUnitFields timeUnitField = TimeUnit::UTIMEUNIT_FIELD_COUNT; |
| if ( uprv_strcmp(timeUnitName, gTimeUnitYear) == 0 ) { |
| timeUnitField = TimeUnit::UTIMEUNIT_YEAR; |
| } else if ( uprv_strcmp(timeUnitName, gTimeUnitMonth) == 0 ) { |
| timeUnitField = TimeUnit::UTIMEUNIT_MONTH; |
| } else if ( uprv_strcmp(timeUnitName, gTimeUnitDay) == 0 ) { |
| timeUnitField = TimeUnit::UTIMEUNIT_DAY; |
| } else if ( uprv_strcmp(timeUnitName, gTimeUnitHour) == 0 ) { |
| timeUnitField = TimeUnit::UTIMEUNIT_HOUR; |
| } else if ( uprv_strcmp(timeUnitName, gTimeUnitMinute) == 0 ) { |
| timeUnitField = TimeUnit::UTIMEUNIT_MINUTE; |
| } else if ( uprv_strcmp(timeUnitName, gTimeUnitSecond) == 0 ) { |
| timeUnitField = TimeUnit::UTIMEUNIT_SECOND; |
| } else if ( uprv_strcmp(timeUnitName, gTimeUnitWeek) == 0 ) { |
| timeUnitField = TimeUnit::UTIMEUNIT_WEEK; |
| } else { |
| ures_close(countsToPatternRB); |
| ures_close(oneTimeUnit); |
| continue; |
| } |
| Hashtable* countToPatterns = fTimeUnitToCountToPatterns[timeUnitField]; |
| if (countToPatterns == NULL) { |
| countToPatterns = initHash(err); |
| if (U_FAILURE(err)) { |
| ures_close(countsToPatternRB); |
| ures_close(oneTimeUnit); |
| delete countToPatterns; |
| break; |
| } |
| } |
| int32_t count = ures_getSize(countsToPatternRB); |
| const char* pluralCount; |
| for ( int32_t pluralIndex = 0; pluralIndex < count; ++pluralIndex) { |
| // resource of count to pattern |
| UnicodeString pattern = |
| ures_getNextUnicodeString(countsToPatternRB, &pluralCount, &status); |
| if (U_FAILURE(status)) { |
| continue; |
| } |
| UnicodeString pluralCountUniStr(pluralCount, -1, US_INV); |
| if (!pluralCounts.contains(&pluralCountUniStr)) { |
| continue; |
| } |
| MessageFormat* messageFormat = new MessageFormat(pattern, getLocale(err), err); |
| if ( U_SUCCESS(err) ) { |
| MessageFormat** formatters = (MessageFormat**)countToPatterns->get(pluralCountUniStr); |
| if (formatters == NULL) { |
| formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*)); |
| formatters[UTMUTFMT_FULL_STYLE] = NULL; |
| formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL; |
| countToPatterns->put(pluralCountUniStr, formatters, err); |
| if (U_FAILURE(err)) { |
| uprv_free(formatters); |
| } |
| } |
| if (U_SUCCESS(err)) { |
| //delete formatters[style]; |
| formatters[style] = messageFormat; |
| } |
| } |
| if (U_FAILURE(err)) { |
| ures_close(countsToPatternRB); |
| ures_close(oneTimeUnit); |
| ures_close(unitsRes); |
| ures_close(rb); |
| delete messageFormat; |
| delete countToPatterns; |
| return; |
| } |
| } |
| if (fTimeUnitToCountToPatterns[timeUnitField] == NULL) { |
| fTimeUnitToCountToPatterns[timeUnitField] = countToPatterns; |
| } |
| ures_close(countsToPatternRB); |
| } |
| ures_close(oneTimeUnit); |
| } |
| ures_close(unitsRes); |
| ures_close(rb); |
| } |
| |
| |
| void |
| TimeUnitFormat::checkConsistency(UTimeUnitFormatStyle style, const char* key, UErrorCode& err) { |
| if (U_FAILURE(err)) { |
| return; |
| } |
| // there should be patterns for each plural rule in each time unit. |
| // For each time unit, |
| // for each plural rule, following is unit pattern fall-back rule: |
| // ( for example: "one" hour ) |
| // look for its unit pattern in its locale tree. |
| // if pattern is not found in its own locale, such as de_DE, |
| // look for the pattern in its parent, such as de, |
| // keep looking till found or till root. |
| // if the pattern is not found in root either, |
| // fallback to plural count "other", |
| // look for the pattern of "other" in the locale tree: |
| // "de_DE" to "de" to "root". |
| // If not found, fall back to value of |
| // static variable DEFAULT_PATTERN_FOR_xxx, such as "{0} h". |
| // |
| // Following is consistency check to create pattern for each |
| // plural rule in each time unit using above fall-back rule. |
| // |
| StringEnumeration* keywords = getPluralRules().getKeywords(err); |
| if (U_SUCCESS(err)) { |
| const UnicodeString* pluralCount; |
| while ((pluralCount = keywords->snext(err)) != NULL) { |
| if ( U_SUCCESS(err) ) { |
| for (int32_t i = 0; i < TimeUnit::UTIMEUNIT_FIELD_COUNT; ++i) { |
| // for each time unit, |
| // get all the patterns for each plural rule in this locale. |
| Hashtable* countToPatterns = fTimeUnitToCountToPatterns[i]; |
| if ( countToPatterns == NULL ) { |
| countToPatterns = initHash(err); |
| if (U_FAILURE(err)) { |
| delete countToPatterns; |
| return; |
| } |
| fTimeUnitToCountToPatterns[i] = countToPatterns; |
| } |
| MessageFormat** formatters = (MessageFormat**)countToPatterns->get(*pluralCount); |
| if( formatters == NULL || formatters[style] == NULL ) { |
| // look through parents |
| const char* localeName = getLocaleID(err); |
| CharString pluralCountChars; |
| pluralCountChars.appendInvariantChars(*pluralCount, err); |
| searchInLocaleChain(style, key, localeName, |
| (TimeUnit::UTimeUnitFields)i, |
| *pluralCount, pluralCountChars.data(), |
| countToPatterns, err); |
| } |
| } |
| } |
| } |
| } |
| delete keywords; |
| } |
| |
| |
| |
| // srcPluralCount is the original plural count on which the pattern is |
| // searched for. |
| // searchPluralCount is the fallback plural count. |
| // For example, to search for pattern for ""one" hour", |
| // "one" is the srcPluralCount, |
| // if the pattern is not found even in root, fallback to |
| // using patterns of plural count "other", |
| // then, "other" is the searchPluralCount. |
| void |
| TimeUnitFormat::searchInLocaleChain(UTimeUnitFormatStyle style, const char* key, const char* localeName, |
| TimeUnit::UTimeUnitFields srcTimeUnitField, |
| const UnicodeString& srcPluralCount, |
| const char* searchPluralCount, |
| Hashtable* countToPatterns, |
| UErrorCode& err) { |
| if (U_FAILURE(err)) { |
| return; |
| } |
| UErrorCode status = U_ZERO_ERROR; |
| char parentLocale[ULOC_FULLNAME_CAPACITY]; |
| uprv_strcpy(parentLocale, localeName); |
| int32_t locNameLen; |
| U_ASSERT(countToPatterns != NULL); |
| while ((locNameLen = uloc_getParent(parentLocale, parentLocale, |
| ULOC_FULLNAME_CAPACITY, &status)) >= 0){ |
| // look for pattern for srcPluralCount in locale tree |
| UResourceBundle *rb, *unitsRes, *countsToPatternRB; |
| rb = ures_open(U_ICUDATA_UNIT, parentLocale, &status); |
| unitsRes = ures_getByKey(rb, key, NULL, &status); |
| const char* timeUnitName = getTimeUnitName(srcTimeUnitField, status); |
| countsToPatternRB = ures_getByKey(unitsRes, timeUnitName, NULL, &status); |
| const UChar* pattern; |
| int32_t ptLength; |
| pattern = ures_getStringByKeyWithFallback(countsToPatternRB, searchPluralCount, &ptLength, &status); |
| if (U_SUCCESS(status)) { |
| //found |
| MessageFormat* messageFormat = new MessageFormat(UnicodeString(TRUE, pattern, ptLength), getLocale(err), err); |
| if (U_SUCCESS(err)) { |
| MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount); |
| if (formatters == NULL) { |
| formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*)); |
| formatters[UTMUTFMT_FULL_STYLE] = NULL; |
| formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL; |
| countToPatterns->put(srcPluralCount, formatters, err); |
| if (U_FAILURE(err)) { |
| uprv_free(formatters); |
| delete messageFormat; |
| } |
| } |
| if (U_SUCCESS(err)) { |
| //delete formatters[style]; |
| formatters[style] = messageFormat; |
| } |
| } else { |
| delete messageFormat; |
| } |
| ures_close(countsToPatternRB); |
| ures_close(unitsRes); |
| ures_close(rb); |
| return; |
| } |
| ures_close(countsToPatternRB); |
| ures_close(unitsRes); |
| ures_close(rb); |
| status = U_ZERO_ERROR; |
| if ( locNameLen ==0 ) { |
| break; |
| } |
| } |
| |
| // if no unitsShort resource was found even after fallback to root locale |
| // then search the units resource fallback from the current level to root |
| if ( locNameLen == 0 && uprv_strcmp(key, gShortUnitsTag) == 0) { |
| #ifdef TMUTFMT_DEBUG |
| std::cout << "loop into searchInLocaleChain since Short-Long-Alternative \n"; |
| #endif |
| char pLocale[ULOC_FULLNAME_CAPACITY]; |
| uprv_strcpy(pLocale, localeName); |
| // Add an underscore at the tail of locale name, |
| // so that searchInLocaleChain will check the current locale before falling back |
| uprv_strcat(pLocale, "_"); |
| searchInLocaleChain(style, gUnitsTag, pLocale, srcTimeUnitField, srcPluralCount, |
| searchPluralCount, countToPatterns, err); |
| MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount); |
| if (formatters != NULL && formatters[style] != NULL) { |
| return; |
| } |
| } |
| |
| // if not found the pattern for this plural count at all, |
| // fall-back to plural count "other" |
| if ( uprv_strcmp(searchPluralCount, gPluralCountOther) == 0 ) { |
| // set default fall back the same as the resource in root |
| MessageFormat* messageFormat = NULL; |
| const UChar *pattern = NULL; |
| if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_SECOND ) { |
| pattern = DEFAULT_PATTERN_FOR_SECOND; |
| } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_MINUTE ) { |
| pattern = DEFAULT_PATTERN_FOR_MINUTE; |
| } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_HOUR ) { |
| pattern = DEFAULT_PATTERN_FOR_HOUR; |
| } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_WEEK ) { |
| pattern = DEFAULT_PATTERN_FOR_WEEK; |
| } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_DAY ) { |
| pattern = DEFAULT_PATTERN_FOR_DAY; |
| } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_MONTH ) { |
| pattern = DEFAULT_PATTERN_FOR_MONTH; |
| } else if ( srcTimeUnitField == TimeUnit::UTIMEUNIT_YEAR ) { |
| pattern = DEFAULT_PATTERN_FOR_YEAR; |
| } |
| if (pattern != NULL) { |
| messageFormat = new MessageFormat(UnicodeString(TRUE, pattern, -1), getLocale(err), err); |
| } |
| if (U_SUCCESS(err)) { |
| MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount); |
| if (formatters == NULL) { |
| formatters = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*)); |
| formatters[UTMUTFMT_FULL_STYLE] = NULL; |
| formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL; |
| countToPatterns->put(srcPluralCount, formatters, err); |
| if (U_FAILURE(err)) { |
| uprv_free(formatters); |
| delete messageFormat; |
| } |
| } |
| if (U_SUCCESS(err)) { |
| //delete formatters[style]; |
| formatters[style] = messageFormat; |
| } |
| } else { |
| delete messageFormat; |
| } |
| } else { |
| // fall back to rule "other", and search in parents |
| searchInLocaleChain(style, key, localeName, srcTimeUnitField, srcPluralCount, |
| gPluralCountOther, countToPatterns, err); |
| } |
| } |
| |
| void |
| TimeUnitFormat::setLocale(const Locale& locale, UErrorCode& status) { |
| if (setMeasureFormatLocale(locale, status)) { |
| setup(status); |
| } |
| } |
| |
| |
| void |
| TimeUnitFormat::setNumberFormat(const NumberFormat& format, UErrorCode& status){ |
| if (U_FAILURE(status)) { |
| return; |
| } |
| adoptNumberFormat((NumberFormat *)format.clone(), status); |
| } |
| |
| |
| void |
| TimeUnitFormat::deleteHash(Hashtable* htable) { |
| int32_t pos = UHASH_FIRST; |
| const UHashElement* element = NULL; |
| if ( htable ) { |
| while ( (element = htable->nextElement(pos)) != NULL ) { |
| const UHashTok valueTok = element->value; |
| const MessageFormat** value = (const MessageFormat**)valueTok.pointer; |
| delete value[UTMUTFMT_FULL_STYLE]; |
| delete value[UTMUTFMT_ABBREVIATED_STYLE]; |
| //delete[] value; |
| uprv_free(value); |
| } |
| } |
| delete htable; |
| } |
| |
| |
| void |
| TimeUnitFormat::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 MessageFormat** value = (const MessageFormat**)valueTok.pointer; |
| MessageFormat** newVal = (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*)); |
| newVal[0] = (MessageFormat*)value[0]->clone(); |
| newVal[1] = (MessageFormat*)value[1]->clone(); |
| target->put(UnicodeString(*key), newVal, status); |
| if ( U_FAILURE(status) ) { |
| delete newVal[0]; |
| delete newVal[1]; |
| uprv_free(newVal); |
| return; |
| } |
| } |
| } |
| } |
| |
| |
| 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 tmutfmtHashTableValueComparator(UHashTok val1, UHashTok val2); |
| |
| static UBool |
| U_CALLCONV tmutfmtHashTableValueComparator(UHashTok val1, UHashTok val2) { |
| const MessageFormat** pattern1 = (const MessageFormat**)val1.pointer; |
| const MessageFormat** pattern2 = (const MessageFormat**)val2.pointer; |
| return *pattern1[0] == *pattern2[0] && *pattern1[1] == *pattern2[1]; |
| } |
| |
| U_CDECL_END |
| |
| Hashtable* |
| TimeUnitFormat::initHash(UErrorCode& status) { |
| if ( U_FAILURE(status) ) { |
| return NULL; |
| } |
| Hashtable* hTable; |
| if ( (hTable = new Hashtable(TRUE, status)) == NULL ) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| if ( U_FAILURE(status) ) { |
| delete hTable; |
| return NULL; |
| } |
| hTable->setValueComparator(tmutfmtHashTableValueComparator); |
| return hTable; |
| } |
| |
| |
| const char* |
| TimeUnitFormat::getTimeUnitName(TimeUnit::UTimeUnitFields unitField, |
| UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| switch (unitField) { |
| case TimeUnit::UTIMEUNIT_YEAR: |
| return gTimeUnitYear; |
| case TimeUnit::UTIMEUNIT_MONTH: |
| return gTimeUnitMonth; |
| case TimeUnit::UTIMEUNIT_DAY: |
| return gTimeUnitDay; |
| case TimeUnit::UTIMEUNIT_WEEK: |
| return gTimeUnitWeek; |
| case TimeUnit::UTIMEUNIT_HOUR: |
| return gTimeUnitHour; |
| case TimeUnit::UTIMEUNIT_MINUTE: |
| return gTimeUnitMinute; |
| case TimeUnit::UTIMEUNIT_SECOND: |
| return gTimeUnitSecond; |
| default: |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| } |
| |
| U_NAMESPACE_END |
| |
| #endif |
