You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

628 lines
19 KiB

// Copyright (C) 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* 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