blob: fbf8787c1ec63782f2ff0753a009c88af5f4b88f [file] [log] [blame]
/*******************************************************************************
* Copyright (C) 2008-2012, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*
* File DTITVFMT.CPP
*
*******************************************************************************
*/
#include "utypeinfo.h" // for 'typeid' to work
#include "unicode/dtitvfmt.h"
#if !UCONFIG_NO_FORMATTING
//TODO: put in compilation
//#define DTITVFMT_DEBUG 1
#include "cstring.h"
#include "unicode/msgfmt.h"
#include "unicode/dtptngen.h"
#include "unicode/dtitvinf.h"
#include "unicode/calendar.h"
#include "dtitv_impl.h"
#ifdef DTITVFMT_DEBUG
#include <iostream>
#include "cstring.h"
#endif
#include "gregoimp.h"
U_NAMESPACE_BEGIN
#ifdef DTITVFMT_DEBUG
#define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
#endif
static const UChar gDateFormatSkeleton[][11] = {
//yMMMMEEEEd
{LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, CAP_E, CAP_E, CAP_E, CAP_E, LOW_D, 0},
//yMMMMd
{LOW_Y, CAP_M, CAP_M, CAP_M, CAP_M, LOW_D, 0},
//yMMMd
{LOW_Y, CAP_M, CAP_M, CAP_M, LOW_D, 0},
//yMd
{LOW_Y, CAP_M, LOW_D, 0} };
static const char gDateTimePatternsTag[]="DateTimePatterns";
// latestFirst:
static const UChar gLaterFirstPrefix[] = {LOW_L, LOW_A, LOW_T, LOW_E, LOW_S,LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON};
// earliestFirst:
static const UChar gEarlierFirstPrefix[] = {LOW_E, LOW_A, LOW_R, LOW_L, LOW_I, LOW_E, LOW_S, LOW_T, CAP_F, LOW_I, LOW_R, LOW_S, LOW_T, COLON};
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalFormat)
DateIntervalFormat* U_EXPORT2
DateIntervalFormat::createInstance(const UnicodeString& skeleton,
UErrorCode& status) {
return createInstance(skeleton, Locale::getDefault(), status);
}
DateIntervalFormat* U_EXPORT2
DateIntervalFormat::createInstance(const UnicodeString& skeleton,
const Locale& locale,
UErrorCode& status) {
#ifdef DTITVFMT_DEBUG
char result[1000];
char result_1[1000];
char mesg[2000];
skeleton.extract(0, skeleton.length(), result, "UTF-8");
UnicodeString pat;
((SimpleDateFormat*)dtfmt)->toPattern(pat);
pat.extract(0, pat.length(), result_1, "UTF-8");
sprintf(mesg, "skeleton: %s; pattern: %s\n", result, result_1);
PRINTMESG(mesg)
#endif
DateIntervalInfo* dtitvinf = new DateIntervalInfo(locale, status);
return create(locale, dtitvinf, &skeleton, status);
}
DateIntervalFormat* U_EXPORT2
DateIntervalFormat::createInstance(const UnicodeString& skeleton,
const DateIntervalInfo& dtitvinf,
UErrorCode& status) {
return createInstance(skeleton, Locale::getDefault(), dtitvinf, status);
}
DateIntervalFormat* U_EXPORT2
DateIntervalFormat::createInstance(const UnicodeString& skeleton,
const Locale& locale,
const DateIntervalInfo& dtitvinf,
UErrorCode& status) {
DateIntervalInfo* ptn = dtitvinf.clone();
return create(locale, ptn, &skeleton, status);
}
DateIntervalFormat::DateIntervalFormat()
: fInfo(NULL),
fDateFormat(NULL),
fFromCalendar(NULL),
fToCalendar(NULL),
fDtpng(NULL)
{}
DateIntervalFormat::DateIntervalFormat(const DateIntervalFormat& itvfmt)
: Format(itvfmt),
fInfo(NULL),
fDateFormat(NULL),
fFromCalendar(NULL),
fToCalendar(NULL),
fDtpng(NULL) {
*this = itvfmt;
}
DateIntervalFormat&
DateIntervalFormat::operator=(const DateIntervalFormat& itvfmt) {
if ( this != &itvfmt ) {
delete fDateFormat;
delete fInfo;
delete fFromCalendar;
delete fToCalendar;
delete fDtpng;
if ( itvfmt.fDateFormat ) {
fDateFormat = (SimpleDateFormat*)itvfmt.fDateFormat->clone();
} else {
fDateFormat = NULL;
}
if ( itvfmt.fInfo ) {
fInfo = itvfmt.fInfo->clone();
} else {
fInfo = NULL;
}
if ( itvfmt.fFromCalendar ) {
fFromCalendar = itvfmt.fFromCalendar->clone();
} else {
fFromCalendar = NULL;
}
if ( itvfmt.fToCalendar ) {
fToCalendar = itvfmt.fToCalendar->clone();
} else {
fToCalendar = NULL;
}
fSkeleton = itvfmt.fSkeleton;
int8_t i;
for ( i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
fIntervalPatterns[i] = itvfmt.fIntervalPatterns[i];
}
if (itvfmt.fDtpng) {
fDtpng = itvfmt.fDtpng->clone();
}
}
return *this;
}
DateIntervalFormat::~DateIntervalFormat() {
delete fInfo;
delete fDateFormat;
delete fFromCalendar;
delete fToCalendar;
delete fDtpng;
}
Format*
DateIntervalFormat::clone(void) const {
return new DateIntervalFormat(*this);
}
UBool
DateIntervalFormat::operator==(const Format& other) const {
if (typeid(*this) == typeid(other)) {
const DateIntervalFormat* fmt = (DateIntervalFormat*)&other;
#ifdef DTITVFMT_DEBUG
UBool equal;
equal = (this == fmt);
equal = (*fInfo == *fmt->fInfo);
equal = (*fDateFormat == *fmt->fDateFormat);
equal = fFromCalendar->isEquivalentTo(*fmt->fFromCalendar) ;
equal = fToCalendar->isEquivalentTo(*fmt->fToCalendar) ;
equal = (fSkeleton == fmt->fSkeleton);
#endif
UBool res;
res = ( this == fmt ) ||
( Format::operator==(other) &&
fInfo &&
( *fInfo == *fmt->fInfo ) &&
fDateFormat &&
( *fDateFormat == *fmt->fDateFormat ) &&
fFromCalendar &&
fFromCalendar->isEquivalentTo(*fmt->fFromCalendar) &&
fToCalendar &&
fToCalendar->isEquivalentTo(*fmt->fToCalendar) &&
fSkeleton == fmt->fSkeleton &&
fDtpng &&
(*fDtpng == *fmt->fDtpng) );
int8_t i;
for (i = 0; i< DateIntervalInfo::kIPI_MAX_INDEX && res == TRUE; ++i ) {
res = ( fIntervalPatterns[i].firstPart ==
fmt->fIntervalPatterns[i].firstPart) &&
( fIntervalPatterns[i].secondPart ==
fmt->fIntervalPatterns[i].secondPart ) &&
( fIntervalPatterns[i].laterDateFirst ==
fmt->fIntervalPatterns[i].laterDateFirst) ;
}
return res;
}
return FALSE;
}
UnicodeString&
DateIntervalFormat::format(const Formattable& obj,
UnicodeString& appendTo,
FieldPosition& fieldPosition,
UErrorCode& status) const {
if ( U_FAILURE(status) ) {
return appendTo;
}
if ( obj.getType() == Formattable::kObject ) {
const UObject* formatObj = obj.getObject();
const DateInterval* interval = dynamic_cast<const DateInterval*>(formatObj);
if (interval != NULL){
return format(interval, appendTo, fieldPosition, status);
}
}
status = U_ILLEGAL_ARGUMENT_ERROR;
return appendTo;
}
UnicodeString&
DateIntervalFormat::format(const DateInterval* dtInterval,
UnicodeString& appendTo,
FieldPosition& fieldPosition,
UErrorCode& status) const {
if ( U_FAILURE(status) ) {
return appendTo;
}
if ( fFromCalendar != NULL && fToCalendar != NULL &&
fDateFormat != NULL && fInfo != NULL ) {
fFromCalendar->setTime(dtInterval->getFromDate(), status);
fToCalendar->setTime(dtInterval->getToDate(), status);
if ( U_SUCCESS(status) ) {
return format(*fFromCalendar, *fToCalendar, appendTo,fieldPosition, status);
}
}
return appendTo;
}
UnicodeString&
DateIntervalFormat::format(Calendar& fromCalendar,
Calendar& toCalendar,
UnicodeString& appendTo,
FieldPosition& pos,
UErrorCode& status) const {
if ( U_FAILURE(status) ) {
return appendTo;
}
// not support different calendar types and time zones
//if ( fromCalendar.getType() != toCalendar.getType() ) {
if ( !fromCalendar.isEquivalentTo(toCalendar) ) {
status = U_ILLEGAL_ARGUMENT_ERROR;
return appendTo;
}
// First, find the largest different calendar field.
UCalendarDateFields field = UCAL_FIELD_COUNT;
if ( fromCalendar.get(UCAL_ERA,status) != toCalendar.get(UCAL_ERA,status)) {
field = UCAL_ERA;
} else if ( fromCalendar.get(UCAL_YEAR, status) !=
toCalendar.get(UCAL_YEAR, status) ) {
field = UCAL_YEAR;
} else if ( fromCalendar.get(UCAL_MONTH, status) !=
toCalendar.get(UCAL_MONTH, status) ) {
field = UCAL_MONTH;
} else if ( fromCalendar.get(UCAL_DATE, status) !=
toCalendar.get(UCAL_DATE, status) ) {
field = UCAL_DATE;
} else if ( fromCalendar.get(UCAL_AM_PM, status) !=
toCalendar.get(UCAL_AM_PM, status) ) {
field = UCAL_AM_PM;
} else if ( fromCalendar.get(UCAL_HOUR, status) !=
toCalendar.get(UCAL_HOUR, status) ) {
field = UCAL_HOUR;
} else if ( fromCalendar.get(UCAL_MINUTE, status) !=
toCalendar.get(UCAL_MINUTE, status) ) {
field = UCAL_MINUTE;
}
if ( U_FAILURE(status) ) {
return appendTo;
}
if ( field == UCAL_FIELD_COUNT ) {
/* ignore the second/millisecond etc. small fields' difference.
* use single date when all the above are the same.
*/
return fDateFormat->format(fromCalendar, appendTo, pos);
}
// following call should not set wrong status,
// all the pass-in fields are valid till here
int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
status);
const PatternInfo& intervalPattern = fIntervalPatterns[itvPtnIndex];
if ( intervalPattern.firstPart.isEmpty() &&
intervalPattern.secondPart.isEmpty() ) {
if ( fDateFormat->isFieldUnitIgnored(field) ) {
/* the largest different calendar field is small than
* the smallest calendar field in pattern,
* return single date format.
*/
return fDateFormat->format(fromCalendar, appendTo, pos);
}
return fallbackFormat(fromCalendar, toCalendar, appendTo, pos, status);
}
// If the first part in interval pattern is empty,
// the 2nd part of it saves the full-pattern used in fall-back.
// For a 'real' interval pattern, the first part will never be empty.
if ( intervalPattern.firstPart.isEmpty() ) {
// fall back
UnicodeString originalPattern;
fDateFormat->toPattern(originalPattern);
fDateFormat->applyPattern(intervalPattern.secondPart);
appendTo = fallbackFormat(fromCalendar, toCalendar, appendTo, pos, status);
fDateFormat->applyPattern(originalPattern);
return appendTo;
}
Calendar* firstCal;
Calendar* secondCal;
if ( intervalPattern.laterDateFirst ) {
firstCal = &toCalendar;
secondCal = &fromCalendar;
} else {
firstCal = &fromCalendar;
secondCal = &toCalendar;
}
// break the interval pattern into 2 parts,
// first part should not be empty,
UnicodeString originalPattern;
fDateFormat->toPattern(originalPattern);
fDateFormat->applyPattern(intervalPattern.firstPart);
fDateFormat->format(*firstCal, appendTo, pos);
if ( !intervalPattern.secondPart.isEmpty() ) {
fDateFormat->applyPattern(intervalPattern.secondPart);
fDateFormat->format(*secondCal, appendTo, pos);
}
fDateFormat->applyPattern(originalPattern);
return appendTo;
}
void
DateIntervalFormat::parseObject(const UnicodeString& /* source */,
Formattable& /* result */,
ParsePosition& /* parse_pos */) const {
// parseObject(const UnicodeString&, Formattable&, UErrorCode&) const
// will set status as U_INVALID_FORMAT_ERROR if
// parse_pos is still 0
}
const DateIntervalInfo*
DateIntervalFormat::getDateIntervalInfo() const {
return fInfo;
}
void
DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern,
UErrorCode& status) {
delete fInfo;
fInfo = new DateIntervalInfo(newItvPattern);
if ( fDateFormat ) {
initializePattern(status);
}
}
const DateFormat*
DateIntervalFormat::getDateFormat() const {
return fDateFormat;
}
void
DateIntervalFormat::adoptTimeZone(TimeZone* zone)
{
if (fDateFormat != NULL) {
fDateFormat->adoptTimeZone(zone);
}
// The fDateFormat has the master calendar for the DateIntervalFormat and has
// ownership of any adopted TimeZone; fFromCalendar and fToCalendar are internal
// work clones of that calendar (and should not also be given ownership of the
// adopted TimeZone).
if (fFromCalendar) {
fFromCalendar->setTimeZone(*zone);
}
if (fToCalendar) {
fToCalendar->setTimeZone(*zone);
}
}
void
DateIntervalFormat::setTimeZone(const TimeZone& zone)
{
if (fDateFormat != NULL) {
fDateFormat->setTimeZone(zone);
}
// The fDateFormat has the master calendar for the DateIntervalFormat;
// fFromCalendar and fToCalendar are internal work clones of that calendar.
if (fFromCalendar) {
fFromCalendar->setTimeZone(zone);
}
if (fToCalendar) {
fToCalendar->setTimeZone(zone);
}
}
const TimeZone&
DateIntervalFormat::getTimeZone() const
{
if (fDateFormat != NULL) {
return fDateFormat->getTimeZone();
}
// If fDateFormat is NULL (unexpected), create default timezone.
return *(TimeZone::createDefault());
}
DateIntervalFormat::DateIntervalFormat(const Locale& locale,
DateIntervalInfo* dtItvInfo,
const UnicodeString* skeleton,
UErrorCode& status)
: fInfo(NULL),
fDateFormat(NULL),
fFromCalendar(NULL),
fToCalendar(NULL),
fDtpng(NULL)
{
if ( U_FAILURE(status) ) {
delete dtItvInfo;
return;
}
fDtpng = DateTimePatternGenerator::createInstance(locale, status);
SimpleDateFormat* dtfmt = createSDFPatternInstance(*skeleton, locale,
fDtpng, status);
if ( U_FAILURE(status) ) {
delete dtItvInfo;
delete fDtpng;
delete dtfmt;
return;
}
if ( dtfmt == NULL || dtItvInfo == NULL || fDtpng == NULL ) {
status = U_MEMORY_ALLOCATION_ERROR;
// safe to delete NULL
delete dtfmt;
delete dtItvInfo;
delete fDtpng;
return;
}
if ( skeleton ) {
fSkeleton = *skeleton;
}
fInfo = dtItvInfo;
fDateFormat = dtfmt;
if ( dtfmt->getCalendar() ) {
fFromCalendar = dtfmt->getCalendar()->clone();
fToCalendar = dtfmt->getCalendar()->clone();
} else {
fFromCalendar = NULL;
fToCalendar = NULL;
}
initializePattern(status);
}
SimpleDateFormat* U_EXPORT2
DateIntervalFormat::createSDFPatternInstance(const UnicodeString& skeleton,
const Locale& locale,
DateTimePatternGenerator* dtpng,
UErrorCode& status)
{
if ( U_FAILURE(status) ) {
return NULL;
}
const UnicodeString pattern = dtpng->getBestPattern(skeleton, status);
if ( U_FAILURE(status) ) {
return NULL;
}
SimpleDateFormat* dtfmt = new SimpleDateFormat(pattern, locale, status);
if ( U_FAILURE(status) ) {
delete dtfmt;
return NULL;
}
return dtfmt;
}
DateIntervalFormat* U_EXPORT2
DateIntervalFormat::create(const Locale& locale,
DateIntervalInfo* dtitvinf,
const UnicodeString* skeleton,
UErrorCode& status) {
DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf,
skeleton, status);
if ( f == NULL ) {
status = U_MEMORY_ALLOCATION_ERROR;
delete dtitvinf;
} else if ( U_FAILURE(status) ) {
// safe to delete f, although nothing acutally is saved
delete f;
f = 0;
}
return f;
}
/**
* Initialize interval patterns locale to this formatter
*
* This code is a bit complicated since
* 1. the interval patterns saved in resource bundle files are interval
* patterns based on date or time only.
* It does not have interval patterns based on both date and time.
* Interval patterns on both date and time are algorithm generated.
*
* For example, it has interval patterns on skeleton "dMy" and "hm",
* but it does not have interval patterns on skeleton "dMyhm".
*
* The rule to genearte interval patterns for both date and time skeleton are
* 1) when the year, month, or day differs, concatenate the two original
* expressions with a separator between,
* For example, interval pattern from "Jan 10, 2007 10:10 am"
* to "Jan 11, 2007 10:10am" is
* "Jan 10, 2007 10:10 am - Jan 11, 2007 10:10am"
*
* 2) otherwise, present the date followed by the range expression
* for the time.
* For example, interval pattern from "Jan 10, 2007 10:10 am"
* to "Jan 10, 2007 11:10am" is
* "Jan 10, 2007 10:10 am - 11:10am"
*
* 2. even a pattern does not request a certion calendar field,
* the interval pattern needs to include such field if such fields are
* different between 2 dates.
* For example, a pattern/skeleton is "hm", but the interval pattern
* includes year, month, and date when year, month, and date differs.
*
* @param status output param set to success/failure code on exit
* @stable ICU 4.0
*/
void
DateIntervalFormat::initializePattern(UErrorCode& status) {
if ( U_FAILURE(status) ) {
return;
}
const Locale& locale = fDateFormat->getSmpFmtLocale();
if ( fSkeleton.isEmpty() ) {
UnicodeString fullPattern;
fDateFormat->toPattern(fullPattern);
#ifdef DTITVFMT_DEBUG
char result[1000];
char result_1[1000];
char mesg[2000];
fSkeleton.extract(0, fSkeleton.length(), result, "UTF-8");
sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result);
PRINTMESG(mesg)
#endif
// fSkeleton is already set by createDateIntervalInstance()
// or by createInstance(UnicodeString skeleton, .... )
fSkeleton = fDtpng->getSkeleton(fullPattern, status);
if ( U_FAILURE(status) ) {
return;
}
}
// initialize the fIntervalPattern ordering
int8_t i;
for ( i = 0; i < DateIntervalInfo::kIPI_MAX_INDEX; ++i ) {
fIntervalPatterns[i].laterDateFirst = fInfo->getDefaultOrder();
}
/* Check whether the skeleton is a combination of date and time.
* For the complication reason 1 explained above.
*/
UnicodeString dateSkeleton;
UnicodeString timeSkeleton;
UnicodeString normalizedTimeSkeleton;
UnicodeString normalizedDateSkeleton;
/* the difference between time skeleton and normalizedTimeSkeleton are:
* 1. (Formerly, normalized time skeleton folded 'H' to 'h'; no longer true)
* 2. 'a' is omitted in normalized time skeleton.
* 3. there is only one appearance for 'h' or 'H', 'm','v', 'z' in normalized
* time skeleton
*
* The difference between date skeleton and normalizedDateSkeleton are:
* 1. both 'y' and 'd' appear only once in normalizeDateSkeleton
* 2. 'E' and 'EE' are normalized into 'EEE'
* 3. 'MM' is normalized into 'M'
*/
getDateTimeSkeleton(fSkeleton, dateSkeleton, normalizedDateSkeleton,
timeSkeleton, normalizedTimeSkeleton);
#ifdef DTITVFMT_DEBUG
char result[1000];
char result_1[1000];
char mesg[2000];
fSkeleton.extract(0, fSkeleton.length(), result, "UTF-8");
sprintf(mesg, "in getBestSkeleton: fSkeleton: %s; \n", result);
PRINTMESG(mesg)
#endif
UBool found = setSeparateDateTimePtn(normalizedDateSkeleton,
normalizedTimeSkeleton);
if ( found == false ) {
// use fallback
// TODO: if user asks "m"(minute), but "d"(day) differ
if ( timeSkeleton.length() != 0 ) {
if ( dateSkeleton.length() == 0 ) {
// prefix with yMd
timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1);
UnicodeString pattern = fDtpng->getBestPattern(timeSkeleton, status);
if ( U_FAILURE(status) ) {
return;
}
// for fall back interval patterns,
// the first part of the pattern is empty,
// the second part of the pattern is the full-pattern
// should be used in fall-back.
setPatternInfo(UCAL_DATE, NULL, &pattern, fInfo->getDefaultOrder());
setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder());
setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder());
} else {
// TODO: fall back
}
} else {
// TODO: fall back
}
return;
} // end of skeleton not found
// interval patterns for skeleton are found in resource
if ( timeSkeleton.length() == 0 ) {
// done
} else if ( dateSkeleton.length() == 0 ) {
// prefix with yMd
timeSkeleton.insert(0, gDateFormatSkeleton[DateFormat::kShort], -1);
UnicodeString pattern = fDtpng->getBestPattern(timeSkeleton, status);
if ( U_FAILURE(status) ) {
return;
}
// for fall back interval patterns,
// the first part of the pattern is empty,
// the second part of the pattern is the full-pattern
// should be used in fall-back.
setPatternInfo(UCAL_DATE, NULL, &pattern, fInfo->getDefaultOrder());
setPatternInfo(UCAL_MONTH, NULL, &pattern, fInfo->getDefaultOrder());
setPatternInfo(UCAL_YEAR, NULL, &pattern, fInfo->getDefaultOrder());
} else {
/* if both present,
* 1) when the year, month, or day differs,
* concatenate the two original expressions with a separator between,
* 2) otherwise, present the date followed by the
* range expression for the time.
*/
/*
* 1) when the year, month, or day differs,
* concatenate the two original expressions with a separator between,
*/
// if field exists, use fall back
UnicodeString skeleton = fSkeleton;
if ( !fieldExistsInSkeleton(UCAL_DATE, dateSkeleton) ) {
// prefix skeleton with 'd'
skeleton.insert(0, LOW_D);
setFallbackPattern(UCAL_DATE, skeleton, status);
}
if ( !fieldExistsInSkeleton(UCAL_MONTH, dateSkeleton) ) {
// then prefix skeleton with 'M'
skeleton.insert(0, CAP_M);
setFallbackPattern(UCAL_MONTH, skeleton, status);
}
if ( !fieldExistsInSkeleton(UCAL_YEAR, dateSkeleton) ) {
// then prefix skeleton with 'y'
skeleton.insert(0, LOW_Y);
setFallbackPattern(UCAL_YEAR, skeleton, status);
}
/*
* 2) otherwise, present the date followed by the
* range expression for the time.
*/
// Need the Date/Time pattern for concatnation the date with
// the time interval.
// The date/time pattern ( such as {0} {1} ) is saved in
// calendar, that is why need to get the CalendarData here.
CalendarData* calData = new CalendarData(locale, NULL, status);
if ( U_FAILURE(status) ) {
delete calData;
return;
}
if ( calData == NULL ) {
status = U_MEMORY_ALLOCATION_ERROR;
return;
}
const UResourceBundle* dateTimePatternsRes = calData->getByKey(
gDateTimePatternsTag, status);
int32_t dateTimeFormatLength;
const UChar* dateTimeFormat = ures_getStringByIndex(
dateTimePatternsRes,
(int32_t)DateFormat::kDateTime,
&dateTimeFormatLength, &status);
if ( U_FAILURE(status) ) {
return;
}
UnicodeString datePattern = fDtpng->getBestPattern(dateSkeleton, status);
concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength,
datePattern, UCAL_AM_PM, status);
concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength,
datePattern, UCAL_HOUR, status);
concatSingleDate2TimeInterval(dateTimeFormat, dateTimeFormatLength,
datePattern, UCAL_MINUTE, status);
delete calData;
}
}
void U_EXPORT2
DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
UnicodeString& dateSkeleton,
UnicodeString& normalizedDateSkeleton,
UnicodeString& timeSkeleton,
UnicodeString& normalizedTimeSkeleton) {
// dateSkeleton follows the sequence of y*M*E*d*
// timeSkeleton follows the sequence of hm*[v|z]?
int32_t ECount = 0;
int32_t dCount = 0;
int32_t MCount = 0;
int32_t yCount = 0;
int32_t hCount = 0;
int32_t HCount = 0;
int32_t mCount = 0;
int32_t vCount = 0;
int32_t zCount = 0;
int32_t i;
for (i = 0; i < skeleton.length(); ++i) {
UChar ch = skeleton[i];
switch ( ch ) {
case CAP_E:
dateSkeleton.append(ch);
++ECount;
break;
case LOW_D:
dateSkeleton.append(ch);
++dCount;
break;
case CAP_M:
dateSkeleton.append(ch);
++MCount;
break;
case LOW_Y:
dateSkeleton.append(ch);
++yCount;
break;
case CAP_G:
case CAP_Y:
case LOW_U:
case CAP_Q:
case LOW_Q:
case CAP_L:
case LOW_L:
case CAP_W:
case LOW_W:
case CAP_D:
case CAP_F:
case LOW_G:
case LOW_E:
case LOW_C:
normalizedDateSkeleton.append(ch);
dateSkeleton.append(ch);
break;
case LOW_A:
// 'a' is implicitly handled
timeSkeleton.append(ch);
break;
case LOW_H:
timeSkeleton.append(ch);
++hCount;
break;
case CAP_H:
timeSkeleton.append(ch);
++HCount;
break;
case LOW_M:
timeSkeleton.append(ch);
++mCount;
break;
case LOW_Z:
++zCount;
timeSkeleton.append(ch);
break;
case LOW_V:
++vCount;
timeSkeleton.append(ch);
break;
case CAP_V:
case CAP_Z:
case LOW_K:
case CAP_K:
case LOW_J:
case LOW_S:
case CAP_S:
case CAP_A:
timeSkeleton.append(ch);
normalizedTimeSkeleton.append(ch);
break;
}
}
/* generate normalized form for date*/
if ( yCount != 0 ) {
normalizedDateSkeleton.append(LOW_Y);
}
if ( MCount != 0 ) {
if ( MCount < 3 ) {
normalizedDateSkeleton.append(CAP_M);
} else {
int32_t i;
for ( i = 0; i < MCount && i < MAX_M_COUNT; ++i ) {
normalizedDateSkeleton.append(CAP_M);
}
}
}
if ( ECount != 0 ) {
if ( ECount <= 3 ) {
normalizedDateSkeleton.append(CAP_E);
} else {
int32_t i;
for ( i = 0; i < ECount && i < MAX_E_COUNT; ++i ) {
normalizedDateSkeleton.append(CAP_E);
}
}
}
if ( dCount != 0 ) {
normalizedDateSkeleton.append(LOW_D);
}
/* generate normalized form for time */
if ( HCount != 0 ) {
normalizedTimeSkeleton.append(CAP_H);
}
else if ( hCount != 0 ) {
normalizedTimeSkeleton.append(LOW_H);
}
if ( mCount != 0 ) {
normalizedTimeSkeleton.append(LOW_M);
}
if ( zCount != 0 ) {
normalizedTimeSkeleton.append(LOW_Z);
}
if ( vCount != 0 ) {
normalizedTimeSkeleton.append(LOW_V);
}
}
/**
* Generate date or time interval pattern from resource,
* and set them into the interval pattern locale to this formatter.
*
* It needs to handle the following:
* 1. need to adjust field width.
* For example, the interval patterns saved in DateIntervalInfo
* includes "dMMMy", but not "dMMMMy".
* Need to get interval patterns for dMMMMy from dMMMy.
* Another example, the interval patterns saved in DateIntervalInfo
* includes "hmv", but not "hmz".
* Need to get interval patterns for "hmz' from 'hmv'
*
* 2. there might be no pattern for 'y' differ for skeleton "Md",
* in order to get interval patterns for 'y' differ,
* need to look for it from skeleton 'yMd'
*
* @param dateSkeleton normalized date skeleton
* @param timeSkeleton normalized time skeleton
* @return whether the resource is found for the skeleton.
* TRUE if interval pattern found for the skeleton,
* FALSE otherwise.
* @stable ICU 4.0
*/
UBool
DateIntervalFormat::setSeparateDateTimePtn(
const UnicodeString& dateSkeleton,
const UnicodeString& timeSkeleton) {
const UnicodeString* skeleton;
// if both date and time skeleton present,
// the final interval pattern might include time interval patterns
// ( when, am_pm, hour, minute differ ),
// but not date interval patterns ( when year, month, day differ ).
// For year/month/day differ, it falls back to fall-back pattern.
if ( timeSkeleton.length() != 0 ) {
skeleton = &timeSkeleton;
} else {
skeleton = &dateSkeleton;
}
/* interval patterns for skeleton "dMMMy" (but not "dMMMMy")
* are defined in resource,
* interval patterns for skeleton "dMMMMy" are calculated by
* 1. get the best match skeleton for "dMMMMy", which is "dMMMy"
* 2. get the interval patterns for "dMMMy",
* 3. extend "MMM" to "MMMM" in above interval patterns for "dMMMMy"
* getBestSkeleton() is step 1.
*/
// best skeleton, and the difference information
int8_t differenceInfo = 0;
const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton,
differenceInfo);
/* best skeleton could be NULL.
For example: in "ca" resource file,
interval format is defined as following
intervalFormats{
fallback{"{0} - {1}"}
}
there is no skeletons/interval patterns defined,
and the best skeleton match could be NULL
*/
if ( bestSkeleton == NULL ) {
return false;
}
// difference:
// 0 means the best matched skeleton is the same as input skeleton
// 1 means the fields are the same, but field width are different
// 2 means the only difference between fields are v/z,
// -1 means there are other fields difference
if ( differenceInfo == -1 ) {
// skeleton has different fields, not only v/z difference
return false;
}
if ( timeSkeleton.length() == 0 ) {
UnicodeString extendedSkeleton;
UnicodeString extendedBestSkeleton;
// only has date skeleton
setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo,
&extendedSkeleton, &extendedBestSkeleton);
UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton,
differenceInfo,
&extendedSkeleton, &extendedBestSkeleton);
if ( extended ) {
bestSkeleton = &extendedBestSkeleton;
skeleton = &extendedSkeleton;
}
setIntervalPattern(UCAL_YEAR, skeleton, bestSkeleton, differenceInfo,
&extendedSkeleton, &extendedBestSkeleton);
} else {
setIntervalPattern(UCAL_MINUTE, skeleton, bestSkeleton, differenceInfo);
setIntervalPattern(UCAL_HOUR, skeleton, bestSkeleton, differenceInfo);
setIntervalPattern(UCAL_AM_PM, skeleton, bestSkeleton, differenceInfo);
}
return true;
}
void
DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
const UnicodeString& skeleton,
UErrorCode& status) {
if ( U_FAILURE(status) ) {
return;
}
UnicodeString pattern = fDtpng->getBestPattern(skeleton, status);
if ( U_FAILURE(status) ) {
return;
}
setPatternInfo(field, NULL, &pattern, fInfo->getDefaultOrder());
}
void
DateIntervalFormat::setPatternInfo(UCalendarDateFields field,
const UnicodeString* firstPart,
const UnicodeString* secondPart,
UBool laterDateFirst) {
// for fall back interval patterns,
// the first part of the pattern is empty,
// the second part of the pattern is the full-pattern
// should be used in fall-back.
UErrorCode status = U_ZERO_ERROR;
// following should not set any wrong status.
int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
status);
if ( U_FAILURE(status) ) {
return;
}
PatternInfo& ptn = fIntervalPatterns[itvPtnIndex];
if ( firstPart ) {
ptn.firstPart = *firstPart;
}
if ( secondPart ) {
ptn.secondPart = *secondPart;
}
ptn.laterDateFirst = laterDateFirst;
}
void
DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
const UnicodeString& intervalPattern) {
UBool order = fInfo->getDefaultOrder();
setIntervalPattern(field, intervalPattern, order);
}
void
DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
const UnicodeString& intervalPattern,
UBool laterDateFirst) {
const UnicodeString* pattern = &intervalPattern;
UBool order = laterDateFirst;
// check for "latestFirst:" or "earliestFirst:" prefix
int8_t prefixLength = sizeof(gLaterFirstPrefix)/sizeof(gLaterFirstPrefix[0]);
int8_t earliestFirstLength = sizeof(gEarlierFirstPrefix)/sizeof(gEarlierFirstPrefix[0]);
UnicodeString realPattern;
if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) {
order = true;
intervalPattern.extract(prefixLength,
intervalPattern.length() - prefixLength,
realPattern);
pattern = &realPattern;
} else if ( intervalPattern.startsWith(gEarlierFirstPrefix,
earliestFirstLength) ) {
order = false;
intervalPattern.extract(earliestFirstLength,
intervalPattern.length() - earliestFirstLength,
realPattern);
pattern = &realPattern;
}
int32_t splitPoint = splitPatternInto2Part(*pattern);
UnicodeString firstPart;
UnicodeString secondPart;
pattern->extract(0, splitPoint, firstPart);
if ( splitPoint < pattern->length() ) {
pattern->extract(splitPoint, pattern->length()-splitPoint, secondPart);
}
setPatternInfo(field, &firstPart, &secondPart, order);
}
/**
* Generate interval pattern from existing resource
*
* It not only save the interval patterns,
* but also return the extended skeleton and its best match skeleton.
*
* @param field largest different calendar field
* @param skeleton skeleton
* @param bestSkeleton the best match skeleton which has interval pattern
* defined in resource
* @param differenceInfo the difference between skeleton and best skeleton
* 0 means the best matched skeleton is the same as input skeleton
* 1 means the fields are the same, but field width are different
* 2 means the only difference between fields are v/z,
* -1 means there are other fields difference
*
* @param extendedSkeleton extended skeleton
* @param extendedBestSkeleton extended best match skeleton
* @return whether the interval pattern is found
* through extending skeleton or not.
* TRUE if interval pattern is found by
* extending skeleton, FALSE otherwise.
* @stable ICU 4.0
*/
UBool
DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
const UnicodeString* skeleton,
const UnicodeString* bestSkeleton,
int8_t differenceInfo,
UnicodeString* extendedSkeleton,
UnicodeString* extendedBestSkeleton) {
UErrorCode status = U_ZERO_ERROR;
// following getIntervalPattern() should not generate error status
UnicodeString pattern;
fInfo->getIntervalPattern(*bestSkeleton, field, pattern, status);
if ( pattern.isEmpty() ) {
// single date
if ( SimpleDateFormat::isFieldUnitIgnored(*bestSkeleton, field) ) {
// do nothing, format will handle it
return false;
}
// for 24 hour system, interval patterns in resource file
// might not include pattern when am_pm differ,
// which should be the same as hour differ.
// add it here for simplicity
if ( field == UCAL_AM_PM ) {
fInfo->getIntervalPattern(*bestSkeleton, UCAL_HOUR, pattern,status);
if ( !pattern.isEmpty() ) {
setIntervalPattern(field, pattern);
}
return false;
}
// else, looking for pattern when 'y' differ for 'dMMMM' skeleton,
// first, get best match pattern "MMMd",
// since there is no pattern for 'y' differs for skeleton 'MMMd',
// need to look for it from skeleton 'yMMMd',
// if found, adjust field width in interval pattern from
// "MMM" to "MMMM".
UChar fieldLetter = fgCalendarFieldToPatternLetter[field];
if ( extendedSkeleton ) {
*extendedSkeleton = *skeleton;
*extendedBestSkeleton = *bestSkeleton;
extendedSkeleton->insert(0, fieldLetter);
extendedBestSkeleton->insert(0, fieldLetter);
// for example, looking for patterns when 'y' differ for
// skeleton "MMMM".
fInfo->getIntervalPattern(*extendedBestSkeleton,field,pattern,status);
if ( pattern.isEmpty() && differenceInfo == 0 ) {
// if there is no skeleton "yMMMM" defined,
// look for the best match skeleton, for example: "yMMM"
const UnicodeString* tmpBest = fInfo->getBestSkeleton(
*extendedBestSkeleton, differenceInfo);
if ( tmpBest != 0 && differenceInfo != -1 ) {
fInfo->getIntervalPattern(*tmpBest, field, pattern, status);
bestSkeleton = tmpBest;
}
}
}
}
if ( !pattern.isEmpty() ) {
if ( differenceInfo != 0 ) {
UnicodeString adjustIntervalPattern;
adjustFieldWidth(*skeleton, *bestSkeleton, pattern, differenceInfo,
adjustIntervalPattern);
setIntervalPattern(field, adjustIntervalPattern);
} else {
setIntervalPattern(field, pattern);
}
if ( extendedSkeleton && !extendedSkeleton->isEmpty() ) {
return TRUE;
}
}
return FALSE;
}
int32_t U_EXPORT2
DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) {
UBool inQuote = false;
UChar prevCh = 0;
int32_t count = 0;
/* repeatedPattern used to record whether a pattern has already seen.
It is a pattern applies to first calendar if it is first time seen,
otherwise, it is a pattern applies to the second calendar
*/
UBool patternRepeated[] =
{
// A B C D E F G H I J K L M N O
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// P Q R S T U V W X Y Z
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// a b c d e f g h i j k l m n o
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// p q r s t u v w x y z
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
int8_t PATTERN_CHAR_BASE = 0x41;
/* loop through the pattern string character by character looking for
* the first repeated pattern letter, which breaks the interval pattern
* into 2 parts.
*/
int32_t i;
UBool foundRepetition = false;
for (i = 0; i < intervalPattern.length(); ++i) {
UChar ch = intervalPattern.charAt(i);
if (ch != prevCh && count > 0) {
// check the repeativeness of pattern letter
UBool repeated = patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)];
if ( repeated == FALSE ) {
patternRepeated[prevCh - PATTERN_CHAR_BASE] = TRUE;
} else {
foundRepetition = true;
break;
}
count = 0;
}
if (ch == '\'') {
// Consecutive single quotes are a single quote literal,
// either outside of quotes or between quotes
if ((i+1) < intervalPattern.length() &&
intervalPattern.charAt(i+1) == '\'') {
++i;
} else {
inQuote = ! inQuote;
}
}
else if (!inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
|| (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
// ch is a date-time pattern character
prevCh = ch;
++count;
}
}
// check last pattern char, distinguish
// "dd MM" ( no repetition ),
// "d-d"(last char repeated ), and
// "d-d MM" ( repetition found )
if ( count > 0 && foundRepetition == FALSE ) {
if ( patternRepeated[(int)(prevCh - PATTERN_CHAR_BASE)] == FALSE ) {
count = 0;
}
}
return (i - count);
}
UnicodeString&
DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
Calendar& toCalendar,
UnicodeString& appendTo,
FieldPosition& pos,
UErrorCode& status) const {
if ( U_FAILURE(status) ) {
return appendTo;
}
// the fall back
// no need delete earlierDate and laterDate since they are adopted
UnicodeString* earlierDate = new UnicodeString();
*earlierDate = fDateFormat->format(fromCalendar, *earlierDate, pos);
UnicodeString* laterDate = new UnicodeString();
*laterDate = fDateFormat->format(toCalendar, *laterDate, pos);
UnicodeString fallbackPattern;
fInfo->getFallbackIntervalPattern(fallbackPattern);
Formattable fmtArray[2];
fmtArray[0].adoptString(earlierDate);
fmtArray[1].adoptString(laterDate);
UnicodeString fallback;
MessageFormat::format(fallbackPattern, fmtArray, 2, fallback, status);
if ( U_SUCCESS(status) ) {
appendTo.append(fallback);
}
return appendTo;
}
UBool U_EXPORT2
DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
const UnicodeString& skeleton)
{
const UChar fieldChar = fgCalendarFieldToPatternLetter[field];
return ( (skeleton.indexOf(fieldChar) == -1)?FALSE:TRUE ) ;
}
void U_EXPORT2
DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
const UnicodeString& bestMatchSkeleton,
const UnicodeString& bestIntervalPattern,
int8_t differenceInfo,
UnicodeString& adjustedPtn) {
adjustedPtn = bestIntervalPattern;
int32_t inputSkeletonFieldWidth[] =
{
// A B C D E F G H I J K L M N O
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// P Q R S T U V W X Y Z
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// a b c d e f g h i j k l m n o
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// p q r s t u v w x y z
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
int32_t bestMatchSkeletonFieldWidth[] =
{
// A B C D E F G H I J K L M N O
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// P Q R S T U V W X Y Z
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// a b c d e f g h i j k l m n o
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// p q r s t u v w x y z
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
DateIntervalInfo::parseSkeleton(inputSkeleton, inputSkeletonFieldWidth);
DateIntervalInfo::parseSkeleton(bestMatchSkeleton, bestMatchSkeletonFieldWidth);
if ( differenceInfo == 2 ) {
adjustedPtn.findAndReplace(UnicodeString((UChar)0x76 /* v */),
UnicodeString((UChar)0x7a /* z */));
}
UBool inQuote = false;
UChar prevCh = 0;
int32_t count = 0;
const int8_t PATTERN_CHAR_BASE = 0x41;
// loop through the pattern string character by character
int32_t adjustedPtnLength = adjustedPtn.length();
int32_t i;
for (i = 0; i < adjustedPtnLength; ++i) {
UChar ch = adjustedPtn.charAt(i);
if (ch != prevCh && count > 0) {
// check the repeativeness of pattern letter
UChar skeletonChar = prevCh;
if ( skeletonChar == CAP_L ) {
// there is no "L" (always be "M") in skeleton,
// but there is "L" in pattern.
// for skeleton "M+", the pattern might be "...L..."
skeletonChar = CAP_M;
}
int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
if ( fieldCount == count && inputFieldCount > fieldCount ) {
count = inputFieldCount - fieldCount;
int32_t j;
for ( j = 0; j < count; ++j ) {
adjustedPtn.insert(i, prevCh);
}
i += count;
adjustedPtnLength += count;
}
count = 0;
}
if (ch == '\'') {
// Consecutive single quotes are a single quote literal,
// either outside of quotes or between quotes
if ((i+1) < adjustedPtn.length() && adjustedPtn.charAt(i+1) == '\'') {
++i;
} else {
inQuote = ! inQuote;
}
}
else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
|| (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
// ch is a date-time pattern character
prevCh = ch;
++count;
}
}
if ( count > 0 ) {
// last item
// check the repeativeness of pattern letter
UChar skeletonChar = prevCh;
if ( skeletonChar == CAP_L ) {
// there is no "L" (always be "M") in skeleton,
// but there is "L" in pattern.
// for skeleton "M+", the pattern might be "...L..."
skeletonChar = CAP_M;
}
int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
int32_t inputFieldCount = inputSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
if ( fieldCount == count && inputFieldCount > fieldCount ) {
count = inputFieldCount - fieldCount;
int32_t j;
for ( j = 0; j < count; ++j ) {
adjustedPtn.append(prevCh);
}
}
}
}
void
DateIntervalFormat::concatSingleDate2TimeInterval(const UChar* format,
int32_t formatLen,
const UnicodeString& datePattern,
UCalendarDateFields field,
UErrorCode& status) {
// following should not set wrong status
int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
status);
if ( U_FAILURE(status) ) {
return;
}
PatternInfo& timeItvPtnInfo = fIntervalPatterns[itvPtnIndex];
if ( !timeItvPtnInfo.firstPart.isEmpty() ) {
// UnicodeString allocated here is adopted, so no need to delete
UnicodeString* timeIntervalPattern = new UnicodeString(timeItvPtnInfo.firstPart);
timeIntervalPattern->append(timeItvPtnInfo.secondPart);
UnicodeString* dateStr = new UnicodeString(datePattern);
Formattable fmtArray[2];
fmtArray[0].adoptString(timeIntervalPattern);
fmtArray[1].adoptString(dateStr);
UnicodeString combinedPattern;
MessageFormat::format(UnicodeString(TRUE, format, formatLen),
fmtArray, 2, combinedPattern, status);
if ( U_FAILURE(status) ) {
return;
}
setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst);
}
// else: fall back
// it should not happen if the interval format defined is valid
}
const UChar
DateIntervalFormat::fgCalendarFieldToPatternLetter[] =
{
/*GyM*/ CAP_G, LOW_Y, CAP_M,
/*wWd*/ LOW_W, CAP_W, LOW_D,
/*DEF*/ CAP_D, CAP_E, CAP_F,
/*ahH*/ LOW_A, LOW_H, CAP_H,
/*m..*/ LOW_M,
};
U_NAMESPACE_END
#endif