| /* |
| ****************************************************************************** |
| * Copyright (C) 2014-2015, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ****************************************************************************** |
| * |
| * File reldatefmt.cpp |
| ****************************************************************************** |
| */ |
| |
| #include "unicode/reldatefmt.h" |
| |
| #if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_BREAK_ITERATION |
| |
| #include "unicode/localpointer.h" |
| #include "quantityformatter.h" |
| #include "unicode/plurrule.h" |
| #include "unicode/msgfmt.h" |
| #include "unicode/decimfmt.h" |
| #include "unicode/numfmt.h" |
| #include "unicode/brkiter.h" |
| #include "uresimp.h" |
| #include "unicode/ures.h" |
| #include "cstring.h" |
| #include "ucln_in.h" |
| #include "mutex.h" |
| #include "charstr.h" |
| #include "uassert.h" |
| |
| #include "sharedbreakiterator.h" |
| #include "sharedpluralrules.h" |
| #include "sharednumberformat.h" |
| #include "unifiedcache.h" |
| |
| // Copied from uscript_props.cpp |
| |
| static UMutex gBrkIterMutex = U_MUTEX_INITIALIZER; |
| |
| U_NAMESPACE_BEGIN |
| |
| // RelativeDateTimeFormatter specific data for a single locale |
| class RelativeDateTimeCacheData: public SharedObject { |
| public: |
| RelativeDateTimeCacheData() : combinedDateAndTime(NULL) { } |
| virtual ~RelativeDateTimeCacheData(); |
| |
| // no numbers: e.g Next Tuesday; Yesterday; etc. |
| UnicodeString absoluteUnits[UDAT_STYLE_COUNT][UDAT_ABSOLUTE_UNIT_COUNT][UDAT_DIRECTION_COUNT]; |
| |
| // has numbers: e.g Next Tuesday; Yesterday; etc. For second index, 0 |
| // means past e.g 5 days ago; 1 means future e.g in 5 days. |
| QuantityFormatter relativeUnits[UDAT_STYLE_COUNT][UDAT_RELATIVE_UNIT_COUNT][2]; |
| |
| void adoptCombinedDateAndTime(MessageFormat *mfToAdopt) { |
| delete combinedDateAndTime; |
| combinedDateAndTime = mfToAdopt; |
| } |
| const MessageFormat *getCombinedDateAndTime() const { |
| return combinedDateAndTime; |
| } |
| private: |
| MessageFormat *combinedDateAndTime; |
| RelativeDateTimeCacheData(const RelativeDateTimeCacheData &other); |
| RelativeDateTimeCacheData& operator=( |
| const RelativeDateTimeCacheData &other); |
| }; |
| |
| RelativeDateTimeCacheData::~RelativeDateTimeCacheData() { |
| delete combinedDateAndTime; |
| } |
| |
| static UBool getStringWithFallback( |
| const UResourceBundle *resource, |
| const char *key, |
| UnicodeString &result, |
| UErrorCode &status) { |
| int32_t len = 0; |
| const UChar *resStr = ures_getStringByKeyWithFallback( |
| resource, key, &len, &status); |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| result.setTo(TRUE, resStr, len); |
| return TRUE; |
| } |
| |
| static UBool getOptionalStringWithFallback( |
| const UResourceBundle *resource, |
| const char *key, |
| UnicodeString &result, |
| UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| int32_t len = 0; |
| const UChar *resStr = ures_getStringByKey( |
| resource, key, &len, &status); |
| if (status == U_MISSING_RESOURCE_ERROR) { |
| result.remove(); |
| status = U_ZERO_ERROR; |
| return TRUE; |
| } |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| result.setTo(TRUE, resStr, len); |
| return TRUE; |
| } |
| |
| static UBool getString( |
| const UResourceBundle *resource, |
| UnicodeString &result, |
| UErrorCode &status) { |
| int32_t len = 0; |
| const UChar *resStr = ures_getString(resource, &len, &status); |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| result.setTo(TRUE, resStr, len); |
| return TRUE; |
| } |
| |
| static UBool getStringByIndex( |
| const UResourceBundle *resource, |
| int32_t idx, |
| UnicodeString &result, |
| UErrorCode &status) { |
| int32_t len = 0; |
| const UChar *resStr = ures_getStringByIndex( |
| resource, idx, &len, &status); |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| result.setTo(TRUE, resStr, len); |
| return TRUE; |
| } |
| |
| static void initAbsoluteUnit( |
| const UResourceBundle *resource, |
| const UnicodeString &unitName, |
| UnicodeString *absoluteUnit, |
| UErrorCode &status) { |
| getStringWithFallback( |
| resource, |
| "-1", |
| absoluteUnit[UDAT_DIRECTION_LAST], |
| status); |
| getStringWithFallback( |
| resource, |
| "0", |
| absoluteUnit[UDAT_DIRECTION_THIS], |
| status); |
| getStringWithFallback( |
| resource, |
| "1", |
| absoluteUnit[UDAT_DIRECTION_NEXT], |
| status); |
| getOptionalStringWithFallback( |
| resource, |
| "-2", |
| absoluteUnit[UDAT_DIRECTION_LAST_2], |
| status); |
| getOptionalStringWithFallback( |
| resource, |
| "2", |
| absoluteUnit[UDAT_DIRECTION_NEXT_2], |
| status); |
| absoluteUnit[UDAT_DIRECTION_PLAIN] = unitName; |
| } |
| |
| static void initQuantityFormatter( |
| const UResourceBundle *resource, |
| QuantityFormatter &formatter, |
| UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| int32_t size = ures_getSize(resource); |
| for (int32_t i = 0; i < size; ++i) { |
| LocalUResourceBundlePointer pluralBundle( |
| ures_getByIndex(resource, i, NULL, &status)); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| UnicodeString rawPattern; |
| if (!getString(pluralBundle.getAlias(), rawPattern, status)) { |
| return; |
| } |
| if (!formatter.addIfAbsent( |
| ures_getKey(pluralBundle.getAlias()), |
| rawPattern, |
| status)) { |
| return; |
| } |
| } |
| } |
| |
| static void initRelativeUnit( |
| const UResourceBundle *resource, |
| QuantityFormatter *relativeUnit, |
| UErrorCode &status) { |
| LocalUResourceBundlePointer topLevel( |
| ures_getByKeyWithFallback( |
| resource, "relativeTime", NULL, &status)); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| LocalUResourceBundlePointer futureBundle(ures_getByKeyWithFallback( |
| topLevel.getAlias(), "future", NULL, &status)); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| initQuantityFormatter( |
| futureBundle.getAlias(), |
| relativeUnit[1], |
| status); |
| LocalUResourceBundlePointer pastBundle(ures_getByKeyWithFallback( |
| topLevel.getAlias(), "past", NULL, &status)); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| initQuantityFormatter( |
| pastBundle.getAlias(), |
| relativeUnit[0], |
| status); |
| } |
| |
| static void initRelativeUnit( |
| const UResourceBundle *resource, |
| const char *path, |
| QuantityFormatter *relativeUnit, |
| UErrorCode &status) { |
| LocalUResourceBundlePointer topLevel( |
| ures_getByKeyWithFallback(resource, path, NULL, &status)); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| initRelativeUnit(topLevel.getAlias(), relativeUnit, status); |
| } |
| |
| static void addTimeUnit( |
| const UResourceBundle *resource, |
| const char *path, |
| QuantityFormatter *relativeUnit, |
| UnicodeString *absoluteUnit, |
| UErrorCode &status) { |
| LocalUResourceBundlePointer topLevel( |
| ures_getByKeyWithFallback(resource, path, NULL, &status)); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| initRelativeUnit(topLevel.getAlias(), relativeUnit, status); |
| UnicodeString unitName; |
| if (!getStringWithFallback(topLevel.getAlias(), "dn", unitName, status)) { |
| return; |
| } |
| // TODO(Travis Keep): This is a hack to get around CLDR bug 6818. |
| const char *localeId = ures_getLocaleByType( |
| topLevel.getAlias(), ULOC_ACTUAL_LOCALE, &status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| Locale locale(localeId); |
| if (uprv_strcmp("en", locale.getLanguage()) == 0) { |
| unitName.toLower(); |
| } |
| // end hack |
| ures_getByKeyWithFallback( |
| topLevel.getAlias(), "relative", topLevel.getAlias(), &status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| initAbsoluteUnit( |
| topLevel.getAlias(), |
| unitName, |
| absoluteUnit, |
| status); |
| } |
| |
| static void readDaysOfWeek( |
| const UResourceBundle *resource, |
| const char *path, |
| UnicodeString *daysOfWeek, |
| UErrorCode &status) { |
| LocalUResourceBundlePointer topLevel( |
| ures_getByKeyWithFallback(resource, path, NULL, &status)); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| int32_t size = ures_getSize(topLevel.getAlias()); |
| if (size != 7) { |
| status = U_INTERNAL_PROGRAM_ERROR; |
| return; |
| } |
| for (int32_t i = 0; i < size; ++i) { |
| if (!getStringByIndex(topLevel.getAlias(), i, daysOfWeek[i], status)) { |
| return; |
| } |
| } |
| } |
| |
| static void addWeekDay( |
| const UResourceBundle *resource, |
| const char *path, |
| const UnicodeString *daysOfWeek, |
| UDateAbsoluteUnit absoluteUnit, |
| UnicodeString absoluteUnits[][UDAT_DIRECTION_COUNT], |
| UErrorCode &status) { |
| LocalUResourceBundlePointer topLevel( |
| ures_getByKeyWithFallback(resource, path, NULL, &status)); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| initAbsoluteUnit( |
| topLevel.getAlias(), |
| daysOfWeek[absoluteUnit - UDAT_ABSOLUTE_SUNDAY], |
| absoluteUnits[absoluteUnit], |
| status); |
| } |
| |
| static void addTimeUnits( |
| const UResourceBundle *resource, |
| const char *path, const char *pathShort, const char *pathNarrow, |
| UDateRelativeUnit relativeUnit, |
| UDateAbsoluteUnit absoluteUnit, |
| RelativeDateTimeCacheData &cacheData, |
| UErrorCode &status) { |
| addTimeUnit( |
| resource, |
| path, |
| cacheData.relativeUnits[UDAT_STYLE_LONG][relativeUnit], |
| cacheData.absoluteUnits[UDAT_STYLE_LONG][absoluteUnit], |
| status); |
| addTimeUnit( |
| resource, |
| pathShort, |
| cacheData.relativeUnits[UDAT_STYLE_SHORT][relativeUnit], |
| cacheData.absoluteUnits[UDAT_STYLE_SHORT][absoluteUnit], |
| status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| addTimeUnit( |
| resource, |
| pathNarrow, |
| cacheData.relativeUnits[UDAT_STYLE_NARROW][relativeUnit], |
| cacheData.absoluteUnits[UDAT_STYLE_NARROW][absoluteUnit], |
| status); |
| if (status == U_MISSING_RESOURCE_ERROR) { |
| // retry addTimeUnit for UDAT_STYLE_NARROW using pathShort |
| status = U_ZERO_ERROR; |
| addTimeUnit( |
| resource, |
| pathShort, |
| cacheData.relativeUnits[UDAT_STYLE_NARROW][relativeUnit], |
| cacheData.absoluteUnits[UDAT_STYLE_NARROW][absoluteUnit], |
| status); |
| } |
| } |
| |
| static void initRelativeUnits( |
| const UResourceBundle *resource, |
| const char *path, const char *pathShort, const char *pathNarrow, |
| UDateRelativeUnit relativeUnit, |
| QuantityFormatter relativeUnits[][UDAT_RELATIVE_UNIT_COUNT][2], |
| UErrorCode &status) { |
| initRelativeUnit( |
| resource, |
| path, |
| relativeUnits[UDAT_STYLE_LONG][relativeUnit], |
| status); |
| initRelativeUnit( |
| resource, |
| pathShort, |
| relativeUnits[UDAT_STYLE_SHORT][relativeUnit], |
| status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| initRelativeUnit( |
| resource, |
| pathNarrow, |
| relativeUnits[UDAT_STYLE_NARROW][relativeUnit], |
| status); |
| if (status == U_MISSING_RESOURCE_ERROR) { |
| // retry initRelativeUnit for UDAT_STYLE_NARROW using pathShort |
| status = U_ZERO_ERROR; |
| initRelativeUnit( |
| resource, |
| pathShort, |
| relativeUnits[UDAT_STYLE_NARROW][relativeUnit], |
| status); |
| } |
| } |
| |
| static void addWeekDays( |
| const UResourceBundle *resource, |
| const char *path, const char *pathShort, const char *pathNarrow, |
| const UnicodeString daysOfWeek[][7], |
| UDateAbsoluteUnit absoluteUnit, |
| UnicodeString absoluteUnits[][UDAT_ABSOLUTE_UNIT_COUNT][UDAT_DIRECTION_COUNT], |
| UErrorCode &status) { |
| addWeekDay( |
| resource, |
| path, |
| daysOfWeek[UDAT_STYLE_LONG], |
| absoluteUnit, |
| absoluteUnits[UDAT_STYLE_LONG], |
| status); |
| addWeekDay( |
| resource, |
| pathShort, |
| daysOfWeek[UDAT_STYLE_SHORT], |
| absoluteUnit, |
| absoluteUnits[UDAT_STYLE_SHORT], |
| status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| addWeekDay( |
| resource, |
| pathNarrow, |
| daysOfWeek[UDAT_STYLE_NARROW], |
| absoluteUnit, |
| absoluteUnits[UDAT_STYLE_NARROW], |
| status); |
| if (status == U_MISSING_RESOURCE_ERROR) { |
| // retry addWeekDay for UDAT_STYLE_NARROW using pathShort |
| status = U_ZERO_ERROR; |
| addWeekDay( |
| resource, |
| pathShort, |
| daysOfWeek[UDAT_STYLE_NARROW], |
| absoluteUnit, |
| absoluteUnits[UDAT_STYLE_NARROW], |
| status); |
| } |
| } |
| |
| static UBool loadUnitData( |
| const UResourceBundle *resource, |
| RelativeDateTimeCacheData &cacheData, |
| UErrorCode &status) { |
| addTimeUnits( |
| resource, |
| "fields/day", "fields/day-short", "fields/day-narrow", |
| UDAT_RELATIVE_DAYS, |
| UDAT_ABSOLUTE_DAY, |
| cacheData, |
| status); |
| addTimeUnits( |
| resource, |
| "fields/week", "fields/week-short", "fields/week-narrow", |
| UDAT_RELATIVE_WEEKS, |
| UDAT_ABSOLUTE_WEEK, |
| cacheData, |
| status); |
| addTimeUnits( |
| resource, |
| "fields/month", "fields/month-short", "fields/month-narrow", |
| UDAT_RELATIVE_MONTHS, |
| UDAT_ABSOLUTE_MONTH, |
| cacheData, |
| status); |
| addTimeUnits( |
| resource, |
| "fields/year", "fields/year-short", "fields/year-narrow", |
| UDAT_RELATIVE_YEARS, |
| UDAT_ABSOLUTE_YEAR, |
| cacheData, |
| status); |
| initRelativeUnits( |
| resource, |
| "fields/second", "fields/second-short", "fields/second-narrow", |
| UDAT_RELATIVE_SECONDS, |
| cacheData.relativeUnits, |
| status); |
| initRelativeUnits( |
| resource, |
| "fields/minute", "fields/minute-short", "fields/minute-narrow", |
| UDAT_RELATIVE_MINUTES, |
| cacheData.relativeUnits, |
| status); |
| initRelativeUnits( |
| resource, |
| "fields/hour", "fields/hour-short", "fields/hour-narrow", |
| UDAT_RELATIVE_HOURS, |
| cacheData.relativeUnits, |
| status); |
| getStringWithFallback( |
| resource, |
| "fields/second/relative/0", |
| cacheData.absoluteUnits[UDAT_STYLE_LONG][UDAT_ABSOLUTE_NOW][UDAT_DIRECTION_PLAIN], |
| status); |
| getStringWithFallback( |
| resource, |
| "fields/second-short/relative/0", |
| cacheData.absoluteUnits[UDAT_STYLE_SHORT][UDAT_ABSOLUTE_NOW][UDAT_DIRECTION_PLAIN], |
| status); |
| getStringWithFallback( |
| resource, |
| "fields/second-narrow/relative/0", |
| cacheData.absoluteUnits[UDAT_STYLE_NARROW][UDAT_ABSOLUTE_NOW][UDAT_DIRECTION_PLAIN], |
| status); |
| UnicodeString daysOfWeek[UDAT_STYLE_COUNT][7]; |
| readDaysOfWeek( |
| resource, |
| "calendar/gregorian/dayNames/stand-alone/wide", |
| daysOfWeek[UDAT_STYLE_LONG], |
| status); |
| readDaysOfWeek( |
| resource, |
| "calendar/gregorian/dayNames/stand-alone/short", |
| daysOfWeek[UDAT_STYLE_SHORT], |
| status); |
| readDaysOfWeek( |
| resource, |
| "calendar/gregorian/dayNames/stand-alone/narrow", |
| daysOfWeek[UDAT_STYLE_NARROW], |
| status); |
| addWeekDays( |
| resource, |
| "fields/mon/relative", |
| "fields/mon-short/relative", |
| "fields/mon-narrow/relative", |
| daysOfWeek, |
| UDAT_ABSOLUTE_MONDAY, |
| cacheData.absoluteUnits, |
| status); |
| addWeekDays( |
| resource, |
| "fields/tue/relative", |
| "fields/tue-short/relative", |
| "fields/tue-narrow/relative", |
| daysOfWeek, |
| UDAT_ABSOLUTE_TUESDAY, |
| cacheData.absoluteUnits, |
| status); |
| addWeekDays( |
| resource, |
| "fields/wed/relative", |
| "fields/wed-short/relative", |
| "fields/wed-narrow/relative", |
| daysOfWeek, |
| UDAT_ABSOLUTE_WEDNESDAY, |
| cacheData.absoluteUnits, |
| status); |
| addWeekDays( |
| resource, |
| "fields/thu/relative", |
| "fields/thu-short/relative", |
| "fields/thu-narrow/relative", |
| daysOfWeek, |
| UDAT_ABSOLUTE_THURSDAY, |
| cacheData.absoluteUnits, |
| status); |
| addWeekDays( |
| resource, |
| "fields/fri/relative", |
| "fields/fri-short/relative", |
| "fields/fri-narrow/relative", |
| daysOfWeek, |
| UDAT_ABSOLUTE_FRIDAY, |
| cacheData.absoluteUnits, |
| status); |
| addWeekDays( |
| resource, |
| "fields/sat/relative", |
| "fields/sat-short/relative", |
| "fields/sat-narrow/relative", |
| daysOfWeek, |
| UDAT_ABSOLUTE_SATURDAY, |
| cacheData.absoluteUnits, |
| status); |
| addWeekDays( |
| resource, |
| "fields/sun/relative", |
| "fields/sun-short/relative", |
| "fields/sun-narrow/relative", |
| daysOfWeek, |
| UDAT_ABSOLUTE_SUNDAY, |
| cacheData.absoluteUnits, |
| status); |
| return U_SUCCESS(status); |
| } |
| |
| static UBool getDateTimePattern( |
| const UResourceBundle *resource, |
| UnicodeString &result, |
| UErrorCode &status) { |
| UnicodeString defaultCalendarName; |
| if (!getStringWithFallback( |
| resource, |
| "calendar/default", |
| defaultCalendarName, |
| status)) { |
| return FALSE; |
| } |
| CharString pathBuffer; |
| pathBuffer.append("calendar/", status) |
| .appendInvariantChars(defaultCalendarName, status) |
| .append("/DateTimePatterns", status); |
| LocalUResourceBundlePointer topLevel( |
| ures_getByKeyWithFallback( |
| resource, pathBuffer.data(), NULL, &status)); |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| int32_t size = ures_getSize(topLevel.getAlias()); |
| if (size <= 8) { |
| // Oops, size is to small to access the index that we want, fallback |
| // to a hard-coded value. |
| result = UNICODE_STRING_SIMPLE("{1} {0}"); |
| return TRUE; |
| } |
| return getStringByIndex(topLevel.getAlias(), 8, result, status); |
| } |
| |
| template<> U_I18N_API |
| const RelativeDateTimeCacheData *LocaleCacheKey<RelativeDateTimeCacheData>::createObject(const void * /*unused*/, UErrorCode &status) const { |
| const char *localeId = fLoc.getName(); |
| LocalUResourceBundlePointer topLevel(ures_open(NULL, localeId, &status)); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| LocalPointer<RelativeDateTimeCacheData> result( |
| new RelativeDateTimeCacheData()); |
| if (result.isNull()) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| if (!loadUnitData( |
| topLevel.getAlias(), |
| *result, |
| status)) { |
| return NULL; |
| } |
| UnicodeString dateTimePattern; |
| if (!getDateTimePattern(topLevel.getAlias(), dateTimePattern, status)) { |
| return NULL; |
| } |
| result->adoptCombinedDateAndTime( |
| new MessageFormat(dateTimePattern, localeId, status)); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| result->addRef(); |
| return result.orphan(); |
| } |
| |
| RelativeDateTimeFormatter::RelativeDateTimeFormatter(UErrorCode& status) : |
| fCache(NULL), |
| fNumberFormat(NULL), |
| fPluralRules(NULL), |
| fStyle(UDAT_STYLE_LONG), |
| fContext(UDISPCTX_CAPITALIZATION_NONE), |
| fOptBreakIterator(NULL) { |
| init(NULL, NULL, status); |
| } |
| |
| RelativeDateTimeFormatter::RelativeDateTimeFormatter( |
| const Locale& locale, UErrorCode& status) : |
| fCache(NULL), |
| fNumberFormat(NULL), |
| fPluralRules(NULL), |
| fStyle(UDAT_STYLE_LONG), |
| fContext(UDISPCTX_CAPITALIZATION_NONE), |
| fOptBreakIterator(NULL), |
| fLocale(locale) { |
| init(NULL, NULL, status); |
| } |
| |
| RelativeDateTimeFormatter::RelativeDateTimeFormatter( |
| const Locale& locale, NumberFormat *nfToAdopt, UErrorCode& status) : |
| fCache(NULL), |
| fNumberFormat(NULL), |
| fPluralRules(NULL), |
| fStyle(UDAT_STYLE_LONG), |
| fContext(UDISPCTX_CAPITALIZATION_NONE), |
| fOptBreakIterator(NULL), |
| fLocale(locale) { |
| init(nfToAdopt, NULL, status); |
| } |
| |
| RelativeDateTimeFormatter::RelativeDateTimeFormatter( |
| const Locale& locale, |
| NumberFormat *nfToAdopt, |
| UDateRelativeDateTimeFormatterStyle styl, |
| UDisplayContext capitalizationContext, |
| UErrorCode& status) : |
| fCache(NULL), |
| fNumberFormat(NULL), |
| fPluralRules(NULL), |
| fStyle(styl), |
| fContext(capitalizationContext), |
| fOptBreakIterator(NULL), |
| fLocale(locale) { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| if ((capitalizationContext >> 8) != UDISPCTX_TYPE_CAPITALIZATION) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| if (capitalizationContext == UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE) { |
| BreakIterator *bi = BreakIterator::createSentenceInstance(locale, status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| init(nfToAdopt, bi, status); |
| } else { |
| init(nfToAdopt, NULL, status); |
| } |
| } |
| |
| RelativeDateTimeFormatter::RelativeDateTimeFormatter( |
| const RelativeDateTimeFormatter& other) |
| : UObject(other), |
| fCache(other.fCache), |
| fNumberFormat(other.fNumberFormat), |
| fPluralRules(other.fPluralRules), |
| fStyle(other.fStyle), |
| fContext(other.fContext), |
| fOptBreakIterator(other.fOptBreakIterator), |
| fLocale(other.fLocale) { |
| fCache->addRef(); |
| fNumberFormat->addRef(); |
| fPluralRules->addRef(); |
| if (fOptBreakIterator != NULL) { |
| fOptBreakIterator->addRef(); |
| } |
| } |
| |
| RelativeDateTimeFormatter& RelativeDateTimeFormatter::operator=( |
| const RelativeDateTimeFormatter& other) { |
| if (this != &other) { |
| SharedObject::copyPtr(other.fCache, fCache); |
| SharedObject::copyPtr(other.fNumberFormat, fNumberFormat); |
| SharedObject::copyPtr(other.fPluralRules, fPluralRules); |
| SharedObject::copyPtr(other.fOptBreakIterator, fOptBreakIterator); |
| fStyle = other.fStyle; |
| fContext = other.fContext; |
| fLocale = other.fLocale; |
| } |
| return *this; |
| } |
| |
| RelativeDateTimeFormatter::~RelativeDateTimeFormatter() { |
| if (fCache != NULL) { |
| fCache->removeRef(); |
| } |
| if (fNumberFormat != NULL) { |
| fNumberFormat->removeRef(); |
| } |
| if (fPluralRules != NULL) { |
| fPluralRules->removeRef(); |
| } |
| if (fOptBreakIterator != NULL) { |
| fOptBreakIterator->removeRef(); |
| } |
| } |
| |
| const NumberFormat& RelativeDateTimeFormatter::getNumberFormat() const { |
| return **fNumberFormat; |
| } |
| |
| UDisplayContext RelativeDateTimeFormatter::getCapitalizationContext() const { |
| return fContext; |
| } |
| |
| UDateRelativeDateTimeFormatterStyle RelativeDateTimeFormatter::getFormatStyle() const { |
| return fStyle; |
| } |
| |
| UnicodeString& RelativeDateTimeFormatter::format( |
| double quantity, UDateDirection direction, UDateRelativeUnit unit, |
| UnicodeString& appendTo, UErrorCode& status) const { |
| if (U_FAILURE(status)) { |
| return appendTo; |
| } |
| if (direction != UDAT_DIRECTION_LAST && direction != UDAT_DIRECTION_NEXT) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return appendTo; |
| } |
| int32_t bFuture = direction == UDAT_DIRECTION_NEXT ? 1 : 0; |
| FieldPosition pos(FieldPosition::DONT_CARE); |
| if (fOptBreakIterator == NULL) { |
| return fCache->relativeUnits[fStyle][unit][bFuture].format( |
| quantity, |
| **fNumberFormat, |
| **fPluralRules, |
| appendTo, |
| pos, |
| status); |
| } |
| UnicodeString result; |
| fCache->relativeUnits[fStyle][unit][bFuture].format( |
| quantity, |
| **fNumberFormat, |
| **fPluralRules, |
| result, |
| pos, |
| status); |
| adjustForContext(result); |
| return appendTo.append(result); |
| } |
| |
| UnicodeString& RelativeDateTimeFormatter::format( |
| UDateDirection direction, UDateAbsoluteUnit unit, |
| UnicodeString& appendTo, UErrorCode& status) const { |
| if (U_FAILURE(status)) { |
| return appendTo; |
| } |
| if (unit == UDAT_ABSOLUTE_NOW && direction != UDAT_DIRECTION_PLAIN) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return appendTo; |
| } |
| if (fOptBreakIterator == NULL) { |
| return appendTo.append(fCache->absoluteUnits[fStyle][unit][direction]); |
| } |
| UnicodeString result(fCache->absoluteUnits[fStyle][unit][direction]); |
| adjustForContext(result); |
| return appendTo.append(result); |
| } |
| |
| UnicodeString& RelativeDateTimeFormatter::combineDateAndTime( |
| const UnicodeString& relativeDateString, const UnicodeString& timeString, |
| UnicodeString& appendTo, UErrorCode& status) const { |
| Formattable args[2] = {timeString, relativeDateString}; |
| FieldPosition fpos(0); |
| return fCache->getCombinedDateAndTime()->format( |
| args, 2, appendTo, fpos, status); |
| } |
| |
| void RelativeDateTimeFormatter::adjustForContext(UnicodeString &str) const { |
| if (fOptBreakIterator == NULL |
| || str.length() == 0 || !u_islower(str.char32At(0))) { |
| return; |
| } |
| |
| // Must guarantee that one thread at a time accesses the shared break |
| // iterator. |
| Mutex lock(&gBrkIterMutex); |
| str.toTitle( |
| fOptBreakIterator->get(), |
| fLocale, |
| U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT); |
| } |
| |
| void RelativeDateTimeFormatter::init( |
| NumberFormat *nfToAdopt, |
| BreakIterator *biToAdopt, |
| UErrorCode &status) { |
| LocalPointer<NumberFormat> nf(nfToAdopt); |
| LocalPointer<BreakIterator> bi(biToAdopt); |
| UnifiedCache::getByLocale(fLocale, fCache, status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| const SharedPluralRules *pr = PluralRules::createSharedInstance( |
| fLocale, UPLURAL_TYPE_CARDINAL, status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| SharedObject::copyPtr(pr, fPluralRules); |
| pr->removeRef(); |
| if (nf.isNull()) { |
| const SharedNumberFormat *shared = NumberFormat::createSharedInstance( |
| fLocale, UNUM_DECIMAL, status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| SharedObject::copyPtr(shared, fNumberFormat); |
| shared->removeRef(); |
| } else { |
| SharedNumberFormat *shared = new SharedNumberFormat(nf.getAlias()); |
| if (shared == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| nf.orphan(); |
| SharedObject::copyPtr(shared, fNumberFormat); |
| } |
| if (bi.isNull()) { |
| SharedObject::clearPtr(fOptBreakIterator); |
| } else { |
| SharedBreakIterator *shared = new SharedBreakIterator(bi.getAlias()); |
| if (shared == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| bi.orphan(); |
| SharedObject::copyPtr(shared, fOptBreakIterator); |
| } |
| } |
| |
| |
| U_NAMESPACE_END |
| |
| #endif /* !UCONFIG_NO_FORMATTING */ |
| |
