| /* |
| ********************************************************************** |
| * Copyright (c) 2003-2013, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| * Author: Alan Liu |
| * Created: July 21 2003 |
| * Since: ICU 2.8 |
| ********************************************************************** |
| */ |
| |
| #include "utypeinfo.h" // for 'typeid' to work |
| |
| #include "olsontz.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "starboard/client_porting/poem/assert_poem.h" |
| #include "starboard/client_porting/poem/string_poem.h" |
| #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 |
| #include "uresimp.h" // struct UResourceBundle |
| #include "zonemeta.h" |
| #include "umutex.h" |
| |
| #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); |
| } |
| // must use double parens, i.e.: U_DEBUG_TZ_MSG(("four is: %d",4)); |
| #define U_DEBUG_TZ_MSG(x) {debug_tz_loc(__FILE__,__LINE__);debug_tz_msg x;} |
| #else |
| #define U_DEBUG_TZ_MSG(x) |
| #endif |
| |
| static UBool arrayEqual(const void *a1, const void *a2, int32_t size) { |
| if (a1 == NULL && a2 == NULL) { |
| return TRUE; |
| } |
| if ((a1 != NULL && a2 == NULL) || (a1 == NULL && a2 != NULL)) { |
| return FALSE; |
| } |
| if (a1 == a2) { |
| return TRUE; |
| } |
| |
| return (uprv_memcmp(a1, a2, size) == 0); |
| } |
| |
| U_NAMESPACE_BEGIN |
| |
| #define kTRANS "trans" |
| #define kTRANSPRE32 "transPre32" |
| #define kTRANSPOST32 "transPost32" |
| #define kTYPEOFFSETS "typeOffsets" |
| #define kTYPEMAP "typeMap" |
| #define kLINKS "links" |
| #define kFINALRULE "finalRule" |
| #define kFINALRAW "finalRaw" |
| #define kFINALYEAR "finalYear" |
| |
| #define SECONDS_PER_DAY (24*60*60) |
| |
| static const int32_t ZEROS[] = {0,0}; |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(OlsonTimeZone) |
| |
| /** |
| * Default constructor. Creates a time zone with an empty ID and |
| * a fixed GMT offset of zero. |
| */ |
| /*OlsonTimeZone::OlsonTimeZone() : finalYear(INT32_MAX), finalMillis(DBL_MAX), finalZone(0), transitionRulesInitialized(FALSE) { |
| clearTransitionRules(); |
| constructEmpty(); |
| }*/ |
| |
| /** |
| * Construct a GMT+0 zone with no transitions. This is done when a |
| * constructor fails so the resultant object is well-behaved. |
| */ |
| void OlsonTimeZone::constructEmpty() { |
| canonicalID = NULL; |
| |
| transitionCountPre32 = transitionCount32 = transitionCountPost32 = 0; |
| transitionTimesPre32 = transitionTimes32 = transitionTimesPost32 = NULL; |
| |
| typeMapData = NULL; |
| |
| typeCount = 1; |
| typeOffsets = ZEROS; |
| |
| finalZone = NULL; |
| } |
| |
| /** |
| * Construct from a resource bundle |
| * @param top the top-level zoneinfo resource bundle. This is used |
| * to lookup the rule that `res' may refer to, if there is one. |
| * @param res the resource bundle of the zone to be constructed |
| * @param ec input-output error code |
| */ |
| OlsonTimeZone::OlsonTimeZone(const UResourceBundle* top, |
| const UResourceBundle* res, |
| const UnicodeString& tzid, |
| UErrorCode& ec) : |
| BasicTimeZone(tzid), finalZone(NULL) |
| { |
| 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)) { |
| // TODO -- clean up -- Doesn't work if res points to an alias |
| // // TODO remove nonconst casts below when ures_* API is fixed |
| // setID(ures_getKey((UResourceBundle*) res)); // cast away const |
| |
| int32_t len; |
| UResourceBundle r; |
| ures_initStackObject(&r); |
| |
| // Pre-32bit second transitions |
| ures_getByKey(res, kTRANSPRE32, &r, &ec); |
| transitionTimesPre32 = ures_getIntVector(&r, &len, &ec); |
| transitionCountPre32 = len >> 1; |
| if (ec == U_MISSING_RESOURCE_ERROR) { |
| // No pre-32bit transitions |
| transitionTimesPre32 = NULL; |
| transitionCountPre32 = 0; |
| ec = U_ZERO_ERROR; |
| } else if (U_SUCCESS(ec) && (len < 0 || len > 0x7FFF || (len & 1) != 0) /* len must be even */) { |
| ec = U_INVALID_FORMAT_ERROR; |
| } |
| |
| // 32bit second transitions |
| ures_getByKey(res, kTRANS, &r, &ec); |
| transitionTimes32 = ures_getIntVector(&r, &len, &ec); |
| transitionCount32 = len; |
| if (ec == U_MISSING_RESOURCE_ERROR) { |
| // No 32bit transitions |
| transitionTimes32 = NULL; |
| transitionCount32 = 0; |
| ec = U_ZERO_ERROR; |
| } else if (U_SUCCESS(ec) && (len < 0 || len > 0x7FFF)) { |
| ec = U_INVALID_FORMAT_ERROR; |
| } |
| |
| // Post-32bit second transitions |
| ures_getByKey(res, kTRANSPOST32, &r, &ec); |
| transitionTimesPost32 = ures_getIntVector(&r, &len, &ec); |
| transitionCountPost32 = len >> 1; |
| if (ec == U_MISSING_RESOURCE_ERROR) { |
| // No pre-32bit transitions |
| transitionTimesPost32 = NULL; |
| transitionCountPost32 = 0; |
| ec = U_ZERO_ERROR; |
| } else if (U_SUCCESS(ec) && (len < 0 || len > 0x7FFF || (len & 1) != 0) /* len must be even */) { |
| ec = U_INVALID_FORMAT_ERROR; |
| } |
| |
| // Type offsets list must be of even size, with size >= 2 |
| ures_getByKey(res, kTYPEOFFSETS, &r, &ec); |
| typeOffsets = ures_getIntVector(&r, &len, &ec); |
| if (U_SUCCESS(ec) && (len < 2 || len > 0x7FFE || (len & 1) != 0)) { |
| ec = U_INVALID_FORMAT_ERROR; |
| } |
| typeCount = (int16_t) len >> 1; |
| |
| // Type map data must be of the same size as the transition count |
| typeMapData = NULL; |
| if (transitionCount() > 0) { |
| ures_getByKey(res, kTYPEMAP, &r, &ec); |
| typeMapData = ures_getBinary(&r, &len, &ec); |
| if (ec == U_MISSING_RESOURCE_ERROR) { |
| // no type mapping data |
| ec = U_INVALID_FORMAT_ERROR; |
| } else if (U_SUCCESS(ec) && len != transitionCount()) { |
| ec = U_INVALID_FORMAT_ERROR; |
| } |
| } |
| |
| // Process final rule and data, if any |
| const UChar *ruleIdUStr = ures_getStringByKey(res, kFINALRULE, &len, &ec); |
| ures_getByKey(res, kFINALRAW, &r, &ec); |
| int32_t ruleRaw = ures_getInt(&r, &ec); |
| ures_getByKey(res, kFINALYEAR, &r, &ec); |
| int32_t ruleYear = ures_getInt(&r, &ec); |
| if (U_SUCCESS(ec)) { |
| UnicodeString ruleID(TRUE, ruleIdUStr, len); |
| UResourceBundle *rule = TimeZone::loadRule(top, ruleID, NULL, ec); |
| const int32_t *ruleData = ures_getIntVector(rule, &len, &ec); |
| if (U_SUCCESS(ec) && len == 11) { |
| UnicodeString emptyStr; |
| finalZone = new SimpleTimeZone( |
| ruleRaw * U_MILLIS_PER_SECOND, |
| emptyStr, |
| (int8_t)ruleData[0], (int8_t)ruleData[1], (int8_t)ruleData[2], |
| ruleData[3] * U_MILLIS_PER_SECOND, |
| (SimpleTimeZone::TimeMode) ruleData[4], |
| (int8_t)ruleData[5], (int8_t)ruleData[6], (int8_t)ruleData[7], |
| ruleData[8] * U_MILLIS_PER_SECOND, |
| (SimpleTimeZone::TimeMode) ruleData[9], |
| ruleData[10] * U_MILLIS_PER_SECOND, ec); |
| if (finalZone == NULL) { |
| ec = U_MEMORY_ALLOCATION_ERROR; |
| } else { |
| finalStartYear = ruleYear; |
| |
| // Note: Setting finalStartYear to the finalZone is problematic. When a date is around |
| // year boundary, SimpleTimeZone may return false result when DST is observed at the |
| // beginning of year. We could apply safe margin (day or two), but when one of recurrent |
| // rules falls around year boundary, it could return false result. Without setting the |
| // start year, finalZone works fine around the year boundary of the start year. |
| |
| // finalZone->setStartYear(finalStartYear); |
| |
| |
| // Compute the millis for Jan 1, 0:00 GMT of the finalYear |
| |
| // Note: finalStartMillis is used for detecting either if |
| // historic transition data or finalZone to be used. In an |
| // extreme edge case - for example, two transitions fall into |
| // small windows of time around the year boundary, this may |
| // result incorrect offset computation. But I think it will |
| // never happen practically. Yoshito - Feb 20, 2010 |
| finalStartMillis = Grego::fieldsToDay(finalStartYear, 0, 1) * U_MILLIS_PER_DAY; |
| } |
| } else { |
| ec = U_INVALID_FORMAT_ERROR; |
| } |
| ures_close(rule); |
| } else if (ec == U_MISSING_RESOURCE_ERROR) { |
| // No final zone |
| ec = U_ZERO_ERROR; |
| } |
| ures_close(&r); |
| |
| // initialize canonical ID |
| canonicalID = ZoneMeta::getCanonicalCLDRID(tzid, ec); |
| } |
| |
| if (U_FAILURE(ec)) { |
| constructEmpty(); |
| } |
| } |
| |
| /** |
| * Copy constructor |
| */ |
| OlsonTimeZone::OlsonTimeZone(const OlsonTimeZone& other) : |
| BasicTimeZone(other), finalZone(0) { |
| *this = other; |
| } |
| |
| /** |
| * Assignment operator |
| */ |
| OlsonTimeZone& OlsonTimeZone::operator=(const OlsonTimeZone& other) { |
| canonicalID = other.canonicalID; |
| |
| transitionTimesPre32 = other.transitionTimesPre32; |
| transitionTimes32 = other.transitionTimes32; |
| transitionTimesPost32 = other.transitionTimesPost32; |
| |
| transitionCountPre32 = other.transitionCountPre32; |
| transitionCount32 = other.transitionCount32; |
| transitionCountPost32 = other.transitionCountPost32; |
| |
| typeCount = other.typeCount; |
| typeOffsets = other.typeOffsets; |
| typeMapData = other.typeMapData; |
| |
| delete finalZone; |
| finalZone = (other.finalZone != 0) ? |
| (SimpleTimeZone*) other.finalZone->clone() : 0; |
| |
| finalStartYear = other.finalStartYear; |
| finalStartMillis = other.finalStartMillis; |
| |
| clearTransitionRules(); |
| |
| return *this; |
| } |
| |
| /** |
| * Destructor |
| */ |
| OlsonTimeZone::~OlsonTimeZone() { |
| deleteTransitionRules(); |
| delete finalZone; |
| } |
| |
| /** |
| * Returns true if the two TimeZone objects are equal. |
| */ |
| UBool OlsonTimeZone::operator==(const TimeZone& other) const { |
| return ((this == &other) || |
| (typeid(*this) == typeid(other) && |
| TimeZone::operator==(other) && |
| hasSameRules(other))); |
| } |
| |
| /** |
| * TimeZone API. |
| */ |
| TimeZone* OlsonTimeZone::clone() const { |
| return new OlsonTimeZone(*this); |
| } |
| |
| /** |
| * TimeZone API. |
| */ |
| 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); |
| } |
| } |
| |
| /** |
| * TimeZone API. |
| */ |
| 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 (finalZone != NULL && year >= finalStartYear) { |
| return finalZone->getOffset(era, year, month, dom, dow, |
| millis, monthLength, ec); |
| } |
| |
| // Compute local epoch millis from input fields |
| 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; |
| } |
| |
| /** |
| * TimeZone API. |
| */ |
| void OlsonTimeZone::getOffset(UDate date, UBool local, int32_t& rawoff, |
| int32_t& dstoff, UErrorCode& ec) const { |
| if (U_FAILURE(ec)) { |
| return; |
| } |
| if (finalZone != NULL && date >= finalStartMillis) { |
| 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) const { |
| if (U_FAILURE(ec)) { |
| return; |
| } |
| if (finalZone != NULL && date >= finalStartMillis) { |
| finalZone->getOffsetFromLocal(date, nonExistingTimeOpt, duplicatedTimeOpt, rawoff, dstoff, ec); |
| } else { |
| getHistoricalOffset(date, TRUE, nonExistingTimeOpt, duplicatedTimeOpt, rawoff, dstoff); |
| } |
| } |
| |
| |
| /** |
| * TimeZone API. |
| */ |
| void OlsonTimeZone::setRawOffset(int32_t /*offsetMillis*/) { |
| // We don't support this operation, since OlsonTimeZones are |
| // immutable (except for the ID, which is in the base class). |
| |
| // Nothing to do! |
| } |
| |
| /** |
| * TimeZone API. |
| */ |
| 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 = ClockMath::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 |
| |
| int64_t |
| OlsonTimeZone::transitionTimeInSeconds(int16_t transIdx) const { |
| U_ASSERT(transIdx >= 0 && transIdx < transitionCount()); |
| |
| if (transIdx < transitionCountPre32) { |
| return (((int64_t)((uint32_t)transitionTimesPre32[transIdx << 1])) << 32) |
| | ((int64_t)((uint32_t)transitionTimesPre32[(transIdx << 1) + 1])); |
| } |
| |
| transIdx -= transitionCountPre32; |
| if (transIdx < transitionCount32) { |
| return (int64_t)transitionTimes32[transIdx]; |
| } |
| |
| transIdx -= transitionCount32; |
| return (((int64_t)((uint32_t)transitionTimesPost32[transIdx << 1])) << 32) |
| | ((int64_t)((uint32_t)transitionTimesPost32[(transIdx << 1) + 1])); |
| } |
| |
| // Maximum absolute offset in seconds (86400 seconds = 1 day) |
| // getHistoricalOffset uses this constant as safety margin of |
| // quick zone transition checking. |
| #define MAX_OFFSET_SECONDS 86400 |
| |
| 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 |
| int16_t transCount = transitionCount(); |
| |
| if (transCount > 0) { |
| double sec = uprv_floor(date / U_MILLIS_PER_SECOND); |
| if (!local && sec < transitionTimeInSeconds(0)) { |
| // Before the first transition time |
| rawoff = initialRawOffset() * U_MILLIS_PER_SECOND; |
| dstoff = initialDstOffset() * U_MILLIS_PER_SECOND; |
| } else { |
| // Linear search from the end is the fastest approach, since |
| // most lookups will happen at/near the end. |
| int16_t transIdx; |
| for (transIdx = transCount - 1; transIdx >= 0; transIdx--) { |
| int64_t transition = transitionTimeInSeconds(transIdx); |
| |
| if (local && (sec >= (transition - MAX_OFFSET_SECONDS))) { |
| int32_t offsetBefore = zoneOffsetAt(transIdx - 1); |
| UBool dstBefore = dstOffsetAt(transIdx - 1) != 0; |
| |
| int32_t offsetAfter = zoneOffsetAt(transIdx); |
| UBool dstAfter = dstOffsetAt(transIdx) != 0; |
| |
| UBool dstToStd = dstBefore && !dstAfter; |
| UBool stdToDst = !dstBefore && dstAfter; |
| |
| if (offsetAfter - offsetBefore >= 0) { |
| // Positive transition, which makes a non-existing local time range |
| 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 { |
| // Interprets the time with rule before the transition, |
| // default for non-existing time range |
| transition += offsetAfter; |
| } |
| } else { |
| // Negative transition, which makes a duplicated local time range |
| 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 { |
| // Interprets the time with rule after the transition, |
| // default for duplicated local time range |
| transition += offsetAfter; |
| } |
| } |
| } |
| if (sec >= transition) { |
| break; |
| } |
| } |
| // transIdx could be -1 when local=true |
| rawoff = rawOffsetAt(transIdx) * U_MILLIS_PER_SECOND; |
| dstoff = dstOffsetAt(transIdx) * U_MILLIS_PER_SECOND; |
| } |
| } else { |
| // No transitions, single pair of offsets only |
| rawoff = initialRawOffset() * U_MILLIS_PER_SECOND; |
| dstoff = initialDstOffset() * 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)); |
| } |
| |
| /** |
| * TimeZone API. |
| */ |
| UBool OlsonTimeZone::useDaylightTime() const { |
| // If DST was observed in 1942 (for example) but has never been |
| // observed from 1943 to the present, most clients will expect |
| // this method to return FALSE. This method determines whether |
| // DST is in use in the current year (at any point in the year) |
| // and returns TRUE if so. |
| |
| UDate current = uprv_getUTCtime(); |
| if (finalZone != NULL && current >= finalStartMillis) { |
| return finalZone->useDaylightTime(); |
| } |
| |
| int32_t year, month, dom, dow, doy, mid; |
| Grego::timeToFields(current, year, month, dom, dow, doy, mid); |
| |
| // Find start of this year, and start of next year |
| double start = Grego::fieldsToDay(year, 0, 1) * SECONDS_PER_DAY; |
| double limit = Grego::fieldsToDay(year+1, 0, 1) * SECONDS_PER_DAY; |
| |
| // Return TRUE if DST is observed at any time during the current |
| // year. |
| for (int16_t i = 0; i < transitionCount(); ++i) { |
| double transition = (double)transitionTimeInSeconds(i); |
| if (transition >= limit) { |
| break; |
| } |
| if ((transition >= start && dstOffsetAt(i) != 0) |
| || (transition > start && dstOffsetAt(i - 1) != 0)) { |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| int32_t |
| OlsonTimeZone::getDSTSavings() const{ |
| if (finalZone != NULL){ |
| return finalZone->getDSTSavings(); |
| } |
| return TimeZone::getDSTSavings(); |
| } |
| /** |
| * TimeZone API. |
| */ |
| 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; |
| } |
| const OlsonTimeZone* z = dynamic_cast<const OlsonTimeZone*>(&other); |
| if (z == NULL) { |
| return FALSE; |
| } |
| |
| // [sic] pointer comparison: typeMapData points into |
| // memory-mapped or DLL space, so if two zones have the same |
| // pointer, they are equal. |
| if (typeMapData == z->typeMapData) { |
| return TRUE; |
| } |
| |
| // If the pointers are not equal, the zones may still |
| // be equal if their rules and transitions are equal |
| if ((finalZone == NULL && z->finalZone != NULL) |
| || (finalZone != NULL && z->finalZone == NULL) |
| || (finalZone != NULL && z->finalZone != NULL && *finalZone != *z->finalZone)) { |
| return FALSE; |
| } |
| |
| if (finalZone != NULL) { |
| if (finalStartYear != z->finalStartYear || finalStartMillis != z->finalStartMillis) { |
| return FALSE; |
| } |
| } |
| if (typeCount != z->typeCount |
| || transitionCountPre32 != z->transitionCountPre32 |
| || transitionCount32 != z->transitionCount32 |
| || transitionCountPost32 != z->transitionCountPost32) { |
| return FALSE; |
| } |
| |
| return |
| arrayEqual(transitionTimesPre32, z->transitionTimesPre32, sizeof(transitionTimesPre32[0]) * transitionCountPre32 << 1) |
| && arrayEqual(transitionTimes32, z->transitionTimes32, sizeof(transitionTimes32[0]) * transitionCount32) |
| && arrayEqual(transitionTimesPost32, z->transitionTimesPost32, sizeof(transitionTimesPost32[0]) * transitionCountPost32 << 1) |
| && arrayEqual(typeOffsets, z->typeOffsets, sizeof(typeOffsets[0]) * typeCount << 1) |
| && arrayEqual(typeMapData, z->typeMapData, sizeof(typeMapData[0]) * transitionCount()); |
| } |
| |
| void |
| OlsonTimeZone::clearTransitionRules(void) { |
| initialRule = NULL; |
| firstTZTransition = NULL; |
| firstFinalTZTransition = NULL; |
| historicRules = NULL; |
| historicRuleCount = 0; |
| finalZoneWithStartYear = NULL; |
| firstTZTransitionIdx = 0; |
| transitionRulesInitOnce.reset(); |
| } |
| |
| 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(); |
| } |
| |
| /* |
| * Lazy transition rules initializer |
| */ |
| |
| static void U_CALLCONV initRules(OlsonTimeZone *This, UErrorCode &status) { |
| This->initTransitionRules(status); |
| } |
| |
| void |
| OlsonTimeZone::checkTransitionRules(UErrorCode& status) const { |
| OlsonTimeZone *ncThis = const_cast<OlsonTimeZone *>(this); |
| umtx_initOnce(ncThis->transitionRulesInitOnce, &initRules, ncThis, status); |
| } |
| |
| void |
| OlsonTimeZone::initTransitionRules(UErrorCode& status) { |
| if(U_FAILURE(status)) { |
| return; |
| } |
| deleteTransitionRules(); |
| UnicodeString tzid; |
| getID(tzid); |
| |
| UnicodeString stdName = tzid + UNICODE_STRING_SIMPLE("(STD)"); |
| UnicodeString dstName = tzid + UNICODE_STRING_SIMPLE("(DST)"); |
| |
| int32_t raw, dst; |
| |
| // Create initial rule |
| raw = initialRawOffset() * U_MILLIS_PER_SECOND; |
| dst = initialDstOffset() * U_MILLIS_PER_SECOND; |
| initialRule = new InitialTimeZoneRule((dst == 0 ? stdName : dstName), raw, dst); |
| // Check to make sure initialRule was created |
| if (initialRule == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| deleteTransitionRules(); |
| return; |
| } |
| |
| int32_t transCount = transitionCount(); |
| if (transCount > 0) { |
| int16_t transitionIdx, typeIdx; |
| |
| // We probably no longer need to check the first "real" transition |
| // here, because the new tzcode remove such transitions already. |
| // For now, keeping this code for just in case. Feb 19, 2010 Yoshito |
| firstTZTransitionIdx = 0; |
| for (transitionIdx = 0; transitionIdx < transCount; transitionIdx++) { |
| if (typeMapData[transitionIdx] != 0) { // type 0 is the initial type |
| break; |
| } |
| firstTZTransitionIdx++; |
| } |
| if (transitionIdx == transCount) { |
| // Actually no transitions... |
| } else { |
| // Build historic rule array |
| UDate* times = (UDate*)uprv_malloc(sizeof(UDate)*transCount); /* large enough to store all transition times */ |
| if (times == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| deleteTransitionRules(); |
| return; |
| } |
| for (typeIdx = 0; typeIdx < typeCount; typeIdx++) { |
| // Gather all start times for each pair of offsets |
| int32_t nTimes = 0; |
| for (transitionIdx = firstTZTransitionIdx; transitionIdx < transCount; transitionIdx++) { |
| if (typeIdx == (int16_t)typeMapData[transitionIdx]) { |
| UDate tt = (UDate)transitionTime(transitionIdx); |
| if (finalZone == NULL || tt <= finalStartMillis) { |
| // Exclude transitions after finalMillis |
| times[nTimes++] = tt; |
| } |
| } |
| } |
| if (nTimes > 0) { |
| // Create a TimeArrayTimeZoneRule |
| raw = typeOffsets[typeIdx << 1] * U_MILLIS_PER_SECOND; |
| dst = typeOffsets[(typeIdx << 1) + 1] * 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++) { |
| // Initialize TimeArrayTimeZoneRule pointers as NULL |
| historicRules[i] = NULL; |
| } |
| } |
| historicRules[typeIdx] = new TimeArrayTimeZoneRule((dst == 0 ? stdName : dstName), |
| raw, dst, times, nTimes, DateTimeRule::UTC_TIME); |
| // Check for memory allocation error |
| if (historicRules[typeIdx] == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| deleteTransitionRules(); |
| return; |
| } |
| } |
| } |
| uprv_free(times); |
| |
| // Create initial transition |
| typeIdx = (int16_t)typeMapData[firstTZTransitionIdx]; |
| firstTZTransition = new TimeZoneTransition((UDate)transitionTime(firstTZTransitionIdx), |
| *initialRule, *historicRules[typeIdx]); |
| // Check to make sure firstTZTransition was created. |
| if (firstTZTransition == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| deleteTransitionRules(); |
| return; |
| } |
| } |
| } |
| if (finalZone != NULL) { |
| // Get the first occurence of final rule starts |
| UDate startTime = (UDate)finalStartMillis; |
| TimeZoneRule *firstFinalRule = NULL; |
| |
| if (finalZone->useDaylightTime()) { |
| /* |
| * Note: When an OlsonTimeZone is constructed, we should set the final year |
| * as the start year of finalZone. However, the bounday condition used for |
| * getting offset from finalZone has some problems. |
| * For now, we do not set the valid start year when the construction time |
| * and create a clone and set the start year when extracting rules. |
| */ |
| finalZoneWithStartYear = (SimpleTimeZone*)finalZone->clone(); |
| // Check to make sure finalZone was actually cloned. |
| if (finalZoneWithStartYear == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| deleteTransitionRules(); |
| return; |
| } |
| finalZoneWithStartYear->setStartYear(finalStartYear); |
| |
| TimeZoneTransition tzt; |
| finalZoneWithStartYear->getNextTransition(startTime, false, tzt); |
| firstFinalRule = tzt.getTo()->clone(); |
| // Check to make sure firstFinalRule received proper clone. |
| if (firstFinalRule == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| deleteTransitionRules(); |
| return; |
| } |
| startTime = tzt.getTime(); |
| } else { |
| // final rule with no transitions |
| finalZoneWithStartYear = (SimpleTimeZone*)finalZone->clone(); |
| // Check to make sure finalZone was actually cloned. |
| 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); |
| // Check firstFinalRule was properly created. |
| if (firstFinalRule == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| deleteTransitionRules(); |
| return; |
| } |
| } |
| TimeZoneRule *prevRule = NULL; |
| if (transCount > 0) { |
| prevRule = historicRules[typeMapData[transCount - 1]]; |
| } |
| if (prevRule == NULL) { |
| // No historic transitions, but only finalZone available |
| prevRule = initialRule; |
| } |
| firstFinalTZTransition = new TimeZoneTransition(); |
| // Check to make sure firstFinalTZTransition was created before dereferencing |
| if (firstFinalTZTransition == NULL) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| deleteTransitionRules(); |
| return; |
| } |
| firstFinalTZTransition->setTime(startTime); |
| firstFinalTZTransition->adoptFrom(prevRule->clone()); |
| firstFinalTZTransition->adoptTo(firstFinalRule); |
| } |
| } |
| |
| UBool |
| OlsonTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const { |
| UErrorCode status = U_ZERO_ERROR; |
| checkTransitionRules(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 finalZone->getNextTransition(base, inclusive, result); |
| return finalZoneWithStartYear->getNextTransition(base, inclusive, result); |
| } else { |
| // No more transitions |
| return FALSE; |
| } |
| } |
| } |
| if (historicRules != NULL) { |
| // Find a historical transition |
| int16_t transCount = transitionCount(); |
| int16_t ttidx = transCount - 1; |
| for (; ttidx >= firstTZTransitionIdx; ttidx--) { |
| UDate t = (UDate)transitionTime(ttidx); |
| if (base > t || (!inclusive && base == t)) { |
| break; |
| } |
| } |
| if (ttidx == transCount - 1) { |
| if (firstFinalTZTransition != NULL) { |
| result = *firstFinalTZTransition; |
| return TRUE; |
| } else { |
| return FALSE; |
| } |
| } else if (ttidx < firstTZTransitionIdx) { |
| result = *firstTZTransition; |
| return TRUE; |
| } else { |
| // Create a TimeZoneTransition |
| TimeZoneRule *to = historicRules[typeMapData[ttidx + 1]]; |
| TimeZoneRule *from = historicRules[typeMapData[ttidx]]; |
| UDate startTime = (UDate)transitionTime(ttidx+1); |
| |
| // The transitions loaded from zoneinfo.res may contain non-transition data |
| 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) const { |
| UErrorCode status = U_ZERO_ERROR; |
| checkTransitionRules(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 finalZone->getPreviousTransition(base, inclusive, result); |
| return finalZoneWithStartYear->getPreviousTransition(base, inclusive, result); |
| } else { |
| result = *firstFinalTZTransition; |
| return TRUE; |
| } |
| } |
| } |
| |
| if (historicRules != NULL) { |
| // Find a historical transition |
| int16_t ttidx = transitionCount() - 1; |
| for (; ttidx >= firstTZTransitionIdx; ttidx--) { |
| UDate t = (UDate)transitionTime(ttidx); |
| if (base > t || (inclusive && base == t)) { |
| break; |
| } |
| } |
| if (ttidx < firstTZTransitionIdx) { |
| // No more transitions |
| return FALSE; |
| } else if (ttidx == firstTZTransitionIdx) { |
| result = *firstTZTransition; |
| return TRUE; |
| } else { |
| // Create a TimeZoneTransition |
| TimeZoneRule *to = historicRules[typeMapData[ttidx]]; |
| TimeZoneRule *from = historicRules[typeMapData[ttidx-1]]; |
| UDate startTime = (UDate)transitionTime(ttidx); |
| |
| // The transitions loaded from zoneinfo.res may contain non-transition data |
| 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) const { |
| if (U_FAILURE(status)) { |
| return 0; |
| } |
| checkTransitionRules(status); |
| if (U_FAILURE(status)) { |
| return 0; |
| } |
| |
| int32_t count = 0; |
| if (historicRules != NULL) { |
| // historicRules may contain null entries when original zoneinfo data |
| // includes non transition data. |
| 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) const { |
| if (U_FAILURE(status)) { |
| return; |
| } |
| checkTransitionRules(status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| // Initial rule |
| initial = initialRule; |
| |
| // Transition rules |
| int32_t cnt = 0; |
| if (historicRules != NULL && trscount > cnt) { |
| // historicRules may contain null entries when original zoneinfo data |
| // includes non transition data. |
| 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; |
| } |
| // Set the result length |
| trscount = cnt; |
| } |
| |
| U_NAMESPACE_END |
| |
| #endif // !UCONFIG_NO_FORMATTING |
| |
| //eof |
