628 lines
19 KiB
C++
628 lines
19 KiB
C++
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 2007-2012, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
*******************************************************************************
|
|
*/
|
|
|
|
#include "utypeinfo.h" // for 'typeid' to work
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
#include "unicode/tzrule.h"
|
|
#include "unicode/ucal.h"
|
|
#include "gregoimp.h"
|
|
#include "cmemory.h"
|
|
#include "uarrsort.h"
|
|
|
|
U_CDECL_BEGIN
|
|
// UComparator function for sorting start times
|
|
static int32_t U_CALLCONV
|
|
compareDates(const void * /*context*/, const void *left, const void *right) {
|
|
UDate l = *((UDate*)left);
|
|
UDate r = *((UDate*)right);
|
|
int32_t res = l < r ? -1 : (l == r ? 0 : 1);
|
|
return res;
|
|
}
|
|
U_CDECL_END
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
TimeZoneRule::TimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSavings)
|
|
: UObject(), fName(name), fRawOffset(rawOffset), fDSTSavings(dstSavings) {
|
|
}
|
|
|
|
TimeZoneRule::TimeZoneRule(const TimeZoneRule& source)
|
|
: UObject(source), fName(source.fName), fRawOffset(source.fRawOffset), fDSTSavings(source.fDSTSavings) {
|
|
}
|
|
|
|
TimeZoneRule::~TimeZoneRule() {
|
|
}
|
|
|
|
TimeZoneRule&
|
|
TimeZoneRule::operator=(const TimeZoneRule& right) {
|
|
if (this != &right) {
|
|
fName = right.fName;
|
|
fRawOffset = right.fRawOffset;
|
|
fDSTSavings = right.fDSTSavings;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
UBool
|
|
TimeZoneRule::operator==(const TimeZoneRule& that) const {
|
|
return ((this == &that) ||
|
|
(typeid(*this) == typeid(that) &&
|
|
fName == that.fName &&
|
|
fRawOffset == that.fRawOffset &&
|
|
fDSTSavings == that.fDSTSavings));
|
|
}
|
|
|
|
UBool
|
|
TimeZoneRule::operator!=(const TimeZoneRule& that) const {
|
|
return !operator==(that);
|
|
}
|
|
|
|
UnicodeString&
|
|
TimeZoneRule::getName(UnicodeString& name) const {
|
|
name = fName;
|
|
return name;
|
|
}
|
|
|
|
int32_t
|
|
TimeZoneRule::getRawOffset(void) const {
|
|
return fRawOffset;
|
|
}
|
|
|
|
int32_t
|
|
TimeZoneRule::getDSTSavings(void) const {
|
|
return fDSTSavings;
|
|
}
|
|
|
|
UBool
|
|
TimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
|
|
return ((this == &other) ||
|
|
(typeid(*this) == typeid(other) &&
|
|
fRawOffset == other.fRawOffset &&
|
|
fDSTSavings == other.fDSTSavings));
|
|
}
|
|
|
|
|
|
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(InitialTimeZoneRule)
|
|
|
|
InitialTimeZoneRule::InitialTimeZoneRule(const UnicodeString& name,
|
|
int32_t rawOffset,
|
|
int32_t dstSavings)
|
|
: TimeZoneRule(name, rawOffset, dstSavings) {
|
|
}
|
|
|
|
InitialTimeZoneRule::InitialTimeZoneRule(const InitialTimeZoneRule& source)
|
|
: TimeZoneRule(source) {
|
|
}
|
|
|
|
InitialTimeZoneRule::~InitialTimeZoneRule() {
|
|
}
|
|
|
|
InitialTimeZoneRule*
|
|
InitialTimeZoneRule::clone(void) const {
|
|
return new InitialTimeZoneRule(*this);
|
|
}
|
|
|
|
InitialTimeZoneRule&
|
|
InitialTimeZoneRule::operator=(const InitialTimeZoneRule& right) {
|
|
if (this != &right) {
|
|
TimeZoneRule::operator=(right);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
UBool
|
|
InitialTimeZoneRule::operator==(const TimeZoneRule& that) const {
|
|
return ((this == &that) ||
|
|
(typeid(*this) == typeid(that) &&
|
|
TimeZoneRule::operator==(that)));
|
|
}
|
|
|
|
UBool
|
|
InitialTimeZoneRule::operator!=(const TimeZoneRule& that) const {
|
|
return !operator==(that);
|
|
}
|
|
|
|
UBool
|
|
InitialTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
|
|
if (this == &other) {
|
|
return TRUE;
|
|
}
|
|
if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
UBool
|
|
InitialTimeZoneRule::getFirstStart(int32_t /*prevRawOffset*/,
|
|
int32_t /*prevDSTSavings*/,
|
|
UDate& /*result*/) const {
|
|
return FALSE;
|
|
}
|
|
|
|
UBool
|
|
InitialTimeZoneRule::getFinalStart(int32_t /*prevRawOffset*/,
|
|
int32_t /*prevDSTSavings*/,
|
|
UDate& /*result*/) const {
|
|
return FALSE;
|
|
}
|
|
|
|
UBool
|
|
InitialTimeZoneRule::getNextStart(UDate /*base*/,
|
|
int32_t /*prevRawOffset*/,
|
|
int32_t /*prevDSTSavings*/,
|
|
UBool /*inclusive*/,
|
|
UDate& /*result*/) const {
|
|
return FALSE;
|
|
}
|
|
|
|
UBool
|
|
InitialTimeZoneRule::getPreviousStart(UDate /*base*/,
|
|
int32_t /*prevRawOffset*/,
|
|
int32_t /*prevDSTSavings*/,
|
|
UBool /*inclusive*/,
|
|
UDate& /*result*/) const {
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(AnnualTimeZoneRule)
|
|
|
|
const int32_t AnnualTimeZoneRule::MAX_YEAR = 0x7FFFFFFF; /* max signed int32 */
|
|
|
|
AnnualTimeZoneRule::AnnualTimeZoneRule(const UnicodeString& name,
|
|
int32_t rawOffset,
|
|
int32_t dstSavings,
|
|
const DateTimeRule& dateTimeRule,
|
|
int32_t startYear,
|
|
int32_t endYear)
|
|
: TimeZoneRule(name, rawOffset, dstSavings), fDateTimeRule(new DateTimeRule(dateTimeRule)),
|
|
fStartYear(startYear), fEndYear(endYear) {
|
|
}
|
|
|
|
AnnualTimeZoneRule::AnnualTimeZoneRule(const UnicodeString& name,
|
|
int32_t rawOffset,
|
|
int32_t dstSavings,
|
|
DateTimeRule* dateTimeRule,
|
|
int32_t startYear,
|
|
int32_t endYear)
|
|
: TimeZoneRule(name, rawOffset, dstSavings), fDateTimeRule(dateTimeRule),
|
|
fStartYear(startYear), fEndYear(endYear) {
|
|
}
|
|
|
|
AnnualTimeZoneRule::AnnualTimeZoneRule(const AnnualTimeZoneRule& source)
|
|
: TimeZoneRule(source), fDateTimeRule(new DateTimeRule(*(source.fDateTimeRule))),
|
|
fStartYear(source.fStartYear), fEndYear(source.fEndYear) {
|
|
}
|
|
|
|
AnnualTimeZoneRule::~AnnualTimeZoneRule() {
|
|
delete fDateTimeRule;
|
|
}
|
|
|
|
AnnualTimeZoneRule*
|
|
AnnualTimeZoneRule::clone(void) const {
|
|
return new AnnualTimeZoneRule(*this);
|
|
}
|
|
|
|
AnnualTimeZoneRule&
|
|
AnnualTimeZoneRule::operator=(const AnnualTimeZoneRule& right) {
|
|
if (this != &right) {
|
|
TimeZoneRule::operator=(right);
|
|
delete fDateTimeRule;
|
|
fDateTimeRule = right.fDateTimeRule->clone();
|
|
fStartYear = right.fStartYear;
|
|
fEndYear = right.fEndYear;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
UBool
|
|
AnnualTimeZoneRule::operator==(const TimeZoneRule& that) const {
|
|
if (this == &that) {
|
|
return TRUE;
|
|
}
|
|
if (typeid(*this) != typeid(that)) {
|
|
return FALSE;
|
|
}
|
|
AnnualTimeZoneRule *atzr = (AnnualTimeZoneRule*)&that;
|
|
return (*fDateTimeRule == *(atzr->fDateTimeRule) &&
|
|
fStartYear == atzr->fStartYear &&
|
|
fEndYear == atzr->fEndYear);
|
|
}
|
|
|
|
UBool
|
|
AnnualTimeZoneRule::operator!=(const TimeZoneRule& that) const {
|
|
return !operator==(that);
|
|
}
|
|
|
|
const DateTimeRule*
|
|
AnnualTimeZoneRule::getRule() const {
|
|
return fDateTimeRule;
|
|
}
|
|
|
|
int32_t
|
|
AnnualTimeZoneRule::getStartYear() const {
|
|
return fStartYear;
|
|
}
|
|
|
|
int32_t
|
|
AnnualTimeZoneRule::getEndYear() const {
|
|
return fEndYear;
|
|
}
|
|
|
|
UBool
|
|
AnnualTimeZoneRule::getStartInYear(int32_t year,
|
|
int32_t prevRawOffset,
|
|
int32_t prevDSTSavings,
|
|
UDate &result) const {
|
|
if (year < fStartYear || year > fEndYear) {
|
|
return FALSE;
|
|
}
|
|
double ruleDay;
|
|
DateTimeRule::DateRuleType type = fDateTimeRule->getDateRuleType();
|
|
if (type == DateTimeRule::DOM) {
|
|
ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(), fDateTimeRule->getRuleDayOfMonth());
|
|
} else {
|
|
UBool after = TRUE;
|
|
if (type == DateTimeRule::DOW) {
|
|
// Normalize DOW rule into DOW_GEQ_DOM or DOW_LEQ_DOM
|
|
int32_t weeks = fDateTimeRule->getRuleWeekInMonth();
|
|
if (weeks > 0) {
|
|
ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(), 1);
|
|
ruleDay += 7 * (weeks - 1);
|
|
} else {
|
|
after = FALSE;
|
|
ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(),
|
|
Grego::monthLength(year, fDateTimeRule->getRuleMonth()));
|
|
ruleDay += 7 * (weeks + 1);
|
|
}
|
|
} else {
|
|
int32_t month = fDateTimeRule->getRuleMonth();
|
|
int32_t dom = fDateTimeRule->getRuleDayOfMonth();
|
|
if (type == DateTimeRule::DOW_LEQ_DOM) {
|
|
after = FALSE;
|
|
// Handle Feb <=29
|
|
if (month == UCAL_FEBRUARY && dom == 29 && !Grego::isLeapYear(year)) {
|
|
dom--;
|
|
}
|
|
}
|
|
ruleDay = Grego::fieldsToDay(year, month, dom);
|
|
}
|
|
int32_t dow = Grego::dayOfWeek(ruleDay);
|
|
int32_t delta = fDateTimeRule->getRuleDayOfWeek() - dow;
|
|
if (after) {
|
|
delta = delta < 0 ? delta + 7 : delta;
|
|
} else {
|
|
delta = delta > 0 ? delta - 7 : delta;
|
|
}
|
|
ruleDay += delta;
|
|
}
|
|
|
|
result = ruleDay*U_MILLIS_PER_DAY + fDateTimeRule->getRuleMillisInDay();
|
|
if (fDateTimeRule->getTimeRuleType() != DateTimeRule::UTC_TIME) {
|
|
result -= prevRawOffset;
|
|
}
|
|
if (fDateTimeRule->getTimeRuleType() == DateTimeRule::WALL_TIME) {
|
|
result -= prevDSTSavings;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
UBool
|
|
AnnualTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
|
|
if (this == &other) {
|
|
return TRUE;
|
|
}
|
|
if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
|
|
return FALSE;
|
|
}
|
|
AnnualTimeZoneRule* that = (AnnualTimeZoneRule*)&other;
|
|
return (*fDateTimeRule == *(that->fDateTimeRule) &&
|
|
fStartYear == that->fStartYear &&
|
|
fEndYear == that->fEndYear);
|
|
}
|
|
|
|
UBool
|
|
AnnualTimeZoneRule::getFirstStart(int32_t prevRawOffset,
|
|
int32_t prevDSTSavings,
|
|
UDate& result) const {
|
|
return getStartInYear(fStartYear, prevRawOffset, prevDSTSavings, result);
|
|
}
|
|
|
|
UBool
|
|
AnnualTimeZoneRule::getFinalStart(int32_t prevRawOffset,
|
|
int32_t prevDSTSavings,
|
|
UDate& result) const {
|
|
if (fEndYear == MAX_YEAR) {
|
|
return FALSE;
|
|
}
|
|
return getStartInYear(fEndYear, prevRawOffset, prevDSTSavings, result);
|
|
}
|
|
|
|
UBool
|
|
AnnualTimeZoneRule::getNextStart(UDate base,
|
|
int32_t prevRawOffset,
|
|
int32_t prevDSTSavings,
|
|
UBool inclusive,
|
|
UDate& result) const {
|
|
int32_t year, month, dom, dow, doy, mid;
|
|
Grego::timeToFields(base, year, month, dom, dow, doy, mid);
|
|
if (year < fStartYear) {
|
|
return getFirstStart(prevRawOffset, prevDSTSavings, result);
|
|
}
|
|
UDate tmp;
|
|
if (getStartInYear(year, prevRawOffset, prevDSTSavings, tmp)) {
|
|
if (tmp < base || (!inclusive && (tmp == base))) {
|
|
// Return the next one
|
|
return getStartInYear(year + 1, prevRawOffset, prevDSTSavings, result);
|
|
} else {
|
|
result = tmp;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
UBool
|
|
AnnualTimeZoneRule::getPreviousStart(UDate base,
|
|
int32_t prevRawOffset,
|
|
int32_t prevDSTSavings,
|
|
UBool inclusive,
|
|
UDate& result) const {
|
|
int32_t year, month, dom, dow, doy, mid;
|
|
Grego::timeToFields(base, year, month, dom, dow, doy, mid);
|
|
if (year > fEndYear) {
|
|
return getFinalStart(prevRawOffset, prevDSTSavings, result);
|
|
}
|
|
UDate tmp;
|
|
if (getStartInYear(year, prevRawOffset, prevDSTSavings, tmp)) {
|
|
if (tmp > base || (!inclusive && (tmp == base))) {
|
|
// Return the previous one
|
|
return getStartInYear(year - 1, prevRawOffset, prevDSTSavings, result);
|
|
} else {
|
|
result = tmp;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeArrayTimeZoneRule)
|
|
|
|
TimeArrayTimeZoneRule::TimeArrayTimeZoneRule(const UnicodeString& name,
|
|
int32_t rawOffset,
|
|
int32_t dstSavings,
|
|
const UDate* startTimes,
|
|
int32_t numStartTimes,
|
|
DateTimeRule::TimeRuleType timeRuleType)
|
|
: TimeZoneRule(name, rawOffset, dstSavings), fTimeRuleType(timeRuleType),
|
|
fStartTimes(NULL) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
initStartTimes(startTimes, numStartTimes, status);
|
|
//TODO - status?
|
|
}
|
|
|
|
|
|
TimeArrayTimeZoneRule::TimeArrayTimeZoneRule(const TimeArrayTimeZoneRule& source)
|
|
: TimeZoneRule(source), fTimeRuleType(source.fTimeRuleType), fStartTimes(NULL) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
initStartTimes(source.fStartTimes, source.fNumStartTimes, status);
|
|
//TODO - status?
|
|
}
|
|
|
|
|
|
TimeArrayTimeZoneRule::~TimeArrayTimeZoneRule() {
|
|
if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) {
|
|
uprv_free(fStartTimes);
|
|
}
|
|
}
|
|
|
|
TimeArrayTimeZoneRule*
|
|
TimeArrayTimeZoneRule::clone(void) const {
|
|
return new TimeArrayTimeZoneRule(*this);
|
|
}
|
|
|
|
|
|
TimeArrayTimeZoneRule&
|
|
TimeArrayTimeZoneRule::operator=(const TimeArrayTimeZoneRule& right) {
|
|
if (this != &right) {
|
|
TimeZoneRule::operator=(right);
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
initStartTimes(right.fStartTimes, right.fNumStartTimes, status);
|
|
//TODO - status?
|
|
fTimeRuleType = right.fTimeRuleType;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
UBool
|
|
TimeArrayTimeZoneRule::operator==(const TimeZoneRule& that) const {
|
|
if (this == &that) {
|
|
return TRUE;
|
|
}
|
|
if (typeid(*this) != typeid(that) || TimeZoneRule::operator==(that) == FALSE) {
|
|
return FALSE;
|
|
}
|
|
TimeArrayTimeZoneRule *tatzr = (TimeArrayTimeZoneRule*)&that;
|
|
if (fTimeRuleType != tatzr->fTimeRuleType ||
|
|
fNumStartTimes != tatzr->fNumStartTimes) {
|
|
return FALSE;
|
|
}
|
|
// Compare start times
|
|
UBool res = TRUE;
|
|
for (int32_t i = 0; i < fNumStartTimes; i++) {
|
|
if (fStartTimes[i] != tatzr->fStartTimes[i]) {
|
|
res = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
UBool
|
|
TimeArrayTimeZoneRule::operator!=(const TimeZoneRule& that) const {
|
|
return !operator==(that);
|
|
}
|
|
|
|
DateTimeRule::TimeRuleType
|
|
TimeArrayTimeZoneRule::getTimeType(void) const {
|
|
return fTimeRuleType;
|
|
}
|
|
|
|
UBool
|
|
TimeArrayTimeZoneRule::getStartTimeAt(int32_t index, UDate& result) const {
|
|
if (index >= fNumStartTimes || index < 0) {
|
|
return FALSE;
|
|
}
|
|
result = fStartTimes[index];
|
|
return TRUE;
|
|
}
|
|
|
|
int32_t
|
|
TimeArrayTimeZoneRule::countStartTimes(void) const {
|
|
return fNumStartTimes;
|
|
}
|
|
|
|
UBool
|
|
TimeArrayTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
|
|
if (this == &other) {
|
|
return TRUE;
|
|
}
|
|
if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) {
|
|
return FALSE;
|
|
}
|
|
TimeArrayTimeZoneRule* that = (TimeArrayTimeZoneRule*)&other;
|
|
if (fTimeRuleType != that->fTimeRuleType ||
|
|
fNumStartTimes != that->fNumStartTimes) {
|
|
return FALSE;
|
|
}
|
|
// Compare start times
|
|
UBool res = TRUE;
|
|
for (int32_t i = 0; i < fNumStartTimes; i++) {
|
|
if (fStartTimes[i] != that->fStartTimes[i]) {
|
|
res = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
UBool
|
|
TimeArrayTimeZoneRule::getFirstStart(int32_t prevRawOffset,
|
|
int32_t prevDSTSavings,
|
|
UDate& result) const {
|
|
if (fNumStartTimes <= 0 || fStartTimes == NULL) {
|
|
return FALSE;
|
|
}
|
|
result = getUTC(fStartTimes[0], prevRawOffset, prevDSTSavings);
|
|
return TRUE;
|
|
}
|
|
|
|
UBool
|
|
TimeArrayTimeZoneRule::getFinalStart(int32_t prevRawOffset,
|
|
int32_t prevDSTSavings,
|
|
UDate& result) const {
|
|
if (fNumStartTimes <= 0 || fStartTimes == NULL) {
|
|
return FALSE;
|
|
}
|
|
result = getUTC(fStartTimes[fNumStartTimes - 1], prevRawOffset, prevDSTSavings);
|
|
return TRUE;
|
|
}
|
|
|
|
UBool
|
|
TimeArrayTimeZoneRule::getNextStart(UDate base,
|
|
int32_t prevRawOffset,
|
|
int32_t prevDSTSavings,
|
|
UBool inclusive,
|
|
UDate& result) const {
|
|
int32_t i = fNumStartTimes - 1;
|
|
for (; i >= 0; i--) {
|
|
UDate time = getUTC(fStartTimes[i], prevRawOffset, prevDSTSavings);
|
|
if (time < base || (!inclusive && time == base)) {
|
|
break;
|
|
}
|
|
result = time;
|
|
}
|
|
if (i == fNumStartTimes - 1) {
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
UBool
|
|
TimeArrayTimeZoneRule::getPreviousStart(UDate base,
|
|
int32_t prevRawOffset,
|
|
int32_t prevDSTSavings,
|
|
UBool inclusive,
|
|
UDate& result) const {
|
|
int32_t i = fNumStartTimes - 1;
|
|
for (; i >= 0; i--) {
|
|
UDate time = getUTC(fStartTimes[i], prevRawOffset, prevDSTSavings);
|
|
if (time < base || (inclusive && time == base)) {
|
|
result = time;
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// ---- private methods ------
|
|
|
|
UBool
|
|
TimeArrayTimeZoneRule::initStartTimes(const UDate source[], int32_t size, UErrorCode& status) {
|
|
// Free old array
|
|
if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) {
|
|
uprv_free(fStartTimes);
|
|
}
|
|
// Allocate new one if needed
|
|
if (size > TIMEARRAY_STACK_BUFFER_SIZE) {
|
|
fStartTimes = (UDate*)uprv_malloc(sizeof(UDate)*size);
|
|
if (fStartTimes == NULL) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
fNumStartTimes = 0;
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
fStartTimes = (UDate*)fLocalStartTimes;
|
|
}
|
|
uprv_memcpy(fStartTimes, source, sizeof(UDate)*size);
|
|
fNumStartTimes = size;
|
|
// Sort dates
|
|
uprv_sortArray(fStartTimes, fNumStartTimes, (int32_t)sizeof(UDate), compareDates, NULL, TRUE, &status);
|
|
if (U_FAILURE(status)) {
|
|
if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) {
|
|
uprv_free(fStartTimes);
|
|
}
|
|
fNumStartTimes = 0;
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
UDate
|
|
TimeArrayTimeZoneRule::getUTC(UDate time, int32_t raw, int32_t dst) const {
|
|
if (fTimeRuleType != DateTimeRule::UTC_TIME) {
|
|
time -= raw;
|
|
}
|
|
if (fTimeRuleType == DateTimeRule::WALL_TIME) {
|
|
time -= dst;
|
|
}
|
|
return time;
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|
|
|
|
//eof
|
|
|