1417 lines
48 KiB
C++
1417 lines
48 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
******************************************************************************
|
|
* 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 <cmath>
|
|
#include <functional>
|
|
#include "unicode/dtfmtsym.h"
|
|
#include "unicode/ucasemap.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"
|
|
#include "util.h"
|
|
#include "formatted_string_builder.h"
|
|
#include "number_utypes.h"
|
|
#include "number_modifiers.h"
|
|
#include "formattedval_impl.h"
|
|
#include "number_utils.h"
|
|
|
|
// Copied from uscript_props.cpp
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
// RelativeDateTimeFormatter specific data for a single locale
|
|
class RelativeDateTimeCacheData: public SharedObject {
|
|
public:
|
|
RelativeDateTimeCacheData() : combinedDateAndTime(nullptr) {
|
|
// Initialize the cache arrays
|
|
for (int32_t style = 0; style < UDAT_STYLE_COUNT; ++style) {
|
|
for (int32_t relUnit = 0; relUnit < UDAT_REL_UNIT_COUNT; ++relUnit) {
|
|
for (int32_t pl = 0; pl < StandardPlural::COUNT; ++pl) {
|
|
relativeUnitsFormatters[style][relUnit][0][pl] = nullptr;
|
|
relativeUnitsFormatters[style][relUnit][1][pl] = nullptr;
|
|
}
|
|
}
|
|
}
|
|
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_REL_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 SimpleFormatter* getRelativeDateTimeUnitFormatter(int32_t fStyle,
|
|
URelativeDateTimeUnit unit,
|
|
int32_t pastFutureIndex,
|
|
int32_t pluralUnit) const;
|
|
|
|
const UnicodeString emptyString;
|
|
|
|
// Mapping 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_REL_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;
|
|
}
|
|
|
|
const SimpleFormatter* RelativeDateTimeCacheData::getRelativeUnitFormatter(
|
|
int32_t fStyle,
|
|
UDateRelativeUnit unit,
|
|
int32_t pastFutureIndex,
|
|
int32_t pluralUnit) const {
|
|
URelativeDateTimeUnit rdtunit = UDAT_REL_UNIT_COUNT;
|
|
switch (unit) {
|
|
case UDAT_RELATIVE_YEARS: rdtunit = UDAT_REL_UNIT_YEAR; break;
|
|
case UDAT_RELATIVE_MONTHS: rdtunit = UDAT_REL_UNIT_MONTH; break;
|
|
case UDAT_RELATIVE_WEEKS: rdtunit = UDAT_REL_UNIT_WEEK; break;
|
|
case UDAT_RELATIVE_DAYS: rdtunit = UDAT_REL_UNIT_DAY; break;
|
|
case UDAT_RELATIVE_HOURS: rdtunit = UDAT_REL_UNIT_HOUR; break;
|
|
case UDAT_RELATIVE_MINUTES: rdtunit = UDAT_REL_UNIT_MINUTE; break;
|
|
case UDAT_RELATIVE_SECONDS: rdtunit = UDAT_REL_UNIT_SECOND; break;
|
|
default: // a unit that the above method does not handle
|
|
return nullptr;
|
|
}
|
|
|
|
return getRelativeDateTimeUnitFormatter(fStyle, rdtunit, pastFutureIndex, pluralUnit);
|
|
}
|
|
|
|
// Use fallback cache for SimpleFormatter relativeUnits.
|
|
const SimpleFormatter* RelativeDateTimeCacheData::getRelativeDateTimeUnitFormatter(
|
|
int32_t fStyle,
|
|
URelativeDateTimeUnit unit,
|
|
int32_t pastFutureIndex,
|
|
int32_t pluralUnit) const {
|
|
while (true) {
|
|
int32_t style = fStyle;
|
|
do {
|
|
if (relativeUnitsFormatters[style][unit][pastFutureIndex][pluralUnit] != nullptr) {
|
|
return relativeUnitsFormatters[style][unit][pastFutureIndex][pluralUnit];
|
|
}
|
|
style = fallBackCache[style];
|
|
} while (style != -1);
|
|
|
|
if (pluralUnit == StandardPlural::OTHER) {
|
|
break;
|
|
}
|
|
pluralUnit = StandardPlural::OTHER;
|
|
}
|
|
return nullptr; // 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.
|
|
*
|
|
* 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.
|
|
*/
|
|
struct RelDateTimeFmtDataSink : public ResourceSink {
|
|
|
|
/**
|
|
* 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_REL_UNIT_SECOND;
|
|
case MINUTE:
|
|
return UDAT_REL_UNIT_MINUTE;
|
|
case HOUR:
|
|
return UDAT_REL_UNIT_HOUR;
|
|
case DAY:
|
|
return UDAT_REL_UNIT_DAY;
|
|
case WEEK:
|
|
return UDAT_REL_UNIT_WEEK;
|
|
case MONTH:
|
|
return UDAT_REL_UNIT_MONTH;
|
|
case QUARTER:
|
|
return UDAT_REL_UNIT_QUARTER;
|
|
case YEAR:
|
|
return UDAT_REL_UNIT_YEAR;
|
|
case SUNDAY:
|
|
return UDAT_REL_UNIT_SUNDAY;
|
|
case MONDAY:
|
|
return UDAT_REL_UNIT_MONDAY;
|
|
case TUESDAY:
|
|
return UDAT_REL_UNIT_TUESDAY;
|
|
case WEDNESDAY:
|
|
return UDAT_REL_UNIT_WEDNESDAY;
|
|
case THURSDAY:
|
|
return UDAT_REL_UNIT_THURSDAY;
|
|
case FRIDAY:
|
|
return UDAT_REL_UNIT_FRIDAY;
|
|
case SATURDAY:
|
|
return UDAT_REL_UNIT_SATURDAY;
|
|
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;
|
|
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;
|
|
case HOUR:
|
|
return UDAT_ABSOLUTE_HOUR;
|
|
case MINUTE:
|
|
return UDAT_ABSOLUTE_MINUTE;
|
|
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;
|
|
}
|
|
|
|
// Values kept between levels of parsing the CLDR data.
|
|
int32_t pastFutureIndex; // 0 == past or 1 == future
|
|
UDateRelativeDateTimeFormatterStyle style; // {LONG, SHORT, NARROW}
|
|
RelAbsUnit genericUnit;
|
|
|
|
RelativeDateTimeCacheData &outputData;
|
|
|
|
// Constructor
|
|
RelDateTimeFmtDataSink(RelativeDateTimeCacheData& cacheData)
|
|
: 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 = static_cast<int32_t>(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;
|
|
}
|
|
|
|
void handlePlainDirection(ResourceValue &value, UErrorCode &errorCode) {
|
|
// Handle Display Name for PLAIN direction for some units.
|
|
if (U_FAILURE(errorCode)) { return; }
|
|
|
|
int32_t absUnit = absUnitFromGeneric(genericUnit);
|
|
if (absUnit < 0) {
|
|
return; // Not interesting.
|
|
}
|
|
|
|
// Store displayname if not set.
|
|
if (outputData.absoluteUnits[style]
|
|
[absUnit][UDAT_DIRECTION_PLAIN].isEmpty()) {
|
|
outputData.absoluteUnits[style]
|
|
[absUnit][UDAT_DIRECTION_PLAIN].fastCopyFrom(value.getUnicodeString(errorCode));
|
|
return;
|
|
}
|
|
}
|
|
|
|
void consumeTableRelative(const char *key, ResourceValue &value, UErrorCode &errorCode) {
|
|
ResourceTable unitTypesTable = value.getTable(errorCode);
|
|
if (U_FAILURE(errorCode)) { return; }
|
|
|
|
for (int32_t i = 0; unitTypesTable.getKeyAndValue(i, key, value); ++i) {
|
|
if (value.getType() == URES_STRING) {
|
|
int32_t direction = keyToDirection(key);
|
|
if (direction < 0) {
|
|
continue;
|
|
}
|
|
|
|
int32_t relUnitIndex = relUnitFromGeneric(genericUnit);
|
|
if (relUnitIndex == UDAT_REL_UNIT_SECOND && uprv_strcmp(key, "0") == 0 &&
|
|
outputData.absoluteUnits[style][UDAT_ABSOLUTE_NOW][UDAT_DIRECTION_PLAIN].isEmpty()) {
|
|
// Handle "NOW"
|
|
outputData.absoluteUnits[style][UDAT_ABSOLUTE_NOW]
|
|
[UDAT_DIRECTION_PLAIN].fastCopyFrom(value.getUnicodeString(errorCode));
|
|
}
|
|
|
|
int32_t absUnitIndex = absUnitFromGeneric(genericUnit);
|
|
if (absUnitIndex < 0) {
|
|
continue;
|
|
}
|
|
// Only reset if slot is empty.
|
|
if (outputData.absoluteUnits[style][absUnitIndex][direction].isEmpty()) {
|
|
outputData.absoluteUnits[style][absUnitIndex]
|
|
[direction].fastCopyFrom(value.getUnicodeString(errorCode));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void consumeTimeDetail(int32_t relUnitIndex,
|
|
const char *key, ResourceValue &value, UErrorCode &errorCode) {
|
|
ResourceTable unitTypesTable = value.getTable(errorCode);
|
|
if (U_FAILURE(errorCode)) { return; }
|
|
|
|
for (int32_t i = 0; unitTypesTable.getKeyAndValue(i, key, value); ++i) {
|
|
if (value.getType() == URES_STRING) {
|
|
int32_t pluralIndex = StandardPlural::indexOrNegativeFromString(key);
|
|
if (pluralIndex >= 0) {
|
|
SimpleFormatter **patterns =
|
|
outputData.relativeUnitsFormatters[style][relUnitIndex]
|
|
[pastFutureIndex];
|
|
// Only set if not already established.
|
|
if (patterns[pluralIndex] == nullptr) {
|
|
patterns[pluralIndex] = new SimpleFormatter(
|
|
value.getUnicodeString(errorCode), 0, 1, errorCode);
|
|
if (patterns[pluralIndex] == nullptr) {
|
|
errorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void consumeTableRelativeTime(const char *key, ResourceValue &value, UErrorCode &errorCode) {
|
|
ResourceTable relativeTimeTable = value.getTable(errorCode);
|
|
if (U_FAILURE(errorCode)) { return; }
|
|
|
|
int32_t relUnitIndex = relUnitFromGeneric(genericUnit);
|
|
if (relUnitIndex < 0) {
|
|
return;
|
|
}
|
|
for (int32_t i = 0; relativeTimeTable.getKeyAndValue(i, key, value); ++i) {
|
|
if (uprv_strcmp(key, "past") == 0) {
|
|
pastFutureIndex = 0;
|
|
} else if (uprv_strcmp(key, "future") == 0) {
|
|
pastFutureIndex = 1;
|
|
} else {
|
|
// Unknown key.
|
|
continue;
|
|
}
|
|
consumeTimeDetail(relUnitIndex, key, value, errorCode);
|
|
}
|
|
}
|
|
|
|
void consumeAlias(const char *key, const ResourceValue &value, UErrorCode &errorCode) {
|
|
|
|
UDateRelativeDateTimeFormatterStyle sourceStyle = styleFromString(key);
|
|
const UnicodeString valueStr = value.getAliasUnicodeString(errorCode);
|
|
if (U_FAILURE(errorCode)) { return; }
|
|
|
|
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;
|
|
}
|
|
|
|
void consumeTimeUnit(const char *key, ResourceValue &value, UErrorCode &errorCode) {
|
|
ResourceTable unitTypesTable = value.getTable(errorCode);
|
|
if (U_FAILURE(errorCode)) { return; }
|
|
|
|
for (int32_t i = 0; unitTypesTable.getKeyAndValue(i, key, value); ++i) {
|
|
// Handle display name.
|
|
if (uprv_strcmp(key, "dn") == 0 && value.getType() == URES_STRING) {
|
|
handlePlainDirection(value, errorCode);
|
|
}
|
|
if (value.getType() == URES_TABLE) {
|
|
if (uprv_strcmp(key, "relative") == 0) {
|
|
consumeTableRelative(key, value, errorCode);
|
|
} else if (uprv_strcmp(key, "relativeTime") == 0) {
|
|
consumeTableRelativeTime(key, value, errorCode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void put(const char *key, ResourceValue &value,
|
|
UBool /*noFallback*/, UErrorCode &errorCode) override {
|
|
// Main entry point to sink
|
|
ResourceTable table = value.getTable(errorCode);
|
|
if (U_FAILURE(errorCode)) { return; }
|
|
for (int32_t i = 0; table.getKeyAndValue(i, key, value); ++i) {
|
|
if (value.getType() == URES_ALIAS) {
|
|
consumeAlias(key, value, errorCode);
|
|
} else {
|
|
style = styleFromString(key);
|
|
int32_t unitSize = static_cast<int32_t>(uprv_strlen(key)) - styleSuffixLength(style);
|
|
genericUnit = unitOrNegativeFromString(key, unitSize);
|
|
if (style >= 0 && genericUnit != INVALID_UNIT) {
|
|
consumeTimeUnit(key, value, errorCode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
// Virtual destructors must be defined out of line.
|
|
RelDateTimeFmtDataSink::~RelDateTimeFmtDataSink() {}
|
|
} // namespace
|
|
|
|
static const 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) {
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
Locale locale(localeId);
|
|
DateFormatSymbols dfSym(locale, status);
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
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);
|
|
|
|
ures_getAllItemsWithFallback(resource, "fields", sink, status);
|
|
if (U_FAILURE(status)) {
|
|
return false;
|
|
}
|
|
|
|
// 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(), nullptr, &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(nullptr, localeId, &status));
|
|
if (U_FAILURE(status)) {
|
|
return nullptr;
|
|
}
|
|
LocalPointer<RelativeDateTimeCacheData> result(
|
|
new RelativeDateTimeCacheData());
|
|
if (result.isNull()) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return nullptr;
|
|
}
|
|
if (!loadUnitData(
|
|
topLevel.getAlias(),
|
|
*result,
|
|
localeId,
|
|
status)) {
|
|
return nullptr;
|
|
}
|
|
UnicodeString dateTimePattern;
|
|
if (!getDateTimePattern(topLevel.getAlias(), dateTimePattern, status)) {
|
|
return nullptr;
|
|
}
|
|
result->adoptCombinedDateAndTime(
|
|
new SimpleFormatter(dateTimePattern, 2, 2, status));
|
|
if (U_FAILURE(status)) {
|
|
return nullptr;
|
|
}
|
|
result->addRef();
|
|
return result.orphan();
|
|
}
|
|
|
|
|
|
|
|
static constexpr FormattedStringBuilder::Field kRDTNumericField
|
|
= {UFIELD_CATEGORY_RELATIVE_DATETIME, UDAT_REL_NUMERIC_FIELD};
|
|
|
|
static constexpr FormattedStringBuilder::Field kRDTLiteralField
|
|
= {UFIELD_CATEGORY_RELATIVE_DATETIME, UDAT_REL_LITERAL_FIELD};
|
|
|
|
class FormattedRelativeDateTimeData : public FormattedValueStringBuilderImpl {
|
|
public:
|
|
FormattedRelativeDateTimeData() : FormattedValueStringBuilderImpl(kRDTNumericField) {}
|
|
virtual ~FormattedRelativeDateTimeData();
|
|
};
|
|
|
|
FormattedRelativeDateTimeData::~FormattedRelativeDateTimeData() = default;
|
|
|
|
|
|
UPRV_FORMATTED_VALUE_SUBCLASS_AUTO_IMPL(FormattedRelativeDateTime)
|
|
|
|
|
|
RelativeDateTimeFormatter::RelativeDateTimeFormatter(UErrorCode& status) :
|
|
fCache(nullptr),
|
|
fNumberFormat(nullptr),
|
|
fPluralRules(nullptr),
|
|
fStyle(UDAT_STYLE_LONG),
|
|
fContext(UDISPCTX_CAPITALIZATION_NONE),
|
|
fOptBreakIterator(nullptr) {
|
|
init(nullptr, nullptr, status);
|
|
}
|
|
|
|
RelativeDateTimeFormatter::RelativeDateTimeFormatter(
|
|
const Locale& locale, UErrorCode& status) :
|
|
fCache(nullptr),
|
|
fNumberFormat(nullptr),
|
|
fPluralRules(nullptr),
|
|
fStyle(UDAT_STYLE_LONG),
|
|
fContext(UDISPCTX_CAPITALIZATION_NONE),
|
|
fOptBreakIterator(nullptr),
|
|
fLocale(locale) {
|
|
init(nullptr, nullptr, status);
|
|
}
|
|
|
|
RelativeDateTimeFormatter::RelativeDateTimeFormatter(
|
|
const Locale& locale, NumberFormat *nfToAdopt, UErrorCode& status) :
|
|
fCache(nullptr),
|
|
fNumberFormat(nullptr),
|
|
fPluralRules(nullptr),
|
|
fStyle(UDAT_STYLE_LONG),
|
|
fContext(UDISPCTX_CAPITALIZATION_NONE),
|
|
fOptBreakIterator(nullptr),
|
|
fLocale(locale) {
|
|
init(nfToAdopt, nullptr, status);
|
|
}
|
|
|
|
RelativeDateTimeFormatter::RelativeDateTimeFormatter(
|
|
const Locale& locale,
|
|
NumberFormat *nfToAdopt,
|
|
UDateRelativeDateTimeFormatterStyle styl,
|
|
UDisplayContext capitalizationContext,
|
|
UErrorCode& status) :
|
|
fCache(nullptr),
|
|
fNumberFormat(nullptr),
|
|
fPluralRules(nullptr),
|
|
fStyle(styl),
|
|
fContext(capitalizationContext),
|
|
fOptBreakIterator(nullptr),
|
|
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, nullptr, 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 != nullptr) {
|
|
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 != nullptr) {
|
|
fCache->removeRef();
|
|
}
|
|
if (fNumberFormat != nullptr) {
|
|
fNumberFormat->removeRef();
|
|
}
|
|
if (fPluralRules != nullptr) {
|
|
fPluralRules->removeRef();
|
|
}
|
|
if (fOptBreakIterator != nullptr) {
|
|
fOptBreakIterator->removeRef();
|
|
}
|
|
}
|
|
|
|
const NumberFormat& RelativeDateTimeFormatter::getNumberFormat() const {
|
|
return **fNumberFormat;
|
|
}
|
|
|
|
UDisplayContext RelativeDateTimeFormatter::getCapitalizationContext() const {
|
|
return fContext;
|
|
}
|
|
|
|
UDateRelativeDateTimeFormatterStyle RelativeDateTimeFormatter::getFormatStyle() const {
|
|
return fStyle;
|
|
}
|
|
|
|
|
|
// To reduce boilerplate code, we use a helper function that forwards variadic
|
|
// arguments to the formatImpl function.
|
|
|
|
template<typename F, typename... Args>
|
|
UnicodeString& RelativeDateTimeFormatter::doFormat(
|
|
F callback,
|
|
UnicodeString& appendTo,
|
|
UErrorCode& status,
|
|
Args... args) const {
|
|
FormattedRelativeDateTimeData output;
|
|
(this->*callback)(std::forward<Args>(args)..., output, status);
|
|
if (U_FAILURE(status)) {
|
|
return appendTo;
|
|
}
|
|
UnicodeString result = output.getStringRef().toUnicodeString();
|
|
return appendTo.append(adjustForContext(result));
|
|
}
|
|
|
|
template<typename F, typename... Args>
|
|
FormattedRelativeDateTime RelativeDateTimeFormatter::doFormatToValue(
|
|
F callback,
|
|
UErrorCode& status,
|
|
Args... args) const {
|
|
if (!checkNoAdjustForContext(status)) {
|
|
return FormattedRelativeDateTime(status);
|
|
}
|
|
LocalPointer<FormattedRelativeDateTimeData> output(
|
|
new FormattedRelativeDateTimeData(), status);
|
|
if (U_FAILURE(status)) {
|
|
return FormattedRelativeDateTime(status);
|
|
}
|
|
(this->*callback)(std::forward<Args>(args)..., *output, status);
|
|
output->getStringRef().writeTerminator(status);
|
|
return FormattedRelativeDateTime(output.orphan());
|
|
}
|
|
|
|
UnicodeString& RelativeDateTimeFormatter::format(
|
|
double quantity,
|
|
UDateDirection direction,
|
|
UDateRelativeUnit unit,
|
|
UnicodeString& appendTo,
|
|
UErrorCode& status) const {
|
|
return doFormat(
|
|
&RelativeDateTimeFormatter::formatImpl,
|
|
appendTo,
|
|
status,
|
|
quantity,
|
|
direction,
|
|
unit);
|
|
}
|
|
|
|
FormattedRelativeDateTime RelativeDateTimeFormatter::formatToValue(
|
|
double quantity,
|
|
UDateDirection direction,
|
|
UDateRelativeUnit unit,
|
|
UErrorCode& status) const {
|
|
return doFormatToValue(
|
|
&RelativeDateTimeFormatter::formatImpl,
|
|
status,
|
|
quantity,
|
|
direction,
|
|
unit);
|
|
}
|
|
|
|
void RelativeDateTimeFormatter::formatImpl(
|
|
double quantity,
|
|
UDateDirection direction,
|
|
UDateRelativeUnit unit,
|
|
FormattedRelativeDateTimeData& output,
|
|
UErrorCode& status) const {
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
if (direction != UDAT_DIRECTION_LAST && direction != UDAT_DIRECTION_NEXT) {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
int32_t bFuture = direction == UDAT_DIRECTION_NEXT ? 1 : 0;
|
|
|
|
StandardPlural::Form pluralForm;
|
|
QuantityFormatter::formatAndSelect(
|
|
quantity,
|
|
**fNumberFormat,
|
|
**fPluralRules,
|
|
output.getStringRef(),
|
|
pluralForm,
|
|
status);
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
|
|
const SimpleFormatter* formatter =
|
|
fCache->getRelativeUnitFormatter(fStyle, unit, bFuture, pluralForm);
|
|
if (formatter == nullptr) {
|
|
// TODO: WARN - look at quantity formatter's action with an error.
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
return;
|
|
}
|
|
|
|
number::impl::SimpleModifier modifier(*formatter, kRDTLiteralField, false);
|
|
modifier.formatAsPrefixSuffix(
|
|
output.getStringRef(), 0, output.getStringRef().length(), status);
|
|
}
|
|
|
|
UnicodeString& RelativeDateTimeFormatter::formatNumeric(
|
|
double offset,
|
|
URelativeDateTimeUnit unit,
|
|
UnicodeString& appendTo,
|
|
UErrorCode& status) const {
|
|
return doFormat(
|
|
&RelativeDateTimeFormatter::formatNumericImpl,
|
|
appendTo,
|
|
status,
|
|
offset,
|
|
unit);
|
|
}
|
|
|
|
FormattedRelativeDateTime RelativeDateTimeFormatter::formatNumericToValue(
|
|
double offset,
|
|
URelativeDateTimeUnit unit,
|
|
UErrorCode& status) const {
|
|
return doFormatToValue(
|
|
&RelativeDateTimeFormatter::formatNumericImpl,
|
|
status,
|
|
offset,
|
|
unit);
|
|
}
|
|
|
|
void RelativeDateTimeFormatter::formatNumericImpl(
|
|
double offset,
|
|
URelativeDateTimeUnit unit,
|
|
FormattedRelativeDateTimeData& output,
|
|
UErrorCode& status) const {
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
UDateDirection direction = UDAT_DIRECTION_NEXT;
|
|
if (std::signbit(offset)) { // needed to handle -0.0
|
|
direction = UDAT_DIRECTION_LAST;
|
|
offset = -offset;
|
|
}
|
|
if (direction != UDAT_DIRECTION_LAST && direction != UDAT_DIRECTION_NEXT) {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
int32_t bFuture = direction == UDAT_DIRECTION_NEXT ? 1 : 0;
|
|
|
|
StandardPlural::Form pluralForm;
|
|
QuantityFormatter::formatAndSelect(
|
|
offset,
|
|
**fNumberFormat,
|
|
**fPluralRules,
|
|
output.getStringRef(),
|
|
pluralForm,
|
|
status);
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
|
|
const SimpleFormatter* formatter =
|
|
fCache->getRelativeDateTimeUnitFormatter(fStyle, unit, bFuture, pluralForm);
|
|
if (formatter == nullptr) {
|
|
// TODO: WARN - look at quantity formatter's action with an error.
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
return;
|
|
}
|
|
|
|
number::impl::SimpleModifier modifier(*formatter, kRDTLiteralField, false);
|
|
modifier.formatAsPrefixSuffix(
|
|
output.getStringRef(), 0, output.getStringRef().length(), status);
|
|
}
|
|
|
|
UnicodeString& RelativeDateTimeFormatter::format(
|
|
UDateDirection direction,
|
|
UDateAbsoluteUnit unit,
|
|
UnicodeString& appendTo,
|
|
UErrorCode& status) const {
|
|
return doFormat(
|
|
&RelativeDateTimeFormatter::formatAbsoluteImpl,
|
|
appendTo,
|
|
status,
|
|
direction,
|
|
unit);
|
|
}
|
|
|
|
FormattedRelativeDateTime RelativeDateTimeFormatter::formatToValue(
|
|
UDateDirection direction,
|
|
UDateAbsoluteUnit unit,
|
|
UErrorCode& status) const {
|
|
return doFormatToValue(
|
|
&RelativeDateTimeFormatter::formatAbsoluteImpl,
|
|
status,
|
|
direction,
|
|
unit);
|
|
}
|
|
|
|
void RelativeDateTimeFormatter::formatAbsoluteImpl(
|
|
UDateDirection direction,
|
|
UDateAbsoluteUnit unit,
|
|
FormattedRelativeDateTimeData& output,
|
|
UErrorCode& status) const {
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
if (unit == UDAT_ABSOLUTE_NOW && direction != UDAT_DIRECTION_PLAIN) {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
|
|
// Get string using fallback.
|
|
output.getStringRef().append(
|
|
fCache->getAbsoluteUnitString(fStyle, unit, direction),
|
|
kRDTLiteralField,
|
|
status);
|
|
}
|
|
|
|
UnicodeString& RelativeDateTimeFormatter::format(
|
|
double offset,
|
|
URelativeDateTimeUnit unit,
|
|
UnicodeString& appendTo,
|
|
UErrorCode& status) const {
|
|
return doFormat(
|
|
&RelativeDateTimeFormatter::formatRelativeImpl,
|
|
appendTo,
|
|
status,
|
|
offset,
|
|
unit);
|
|
}
|
|
|
|
FormattedRelativeDateTime RelativeDateTimeFormatter::formatToValue(
|
|
double offset,
|
|
URelativeDateTimeUnit unit,
|
|
UErrorCode& status) const {
|
|
return doFormatToValue(
|
|
&RelativeDateTimeFormatter::formatRelativeImpl,
|
|
status,
|
|
offset,
|
|
unit);
|
|
}
|
|
|
|
void RelativeDateTimeFormatter::formatRelativeImpl(
|
|
double offset,
|
|
URelativeDateTimeUnit unit,
|
|
FormattedRelativeDateTimeData& output,
|
|
UErrorCode& status) const {
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
// 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 https://unicode-org.atlassian.net/browse/ICU-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_QUARTER: absunit = UDAT_ABSOLUTE_QUARTER; 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;
|
|
case UDAT_REL_UNIT_HOUR: absunit = UDAT_ABSOLUTE_HOUR; break;
|
|
case UDAT_REL_UNIT_MINUTE: absunit = UDAT_ABSOLUTE_MINUTE; break;
|
|
default: break;
|
|
}
|
|
if (direction != UDAT_DIRECTION_COUNT && absunit != UDAT_ABSOLUTE_UNIT_COUNT) {
|
|
formatAbsoluteImpl(direction, absunit, output, status);
|
|
if (output.getStringRef().length() != 0) {
|
|
return;
|
|
}
|
|
}
|
|
// otherwise fallback to formatNumeric
|
|
formatNumericImpl(offset, unit, output, status);
|
|
}
|
|
|
|
UnicodeString& RelativeDateTimeFormatter::combineDateAndTime(
|
|
const UnicodeString& relativeDateString, const UnicodeString& timeString,
|
|
UnicodeString& appendTo, UErrorCode& status) const {
|
|
return fCache->getCombinedDateAndTime()->format(
|
|
timeString, relativeDateString, appendTo, status);
|
|
}
|
|
|
|
UnicodeString& RelativeDateTimeFormatter::adjustForContext(UnicodeString &str) const {
|
|
if (fOptBreakIterator == nullptr
|
|
|| str.length() == 0 || !u_islower(str.char32At(0))) {
|
|
return str;
|
|
}
|
|
|
|
// Must guarantee that one thread at a time accesses the shared break
|
|
// iterator.
|
|
static UMutex gBrkIterMutex;
|
|
Mutex lock(&gBrkIterMutex);
|
|
str.toTitle(
|
|
fOptBreakIterator->get(),
|
|
fLocale,
|
|
U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
|
|
return str;
|
|
}
|
|
|
|
UBool RelativeDateTimeFormatter::checkNoAdjustForContext(UErrorCode& status) const {
|
|
// This is unsupported because it's hard to keep fields in sync with title
|
|
// casing. The code could be written and tested if there is demand.
|
|
if (fOptBreakIterator != nullptr) {
|
|
status = U_UNSUPPORTED_ERROR;
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
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 == nullptr) {
|
|
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 == nullptr) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
bi.orphan();
|
|
SharedObject::copyPtr(shared, fOptBreakIterator);
|
|
}
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
// Plain C API
|
|
|
|
U_NAMESPACE_USE
|
|
|
|
|
|
// Magic number: "FRDT" (FormattedRelativeDateTime) in ASCII
|
|
UPRV_FORMATTED_VALUE_CAPI_AUTO_IMPL(
|
|
FormattedRelativeDateTime,
|
|
UFormattedRelativeDateTime,
|
|
UFormattedRelativeDateTimeImpl,
|
|
UFormattedRelativeDateTimeApiHelper,
|
|
ureldatefmt,
|
|
0x46524454)
|
|
|
|
|
|
U_CAPI URelativeDateTimeFormatter* U_EXPORT2
|
|
ureldatefmt_open( const char* locale,
|
|
UNumberFormat* nfToAdopt,
|
|
UDateRelativeDateTimeFormatterStyle width,
|
|
UDisplayContext capitalizationContext,
|
|
UErrorCode* status )
|
|
{
|
|
if (U_FAILURE(*status)) {
|
|
return nullptr;
|
|
}
|
|
LocalPointer<RelativeDateTimeFormatter> formatter(new RelativeDateTimeFormatter(Locale(locale),
|
|
(NumberFormat*)nfToAdopt, width,
|
|
capitalizationContext, *status), *status);
|
|
if (U_FAILURE(*status)) {
|
|
return nullptr;
|
|
}
|
|
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 == nullptr ? resultCapacity != 0 : resultCapacity < 0) {
|
|
*status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return 0;
|
|
}
|
|
UnicodeString res;
|
|
if (result != nullptr) {
|
|
// nullptr 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 void U_EXPORT2
|
|
ureldatefmt_formatNumericToResult(
|
|
const URelativeDateTimeFormatter* reldatefmt,
|
|
double offset,
|
|
URelativeDateTimeUnit unit,
|
|
UFormattedRelativeDateTime* result,
|
|
UErrorCode* status) {
|
|
if (U_FAILURE(*status)) {
|
|
return;
|
|
}
|
|
auto* fmt = reinterpret_cast<const RelativeDateTimeFormatter*>(reldatefmt);
|
|
auto* resultImpl = UFormattedRelativeDateTimeApiHelper::validate(result, *status);
|
|
resultImpl->fImpl = fmt->formatNumericToValue(offset, unit, *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 == nullptr ? resultCapacity != 0 : resultCapacity < 0) {
|
|
*status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return 0;
|
|
}
|
|
UnicodeString res;
|
|
if (result != nullptr) {
|
|
// nullptr 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 void U_EXPORT2
|
|
ureldatefmt_formatToResult(
|
|
const URelativeDateTimeFormatter* reldatefmt,
|
|
double offset,
|
|
URelativeDateTimeUnit unit,
|
|
UFormattedRelativeDateTime* result,
|
|
UErrorCode* status) {
|
|
if (U_FAILURE(*status)) {
|
|
return;
|
|
}
|
|
auto* fmt = reinterpret_cast<const RelativeDateTimeFormatter*>(reldatefmt);
|
|
auto* resultImpl = UFormattedRelativeDateTimeApiHelper::validate(result, *status);
|
|
resultImpl->fImpl = fmt->formatToValue(offset, unit, *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 == nullptr ? resultCapacity != 0 : resultCapacity < 0 ||
|
|
(relativeDateString == nullptr ? relativeDateStringLen != 0 : relativeDateStringLen < -1) ||
|
|
(timeString == nullptr ? 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 */
|