mirror of
https://github.com/unicode-org/icu.git
synced 2025-04-06 22:15:31 +00:00
ICU-12065 DateIntervalFormat operator ==, remove from/to calendars from consideration.
X-SVN-Rev: 38749
This commit is contained in:
Andy Heninger
parent
3f14902d29
commit
3f05ba059e
3 changed files with 850 additions and 828 deletions
|
|
@ -3,7 +3,7 @@
|
|||
* others. All Rights Reserved.
|
||||
*******************************************************************************
|
||||
*
|
||||
* File DTITVFMT.CPP
|
||||
* File DTITVFMT.CPP
|
||||
*
|
||||
*******************************************************************************
|
||||
*/
|
||||
|
|
@ -27,7 +27,7 @@
|
|||
#include "gregoimp.h"
|
||||
#include "mutex.h"
|
||||
|
||||
#ifdef DTITVFMT_DEBUG
|
||||
#ifdef DTITVFMT_DEBUG
|
||||
#include <iostream>
|
||||
#endif
|
||||
|
||||
|
|
@ -35,7 +35,7 @@ U_NAMESPACE_BEGIN
|
|||
|
||||
|
||||
|
||||
#ifdef DTITVFMT_DEBUG
|
||||
#ifdef DTITVFMT_DEBUG
|
||||
#define PRINTMESG(msg) { std::cout << "(" << __FILE__ << ":" << __LINE__ << ") " << msg << "\n"; }
|
||||
#endif
|
||||
|
||||
|
|
@ -63,21 +63,21 @@ static const UChar gEarlierFirstPrefix[] = {LOW_E, LOW_A, LOW_R, LOW_L, LOW_I, L
|
|||
|
||||
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(DateIntervalFormat)
|
||||
|
||||
// Mutex, protects access to fDateFormat, fFromCalendar and fToCalendar.
|
||||
// Mutex, protects access to fDateFormat, fFromCalendar and fToCalendar.
|
||||
// Needed because these data members are modified by const methods of DateIntervalFormat.
|
||||
|
||||
static UMutex gFormatterMutex = U_MUTEX_INITIALIZER;
|
||||
|
||||
DateIntervalFormat* U_EXPORT2
|
||||
DateIntervalFormat::createInstance(const UnicodeString& skeleton,
|
||||
DateIntervalFormat::createInstance(const UnicodeString& skeleton,
|
||||
UErrorCode& status) {
|
||||
return createInstance(skeleton, Locale::getDefault(), status);
|
||||
}
|
||||
|
||||
|
||||
DateIntervalFormat* U_EXPORT2
|
||||
DateIntervalFormat::createInstance(const UnicodeString& skeleton,
|
||||
const Locale& locale,
|
||||
DateIntervalFormat::createInstance(const UnicodeString& skeleton,
|
||||
const Locale& locale,
|
||||
UErrorCode& status) {
|
||||
#ifdef DTITVFMT_DEBUG
|
||||
char result[1000];
|
||||
|
|
@ -217,15 +217,9 @@ DateIntervalFormat::operator==(const Format& other) const {
|
|||
Mutex lock(&gFormatterMutex);
|
||||
if (fDateFormat != fmt->fDateFormat && (fDateFormat == NULL || fmt->fDateFormat == NULL)) {return FALSE;}
|
||||
if (fDateFormat && fmt->fDateFormat && (*fDateFormat != *fmt->fDateFormat)) {return FALSE;}
|
||||
|
||||
// TODO: should operator == ignore the From and ToCalendar? They hold transient values during
|
||||
// formatting of a DateInterval.
|
||||
if (fFromCalendar != fmt->fFromCalendar && (fFromCalendar == NULL || fmt->fFromCalendar == NULL)) {return FALSE;}
|
||||
if (fFromCalendar && fmt->fFromCalendar && !fFromCalendar->isEquivalentTo(*fmt->fFromCalendar)) {return FALSE;}
|
||||
|
||||
if (fToCalendar != fmt->fToCalendar && (fToCalendar == NULL || fmt->fToCalendar == NULL)) {return FALSE;}
|
||||
if (fToCalendar && fmt->fToCalendar && !fToCalendar->isEquivalentTo(*fmt->fToCalendar)) {return FALSE;}
|
||||
}
|
||||
// note: fFromCalendar and fToCalendar hold no persistent state, and therefore do not participate in operator ==.
|
||||
// fDateFormat has the master calendar for the DateIntervalFormat.
|
||||
if (fSkeleton != fmt->fSkeleton) {return FALSE;}
|
||||
if (fDatePattern != fmt->fDatePattern && (fDatePattern == NULL || fmt->fDatePattern == NULL)) {return FALSE;}
|
||||
if (fDatePattern && fmt->fDatePattern && (*fDatePattern != *fmt->fDatePattern)) {return FALSE;}
|
||||
|
|
@ -294,7 +288,7 @@ DateIntervalFormat::format(Calendar& fromCalendar,
|
|||
Mutex lock(&gFormatterMutex);
|
||||
return formatImpl(fromCalendar, toCalendar, appendTo, pos, status);
|
||||
}
|
||||
|
||||
|
||||
|
||||
UnicodeString&
|
||||
DateIntervalFormat::formatImpl(Calendar& fromCalendar,
|
||||
|
|
@ -318,7 +312,7 @@ DateIntervalFormat::formatImpl(Calendar& fromCalendar,
|
|||
|
||||
if ( fromCalendar.get(UCAL_ERA,status) != toCalendar.get(UCAL_ERA,status)) {
|
||||
field = UCAL_ERA;
|
||||
} else if ( fromCalendar.get(UCAL_YEAR, status) !=
|
||||
} else if ( fromCalendar.get(UCAL_YEAR, status) !=
|
||||
toCalendar.get(UCAL_YEAR, status) ) {
|
||||
field = UCAL_YEAR;
|
||||
} else if ( fromCalendar.get(UCAL_MONTH, status) !=
|
||||
|
|
@ -351,7 +345,7 @@ DateIntervalFormat::formatImpl(Calendar& fromCalendar,
|
|||
return fDateFormat->format(fromCalendar, appendTo, pos);
|
||||
}
|
||||
UBool fromToOnSameDay = (field==UCAL_AM_PM || field==UCAL_HOUR || field==UCAL_MINUTE || field==UCAL_SECOND);
|
||||
|
||||
|
||||
// following call should not set wrong status,
|
||||
// all the pass-in fields are valid till here
|
||||
int32_t itvPtnIndex = DateIntervalInfo::calendarFieldToIntervalIndex(field,
|
||||
|
|
@ -369,7 +363,7 @@ DateIntervalFormat::formatImpl(Calendar& fromCalendar,
|
|||
}
|
||||
return fallbackFormat(fromCalendar, toCalendar, fromToOnSameDay, appendTo, pos, status);
|
||||
}
|
||||
// If the first part in interval pattern is empty,
|
||||
// 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() ) {
|
||||
|
|
@ -391,7 +385,7 @@ DateIntervalFormat::formatImpl(Calendar& fromCalendar,
|
|||
secondCal = &toCalendar;
|
||||
}
|
||||
// break the interval pattern into 2 parts,
|
||||
// first part should not be empty,
|
||||
// first part should not be empty,
|
||||
UnicodeString originalPattern;
|
||||
fDateFormat->toPattern(originalPattern);
|
||||
fDateFormat->applyPattern(intervalPattern.firstPart);
|
||||
|
|
@ -412,11 +406,11 @@ DateIntervalFormat::formatImpl(Calendar& fromCalendar,
|
|||
|
||||
|
||||
void
|
||||
DateIntervalFormat::parseObject(const UnicodeString& /* source */,
|
||||
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
|
||||
// will set status as U_INVALID_FORMAT_ERROR if
|
||||
// parse_pos is still 0
|
||||
}
|
||||
|
||||
|
|
@ -449,7 +443,7 @@ DateIntervalFormat::setDateIntervalInfo(const DateIntervalInfo& newItvPattern,
|
|||
}
|
||||
|
||||
|
||||
|
||||
|
||||
const DateFormat*
|
||||
DateIntervalFormat::getDateFormat() const {
|
||||
return fDateFormat;
|
||||
|
|
@ -504,7 +498,7 @@ DateIntervalFormat::getTimeZone() const
|
|||
DateIntervalFormat::DateIntervalFormat(const Locale& locale,
|
||||
DateIntervalInfo* dtItvInfo,
|
||||
const UnicodeString* skeleton,
|
||||
UErrorCode& status)
|
||||
UErrorCode& status)
|
||||
: fInfo(NULL),
|
||||
fDateFormat(NULL),
|
||||
fFromCalendar(NULL),
|
||||
|
|
@ -538,7 +532,7 @@ DateIntervalFormat::create(const Locale& locale,
|
|||
DateIntervalInfo* dtitvinf,
|
||||
const UnicodeString* skeleton,
|
||||
UErrorCode& status) {
|
||||
DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf,
|
||||
DateIntervalFormat* f = new DateIntervalFormat(locale, dtitvinf,
|
||||
skeleton, status);
|
||||
if ( f == NULL ) {
|
||||
status = U_MEMORY_ALLOCATION_ERROR;
|
||||
|
|
@ -553,10 +547,10 @@ DateIntervalFormat::create(const Locale& locale,
|
|||
|
||||
|
||||
|
||||
/**
|
||||
/**
|
||||
* Initialize interval patterns locale to this formatter
|
||||
*
|
||||
* This code is a bit complicated since
|
||||
*
|
||||
* 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.
|
||||
|
|
@ -564,30 +558,30 @@ DateIntervalFormat::create(const Locale& locale,
|
|||
*
|
||||
* 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
|
||||
* 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"
|
||||
* 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
|
||||
* 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
|
||||
* @stable ICU 4.0
|
||||
*/
|
||||
void
|
||||
void
|
||||
DateIntervalFormat::initializePattern(UErrorCode& status) {
|
||||
if ( U_FAILURE(status) ) {
|
||||
return;
|
||||
|
|
@ -609,7 +603,7 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
|
|||
fSkeleton = DateTimePatternGenerator::staticGetSkeleton(
|
||||
fullPattern, status);
|
||||
if ( U_FAILURE(status) ) {
|
||||
return;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -631,7 +625,7 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
|
|||
/* 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
|
||||
* 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:
|
||||
|
|
@ -666,7 +660,7 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
|
|||
status = U_MEMORY_ALLOCATION_ERROR;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
const UResourceBundle* dateTimePatternsRes = calData->getByKey(
|
||||
gDateTimePatternsTag, status);
|
||||
int32_t dateTimeFormatLength;
|
||||
|
|
@ -680,7 +674,7 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
|
|||
delete calData;
|
||||
}
|
||||
|
||||
UBool found = setSeparateDateTimePtn(normalizedDateSkeleton,
|
||||
UBool found = setSeparateDateTimePtn(normalizedDateSkeleton,
|
||||
normalizedTimeSkeleton);
|
||||
|
||||
// for skeletons with seconds, found is false and we enter this block
|
||||
|
|
@ -694,15 +688,15 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
|
|||
UnicodeString pattern = DateFormat::getBestPattern(
|
||||
locale, timeSkeleton, status);
|
||||
if ( U_FAILURE(status) ) {
|
||||
return;
|
||||
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());
|
||||
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
|
||||
}
|
||||
|
|
@ -711,7 +705,7 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
|
|||
}
|
||||
return;
|
||||
} // end of skeleton not found
|
||||
// interval patterns for skeleton are found in resource
|
||||
// interval patterns for skeleton are found in resource
|
||||
if ( timeSkeleton.length() == 0 ) {
|
||||
// done
|
||||
} else if ( dateSkeleton.length() == 0 ) {
|
||||
|
|
@ -720,25 +714,25 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
|
|||
UnicodeString pattern = DateFormat::getBestPattern(
|
||||
locale, timeSkeleton, status);
|
||||
if ( U_FAILURE(status) ) {
|
||||
return;
|
||||
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());
|
||||
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,
|
||||
* 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,
|
||||
* 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;
|
||||
|
|
@ -757,10 +751,10 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
|
|||
skeleton.insert(0, LOW_Y);
|
||||
setFallbackPattern(UCAL_YEAR, skeleton, status);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* 2) otherwise, present the date followed by the
|
||||
* range expression for the time.
|
||||
* 2) otherwise, present the date followed by the
|
||||
* range expression for the time.
|
||||
*/
|
||||
|
||||
if ( fDateTimeFormat == NULL ) {
|
||||
|
|
@ -779,10 +773,10 @@ DateIntervalFormat::initializePattern(UErrorCode& status) {
|
|||
|
||||
|
||||
|
||||
void U_EXPORT2
|
||||
DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
|
||||
UnicodeString& dateSkeleton,
|
||||
UnicodeString& normalizedDateSkeleton,
|
||||
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*
|
||||
|
|
@ -837,7 +831,7 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
|
|||
dateSkeleton.append(ch);
|
||||
break;
|
||||
case LOW_A:
|
||||
// 'a' is implicitly handled
|
||||
// 'a' is implicitly handled
|
||||
timeSkeleton.append(ch);
|
||||
break;
|
||||
case LOW_H:
|
||||
|
|
@ -870,7 +864,7 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
|
|||
case CAP_A:
|
||||
timeSkeleton.append(ch);
|
||||
normalizedTimeSkeleton.append(ch);
|
||||
break;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -927,7 +921,7 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
|
|||
* 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:
|
||||
* 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".
|
||||
|
|
@ -947,7 +941,7 @@ DateIntervalFormat::getDateTimeSkeleton(const UnicodeString& skeleton,
|
|||
* FALSE otherwise.
|
||||
* @stable ICU 4.0
|
||||
*/
|
||||
UBool
|
||||
UBool
|
||||
DateIntervalFormat::setSeparateDateTimePtn(
|
||||
const UnicodeString& dateSkeleton,
|
||||
const UnicodeString& timeSkeleton) {
|
||||
|
|
@ -963,17 +957,17 @@ DateIntervalFormat::setSeparateDateTimePtn(
|
|||
skeleton = &dateSkeleton;
|
||||
}
|
||||
|
||||
/* interval patterns for skeleton "dMMMy" (but not "dMMMMy")
|
||||
/* 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"
|
||||
* 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,
|
||||
const UnicodeString* bestSkeleton = fInfo->getBestSkeleton(*skeleton,
|
||||
differenceInfo);
|
||||
/* best skeleton could be NULL.
|
||||
For example: in "ca" resource file,
|
||||
|
|
@ -985,9 +979,9 @@ DateIntervalFormat::setSeparateDateTimePtn(
|
|||
and the best skeleton match could be NULL
|
||||
*/
|
||||
if ( bestSkeleton == NULL ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// Set patterns for fallback use, need to do this
|
||||
// before returning if differenceInfo == -1
|
||||
UErrorCode status;
|
||||
|
|
@ -1006,10 +1000,10 @@ DateIntervalFormat::setSeparateDateTimePtn(
|
|||
// 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
|
||||
// -1 means there are other fields difference
|
||||
// (this will happen, for instance, if the supplied skeleton has seconds,
|
||||
// but no skeletons in the intervalFormats data do)
|
||||
if ( differenceInfo == -1 ) {
|
||||
if ( differenceInfo == -1 ) {
|
||||
// skeleton has different fields, not only v/z difference
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1021,10 +1015,10 @@ DateIntervalFormat::setSeparateDateTimePtn(
|
|||
setIntervalPattern(UCAL_DATE, skeleton, bestSkeleton, differenceInfo,
|
||||
&extendedSkeleton, &extendedBestSkeleton);
|
||||
|
||||
UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton,
|
||||
UBool extended = setIntervalPattern(UCAL_MONTH, skeleton, bestSkeleton,
|
||||
differenceInfo,
|
||||
&extendedSkeleton, &extendedBestSkeleton);
|
||||
|
||||
|
||||
if ( extended ) {
|
||||
bestSkeleton = &extendedBestSkeleton;
|
||||
skeleton = &extendedSkeleton;
|
||||
|
|
@ -1060,9 +1054,9 @@ DateIntervalFormat::setFallbackPattern(UCalendarDateFields field,
|
|||
|
||||
|
||||
void
|
||||
DateIntervalFormat::setPatternInfo(UCalendarDateFields field,
|
||||
DateIntervalFormat::setPatternInfo(UCalendarDateFields field,
|
||||
const UnicodeString* firstPart,
|
||||
const UnicodeString* secondPart,
|
||||
const UnicodeString* secondPart,
|
||||
UBool laterDateFirst) {
|
||||
// for fall back interval patterns,
|
||||
// the first part of the pattern is empty,
|
||||
|
|
@ -1105,7 +1099,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
|
|||
UnicodeString realPattern;
|
||||
if ( intervalPattern.startsWith(gLaterFirstPrefix, prefixLength) ) {
|
||||
order = true;
|
||||
intervalPattern.extract(prefixLength,
|
||||
intervalPattern.extract(prefixLength,
|
||||
intervalPattern.length() - prefixLength,
|
||||
realPattern);
|
||||
pattern = &realPattern;
|
||||
|
|
@ -1119,7 +1113,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
|
|||
}
|
||||
|
||||
int32_t splitPoint = splitPatternInto2Part(*pattern);
|
||||
|
||||
|
||||
UnicodeString firstPart;
|
||||
UnicodeString secondPart;
|
||||
pattern->extract(0, splitPoint, firstPart);
|
||||
|
|
@ -1146,11 +1140,11 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
|
|||
* 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
|
||||
* -1 means there are other fields difference
|
||||
*
|
||||
* @param extendedSkeleton extended skeleton
|
||||
* @param extendedBestSkeleton extended best match skeleton
|
||||
* @return whether the interval pattern is found
|
||||
* @return whether the interval pattern is found
|
||||
* through extending skeleton or not.
|
||||
* TRUE if interval pattern is found by
|
||||
* extending skeleton, FALSE otherwise.
|
||||
|
|
@ -1175,7 +1169,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
|
|||
}
|
||||
|
||||
// for 24 hour system, interval patterns in resource file
|
||||
// might not include pattern when am_pm differ,
|
||||
// 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 ) {
|
||||
|
|
@ -1184,7 +1178,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
|
|||
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',
|
||||
|
|
@ -1198,11 +1192,11 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
|
|||
extendedSkeleton->insert(0, fieldLetter);
|
||||
extendedBestSkeleton->insert(0, fieldLetter);
|
||||
// for example, looking for patterns when 'y' differ for
|
||||
// skeleton "MMMM".
|
||||
// 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"
|
||||
// look for the best match skeleton, for example: "yMMM"
|
||||
const UnicodeString* tmpBest = fInfo->getBestSkeleton(
|
||||
*extendedBestSkeleton, differenceInfo);
|
||||
if ( tmpBest != 0 && differenceInfo != -1 ) {
|
||||
|
|
@ -1211,7 +1205,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( !pattern.isEmpty() ) {
|
||||
if ( differenceInfo != 0 ) {
|
||||
UnicodeString adjustIntervalPattern;
|
||||
|
|
@ -1230,7 +1224,7 @@ DateIntervalFormat::setIntervalPattern(UCalendarDateFields field,
|
|||
|
||||
|
||||
|
||||
int32_t U_EXPORT2
|
||||
int32_t U_EXPORT2
|
||||
DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern) {
|
||||
UBool inQuote = false;
|
||||
UChar prevCh = 0;
|
||||
|
|
@ -1240,7 +1234,7 @@ DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern)
|
|||
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[] =
|
||||
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,
|
||||
|
|
@ -1253,16 +1247,16 @@ DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern)
|
|||
};
|
||||
|
||||
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.
|
||||
* 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)];
|
||||
|
|
@ -1277,23 +1271,23 @@ DateIntervalFormat::splitPatternInto2Part(const UnicodeString& intervalPattern)
|
|||
if (ch == '\'') {
|
||||
// Consecutive single quotes are a single quote literal,
|
||||
// either outside of quotes or between quotes
|
||||
if ((i+1) < intervalPattern.length() &&
|
||||
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
|
||||
// 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
|
||||
// "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 ) {
|
||||
|
|
@ -1340,7 +1334,7 @@ DateIntervalFormat::adjustPosition(UnicodeString& combiningPattern, // has {0} a
|
|||
}
|
||||
}
|
||||
|
||||
UnicodeString&
|
||||
UnicodeString&
|
||||
DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
|
||||
Calendar& toCalendar,
|
||||
UBool fromToOnSameDay, // new
|
||||
|
|
@ -1397,7 +1391,7 @@ DateIntervalFormat::fallbackFormat(Calendar& fromCalendar,
|
|||
|
||||
|
||||
|
||||
UBool U_EXPORT2
|
||||
UBool U_EXPORT2
|
||||
DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
|
||||
const UnicodeString& skeleton)
|
||||
{
|
||||
|
|
@ -1407,14 +1401,14 @@ DateIntervalFormat::fieldExistsInSkeleton(UCalendarDateFields field,
|
|||
|
||||
|
||||
|
||||
void U_EXPORT2
|
||||
void U_EXPORT2
|
||||
DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
|
||||
const UnicodeString& bestMatchSkeleton,
|
||||
const UnicodeString& bestIntervalPattern,
|
||||
int8_t differenceInfo,
|
||||
UnicodeString& adjustedPtn) {
|
||||
adjustedPtn = bestIntervalPattern;
|
||||
int32_t inputSkeletonFieldWidth[] =
|
||||
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,
|
||||
|
|
@ -1426,7 +1420,7 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
|
|||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
int32_t bestMatchSkeletonFieldWidth[] =
|
||||
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,
|
||||
|
|
@ -1450,8 +1444,8 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
|
|||
int32_t count = 0;
|
||||
|
||||
const int8_t PATTERN_CHAR_BASE = 0x41;
|
||||
|
||||
// loop through the pattern string character by character
|
||||
|
||||
// loop through the pattern string character by character
|
||||
int32_t adjustedPtnLength = adjustedPtn.length();
|
||||
int32_t i;
|
||||
for (i = 0; i < adjustedPtnLength; ++i) {
|
||||
|
|
@ -1460,9 +1454,9 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
|
|||
// check the repeativeness of pattern letter
|
||||
UChar skeletonChar = prevCh;
|
||||
if ( skeletonChar == CAP_L ) {
|
||||
// there is no "L" (always be "M") in skeleton,
|
||||
// there is no "L" (always be "M") in skeleton,
|
||||
// but there is "L" in pattern.
|
||||
// for skeleton "M+", the pattern might be "...L..."
|
||||
// for skeleton "M+", the pattern might be "...L..."
|
||||
skeletonChar = CAP_M;
|
||||
}
|
||||
int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
|
||||
|
|
@ -1471,8 +1465,8 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
|
|||
count = inputFieldCount - fieldCount;
|
||||
int32_t j;
|
||||
for ( j = 0; j < count; ++j ) {
|
||||
adjustedPtn.insert(i, prevCh);
|
||||
}
|
||||
adjustedPtn.insert(i, prevCh);
|
||||
}
|
||||
i += count;
|
||||
adjustedPtnLength += count;
|
||||
}
|
||||
|
|
@ -1486,10 +1480,10 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
|
|||
} else {
|
||||
inQuote = ! inQuote;
|
||||
}
|
||||
}
|
||||
else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
|
||||
}
|
||||
else if ( ! inQuote && ((ch >= 0x0061 /*'a'*/ && ch <= 0x007A /*'z'*/)
|
||||
|| (ch >= 0x0041 /*'A'*/ && ch <= 0x005A /*'Z'*/))) {
|
||||
// ch is a date-time pattern character
|
||||
// ch is a date-time pattern character
|
||||
prevCh = ch;
|
||||
++count;
|
||||
}
|
||||
|
|
@ -1499,9 +1493,9 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
|
|||
// check the repeativeness of pattern letter
|
||||
UChar skeletonChar = prevCh;
|
||||
if ( skeletonChar == CAP_L ) {
|
||||
// there is no "L" (always be "M") in skeleton,
|
||||
// there is no "L" (always be "M") in skeleton,
|
||||
// but there is "L" in pattern.
|
||||
// for skeleton "M+", the pattern might be "...L..."
|
||||
// for skeleton "M+", the pattern might be "...L..."
|
||||
skeletonChar = CAP_M;
|
||||
}
|
||||
int32_t fieldCount = bestMatchSkeletonFieldWidth[(int)(skeletonChar - PATTERN_CHAR_BASE)];
|
||||
|
|
@ -1510,15 +1504,15 @@ DateIntervalFormat::adjustFieldWidth(const UnicodeString& inputSkeleton,
|
|||
count = inputFieldCount - fieldCount;
|
||||
int32_t j;
|
||||
for ( j = 0; j < count; ++j ) {
|
||||
adjustedPtn.append(prevCh);
|
||||
}
|
||||
adjustedPtn.append(prevCh);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
void
|
||||
DateIntervalFormat::concatSingleDate2TimeInterval(UnicodeString& format,
|
||||
const UnicodeString& datePattern,
|
||||
UCalendarDateFields field,
|
||||
|
|
@ -1540,7 +1534,7 @@ DateIntervalFormat::concatSingleDate2TimeInterval(UnicodeString& format,
|
|||
return;
|
||||
}
|
||||
setIntervalPattern(field, combinedPattern, timeItvPtnInfo.laterDateFirst);
|
||||
}
|
||||
}
|
||||
// else: fall back
|
||||
// it should not happen if the interval format defined is valid
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,5 +1,5 @@
|
|||
/********************************************************************
|
||||
* COPYRIGHT:
|
||||
* COPYRIGHT:
|
||||
* Copyright (c) 2008-2016 International Business Machines Corporation and
|
||||
* others. All Rights Reserved.
|
||||
********************************************************************/
|
||||
|
|
@ -18,7 +18,7 @@
|
|||
* Test basic functionality of various API functions
|
||||
**/
|
||||
class DateIntervalFormatTest: public IntlTest {
|
||||
void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL );
|
||||
void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par = NULL );
|
||||
|
||||
public:
|
||||
/**
|
||||
|
|
@ -59,6 +59,8 @@ public:
|
|||
void testTicket11669();
|
||||
void threadFunc11669(int32_t threadNum);
|
||||
|
||||
void testTicket12065();
|
||||
|
||||
private:
|
||||
/**
|
||||
* Test formatting against expected result
|
||||
|
|
@ -66,15 +68,15 @@ private:
|
|||
void expect(const char** data, int32_t data_length);
|
||||
|
||||
/**
|
||||
* Test formatting against expected result using user defined
|
||||
* Test formatting against expected result using user defined
|
||||
* DateIntervalInfo
|
||||
*/
|
||||
void expectUserDII(const char** data, int32_t data_length);
|
||||
|
||||
/**
|
||||
* Stress test formatting
|
||||
* Stress test formatting
|
||||
*/
|
||||
void stress(const char** data, int32_t data_length, const Locale& loc,
|
||||
void stress(const char** data, int32_t data_length, const Locale& loc,
|
||||
const char* locName);
|
||||
};
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue