#include "olsontz.h"
#if !UCONFIG_NO_FORMATTING
#include "unicode/ures.h"
#include "unicode/simpletz.h"
#include "unicode/gregocal.h"
#include "gregoimp.h"
#include "cmemory.h"
#include "uassert.h"
#include "uvector.h"
#include <float.h> // DBL_MAX
#ifdef U_DEBUG_TZ
# include <stdio.h>
# include "uresimp.h" // for debugging
static void debug_tz_loc(const char *f, int32_t l)
{
fprintf(stderr, "%s:%d: ", f, l);
}
static void debug_tz_msg(const char *pat, ...)
{
va_list ap;
va_start(ap, pat);
vfprintf(stderr, pat, ap);
fflush(stderr);
}
#define U_DEBUG_TZ_MSG(x) {debug_tz_loc(__FILE__,__LINE__);debug_tz_msg x;}
#else
#define U_DEBUG_TZ_MSG(x)
#endif
U_NAMESPACE_BEGIN
#define SECONDS_PER_DAY (24*60*60)
static const int32_t ZEROS[] = {0,0};
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(OlsonTimeZone)
void OlsonTimeZone::constructEmpty() {
transitionCount = 0;
typeCount = 1;
transitionTimes = typeOffsets = ZEROS;
typeData = (const uint8_t*) ZEROS;
}
OlsonTimeZone::OlsonTimeZone(const UResourceBundle* top,
const UResourceBundle* res,
UErrorCode& ec) :
finalYear(INT32_MAX), finalMillis(DBL_MAX), finalZone(0), transitionRulesInitialized(FALSE)
{
clearTransitionRules();
U_DEBUG_TZ_MSG(("OlsonTimeZone(%s)\n", ures_getKey((UResourceBundle*)res)));
if ((top == NULL || res == NULL) && U_SUCCESS(ec)) {
ec = U_ILLEGAL_ARGUMENT_ERROR;
}
if (U_SUCCESS(ec)) {
int32_t size = ures_getSize(res);
if (size < 3 || size > 6) {
ec = U_INVALID_FORMAT_ERROR;
}
int32_t i;
UResourceBundle* r = ures_getByIndex(res, 0, NULL, &ec);
transitionTimes = ures_getIntVector(r, &i, &ec);
if ((i<0 || i>0x7FFF) && U_SUCCESS(ec)) {
ec = U_INVALID_FORMAT_ERROR;
}
transitionCount = (int16_t) i;
r = ures_getByIndex(res, 1, r, &ec);
typeOffsets = ures_getIntVector(r, &i, &ec);
if ((i<2 || i>0x7FFE || ((i&1)!=0)) && U_SUCCESS(ec)) {
ec = U_INVALID_FORMAT_ERROR;
}
typeCount = (int16_t) i >> 1;
r = ures_getByIndex(res, 2, r, &ec);
int32_t len;
typeData = ures_getBinary(r, &len, &ec);
ures_close(r);
if (len != transitionCount && U_SUCCESS(ec)) {
ec = U_INVALID_FORMAT_ERROR;
}
#if defined (U_DEBUG_TZ)
U_DEBUG_TZ_MSG(("OlsonTimeZone(%s) - size = %d, typecount %d transitioncount %d - err %s\n", ures_getKey((UResourceBundle*)res), size, typeCount, transitionCount, u_errorName(ec)));
if(U_SUCCESS(ec)) {
int32_t jj;
for(jj=0;jj<transitionCount;jj++) {
int32_t year, month, dom, dow;
double millis=0;
double days = Math::floorDivide(((double)transitionTimes[jj])*1000.0, (double)U_MILLIS_PER_DAY, millis);
Grego::dayToFields(days, year, month, dom, dow);
U_DEBUG_TZ_MSG((" Transition %d: time %d (%04d.%02d.%02d+%.1fh), typedata%d\n", jj, transitionTimes[jj],
year, month+1, dom, (millis/kOneHour), typeData[jj]));
int16_t f = jj;
f <<= 1;
U_DEBUG_TZ_MSG((" offsets[%d+%d]=(%d+%d)=(%d==%d)\n", (int)f,(int)f+1,(int)typeOffsets[f],(int)typeOffsets[f+1],(int)zoneOffset(jj),
(int)typeOffsets[f]+(int)typeOffsets[f+1]));
}
}
#endif
if (size >= 5) {
int32_t ruleidLen = 0;
const UChar* idUStr = ures_getStringByIndex(res, 3, &ruleidLen, &ec);
UnicodeString ruleid(TRUE, idUStr, ruleidLen);
r = ures_getByIndex(res, 4, NULL, &ec);
const int32_t* data = ures_getIntVector(r, &len, &ec);
#if defined U_DEBUG_TZ
const char *rKey = ures_getKey(r);
const char *zKey = ures_getKey((UResourceBundle*)res);
#endif
ures_close(r);
if (U_SUCCESS(ec)) {
if (data != 0 && len == 2) {
int32_t rawOffset = data[0] * U_MILLIS_PER_SECOND;
U_ASSERT(data[1] > INT32_MIN);
finalYear = data[1] - 1;
finalMillis = Grego::fieldsToDay(data[1], 0, 1) * U_MILLIS_PER_DAY;
U_DEBUG_TZ_MSG(("zone%s|%s: {%d,%d}, finalYear%d, finalMillis%.1lf\n",
zKey,rKey, data[0], data[1], finalYear, finalMillis));
r = TimeZone::loadRule(top, ruleid, NULL, ec);
if (U_SUCCESS(ec)) {
data = ures_getIntVector(r, &len, &ec);
if (U_SUCCESS(ec) && len == 11) {
UnicodeString emptyStr;
U_DEBUG_TZ_MSG(("zone%s, rule%s: {%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d}\n", zKey, ures_getKey(r),
data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10]));
finalZone = new SimpleTimeZone(rawOffset, emptyStr,
(int8_t)data[0], (int8_t)data[1], (int8_t)data[2],
data[3] * U_MILLIS_PER_SECOND,
(SimpleTimeZone::TimeMode) data[4],
(int8_t)data[5], (int8_t)data[6], (int8_t)data[7],
data[8] * U_MILLIS_PER_SECOND,
(SimpleTimeZone::TimeMode) data[9],
data[10] * U_MILLIS_PER_SECOND, ec);
if (finalZone == NULL) {
ec = U_MEMORY_ALLOCATION_ERROR;
}
} else {
ec = U_INVALID_FORMAT_ERROR;
}
}
ures_close(r);
} else {
ec = U_INVALID_FORMAT_ERROR;
}
}
}
}
if (U_FAILURE(ec)) {
constructEmpty();
}
}
OlsonTimeZone::OlsonTimeZone(const OlsonTimeZone& other) :
BasicTimeZone(other), finalZone(0) {
*this = other;
}
OlsonTimeZone& OlsonTimeZone::operator=(const OlsonTimeZone& other) {
transitionCount = other.transitionCount;
typeCount = other.typeCount;
transitionTimes = other.transitionTimes;
typeOffsets = other.typeOffsets;
typeData = other.typeData;
finalYear = other.finalYear;
finalMillis = other.finalMillis;
delete finalZone;
finalZone = (other.finalZone != 0) ?
(SimpleTimeZone*) other.finalZone->clone() : 0;
clearTransitionRules();
return *this;
}
OlsonTimeZone::~OlsonTimeZone() {
deleteTransitionRules();
delete finalZone;
}
UBool OlsonTimeZone::operator==(const TimeZone& other) const {
return ((this == &other) ||
(getDynamicClassID() == other.getDynamicClassID() &&
TimeZone::operator==(other) &&
hasSameRules(other)));
}
TimeZone* OlsonTimeZone::clone() const {
return new OlsonTimeZone(*this);
}
int32_t OlsonTimeZone::getOffset(uint8_t era, int32_t year, int32_t month,
int32_t dom, uint8_t dow,
int32_t millis, UErrorCode& ec) const {
if (month < UCAL_JANUARY || month > UCAL_DECEMBER) {
if (U_SUCCESS(ec)) {
ec = U_ILLEGAL_ARGUMENT_ERROR;
}
return 0;
} else {
return getOffset(era, year, month, dom, dow, millis,
Grego::monthLength(year, month),
ec);
}
}
int32_t OlsonTimeZone::getOffset(uint8_t era, int32_t year, int32_t month,
int32_t dom, uint8_t dow,
int32_t millis, int32_t monthLength,
UErrorCode& ec) const {
if (U_FAILURE(ec)) {
return 0;
}
if ((era != GregorianCalendar::AD && era != GregorianCalendar::BC)
|| month < UCAL_JANUARY
|| month > UCAL_DECEMBER
|| dom < 1
|| dom > monthLength
|| dow < UCAL_SUNDAY
|| dow > UCAL_SATURDAY
|| millis < 0
|| millis >= U_MILLIS_PER_DAY
|| monthLength < 28
|| monthLength > 31) {
ec = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
if (era == GregorianCalendar::BC) {
year = -year;
}
if (year > finalYear) { U_ASSERT(finalZone != 0);
return finalZone->getOffset(era, year, month, dom, dow,
millis, monthLength, ec);
}
UDate date = (UDate)(Grego::fieldsToDay(year, month, dom) * U_MILLIS_PER_DAY + millis);
int32_t rawoff, dstoff;
getHistoricalOffset(date, TRUE, kDaylight, kStandard, rawoff, dstoff);
return rawoff + dstoff;
}
void OlsonTimeZone::getOffset(UDate date, UBool local, int32_t& rawoff,
int32_t& dstoff, UErrorCode& ec) const {
if (U_FAILURE(ec)) {
return;
}
if (date >= finalMillis && finalZone != 0) {
finalZone->getOffset(date, local, rawoff, dstoff, ec);
} else {
getHistoricalOffset(date, local, kFormer, kLatter, rawoff, dstoff);
}
}
void
OlsonTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
int32_t& rawoff, int32_t& dstoff, UErrorCode& ec) {
if (U_FAILURE(ec)) {
return;
}
if (date >= finalMillis && finalZone != 0) {
finalZone->getOffsetFromLocal(date, nonExistingTimeOpt, duplicatedTimeOpt, rawoff, dstoff, ec);
} else {
getHistoricalOffset(date, TRUE, nonExistingTimeOpt, duplicatedTimeOpt, rawoff, dstoff);
}
}
void OlsonTimeZone::setRawOffset(int32_t ) {
}
int32_t OlsonTimeZone::getRawOffset() const {
UErrorCode ec = U_ZERO_ERROR;
int32_t raw, dst;
getOffset((double) uprv_getUTCtime() * U_MILLIS_PER_SECOND,
FALSE, raw, dst, ec);
return raw;
}
#if defined U_DEBUG_TZ
void printTime(double ms) {
int32_t year, month, dom, dow;
double millis=0;
double days = Math::floorDivide(((double)ms), (double)U_MILLIS_PER_DAY, millis);
Grego::dayToFields(days, year, month, dom, dow);
U_DEBUG_TZ_MSG((" getHistoricalOffset: time %.1f (%04d.%02d.%02d+%.1fh)\n", ms,
year, month+1, dom, (millis/kOneHour)));
}
#endif
void
OlsonTimeZone::getHistoricalOffset(UDate date, UBool local,
int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt,
int32_t& rawoff, int32_t& dstoff) const {
U_DEBUG_TZ_MSG(("getHistoricalOffset(%.1f, %s, %d, %d, raw, dst)\n",
date, local?"T":"F", NonExistingTimeOpt, DuplicatedTimeOpt));
#if defined U_DEBUG_TZ
printTime(date*1000.0);
#endif
if (transitionCount != 0) {
double sec = uprv_floor(date / U_MILLIS_PER_SECOND);
int16_t i;
for (i = transitionCount - 1; i > 0; --i) {
int32_t transition = transitionTimes[i];
if (local) {
int32_t offsetBefore = zoneOffset(typeData[i-1]);
UBool dstBefore = dstOffset(typeData[i-1]) != 0;
int32_t offsetAfter = zoneOffset(typeData[i]);
UBool dstAfter = dstOffset(typeData[i]) != 0;
UBool dstToStd = dstBefore && !dstAfter;
UBool stdToDst = !dstBefore && dstAfter;
if (offsetAfter - offsetBefore >= 0) {
if (((NonExistingTimeOpt & kStdDstMask) == kStandard && dstToStd)
|| ((NonExistingTimeOpt & kStdDstMask) == kDaylight && stdToDst)) {
transition += offsetBefore;
} else if (((NonExistingTimeOpt & kStdDstMask) == kStandard && stdToDst)
|| ((NonExistingTimeOpt & kStdDstMask) == kDaylight && dstToStd)) {
transition += offsetAfter;
} else if ((NonExistingTimeOpt & kFormerLatterMask) == kLatter) {
transition += offsetBefore;
} else {
transition += offsetAfter;
}
} else {
if (((DuplicatedTimeOpt & kStdDstMask) == kStandard && dstToStd)
|| ((DuplicatedTimeOpt & kStdDstMask) == kDaylight && stdToDst)) {
transition += offsetAfter;
} else if (((DuplicatedTimeOpt & kStdDstMask) == kStandard && stdToDst)
|| ((DuplicatedTimeOpt & kStdDstMask) == kDaylight && dstToStd)) {
transition += offsetBefore;
} else if ((DuplicatedTimeOpt & kFormerLatterMask) == kFormer) {
transition += offsetBefore;
} else {
transition += offsetAfter;
}
}
}
if (sec >= transition) {
U_DEBUG_TZ_MSG(("Found@%d: time=%.1f, localtransition=%d (orig %d) dz %d\n", i, sec, transition, transitionTimes[i],
zoneOffset(typeData[i-1])));
#if defined U_DEBUG_TZ
printTime(transition*1000.0);
printTime(transitionTimes[i]*1000.0);
#endif
break;
} else {
U_DEBUG_TZ_MSG(("miss@%d: time=%.1f, localtransition=%d (orig %d) dz %d\n", i, sec, transition, transitionTimes[i],
zoneOffset(typeData[i-1])));
#if defined U_DEBUG_TZ
printTime(transition*1000.0);
printTime(transitionTimes[i]*1000.0);
#endif
}
}
U_ASSERT(i>=0 && i<transitionCount);
U_ASSERT(local || sec < transitionTimes[0] || sec >= transitionTimes[i]);
U_ASSERT(local || i == transitionCount-1 || sec < transitionTimes[i+1]);
U_DEBUG_TZ_MSG(("getHistoricalOffset(%.1f, %s, %d, %d, raw, dst) - trans %d\n",
date, local?"T":"F", NonExistingTimeOpt, DuplicatedTimeOpt, i));
int16_t index = typeData[i];
rawoff = rawOffset(index) * U_MILLIS_PER_SECOND;
dstoff = dstOffset(index) * U_MILLIS_PER_SECOND;
} else {
rawoff = rawOffset(0) * U_MILLIS_PER_SECOND;
dstoff = dstOffset(0) * U_MILLIS_PER_SECOND;
}
U_DEBUG_TZ_MSG(("getHistoricalOffset(%.1f, %s, %d, %d, raw, dst) - raw=%d, dst=%d\n",
date, local?"T":"F", NonExistingTimeOpt, DuplicatedTimeOpt, rawoff, dstoff));
}
UBool OlsonTimeZone::useDaylightTime() const {
int32_t days = (int32_t)Math::floorDivide(uprv_getUTCtime(), (double)U_MILLIS_PER_DAY);
int32_t year, month, dom, dow;
Grego::dayToFields(days, year, month, dom, dow);
if (year > finalYear) { U_ASSERT(finalZone != 0 && finalZone->useDaylightTime());
return TRUE;
}
int32_t start = (int32_t) Grego::fieldsToDay(year, 0, 1) * SECONDS_PER_DAY;
int32_t limit = (int32_t) Grego::fieldsToDay(year+1, 0, 1) * SECONDS_PER_DAY;
for (int16_t i=0; i<transitionCount; ++i) {
if (transitionTimes[i] >= limit) {
break;
}
if ((transitionTimes[i] >= start && dstOffset(typeData[i]) != 0)
|| (transitionTimes[i] > start && i > 0 && dstOffset(typeData[i - 1]) != 0)) {
return TRUE;
}
}
return FALSE;
}
int32_t
OlsonTimeZone::getDSTSavings() const{
if(finalZone!=NULL){
return finalZone->getDSTSavings();
}
return TimeZone::getDSTSavings();
}
UBool OlsonTimeZone::inDaylightTime(UDate date, UErrorCode& ec) const {
int32_t raw, dst;
getOffset(date, FALSE, raw, dst, ec);
return dst != 0;
}
UBool
OlsonTimeZone::hasSameRules(const TimeZone &other) const {
if (this == &other) {
return TRUE;
}
if (other.getDynamicClassID() != OlsonTimeZone::getStaticClassID()) {
return FALSE;
}
const OlsonTimeZone* z = (const OlsonTimeZone*) &other;
if (typeData == z->typeData) {
return TRUE;
}
return
(finalYear == z->finalYear &&
((finalZone == 0 && z->finalZone == 0) ||
(finalZone != 0 && z->finalZone != 0 && *finalZone == *z->finalZone)) &&
transitionCount == z->transitionCount &&
typeCount == z->typeCount &&
uprv_memcmp(transitionTimes, z->transitionTimes,
sizeof(transitionTimes[0]) * transitionCount) == 0 &&
uprv_memcmp(typeOffsets, z->typeOffsets,
(sizeof(typeOffsets[0]) * typeCount) << 1) == 0 &&
uprv_memcmp(typeData, z->typeData,
(sizeof(typeData[0]) * typeCount)) == 0);
}
void
OlsonTimeZone::clearTransitionRules(void) {
initialRule = NULL;
firstTZTransition = NULL;
firstFinalTZTransition = NULL;
historicRules = NULL;
historicRuleCount = 0;
finalZoneWithStartYear = NULL;
firstTZTransitionIdx = 0;
transitionRulesInitialized = FALSE;
}
void
OlsonTimeZone::deleteTransitionRules(void) {
if (initialRule != NULL) {
delete initialRule;
}
if (firstTZTransition != NULL) {
delete firstTZTransition;
}
if (firstFinalTZTransition != NULL) {
delete firstFinalTZTransition;
}
if (finalZoneWithStartYear != NULL) {
delete finalZoneWithStartYear;
}
if (historicRules != NULL) {
for (int i = 0; i < historicRuleCount; i++) {
if (historicRules[i] != NULL) {
delete historicRules[i];
}
}
uprv_free(historicRules);
}
clearTransitionRules();
}
void
OlsonTimeZone::initTransitionRules(UErrorCode& status) {
if(U_FAILURE(status)) {
return;
}
if (transitionRulesInitialized) {
return;
}
deleteTransitionRules();
UnicodeString tzid;
getID(tzid);
UnicodeString stdName = tzid + UNICODE_STRING_SIMPLE("(STD)");
UnicodeString dstName = tzid + UNICODE_STRING_SIMPLE("(DST)");
int32_t raw, dst;
if (transitionCount > 0) {
int16_t transitionIdx, typeIdx;
typeIdx = (int16_t)typeData[0]; raw = rawOffset(typeIdx) * U_MILLIS_PER_SECOND;
dst = dstOffset(typeIdx) * U_MILLIS_PER_SECOND;
initialRule = new InitialTimeZoneRule((dst == 0 ? stdName : dstName), raw, dst);
if (initialRule == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
firstTZTransitionIdx = 0;
for (transitionIdx = 1; transitionIdx < transitionCount; transitionIdx++) {
firstTZTransitionIdx++;
if (typeIdx != (int16_t)typeData[transitionIdx]) {
break;
}
}
if (transitionIdx == transitionCount) {
} else {
UDate* times = (UDate*)uprv_malloc(sizeof(UDate)*transitionCount);
if (times == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
for (typeIdx = 0; typeIdx < typeCount; typeIdx++) {
int32_t nTimes = 0;
for (transitionIdx = firstTZTransitionIdx; transitionIdx < transitionCount; transitionIdx++) {
if (typeIdx == (int16_t)typeData[transitionIdx]) {
UDate tt = ((UDate)transitionTimes[transitionIdx]) * U_MILLIS_PER_SECOND;
if (tt < finalMillis) {
times[nTimes++] = tt;
}
}
}
if (nTimes > 0) {
raw = rawOffset(typeIdx) * U_MILLIS_PER_SECOND;
dst = dstOffset(typeIdx) * U_MILLIS_PER_SECOND;
if (historicRules == NULL) {
historicRuleCount = typeCount;
historicRules = (TimeArrayTimeZoneRule**)uprv_malloc(sizeof(TimeArrayTimeZoneRule*)*historicRuleCount);
if (historicRules == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
uprv_free(times);
return;
}
for (int i = 0; i < historicRuleCount; i++) {
historicRules[i] = NULL;
}
}
historicRules[typeIdx] = new TimeArrayTimeZoneRule((dst == 0 ? stdName : dstName),
raw, dst, times, nTimes, DateTimeRule::UTC_TIME);
if (historicRules[typeIdx] == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
}
}
uprv_free(times);
typeIdx = (int16_t)typeData[firstTZTransitionIdx];
firstTZTransition = new TimeZoneTransition(((UDate)transitionTimes[firstTZTransitionIdx]) * U_MILLIS_PER_SECOND,
*initialRule, *historicRules[typeIdx]);
if (firstTZTransition == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
}
}
if (initialRule == NULL) {
raw = rawOffset(0) * U_MILLIS_PER_SECOND;
dst = dstOffset(0) * U_MILLIS_PER_SECOND;
initialRule = new InitialTimeZoneRule((dst == 0 ? stdName : dstName), raw, dst);
if (initialRule == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
}
if (finalZone != NULL) {
UDate startTime = (UDate)finalMillis;
TimeZoneRule *firstFinalRule = NULL;
if (finalZone->useDaylightTime()) {
finalZoneWithStartYear = (SimpleTimeZone*)finalZone->clone();
if (finalZoneWithStartYear == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
finalZoneWithStartYear->setStartYear(finalYear + 1);
TimeZoneTransition tzt;
finalZoneWithStartYear->getNextTransition(startTime, false, tzt);
firstFinalRule = tzt.getTo()->clone();
if (firstFinalRule == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
startTime = tzt.getTime();
} else {
finalZoneWithStartYear = (SimpleTimeZone*)finalZone->clone();
if (finalZoneWithStartYear == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
finalZone->getID(tzid);
firstFinalRule = new TimeArrayTimeZoneRule(tzid,
finalZone->getRawOffset(), 0, &startTime, 1, DateTimeRule::UTC_TIME);
if (firstFinalRule == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
}
TimeZoneRule *prevRule = NULL;
if (transitionCount > 0) {
prevRule = historicRules[typeData[transitionCount - 1]];
}
if (prevRule == NULL) {
prevRule = initialRule;
}
firstFinalTZTransition = new TimeZoneTransition();
if (firstFinalTZTransition == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
deleteTransitionRules();
return;
}
firstFinalTZTransition->setTime(startTime);
firstFinalTZTransition->adoptFrom(prevRule->clone());
firstFinalTZTransition->adoptTo(firstFinalRule);
}
transitionRulesInitialized = TRUE;
}
UBool
OlsonTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) {
UErrorCode status = U_ZERO_ERROR;
initTransitionRules(status);
if (U_FAILURE(status)) {
return FALSE;
}
if (finalZone != NULL) {
if (inclusive && base == firstFinalTZTransition->getTime()) {
result = *firstFinalTZTransition;
return TRUE;
} else if (base >= firstFinalTZTransition->getTime()) {
if (finalZone->useDaylightTime()) {
return finalZoneWithStartYear->getNextTransition(base, inclusive, result);
} else {
return FALSE;
}
}
}
if (historicRules != NULL) {
int16_t ttidx = transitionCount - 1;
for (; ttidx >= firstTZTransitionIdx; ttidx--) {
UDate t = ((UDate)transitionTimes[ttidx]) * U_MILLIS_PER_SECOND;
if (base > t || (!inclusive && base == t)) {
break;
}
}
if (ttidx == transitionCount - 1) {
if (firstFinalTZTransition != NULL) {
result = *firstFinalTZTransition;
return TRUE;
} else {
return FALSE;
}
} else if (ttidx < firstTZTransitionIdx) {
result = *firstTZTransition;
return TRUE;
} else {
TimeZoneRule *to = historicRules[typeData[ttidx + 1]];
TimeZoneRule *from = historicRules[typeData[ttidx]];
UDate startTime = ((UDate)transitionTimes[ttidx+1]) * U_MILLIS_PER_SECOND;
UnicodeString fromName, toName;
from->getName(fromName);
to->getName(toName);
if (fromName == toName && from->getRawOffset() == to->getRawOffset()
&& from->getDSTSavings() == to->getDSTSavings()) {
return getNextTransition(startTime, false, result);
}
result.setTime(startTime);
result.adoptFrom(from->clone());
result.adoptTo(to->clone());
return TRUE;
}
}
return FALSE;
}
UBool
OlsonTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) {
UErrorCode status = U_ZERO_ERROR;
initTransitionRules(status);
if (U_FAILURE(status)) {
return FALSE;
}
if (finalZone != NULL) {
if (inclusive && base == firstFinalTZTransition->getTime()) {
result = *firstFinalTZTransition;
return TRUE;
} else if (base > firstFinalTZTransition->getTime()) {
if (finalZone->useDaylightTime()) {
return finalZoneWithStartYear->getPreviousTransition(base, inclusive, result);
} else {
result = *firstFinalTZTransition;
return TRUE;
}
}
}
if (historicRules != NULL) {
int16_t ttidx = transitionCount - 1;
for (; ttidx >= firstTZTransitionIdx; ttidx--) {
UDate t = ((UDate)transitionTimes[ttidx]) * U_MILLIS_PER_SECOND;
if (base > t || (inclusive && base == t)) {
break;
}
}
if (ttidx < firstTZTransitionIdx) {
return FALSE;
} else if (ttidx == firstTZTransitionIdx) {
result = *firstTZTransition;
return TRUE;
} else {
TimeZoneRule *to = historicRules[typeData[ttidx]];
TimeZoneRule *from = historicRules[typeData[ttidx-1]];
UDate startTime = ((UDate)transitionTimes[ttidx]) * U_MILLIS_PER_SECOND;
UnicodeString fromName, toName;
from->getName(fromName);
to->getName(toName);
if (fromName == toName && from->getRawOffset() == to->getRawOffset()
&& from->getDSTSavings() == to->getDSTSavings()) {
return getPreviousTransition(startTime, false, result);
}
result.setTime(startTime);
result.adoptFrom(from->clone());
result.adoptTo(to->clone());
return TRUE;
}
}
return FALSE;
}
int32_t
OlsonTimeZone::countTransitionRules(UErrorCode& status) {
if (U_FAILURE(status)) {
return 0;
}
initTransitionRules(status);
if (U_FAILURE(status)) {
return 0;
}
int32_t count = 0;
if (historicRules != NULL) {
for (int32_t i = 0; i < historicRuleCount; i++) {
if (historicRules[i] != NULL) {
count++;
}
}
}
if (finalZone != NULL) {
if (finalZone->useDaylightTime()) {
count += 2;
} else {
count++;
}
}
return count;
}
void
OlsonTimeZone::getTimeZoneRules(const InitialTimeZoneRule*& initial,
const TimeZoneRule* trsrules[],
int32_t& trscount,
UErrorCode& status) {
if (U_FAILURE(status)) {
return;
}
initTransitionRules(status);
if (U_FAILURE(status)) {
return;
}
initial = initialRule;
int32_t cnt = 0;
if (historicRules != NULL && trscount > cnt) {
for (int32_t i = 0; i < historicRuleCount; i++) {
if (historicRules[i] != NULL) {
trsrules[cnt++] = historicRules[i];
if (cnt >= trscount) {
break;
}
}
}
}
if (finalZoneWithStartYear != NULL && trscount > cnt) {
const InitialTimeZoneRule *tmpini;
int32_t tmpcnt = trscount - cnt;
finalZoneWithStartYear->getTimeZoneRules(tmpini, &trsrules[cnt], tmpcnt, status);
if (U_FAILURE(status)) {
return;
}
cnt += tmpcnt;
}
trscount = cnt;
}
U_NAMESPACE_END
#endif // !UCONFIG_NO_FORMATTING