diff options
Diffstat (limited to 'intl/icu/source/i18n/tmutfmt.cpp')
| -rw-r--r-- | intl/icu/source/i18n/tmutfmt.cpp | 806 |
1 files changed, 806 insertions, 0 deletions
diff --git a/intl/icu/source/i18n/tmutfmt.cpp b/intl/icu/source/i18n/tmutfmt.cpp new file mode 100644 index 000000000..1669546f7 --- /dev/null +++ b/intl/icu/source/i18n/tmutfmt.cpp @@ -0,0 +1,806 @@ +// Copyright (C) 2016 and later: Unicode, Inc. and others. +// License & terms of use: http://www.unicode.org/copyright.html +/* + ******************************************************************************* + * Copyright (C) 2008-2015, Google, International Business Machines Corporation + * and others. All Rights Reserved. + ******************************************************************************* + */ + +#include "unicode/tmutfmt.h" + +#if !UCONFIG_NO_FORMATTING + +#include "unicode/decimfmt.h" +#include "unicode/localpointer.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; + LocalPointer<TimeUnitAmount> tmutamt(new TimeUnitAmount(resultNumber, resultTimeUnit, status), status); + if (U_SUCCESS(status)) { + result.adoptObject(tmutamt.orphan()); + 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); + LocalPointer<StringEnumeration> keywords(getPluralRules().getKeywords(err), 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); +} + + +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; + } +} + +struct TimeUnitFormatReadSink : public ResourceSink { + TimeUnitFormat *timeUnitFormatObj; + const UVector &pluralCounts; + UTimeUnitFormatStyle style; + UBool beenHere; + + TimeUnitFormatReadSink(TimeUnitFormat *timeUnitFormatObj, + const UVector &pluralCounts, UTimeUnitFormatStyle style) : + timeUnitFormatObj(timeUnitFormatObj), pluralCounts(pluralCounts), + style(style), beenHere(FALSE){} + + virtual ~TimeUnitFormatReadSink(); + + virtual void put(const char *key, ResourceValue &value, UBool, UErrorCode &errorCode) { + // Skip all put() calls except the first one -- discard all fallback data. + if (beenHere) { + return; + } else { + beenHere = TRUE; + } + + ResourceTable units = value.getTable(errorCode); + if (U_FAILURE(errorCode)) { return; } + + for (int32_t i = 0; units.getKeyAndValue(i, key, value); ++i) { + const char* timeUnitName = key; + if (timeUnitName == NULL) { + 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 { + continue; + } + LocalPointer<Hashtable> localCountToPatterns; + Hashtable *countToPatterns = + timeUnitFormatObj->fTimeUnitToCountToPatterns[timeUnitField]; + if (countToPatterns == NULL) { + localCountToPatterns.adoptInsteadAndCheckErrorCode( + timeUnitFormatObj->initHash(errorCode), errorCode); + countToPatterns = localCountToPatterns.getAlias(); + if (U_FAILURE(errorCode)) { + return; + } + } + + ResourceTable countsToPatternTable = value.getTable(errorCode); + if (U_FAILURE(errorCode)) { + continue; + } + for (int32_t j = 0; countsToPatternTable.getKeyAndValue(j, key, value); ++j) { + errorCode = U_ZERO_ERROR; + UnicodeString pattern = value.getUnicodeString(errorCode); + if (U_FAILURE(errorCode)) { + continue; + } + UnicodeString pluralCountUniStr(key, -1, US_INV); + if (!pluralCounts.contains(&pluralCountUniStr)) { + continue; + } + LocalPointer<MessageFormat> messageFormat(new MessageFormat( + pattern, timeUnitFormatObj->getLocale(errorCode), errorCode), errorCode); + if (U_FAILURE(errorCode)) { + return; + } + MessageFormat** formatters = + (MessageFormat**)countToPatterns->get(pluralCountUniStr); + if (formatters == NULL) { + LocalMemory<MessageFormat *> localFormatters( + (MessageFormat **)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*))); + if (localFormatters.isNull()) { + errorCode = U_MEMORY_ALLOCATION_ERROR; + return; + } + localFormatters[UTMUTFMT_FULL_STYLE] = NULL; + localFormatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL; + countToPatterns->put(pluralCountUniStr, localFormatters.getAlias(), errorCode); + if (U_FAILURE(errorCode)) { + return; + } + formatters = localFormatters.orphan(); + } + formatters[style] = messageFormat.orphan(); + } + + if (timeUnitFormatObj->fTimeUnitToCountToPatterns[timeUnitField] == NULL) { + timeUnitFormatObj->fTimeUnitToCountToPatterns[timeUnitField] = localCountToPatterns.orphan(); + } + } + } + +}; + +TimeUnitFormatReadSink::~TimeUnitFormatReadSink() {} + +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; + LocalUResourceBundlePointer rb(ures_open(U_ICUDATA_UNIT, getLocaleID(status), &status)); + + LocalUResourceBundlePointer unitsRes(ures_getByKey(rb.getAlias(), key, NULL, &status)); + ures_getByKey(unitsRes.getAlias(), "duration", unitsRes.getAlias(), &status); + if (U_FAILURE(status)) { + return; + } + + TimeUnitFormatReadSink sink(this, pluralCounts, style); + ures_getAllItemsWithFallback(unitsRes.getAlias(), "", sink, status); +} + +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. + // + LocalPointer<StringEnumeration> keywords( + getPluralRules().getKeywords(err), err); + const UnicodeString* pluralCount; + while (U_SUCCESS(err) && (pluralCount = keywords->snext(err)) != NULL) { + 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 ) { + fTimeUnitToCountToPatterns[i] = countToPatterns = initHash(err); + if (U_FAILURE(err)) { + return; + } + } + 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); + } + // TODO: what to do with U_FAILURE(err) at this point. + // As is, the outer loop continues to run, but does nothing. + } + } +} + + + +// 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 + LocalUResourceBundlePointer rb(ures_open(U_ICUDATA_UNIT, parentLocale, &status)); + LocalUResourceBundlePointer unitsRes(ures_getByKey(rb.getAlias(), key, NULL, &status)); + const char* timeUnitName = getTimeUnitName(srcTimeUnitField, status); + LocalUResourceBundlePointer countsToPatternRB(ures_getByKey(unitsRes.getAlias(), timeUnitName, NULL, &status)); + const UChar* pattern; + int32_t ptLength; + pattern = ures_getStringByKeyWithFallback(countsToPatternRB.getAlias(), searchPluralCount, &ptLength, &status); + if (U_SUCCESS(status)) { + //found + LocalPointer<MessageFormat> messageFormat( + new MessageFormat(UnicodeString(TRUE, pattern, ptLength), getLocale(err), err), err); + if (U_FAILURE(err)) { + return; + } + MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount); + if (formatters == NULL) { + LocalMemory<MessageFormat *> localFormatters( + (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*))); + formatters = localFormatters.getAlias(); + localFormatters[UTMUTFMT_FULL_STYLE] = NULL; + localFormatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL; + countToPatterns->put(srcPluralCount, localFormatters.orphan(), err); + if (U_FAILURE(err)) { + return; + } + } + //delete formatters[style]; + formatters[style] = messageFormat.orphan(); + return; + } + 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 + CharString pLocale(localeName, -1, err); + // Add an underscore at the tail of locale name, + // so that searchInLocaleChain will check the current locale before falling back + pLocale.append('_', err); + searchInLocaleChain(style, gUnitsTag, pLocale.data(), srcTimeUnitField, srcPluralCount, + searchPluralCount, countToPatterns, err); + if (U_FAILURE(err)) { + return; + } + 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 + LocalPointer<MessageFormat> messageFormat; + 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.adoptInsteadAndCheckErrorCode( + new MessageFormat(UnicodeString(TRUE, pattern, -1), getLocale(err), err), err); + } + if (U_FAILURE(err)) { + return; + } + MessageFormat** formatters = (MessageFormat**)countToPatterns->get(srcPluralCount); + if (formatters == NULL) { + LocalMemory<MessageFormat *> localFormatters ( + (MessageFormat**)uprv_malloc(UTMUTFMT_FORMAT_STYLE_COUNT*sizeof(MessageFormat*))); + if (localFormatters.isNull()) { + err = U_MEMORY_ALLOCATION_ERROR; + return; + } + formatters = localFormatters.getAlias(); + formatters[UTMUTFMT_FULL_STYLE] = NULL; + formatters[UTMUTFMT_ABBREVIATED_STYLE] = NULL; + countToPatterns->put(srcPluralCount, localFormatters.orphan(), err); + } + if (U_SUCCESS(err)) { + //delete formatters[style]; + formatters[style] = messageFormat.orphan(); + } + } 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 |