lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
14082 Commits
131 Branches
446 Tags
325 MiB
 
 
 
 
 
 
Tree: d23b7d2656
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd23b7d2656'
${ noResults }
node/deps/icu-small/source/i18n/reldatefmt.cpp

1190 lines
42 KiB
Raw Blame History

/*
******************************************************************************
* Copyright (C) 2014-2016, 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/dtfmtsym.h"
#include "unicode/ureldatefmt.h"
#include "unicode/udisplaycontext.h"
#include "unicode/unum.h"
#include "unicode/localpointer.h"
#include "unicode/plurrule.h"
#include "unicode/simpleformatter.h"
#include "unicode/decimfmt.h"
#include "unicode/numfmt.h"
#include "unicode/brkiter.h"
#include "unicode/simpleformatter.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 "quantityformatter.h"
#include "resource.h"
#include "sharedbreakiterator.h"
#include "sharedpluralrules.h"
#include "sharednumberformat.h"
#include "standardplural.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) {
// Initialize the cache arrays
for (int32_t style = 0; style < UDAT_STYLE_COUNT; ++style) {
for (int32_t relUnit = 0; relUnit < UDAT_RELATIVE_UNIT_COUNT; ++relUnit) {
for (int32_t pl = 0; pl < StandardPlural::COUNT; ++pl) {
relativeUnitsFormatters[style][relUnit][0][pl] = NULL;
relativeUnitsFormatters[style][relUnit][1][pl] = NULL;
}
}
}
for (int32_t i = 0; i < UDAT_STYLE_COUNT; ++i) {
fallBackCache[i] = -1;
}
}
virtual ~RelativeDateTimeCacheData();
// no numbers: e.g Next Tuesday; Yesterday; etc.
UnicodeString absoluteUnits[UDAT_STYLE_COUNT][UDAT_ABSOLUTE_UNIT_COUNT][UDAT_DIRECTION_COUNT];
// SimpleFormatter pointers for relative unit format,
// e.g., Next Tuesday; Yesterday; etc. For third index, 0
// means past, e.g., 5 days ago; 1 means future, e.g., in 5 days.
SimpleFormatter *relativeUnitsFormatters[UDAT_STYLE_COUNT]
[UDAT_RELATIVE_UNIT_COUNT][2][StandardPlural::COUNT];
const UnicodeString& getAbsoluteUnitString(int32_t fStyle,
UDateAbsoluteUnit unit,
UDateDirection direction) const;
const SimpleFormatter* getRelativeUnitFormatter(int32_t fStyle,
UDateRelativeUnit unit,
int32_t pastFutureIndex,
int32_t pluralUnit) const;
const UnicodeString emptyString;
// Mappping from source to target styles for alias fallback.
int32_t fallBackCache[UDAT_STYLE_COUNT];
void adoptCombinedDateAndTime(SimpleFormatter *fmtToAdopt) {
delete combinedDateAndTime;
combinedDateAndTime = fmtToAdopt;
}
const SimpleFormatter *getCombinedDateAndTime() const {
return combinedDateAndTime;
}
private:
SimpleFormatter *combinedDateAndTime;
RelativeDateTimeCacheData(const RelativeDateTimeCacheData &other);
RelativeDateTimeCacheData& operator=(
const RelativeDateTimeCacheData &other);
};
RelativeDateTimeCacheData::~RelativeDateTimeCacheData() {
// clear out the cache arrays
for (int32_t style = 0; style < UDAT_STYLE_COUNT; ++style) {
for (int32_t relUnit = 0; relUnit < UDAT_RELATIVE_UNIT_COUNT; ++relUnit) {
for (int32_t pl = 0; pl < StandardPlural::COUNT; ++pl) {
delete relativeUnitsFormatters[style][relUnit][0][pl];
delete relativeUnitsFormatters[style][relUnit][1][pl];
}
}
}
delete combinedDateAndTime;
}
// Use fallback cache for absolute units.
const UnicodeString& RelativeDateTimeCacheData::getAbsoluteUnitString(
int32_t fStyle, UDateAbsoluteUnit unit, UDateDirection direction) const {
int32_t style = fStyle;
do {
if (!absoluteUnits[style][unit][direction].isEmpty()) {
return absoluteUnits[style][unit][direction];
}
style = fallBackCache[style];
} while (style != -1);
return emptyString;
}
// Use fallback cache for SimpleFormatter relativeUnits.
const SimpleFormatter* RelativeDateTimeCacheData::getRelativeUnitFormatter(
int32_t fStyle,
UDateRelativeUnit unit,
int32_t pastFutureIndex,
int32_t pluralUnit) const {
int32_t style = fStyle;
do {
if (relativeUnitsFormatters[style][unit][pastFutureIndex][pluralUnit] != NULL) {
return relativeUnitsFormatters[style][unit][pastFutureIndex][pluralUnit];
}
style = fallBackCache[style];
} while (style != -1);
return NULL; // No formatter found.
}
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 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;
}
namespace {
/**
* Sink for enumerating all of the measurement unit display names.
* Contains inner sink classes, each one corresponding to a level of the resource table.
*
* More specific bundles (en_GB) are enumerated before their parents (en_001, en, root):
* Only store a value if it is still missing, that is, it has not been overridden.
*
* C++: Each inner sink class has a reference to the main outer sink.
*/
struct RelDateTimeFmtDataSink : public ResourceTableSink {
/**
* Sink for patterns for relative dates and times. For example,
* fields/relative/...
*/
// Generic unit enum for storing Unit info.
typedef enum RelAbsUnit {
INVALID_UNIT = -1,
SECOND,
MINUTE,
HOUR,
DAY,
WEEK,
MONTH,
QUARTER,
YEAR,
SUNDAY,
MONDAY,
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATURDAY
} RelAbsUnit;
static int32_t relUnitFromGeneric(RelAbsUnit genUnit) {
// Converts the generic units to UDAT_RELATIVE version.
switch (genUnit) {
case SECOND:
return UDAT_RELATIVE_SECONDS;
case MINUTE:
return UDAT_RELATIVE_MINUTES;
case HOUR:
return UDAT_RELATIVE_HOURS;
case DAY:
return UDAT_RELATIVE_DAYS;
case WEEK:
return UDAT_RELATIVE_WEEKS;
case MONTH:
return UDAT_RELATIVE_MONTHS;
/*
* case QUARTER:
* return UDATE_RELATIVE_QUARTERS;
*/
case YEAR:
return UDAT_RELATIVE_YEARS;
default:
return -1;
}
}
static int32_t absUnitFromGeneric(RelAbsUnit genUnit) {
// Converts the generic units to UDAT_RELATIVE version.
switch (genUnit) {
case DAY:
return UDAT_ABSOLUTE_DAY;
case WEEK:
return UDAT_ABSOLUTE_WEEK;
case MONTH:
return UDAT_ABSOLUTE_MONTH;
/* TODO: Add in QUARTER
* case QUARTER:
* return UDAT_ABSOLUTE_QUARTER;
*/
case YEAR:
return UDAT_ABSOLUTE_YEAR;
case SUNDAY:
return UDAT_ABSOLUTE_SUNDAY;
case MONDAY:
return UDAT_ABSOLUTE_MONDAY;
case TUESDAY:
return UDAT_ABSOLUTE_TUESDAY;
case WEDNESDAY:
return UDAT_ABSOLUTE_WEDNESDAY;
case THURSDAY:
return UDAT_ABSOLUTE_THURSDAY;
case FRIDAY:
return UDAT_ABSOLUTE_FRIDAY;
case SATURDAY:
return UDAT_ABSOLUTE_SATURDAY;
default:
return -1;
}
}
static int32_t keyToDirection(const char* key) {
if (uprv_strcmp(key, "-2") == 0) {
return UDAT_DIRECTION_LAST_2;
}
if (uprv_strcmp(key, "-1") == 0) {
return UDAT_DIRECTION_LAST;
}
if (uprv_strcmp(key, "0") == 0) {
return UDAT_DIRECTION_THIS;
}
if (uprv_strcmp(key, "1") == 0) {
return UDAT_DIRECTION_NEXT;
}
if (uprv_strcmp(key, "2") == 0) {
return UDAT_DIRECTION_NEXT_2;
}
return -1;
}
// Sinks for additional levels under /fields/*/relative/ and /fields/*/relativeTime/
/**
* Make list of simplePatternFmtList, for past and for future.
* Set a SimpleFormatter for the <style, relative unit, plurality>
*
* Fill in values for the particular plural given, e.g., ONE, FEW, OTHER, etc.
*/
struct RelDateTimeDetailSink : public ResourceTableSink {
RelDateTimeDetailSink(RelDateTimeFmtDataSink &sink) : outer(sink) {}
~RelDateTimeDetailSink();
virtual void put(const char *key, const ResourceValue &value,
UErrorCode &errorCode) {
if (U_FAILURE(errorCode)) { return; }
outer.relUnitIndex = relUnitFromGeneric(outer.genericUnit);
if (outer.relUnitIndex < 0) {
return;
}
/* Make two lists of simplePatternFmtList, one for past and one for future.
* Set a SimpleFormatter pattern for the <style, relative unit, plurality>
*
* Fill in values for the particular plural given, e.g., ONE, FEW, OTHER, etc.
*/
int32_t pluralIndex = StandardPlural::indexOrNegativeFromString(key);
if (pluralIndex >= 0) {
SimpleFormatter **patterns =
outer.outputData.relativeUnitsFormatters[outer.style][outer.relUnitIndex]
[outer.pastFutureIndex];
// Only set if not already established.
if (patterns[pluralIndex] == NULL) {
patterns[pluralIndex] = new SimpleFormatter(
value.getUnicodeString(errorCode), 0, 1, errorCode);
if (patterns[pluralIndex] == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
}
}
}
}
RelDateTimeFmtDataSink &outer;
} relDateTimeDetailSink;
/*
* Handles "relativeTime" entries, e.g., under "day", "hour", "minute",
* "minute-short", etc.
*/
struct RelativeTimeSink : public ResourceTableSink {
RelativeTimeSink(RelDateTimeFmtDataSink &sink) : outer(sink) {}
~RelativeTimeSink();
virtual ResourceTableSink *getOrCreateTableSink(
const char *key, int32_t /* initialSize */, UErrorCode& errorCode) {
if (U_FAILURE(errorCode)) { return NULL; }
outer.relUnitIndex = relUnitFromGeneric(outer.genericUnit);
if (outer.relUnitIndex < 0) {
return NULL;
}
if (uprv_strcmp(key, "past") == 0) {
outer.pastFutureIndex = 0;
} else if (uprv_strcmp(key, "future") == 0) {
outer.pastFutureIndex = 1;
} else {
// Unknown key.
return NULL;
}
return &outer.relDateTimeDetailSink;
}
RelDateTimeFmtDataSink &outer;
} relativeTimeSink;
/*
* Handles "relative" entries, e.g., under "day", "day-short", "fri",
* "fri-narrow", "fri-short", etc.
*/
struct RelativeSink : public ResourceTableSink {
RelativeSink(RelDateTimeFmtDataSink &sink) : outer(sink) {}
~RelativeSink();
virtual void put(const char *key, const ResourceValue &value, UErrorCode &errorCode) {
if (U_FAILURE(errorCode)) { return; }
int32_t direction = keyToDirection(key);
if (direction < 0) {
return;
}
int32_t relUnitIndex = relUnitFromGeneric(outer.genericUnit);
if (relUnitIndex == UDAT_RELATIVE_SECONDS &&
direction == UDAT_DIRECTION_THIS &&
outer.outputData.absoluteUnits[outer.style][UDAT_ABSOLUTE_NOW]
[UDAT_DIRECTION_PLAIN].isEmpty()) {
// Handle "NOW"
outer.outputData.absoluteUnits[outer.style][UDAT_ABSOLUTE_NOW]
[UDAT_DIRECTION_PLAIN].fastCopyFrom(value.getUnicodeString(errorCode));
}
int32_t absUnitIndex = absUnitFromGeneric(outer.genericUnit);
if (absUnitIndex < 0) {
return;
}
// Only reset if slot is empty.
if (outer.outputData.absoluteUnits[outer.style][absUnitIndex][direction].isEmpty()) {
outer.outputData.absoluteUnits[outer.style][absUnitIndex]
[direction].fastCopyFrom(value.getUnicodeString(errorCode));
}
}
RelDateTimeFmtDataSink &outer;
} relativeSink;
/*
* Handles entries under "fields", recognizing "relative" and "relativeTime" entries.
*/
struct UnitSink : public ResourceTableSink {
UnitSink(RelDateTimeFmtDataSink &sink) : outer(sink) {}
~UnitSink();
virtual void put(const char *key, const ResourceValue &value, UErrorCode &errorCode) {
if (U_FAILURE(errorCode)) { return; }
if (uprv_strcmp(key, "dn") != 0) {
return;
}
// Handle Display Name for PLAIN direction for some units.
int32_t absUnit = absUnitFromGeneric(outer.genericUnit);
if (absUnit < 0) {
return; // Not interesting.
}
// TODO(Travis Keep): This is a hack to get around CLDR bug 6818.
UnicodeString displayName = value.getUnicodeString(errorCode);
if (U_SUCCESS(errorCode)) {
if (uprv_strcmp("en", outer.sinkLocaleId) == 0) {
displayName.toLower();
}
}
// end hack
// Store displayname if not set.
if (outer.outputData.absoluteUnits[outer.style]
[absUnit][UDAT_DIRECTION_PLAIN].isEmpty()) {
outer.outputData.absoluteUnits[outer.style]
[absUnit][UDAT_DIRECTION_PLAIN].fastCopyFrom(displayName);
return;
}
}
virtual ResourceTableSink *getOrCreateTableSink(
const char *key, int32_t /* initialSize */, UErrorCode &errorCode) {
if (U_FAILURE(errorCode)) { return NULL; }
if (uprv_strcmp(key, "relative") == 0) {
return &outer.relativeSink;
} else if (uprv_strcmp(key, "relativeTime") == 0) {
return &outer.relativeTimeSink;
}
return NULL;
}
RelDateTimeFmtDataSink &outer;
} unitSink;
// For hack for locale "en".
// TODO(Travis Keep): This is a hack to get around CLDR bug 6818.
const char* sinkLocaleId;
// Values kept between levels of parsing the CLDR data.
int32_t pastFutureIndex; // 0 == past or 1 == future
UDateRelativeDateTimeFormatterStyle style; // {LONG, SHORT, NARROW}
RelAbsUnit genericUnit;
int32_t relUnitIndex;
int32_t absUnitIndex;
RelativeDateTimeCacheData &outputData;
// Constructor
RelDateTimeFmtDataSink(RelativeDateTimeCacheData& cacheData, const char* localeId)
: relDateTimeDetailSink(*this), relativeTimeSink(*this), relativeSink(*this),
unitSink(*this), sinkLocaleId(localeId), outputData(cacheData) {
// Clear cacheData.fallBackCache
cacheData.fallBackCache[UDAT_STYLE_LONG] = -1;
cacheData.fallBackCache[UDAT_STYLE_SHORT] = -1;
cacheData.fallBackCache[UDAT_STYLE_NARROW] = -1;
}
~RelDateTimeFmtDataSink();
// Utility functions
static UDateRelativeDateTimeFormatterStyle styleFromString(const char *s) {
int32_t len = uprv_strlen(s);
if (len >= 7 && uprv_strcmp(s + len - 7, "-narrow") == 0) {
return UDAT_STYLE_NARROW;
}
if (len >= 6 && uprv_strcmp(s + len - 6, "-short") == 0) {
return UDAT_STYLE_SHORT;
}
return UDAT_STYLE_LONG;
}
static int32_t styleSuffixLength(UDateRelativeDateTimeFormatterStyle style) {
switch (style) {
case UDAT_STYLE_NARROW:
return 7;
case UDAT_STYLE_SHORT:
return 6;
default:
return 0;
}
}
// Utility functions
static UDateRelativeDateTimeFormatterStyle styleFromAliasUnicodeString(UnicodeString s) {
static const UChar narrow[7] = {0x002D, 0x006E, 0x0061, 0x0072, 0x0072, 0x006F, 0x0077};
static const UChar sshort[6] = {0x002D, 0x0073, 0x0068, 0x006F, 0x0072, 0x0074,};
if (s.endsWith(narrow, 7)) {
return UDAT_STYLE_NARROW;
}
if (s.endsWith(sshort, 6)) {
return UDAT_STYLE_SHORT;
}
return UDAT_STYLE_LONG;
}
static RelAbsUnit unitOrNegativeFromString(const char* keyword, int32_t length) {
// Quick check from string to enum.
switch (length) {
case 3:
if (uprv_strncmp(keyword, "day", length) == 0) {
return DAY;
} else if (uprv_strncmp(keyword, "sun", length) == 0) {
return SUNDAY;
} else if (uprv_strncmp(keyword, "mon", length) == 0) {
return MONDAY;
} else if (uprv_strncmp(keyword, "tue", length) == 0) {
return TUESDAY;
} else if (uprv_strncmp(keyword, "wed", length) == 0) {
return WEDNESDAY;
} else if (uprv_strncmp(keyword, "thu", length) == 0) {
return THURSDAY;
} else if (uprv_strncmp(keyword, "fri", length) == 0) {
return FRIDAY;
} else if (uprv_strncmp(keyword, "sat", length) == 0) {
return SATURDAY;
}
break;
case 4:
if (uprv_strncmp(keyword, "hour", length) == 0) {
return HOUR;
} else if (uprv_strncmp(keyword, "week", length) == 0) {
return WEEK;
} else if (uprv_strncmp(keyword, "year", length) == 0) {
return YEAR;
}
break;
case 5:
if (uprv_strncmp(keyword, "month", length) == 0) {
return MONTH;
}
break;
case 6:
if (uprv_strncmp(keyword, "minute", length) == 0) {
return MINUTE;
} else if (uprv_strncmp(keyword, "second", length) == 0) {
return SECOND;
}
break;
case 7:
if (uprv_strncmp(keyword, "quarter", length) == 0) {
return QUARTER; // TODO: Check @provisional
}
break;
default:
break;
}
return INVALID_UNIT;
}
// Member functions of top level sink.
virtual void put(const char *key, const ResourceValue &value, UErrorCode &errorCode) {
// Only handle aliases, storing information about alias fallback.
if (U_SUCCESS(errorCode)) {
if (value.getType() != URES_ALIAS) {
return;
}
const UnicodeString valueStr = value.getAliasUnicodeString(errorCode);
if (U_SUCCESS(errorCode)) {
UDateRelativeDateTimeFormatterStyle sourceStyle= styleFromString(key);
UDateRelativeDateTimeFormatterStyle targetStyle =
styleFromAliasUnicodeString(valueStr);
if (sourceStyle == targetStyle) {
errorCode = U_INVALID_FORMAT_ERROR;
return;
}
if (outputData.fallBackCache[sourceStyle] != -1 &&
outputData.fallBackCache[sourceStyle] != targetStyle) {
errorCode = U_INVALID_FORMAT_ERROR;
return;
}
outputData.fallBackCache[sourceStyle] = targetStyle;
}
}
return;
}
// Top level sink
virtual ResourceTableSink *getOrCreateTableSink(
const char *key, int32_t /* initialSize */, UErrorCode& /* errorCode */) {
style= styleFromString(key);
int32_t unitSize = uprv_strlen(key) - styleSuffixLength(style);
genericUnit = unitOrNegativeFromString(key, unitSize);
if (style < 0 || genericUnit == INVALID_UNIT) {
return NULL;
}
return &unitSink;
}
};
// Virtual destructors must be defined out of line.
RelDateTimeFmtDataSink::RelDateTimeDetailSink::~RelDateTimeDetailSink() {}
RelDateTimeFmtDataSink::RelativeTimeSink::~RelativeTimeSink() {}
RelDateTimeFmtDataSink::RelativeSink::~RelativeSink() {}
RelDateTimeFmtDataSink::UnitSink::~UnitSink() {}
RelDateTimeFmtDataSink::~RelDateTimeFmtDataSink() {}
} // namespace
DateFormatSymbols::DtWidthType styleToDateFormatSymbolWidth[UDAT_STYLE_COUNT] = {
DateFormatSymbols::WIDE, DateFormatSymbols::SHORT, DateFormatSymbols::NARROW
};
// Get days of weeks from the DateFormatSymbols class.
static void loadWeekdayNames(UnicodeString absoluteUnits[UDAT_STYLE_COUNT]
[UDAT_ABSOLUTE_UNIT_COUNT][UDAT_DIRECTION_COUNT],
const char* localeId,
UErrorCode& status) {
Locale locale(localeId);
DateFormatSymbols dfSym(locale, status);
for (int32_t style = 0; style < UDAT_STYLE_COUNT; ++style) {
DateFormatSymbols::DtWidthType dtfmtWidth = styleToDateFormatSymbolWidth[style];
int32_t count;
const UnicodeString* weekdayNames =
dfSym.getWeekdays(count, DateFormatSymbols::STANDALONE, dtfmtWidth);
for (int32_t dayIndex = UDAT_ABSOLUTE_SUNDAY;
dayIndex <= UDAT_ABSOLUTE_SATURDAY; ++ dayIndex) {
int32_t dateSymbolIndex = (dayIndex - UDAT_ABSOLUTE_SUNDAY) + UCAL_SUNDAY;
absoluteUnits[style][dayIndex][UDAT_DIRECTION_PLAIN].fastCopyFrom(
weekdayNames[dateSymbolIndex]);
}
}
}
static UBool loadUnitData(
const UResourceBundle *resource,
RelativeDateTimeCacheData &cacheData,
const char* localeId,
UErrorCode &status) {
RelDateTimeFmtDataSink sink(cacheData, localeId);
ures_getAllTableItemsWithFallback(resource, "fields", sink, status);
// Get the weekday names from DateFormatSymbols.
loadWeekdayNames(cacheData.absoluteUnits, localeId, 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 too 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,
localeId,
status)) {
return NULL;
}
UnicodeString dateTimePattern;
if (!getDateTimePattern(topLevel.getAlias(), dateTimePattern, status)) {
return NULL;
}
result->adoptCombinedDateAndTime(
new SimpleFormatter(dateTimePattern, 2, 2, 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);
UnicodeString result;
UnicodeString formattedNumber;
StandardPlural::Form pluralIndex = QuantityFormatter::selectPlural(
quantity, **fNumberFormat, **fPluralRules, formattedNumber, pos,
status);
const SimpleFormatter* formatter =
fCache->getRelativeUnitFormatter(fStyle, unit, bFuture, pluralIndex);
if (formatter == NULL) {
// TODO: WARN - look at quantity formatter's action with an error.
status = U_INVALID_FORMAT_ERROR;
return appendTo;
}
formatter->format(formattedNumber, result, status);
adjustForContext(result);
return appendTo.append(result);
}
UnicodeString& RelativeDateTimeFormatter::formatNumeric(
double offset, URelativeDateTimeUnit unit,
UnicodeString& appendTo, UErrorCode& status) const {
if (U_FAILURE(status)) {
return appendTo;
}
// TODO:
// The full implementation of this depends on CLDR data that is not yet available,
// see: http://unicode.org/cldr/trac/ticket/9165 Add more relative field data.
// In the meantime do a quick bring-up by calling the old format method; this
// leaves some holes (even for data that is currently available, such as quarter).
// When the new CLDR data is available, update the data storage accordingly,
// rewrite this to use it directly, and rewrite the old format method to call this
// new one; that is covered by http://bugs.icu-project.org/trac/ticket/12171.
UDateRelativeUnit relunit = UDAT_RELATIVE_UNIT_COUNT;
switch (unit) {
case UDAT_REL_UNIT_YEAR: relunit = UDAT_RELATIVE_YEARS; break;
case UDAT_REL_UNIT_MONTH: relunit = UDAT_RELATIVE_MONTHS; break;
case UDAT_REL_UNIT_WEEK: relunit = UDAT_RELATIVE_WEEKS; break;
case UDAT_REL_UNIT_DAY: relunit = UDAT_RELATIVE_DAYS; break;
case UDAT_REL_UNIT_HOUR: relunit = UDAT_RELATIVE_HOURS; break;
case UDAT_REL_UNIT_MINUTE: relunit = UDAT_RELATIVE_MINUTES; break;
case UDAT_REL_UNIT_SECOND: relunit = UDAT_RELATIVE_SECONDS; break;
default: // a unit that the above method does not handle
status = U_UNSUPPORTED_ERROR;
return appendTo;
}
UDateDirection direction = UDAT_DIRECTION_NEXT;
if (offset < 0) {
direction = UDAT_DIRECTION_LAST;
offset = -offset;
}
return format(offset, direction, relunit, appendTo, status);
}
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;
}
// Get string using fallback.
UnicodeString result;
result.fastCopyFrom(fCache->getAbsoluteUnitString(fStyle, unit, direction));
if (fOptBreakIterator != NULL) {
adjustForContext(result);
}
return appendTo.append(result);
}
UnicodeString& RelativeDateTimeFormatter::format(
double offset, URelativeDateTimeUnit unit,
UnicodeString& appendTo, UErrorCode& status) const {
if (U_FAILURE(status)) {
return appendTo;
}
// TODO:
// The full implementation of this depends on CLDR data that is not yet available,
// see: http://unicode.org/cldr/trac/ticket/9165 Add more relative field data.
// In the meantime do a quick bring-up by calling the old format method; this
// leaves some holes (even for data that is currently available, such as quarter).
// When the new CLDR data is available, update the data storage accordingly,
// rewrite this to use it directly, and rewrite the old format method to call this
// new one; that is covered by http://bugs.icu-project.org/trac/ticket/12171.
UDateDirection direction = UDAT_DIRECTION_COUNT;
if (offset > -2.1 && offset < 2.1) {
// Allow a 1% epsilon, so offsets in -1.01..-0.99 map to LAST
double offsetx100 = offset * 100.0;
int32_t intoffset = (offsetx100 < 0)? (int32_t)(offsetx100-0.5) : (int32_t)(offsetx100+0.5);
switch (intoffset) {
case -200/*-2*/: direction = UDAT_DIRECTION_LAST_2; break;
case -100/*-1*/: direction = UDAT_DIRECTION_LAST; break;
case 0/* 0*/: direction = UDAT_DIRECTION_THIS; break;
case 100/* 1*/: direction = UDAT_DIRECTION_NEXT; break;
case 200/* 2*/: direction = UDAT_DIRECTION_NEXT_2; break;
default: break;
}
}
UDateAbsoluteUnit absunit = UDAT_ABSOLUTE_UNIT_COUNT;
switch (unit) {
case UDAT_REL_UNIT_YEAR: absunit = UDAT_ABSOLUTE_YEAR; break;
case UDAT_REL_UNIT_MONTH: absunit = UDAT_ABSOLUTE_MONTH; break;
case UDAT_REL_UNIT_WEEK: absunit = UDAT_ABSOLUTE_WEEK; break;
case UDAT_REL_UNIT_DAY: absunit = UDAT_ABSOLUTE_DAY; break;
case UDAT_REL_UNIT_SECOND:
if (direction == UDAT_DIRECTION_THIS) {
absunit = UDAT_ABSOLUTE_NOW;
direction = UDAT_DIRECTION_PLAIN;
}
break;
case UDAT_REL_UNIT_SUNDAY: absunit = UDAT_ABSOLUTE_SUNDAY; break;
case UDAT_REL_UNIT_MONDAY: absunit = UDAT_ABSOLUTE_MONDAY; break;
case UDAT_REL_UNIT_TUESDAY: absunit = UDAT_ABSOLUTE_TUESDAY; break;
case UDAT_REL_UNIT_WEDNESDAY: absunit = UDAT_ABSOLUTE_WEDNESDAY; break;
case UDAT_REL_UNIT_THURSDAY: absunit = UDAT_ABSOLUTE_THURSDAY; break;
case UDAT_REL_UNIT_FRIDAY: absunit = UDAT_ABSOLUTE_FRIDAY; break;
case UDAT_REL_UNIT_SATURDAY: absunit = UDAT_ABSOLUTE_SATURDAY; break;
default: break;
}
if (direction != UDAT_DIRECTION_COUNT && absunit != UDAT_ABSOLUTE_UNIT_COUNT) {
const UnicodeString &unitFormatString =
fCache->getAbsoluteUnitString(fStyle, absunit, direction);
if (!unitFormatString.isEmpty()) {
if (fOptBreakIterator != NULL) {
UnicodeString result(unitFormatString);
adjustForContext(result);
return appendTo.append(result);
} else {
return appendTo.append(unitFormatString);
}
}
}
// otherwise fallback to formatNumeric
return formatNumeric(offset, unit, appendTo, status);
}
UnicodeString& RelativeDateTimeFormatter::combineDateAndTime(
const UnicodeString& relativeDateString, const UnicodeString& timeString,
UnicodeString& appendTo, UErrorCode& status) const {
return fCache->getCombinedDateAndTime()->format(
timeString, relativeDateString, appendTo, 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
// Plain C API
U_NAMESPACE_USE
U_CAPI URelativeDateTimeFormatter* U_EXPORT2
ureldatefmt_open( const char* locale,
UNumberFormat* nfToAdopt,
UDateRelativeDateTimeFormatterStyle width,
UDisplayContext capitalizationContext,
UErrorCode* status )
{
if (U_FAILURE(*status)) {
return NULL;
}
LocalPointer<RelativeDateTimeFormatter> formatter(new RelativeDateTimeFormatter(Locale(locale),
(NumberFormat*)nfToAdopt, width,
capitalizationContext, *status), *status);
if (U_FAILURE(*status)) {
return NULL;
}
return (URelativeDateTimeFormatter*)formatter.orphan();
}
U_CAPI void U_EXPORT2
ureldatefmt_close(URelativeDateTimeFormatter *reldatefmt)
{
delete (RelativeDateTimeFormatter*)reldatefmt;
}
U_CAPI int32_t U_EXPORT2
ureldatefmt_formatNumeric( const URelativeDateTimeFormatter* reldatefmt,
double offset,
URelativeDateTimeUnit unit,
UChar* result,
int32_t resultCapacity,
UErrorCode* status)
{
if (U_FAILURE(*status)) {
return 0;
}
if (result == NULL ? resultCapacity != 0 : resultCapacity < 0) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
UnicodeString res;
if (result != NULL) {
// NULL destination for pure preflighting: empty dummy string
// otherwise, alias the destination buffer (copied from udat_format)
res.setTo(result, 0, resultCapacity);
}
((RelativeDateTimeFormatter*)reldatefmt)->formatNumeric(offset, unit, res, *status);
if (U_FAILURE(*status)) {
return 0;
}
return res.extract(result, resultCapacity, *status);
}
U_CAPI int32_t U_EXPORT2
ureldatefmt_format( const URelativeDateTimeFormatter* reldatefmt,
double offset,
URelativeDateTimeUnit unit,
UChar* result,
int32_t resultCapacity,
UErrorCode* status)
{
if (U_FAILURE(*status)) {
return 0;
}
if (result == NULL ? resultCapacity != 0 : resultCapacity < 0) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
UnicodeString res;
if (result != NULL) {
// NULL destination for pure preflighting: empty dummy string
// otherwise, alias the destination buffer (copied from udat_format)
res.setTo(result, 0, resultCapacity);
}
((RelativeDateTimeFormatter*)reldatefmt)->format(offset, unit, res, *status);
if (U_FAILURE(*status)) {
return 0;
}
return res.extract(result, resultCapacity, *status);
}
U_CAPI int32_t U_EXPORT2
ureldatefmt_combineDateAndTime( const URelativeDateTimeFormatter* reldatefmt,
const UChar * relativeDateString,
int32_t relativeDateStringLen,
const UChar * timeString,
int32_t timeStringLen,
UChar* result,
int32_t resultCapacity,
UErrorCode* status )
{
if (U_FAILURE(*status)) {
return 0;
}
if (result == NULL ? resultCapacity != 0 : resultCapacity < 0 ||
(relativeDateString == NULL ? relativeDateStringLen != 0 : relativeDateStringLen < -1) ||
(timeString == NULL ? timeStringLen != 0 : timeStringLen < -1)) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
UnicodeString relDateStr((UBool)(relativeDateStringLen == -1), relativeDateString, relativeDateStringLen);
UnicodeString timeStr((UBool)(timeStringLen == -1), timeString, timeStringLen);
UnicodeString res(result, 0, resultCapacity);
((RelativeDateTimeFormatter*)reldatefmt)->combineDateAndTime(relDateStr, timeStr, res, *status);
if (U_FAILURE(*status)) {
return 0;
}
return res.extract(result, resultCapacity, *status);
}
#endif /* !UCONFIG_NO_FORMATTING */