+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/*
**********************************************************************
-* Copyright (c) 2003-2006, International Business Machines
+* Copyright (c) 2003-2013, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Author: Alan Liu
**********************************************************************
*/
+#include "utypeinfo.h" // for 'typeid' to work
+
#include "olsontz.h"
#if !UCONFIG_NO_FORMATTING
#include "gregoimp.h"
#include "cmemory.h"
#include "uassert.h"
+#include "uvector.h"
#include <float.h> // DBL_MAX
+#include "uresimp.h"
+#include "zonemeta.h"
+#include "umutex.h"
#ifdef U_DEBUG_TZ
# include <stdio.h>
#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};
* 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) {
+/*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() {
- transitionCount = 0;
+ canonicalID = NULL;
+
+ transitionCountPre32 = transitionCount32 = transitionCountPost32 = 0;
+ transitionTimesPre32 = transitionTimes32 = transitionTimesPost32 = NULL;
+
+ typeMapData = NULL;
+
typeCount = 1;
- transitionTimes = typeOffsets = ZEROS;
- typeData = (const uint8_t*) ZEROS;
+ typeOffsets = ZEROS;
+
+ finalZone = NULL;
}
/**
*/
OlsonTimeZone::OlsonTimeZone(const UResourceBundle* top,
const UResourceBundle* res,
+ const UnicodeString& tzid,
UErrorCode& ec) :
- finalYear(INT32_MAX), finalMillis(DBL_MAX), finalZone(0)
+ 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;
// // TODO remove nonconst casts below when ures_* API is fixed
// setID(ures_getKey((UResourceBundle*) res)); // cast away const
- // Size 1 is an alias TO another zone (int)
- // HOWEVER, the caller should dereference this and never pass it in to us
- // Size 3 is a purely historical zone (no final rules)
- // Size 4 is like size 3, but with an alias list at the end
- // Size 5 is a hybrid zone, with historical and final elements
- // Size 6 is like size 5, but with an alias list at the end
- int32_t size = ures_getSize(res);
- if (size < 3 || size > 6) {
+ int32_t len;
+ StackUResourceBundle r;
+
+ // Pre-32bit second transitions
+ ures_getByKey(res, kTRANSPRE32, r.getAlias(), &ec);
+ transitionTimesPre32 = ures_getIntVector(r.getAlias(), &len, &ec);
+ transitionCountPre32 = static_cast<int16_t>(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;
}
- // Transitions list may be empty
- 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)) {
+ // 32bit second transitions
+ ures_getByKey(res, kTRANS, r.getAlias(), &ec);
+ transitionTimes32 = ures_getIntVector(r.getAlias(), &len, &ec);
+ transitionCount32 = static_cast<int16_t>(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;
}
- transitionCount = (int16_t) i;
-
- // Type offsets list must be of even size, with size >= 2
- r = ures_getByIndex(res, 1, r, &ec);
- typeOffsets = ures_getIntVector(r, &i, &ec);
- if ((i<2 || i>0x7FFE || ((i&1)!=0)) && U_SUCCESS(ec)) {
+
+ // Post-32bit second transitions
+ ures_getByKey(res, kTRANSPOST32, r.getAlias(), &ec);
+ transitionTimesPost32 = ures_getIntVector(r.getAlias(), &len, &ec);
+ transitionCountPost32 = static_cast<int16_t>(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;
}
- typeCount = (int16_t) i >> 1;
- // Type data must be of the same size as the transitions list
- 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)) {
+ // Type offsets list must be of even size, with size >= 2
+ ures_getByKey(res, kTYPEOFFSETS, r.getAlias(), &ec);
+ typeOffsets = ures_getIntVector(r.getAlias(), &len, &ec);
+ if (U_SUCCESS(ec) && (len < 2 || len > 0x7FFE || (len & 1) != 0)) {
ec = U_INVALID_FORMAT_ERROR;
}
+ typeCount = (int16_t) len >> 1;
-#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]));
-// U_DEBUG_TZ_MSG((" offset%d\n", typeOffsets[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]));
- }
+ // Type map data must be of the same size as the transition count
+ typeMapData = NULL;
+ if (transitionCount() > 0) {
+ ures_getByKey(res, kTYPEMAP, r.getAlias(), &ec);
+ typeMapData = ures_getBinary(r.getAlias(), &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;
+ }
}
-#endif
// Process final rule and data, if any
- 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;
- // Subtract one from the actual final year; we
- // actually store final year - 1, and compare
- // using > rather than >=. This allows us to use
- // INT32_MAX as an exclusive upper limit for all
- // years, including INT32_MAX.
- U_ASSERT(data[1] > INT32_MIN);
- finalYear = data[1] - 1;
- // Also compute the millis for Jan 1, 0:00 GMT of the
- // finalYear. This reduces runtime computations.
- 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)) {
- // 3, 1, -1, 7200, 0, 9, -31, -1, 7200, 0, 3600
- 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);
- } else {
- ec = U_INVALID_FORMAT_ERROR;
- }
- }
- ures_close(r);
+ const UChar *ruleIdUStr = ures_getStringByKey(res, kFINALRULE, &len, &ec);
+ ures_getByKey(res, kFINALRAW, r.getAlias(), &ec);
+ int32_t ruleRaw = ures_getInt(r.getAlias(), &ec);
+ ures_getByKey(res, kFINALYEAR, r.getAlias(), &ec);
+ int32_t ruleYear = ures_getInt(r.getAlias(), &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 {
- ec = U_INVALID_FORMAT_ERROR;
+ 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;
}
+
+ // initialize canonical ID
+ canonicalID = ZoneMeta::getCanonicalCLDRID(tzid, ec);
}
if (U_FAILURE(ec)) {
* Copy constructor
*/
OlsonTimeZone::OlsonTimeZone(const OlsonTimeZone& other) :
- TimeZone(other), finalZone(0) {
+ BasicTimeZone(other), finalZone(0) {
*this = other;
}
* Assignment operator
*/
OlsonTimeZone& OlsonTimeZone::operator=(const OlsonTimeZone& other) {
- transitionCount = other.transitionCount;
+ canonicalID = other.canonicalID;
+
+ transitionTimesPre32 = other.transitionTimesPre32;
+ transitionTimes32 = other.transitionTimes32;
+ transitionTimesPost32 = other.transitionTimesPost32;
+
+ transitionCountPre32 = other.transitionCountPre32;
+ transitionCount32 = other.transitionCount32;
+ transitionCountPost32 = other.transitionCountPost32;
+
typeCount = other.typeCount;
- transitionTimes = other.transitionTimes;
typeOffsets = other.typeOffsets;
- typeData = other.typeData;
- finalYear = other.finalYear;
- finalMillis = other.finalMillis;
+ 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 {
- const OlsonTimeZone* z = (const OlsonTimeZone*) &other;
-
- return TimeZone::operator==(other) &&
- // [sic] pointer comparison: typeData points into
- // memory-mapped or DLL space, so if two zones have the same
- // pointer, they are equal.
- (typeData == z->typeData ||
- // If the pointers are not equal, the zones may still
- // be equal if their rules and transitions are equal
- (finalYear == z->finalYear &&
- // Don't compare finalMillis; if finalYear is ==, so is finalMillis
- ((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
- ));
+ return ((this == &other) ||
+ (typeid(*this) == typeid(other) &&
+ TimeZone::operator==(other) &&
+ hasSameRules(other)));
}
/**
year = -year;
}
- if (year > finalYear) { // [sic] >, not >=; see above
- U_ASSERT(finalZone != 0);
+ if (finalZone != NULL && year >= finalStartYear) {
return finalZone->getOffset(era, year, month, dom, dow,
millis, monthLength, ec);
}
- // Compute local epoch seconds from input fields
- double time = Grego::fieldsToDay(year, month, dom) * SECONDS_PER_DAY +
- uprv_floor(millis / (double) U_MILLIS_PER_SECOND);
-
- return zoneOffset(findTransition(time, TRUE)) * U_MILLIS_PER_SECOND;
+ // 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;
}
/**
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);
+ }
+}
- // The check against finalMillis will suffice most of the time, except
- // for the case in which finalMillis == DBL_MAX, date == DBL_MAX,
- // and finalZone == 0. For this case we add "&& finalZone != 0".
- if (date >= finalMillis && finalZone != 0) {
- int32_t year, month, dom, dow;
- double millis;
- double days = Math::floorDivide(date, (double)U_MILLIS_PER_DAY, millis);
-
- Grego::dayToFields(days, year, month, dom, dow);
-
- rawoff = finalZone->getRawOffset();
-
- if (!local) {
- // Adjust from GMT to local
- date += rawoff;
- double days2 = Math::floorDivide(date, (double)U_MILLIS_PER_DAY, millis);
- if (days2 != days) {
- Grego::dayToFields(days2, year, month, dom, dow);
- }
- }
-
- dstoff = finalZone->getOffset(
- GregorianCalendar::AD, year, month,
- dom, (uint8_t) dow, (int32_t) millis, ec) - rawoff;
+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;
}
-
- double secs = uprv_floor(date / U_MILLIS_PER_SECOND);
- int16_t i = findTransition(secs, local);
- rawoff = rawOffset(i) * U_MILLIS_PER_SECOND;
- dstoff = dstOffset(i) * U_MILLIS_PER_SECOND;
+ if (finalZone != NULL && date >= finalStartMillis) {
+ finalZone->getOffsetFromLocal(date, nonExistingTimeOpt, duplicatedTimeOpt, rawoff, dstoff, ec);
+ } else {
+ getHistoricalOffset(date, TRUE, nonExistingTimeOpt, duplicatedTimeOpt, rawoff, dstoff);
+ }
}
+
/**
* TimeZone API.
*/
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);
+ double days = ClockMath::floorDivide(((double)ms), (double)U_MILLIS_PER_DAY, millis);
Grego::dayToFields(days, year, month, dom, dow);
- U_DEBUG_TZ_MSG((" findTransition: time %.1f (%04d.%02d.%02d+%.1fh)\n", ms,
+ U_DEBUG_TZ_MSG((" getHistoricalOffset: time %.1f (%04d.%02d.%02d+%.1fh)\n", ms,
year, month+1, dom, (millis/kOneHour)));
}
#endif
-/**
- * Find the smallest i (in 0..transitionCount-1) such that time >=
- * transition(i), where transition(i) is either the GMT or the local
- * transition time, as specified by `local'.
- * @param time epoch seconds, either GMT or local wall
- * @param local if TRUE, `time' is in local wall units, otherwise it
- * is GMT
- * @return an index i, where 0 <= i < transitionCount, and
- * transition(i) <= time < transition(i+1), or i == 0 if
- * transitionCount == 0 or time < transition(0).
- */
-int16_t OlsonTimeZone::findTransition(double time, UBool local) const {
- int16_t i = 0;
- U_DEBUG_TZ_MSG(("findTransition(%.1f, %s)\n", time, local?"T":"F"));
-#if defined U_DEBUG_TZ
- printTime(time*1000.0);
-#endif
-
- if (transitionCount != 0) {
- // Linear search from the end is the fastest approach, since
- // most lookups will happen at/near the end.
- for (i = transitionCount - 1; i > 0; --i) {
- int32_t transition = transitionTimes[i];
- if (local) {
- int32_t zoneOffsetPrev = zoneOffset(typeData[i-1]);
- int32_t zoneOffsetCurr = zoneOffset(typeData[i]);
-
- // use the lowest offset ( == standard time ). as per tzregts.cpp which says:
-
- /**
- * @bug 4084933
- * The expected behavior of TimeZone around the boundaries is:
- * (Assume transition time of 2:00 AM)
- * day of onset 1:59 AM STD = display name 1:59 AM ST
- * 2:00 AM STD = display name 3:00 AM DT
- * day of end 0:59 AM STD = display name 1:59 AM DT
- * 1:00 AM STD = display name 1:00 AM ST
- */
- if(zoneOffsetPrev<zoneOffsetCurr) {
- transition += zoneOffsetPrev;
- } else {
- transition += zoneOffsetCurr;
- }
- }
- if (time >= transition) {
- U_DEBUG_TZ_MSG(("Found@%d: time=%.1f, localtransition=%d (orig %d) dz %d\n", i, time, 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, time, transition, transitionTimes[i],
- zoneOffset(typeData[i-1])));
+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(transition*1000.0);
- printTime(transitionTimes[i]*1000.0);
+ printTime(date*1000.0);
#endif
- }
- }
+ int16_t transCount = transitionCount();
- U_ASSERT(i>=0 && i<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);
- // Check invariants for GMT times; if these pass for GMT times
- // the local logic should be working too.
- U_ASSERT(local || time < transitionTimes[0] || time >= transitionTimes[i]);
- U_ASSERT(local || i == transitionCount-1 || time < transitionTimes[i+1]);
+ if (local && (sec >= (transition - MAX_OFFSET_SECONDS))) {
+ int32_t offsetBefore = zoneOffsetAt(transIdx - 1);
+ UBool dstBefore = dstOffsetAt(transIdx - 1) != 0;
- U_DEBUG_TZ_MSG(("findTransition(%.1f, %s)= trans %d\n", time, local?"T":"F", i));
- i = typeData[i];
- }
+ int32_t offsetAfter = zoneOffsetAt(transIdx);
+ UBool dstAfter = dstOffsetAt(transIdx) != 0;
- U_ASSERT(i>=0 && i<typeCount);
-
- U_DEBUG_TZ_MSG(("findTransition(%.1f, %s)=%d, offset %d\n", time, local?"T":"F", i, zoneOffset(i)));
- return i;
+ 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));
}
/**
// DST is in use in the current year (at any point in the year)
// and returns TRUE if so.
- int32_t days = (int32_t)Math::floorDivide(uprv_getUTCtime(), (double)U_MILLIS_PER_DAY); // epoch days
-
- int32_t year, month, dom, dow;
-
- Grego::dayToFields(days, year, month, dom, dow);
-
- if (year > finalYear) { // [sic] >, not >=; see above
- U_ASSERT(finalZone != 0 && finalZone->useDaylightTime());
- return TRUE;
+ 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
- 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;
+ 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) {
- if (transitionTimes[i] >= limit) {
+ for (int16_t i = 0; i < transitionCount(); ++i) {
+ double transition = (double)transitionTimeInSeconds(i);
+ if (transition >= limit) {
break;
}
- if (transitionTimes[i] >= start &&
- dstOffset(typeData[i]) != 0) {
+ if ((transition >= start && dstOffsetAt(i) != 0)
+ || (transition > start && dstOffsetAt(i - 1) != 0)) {
return TRUE;
}
}
}
int32_t
OlsonTimeZone::getDSTSavings() const{
- if(finalZone!=NULL){
+ if (finalZone != NULL){
return finalZone->getDSTSavings();
}
return TimeZone::getDSTSavings();
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
projects / apple / icu.git / blobdiff