icuSources/i18n/olsontz.cpp

   1 /*
   2 **********************************************************************
   3 * Copyright (c) 2003-2009, International Business Machines
   4 * Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 * Author: Alan Liu
   7 * Created: July 21 2003
   8 * Since: ICU 2.8
   9 **********************************************************************
  10 */
  11
  12 #include "olsontz.h"
  13
  14 #if !UCONFIG_NO_FORMATTING
  15
  16 #include "unicode/ures.h"
  17 #include "unicode/simpletz.h"
  18 #include "unicode/gregocal.h"
  19 #include "gregoimp.h"
  20 #include "cmemory.h"
  21 #include "uassert.h"
  22 #include "uvector.h"
  23 #include <float.h> // DBL_MAX
  24
  25 #ifdef U_DEBUG_TZ
  26 # include <stdio.h>
  27 # include "uresimp.h" // for debugging
  28
  29 static void debug_tz_loc(const char *f, int32_t l)
  30 {
  31   fprintf(stderr, "%s:%d: ", f, l);
  32 }
  33
  34 static void debug_tz_msg(const char *pat, ...)
  35 {
  36   va_list ap;
  37   va_start(ap, pat);
  38   vfprintf(stderr, pat, ap);
  39   fflush(stderr);
  40 }
  41 // must use double parens, i.e.:  U_DEBUG_TZ_MSG(("four is: %d",4));
  42 #define U_DEBUG_TZ_MSG(x) {debug_tz_loc(__FILE__,__LINE__);debug_tz_msg x;}
  43 #else
  44 #define U_DEBUG_TZ_MSG(x)
  45 #endif
  46
  47 U_NAMESPACE_BEGIN
  48
  49 #define SECONDS_PER_DAY (24*60*60)
  50
  51 static const int32_t ZEROS[] = {0,0};
  52
  53 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(OlsonTimeZone)
  54
  55 /**
  56  * Default constructor.  Creates a time zone with an empty ID and
  57  * a fixed GMT offset of zero.
  58  */
  59 /*OlsonTimeZone::OlsonTimeZone() : finalYear(INT32_MAX), finalMillis(DBL_MAX), finalZone(0), transitionRulesInitialized(FALSE) {
  60     clearTransitionRules();
  61     constructEmpty();
  62 }*/
  63
  64 /**
  65  * Construct a GMT+0 zone with no transitions.  This is done when a
  66  * constructor fails so the resultant object is well-behaved.
  67  */
  68 void OlsonTimeZone::constructEmpty() {
  69     transitionCount = 0;
  70     typeCount = 1;
  71     transitionTimes = typeOffsets = ZEROS;
  72     typeData = (const uint8_t*) ZEROS;
  73 }
  74
  75 /**
  76  * Construct from a resource bundle
  77  * @param top the top-level zoneinfo resource bundle.  This is used
  78  * to lookup the rule that `res' may refer to, if there is one.
  79  * @param res the resource bundle of the zone to be constructed
  80  * @param ec input-output error code
  81  */
  82 OlsonTimeZone::OlsonTimeZone(const UResourceBundle* top,
  83                              const UResourceBundle* res,
  84                              UErrorCode& ec) :
  85   finalYear(INT32_MAX), finalMillis(DBL_MAX), finalZone(0), transitionRulesInitialized(FALSE)
  86 {
  87     clearTransitionRules();
  88     U_DEBUG_TZ_MSG(("OlsonTimeZone(%s)\n", ures_getKey((UResourceBundle*)res)));
  89     if ((top == NULL || res == NULL) && U_SUCCESS(ec)) {
  90         ec = U_ILLEGAL_ARGUMENT_ERROR;
  91     }
  92     if (U_SUCCESS(ec)) {
  93         // TODO -- clean up -- Doesn't work if res points to an alias
  94         //        // TODO remove nonconst casts below when ures_* API is fixed
  95         //        setID(ures_getKey((UResourceBundle*) res)); // cast away const
  96
  97         // Size 1 is an alias TO another zone (int)
  98         // HOWEVER, the caller should dereference this and never pass it in to us
  99         // Size 3 is a purely historical zone (no final rules)
 100         // Size 4 is like size 3, but with an alias list at the end
 101         // Size 5 is a hybrid zone, with historical and final elements
 102         // Size 6 is like size 5, but with an alias list at the end
 103         int32_t size = ures_getSize(res);
 104         if (size < 3 || size > 6) {
 105             ec = U_INVALID_FORMAT_ERROR;
 106         }
 107
 108         // Transitions list may be empty
 109         int32_t i;
 110         UResourceBundle* r = ures_getByIndex(res, 0, NULL, &ec);
 111         transitionTimes = ures_getIntVector(r, &i, &ec);
 112         if ((i<0 || i>0x7FFF) && U_SUCCESS(ec)) {
 113             ec = U_INVALID_FORMAT_ERROR;
 114         }
 115         transitionCount = (int16_t) i;
 116
 117         // Type offsets list must be of even size, with size >= 2
 118         r = ures_getByIndex(res, 1, r, &ec);
 119         typeOffsets = ures_getIntVector(r, &i, &ec);
 120         if ((i<2 || i>0x7FFE || ((i&1)!=0)) && U_SUCCESS(ec)) {
 121             ec = U_INVALID_FORMAT_ERROR;
 122         }
 123         typeCount = (int16_t) i >> 1;
 124
 125         // Type data must be of the same size as the transitions list
 126         r = ures_getByIndex(res, 2, r, &ec);
 127         int32_t len;
 128         typeData = ures_getBinary(r, &len, &ec);
 129         ures_close(r);
 130         if (len != transitionCount && U_SUCCESS(ec)) {
 131             ec = U_INVALID_FORMAT_ERROR;
 132         }
 133
 134 #if defined (U_DEBUG_TZ)
 135         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)));
 136         if(U_SUCCESS(ec)) {
 137           int32_t jj;
 138           for(jj=0;jj<transitionCount;jj++) {
 139             int32_t year, month, dom, dow;
 140             double millis=0;
 141             double days = Math::floorDivide(((double)transitionTimes[jj])*1000.0, (double)U_MILLIS_PER_DAY, millis);
 142
 143             Grego::dayToFields(days, year, month, dom, dow);
 144             U_DEBUG_TZ_MSG(("   Transition %d:  time %d (%04d.%02d.%02d+%.1fh), typedata%d\n", jj, transitionTimes[jj],
 145                             year, month+1, dom, (millis/kOneHour), typeData[jj]));
 146 //            U_DEBUG_TZ_MSG(("     offset%d\n", typeOffsets[jj]));
 147             int16_t f = jj;
 148             f <<= 1;
 149             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),
 150                 (int)typeOffsets[f]+(int)typeOffsets[f+1]));
 151           }
 152         }
 153 #endif
 154
 155         // Process final rule and data, if any
 156         if (size >= 5) {
 157             int32_t ruleidLen = 0;
 158             const UChar* idUStr = ures_getStringByIndex(res, 3, &ruleidLen, &ec);
 159             UnicodeString ruleid(TRUE, idUStr, ruleidLen);
 160             r = ures_getByIndex(res, 4, NULL, &ec);
 161             const int32_t* data = ures_getIntVector(r, &len, &ec);
 162 #if defined U_DEBUG_TZ
 163             const char *rKey = ures_getKey(r);
 164             const char *zKey = ures_getKey((UResourceBundle*)res);
 165 #endif
 166             ures_close(r);
 167             if (U_SUCCESS(ec)) {
 168                 if (data != 0 && len == 2) {
 169                     int32_t rawOffset = data[0] * U_MILLIS_PER_SECOND;
 170                     // Subtract one from the actual final year; we
 171                     // actually store final year - 1, and compare
 172                     // using > rather than >=.  This allows us to use
 173                     // INT32_MAX as an exclusive upper limit for all
 174                     // years, including INT32_MAX.
 175                     U_ASSERT(data[1] > INT32_MIN);
 176                     finalYear = data[1] - 1;
 177                     // Also compute the millis for Jan 1, 0:00 GMT of the
 178                     // finalYear.  This reduces runtime computations.
 179                     finalMillis = Grego::fieldsToDay(data[1], 0, 1) * U_MILLIS_PER_DAY;
 180                     U_DEBUG_TZ_MSG(("zone%s|%s: {%d,%d}, finalYear%d, finalMillis%.1lf\n",
 181                                     zKey,rKey, data[0], data[1], finalYear, finalMillis));
 182                     r = TimeZone::loadRule(top, ruleid, NULL, ec);
 183                     if (U_SUCCESS(ec)) {
 184                         // 3, 1, -1, 7200, 0, 9, -31, -1, 7200, 0, 3600
 185                         data = ures_getIntVector(r, &len, &ec);
 186                         if (U_SUCCESS(ec) && len == 11) {
 187                             UnicodeString emptyStr;
 188                             U_DEBUG_TZ_MSG(("zone%s, rule%s: {%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d}\n", zKey, ures_getKey(r),
 189                                           data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10]));
 190                             finalZone = new SimpleTimeZone(rawOffset, emptyStr,
 191                                 (int8_t)data[0], (int8_t)data[1], (int8_t)data[2],
 192                                 data[3] * U_MILLIS_PER_SECOND,
 193                                 (SimpleTimeZone::TimeMode) data[4],
 194                                 (int8_t)data[5], (int8_t)data[6], (int8_t)data[7],
 195                                 data[8] * U_MILLIS_PER_SECOND,
 196                                 (SimpleTimeZone::TimeMode) data[9],
 197                                 data[10] * U_MILLIS_PER_SECOND, ec);
 198                             // Make sure finalZone was created
 199                             if (finalZone == NULL) {
 200                                 ec = U_MEMORY_ALLOCATION_ERROR;
 201                             }
 202                         } else {
 203                             ec = U_INVALID_FORMAT_ERROR;
 204                         }
 205                     }
 206                     ures_close(r);
 207                 } else {
 208                     ec = U_INVALID_FORMAT_ERROR;
 209                 }
 210             }
 211         }
 212     }
 213
 214     if (U_FAILURE(ec)) {
 215         constructEmpty();
 216     }
 217 }
 218
 219 /**
 220  * Copy constructor
 221  */
 222 OlsonTimeZone::OlsonTimeZone(const OlsonTimeZone& other) :
 223     BasicTimeZone(other), finalZone(0) {
 224     *this = other;
 225 }
 226
 227 /**
 228  * Assignment operator
 229  */
 230 OlsonTimeZone& OlsonTimeZone::operator=(const OlsonTimeZone& other) {
 231     transitionCount = other.transitionCount;
 232     typeCount = other.typeCount;
 233     transitionTimes = other.transitionTimes;
 234     typeOffsets = other.typeOffsets;
 235     typeData = other.typeData;
 236     finalYear = other.finalYear;
 237     finalMillis = other.finalMillis;
 238     delete finalZone;
 239     finalZone = (other.finalZone != 0) ?
 240         (SimpleTimeZone*) other.finalZone->clone() : 0;
 241     clearTransitionRules();
 242     return *this;
 243 }
 244
 245 /**
 246  * Destructor
 247  */
 248 OlsonTimeZone::~OlsonTimeZone() {
 249     deleteTransitionRules();
 250     delete finalZone;
 251 }
 252
 253 /**
 254  * Returns true if the two TimeZone objects are equal.
 255  */
 256 UBool OlsonTimeZone::operator==(const TimeZone& other) const {
 257     return ((this == &other) ||
 258             (getDynamicClassID() == other.getDynamicClassID() &&
 259             TimeZone::operator==(other) &&
 260             hasSameRules(other)));
 261 }
 262
 263 /**
 264  * TimeZone API.
 265  */
 266 TimeZone* OlsonTimeZone::clone() const {
 267     return new OlsonTimeZone(*this);
 268 }
 269
 270 /**
 271  * TimeZone API.
 272  */
 273 int32_t OlsonTimeZone::getOffset(uint8_t era, int32_t year, int32_t month,
 274                                  int32_t dom, uint8_t dow,
 275                                  int32_t millis, UErrorCode& ec) const {
 276     if (month < UCAL_JANUARY || month > UCAL_DECEMBER) {
 277         if (U_SUCCESS(ec)) {
 278             ec = U_ILLEGAL_ARGUMENT_ERROR;
 279         }
 280         return 0;
 281     } else {
 282         return getOffset(era, year, month, dom, dow, millis,
 283                          Grego::monthLength(year, month),
 284                          ec);
 285     }
 286 }
 287
 288 /**
 289  * TimeZone API.
 290  */
 291 int32_t OlsonTimeZone::getOffset(uint8_t era, int32_t year, int32_t month,
 292                                  int32_t dom, uint8_t dow,
 293                                  int32_t millis, int32_t monthLength,
 294                                  UErrorCode& ec) const {
 295     if (U_FAILURE(ec)) {
 296         return 0;
 297     }
 298
 299     if ((era != GregorianCalendar::AD && era != GregorianCalendar::BC)
 300         || month < UCAL_JANUARY
 301         || month > UCAL_DECEMBER
 302         || dom < 1
 303         || dom > monthLength
 304         || dow < UCAL_SUNDAY
 305         || dow > UCAL_SATURDAY
 306         || millis < 0
 307         || millis >= U_MILLIS_PER_DAY
 308         || monthLength < 28
 309         || monthLength > 31) {
 310         ec = U_ILLEGAL_ARGUMENT_ERROR;
 311         return 0;
 312     }
 313
 314     if (era == GregorianCalendar::BC) {
 315         year = -year;
 316     }
 317
 318     if (year > finalYear) { // [sic] >, not >=; see above
 319         U_ASSERT(finalZone != 0);
 320         return finalZone->getOffset(era, year, month, dom, dow,
 321                                     millis, monthLength, ec);
 322     }
 323
 324     // Compute local epoch millis from input fields
 325     UDate date = (UDate)(Grego::fieldsToDay(year, month, dom) * U_MILLIS_PER_DAY + millis);
 326     int32_t rawoff, dstoff;
 327     getHistoricalOffset(date, TRUE, kDaylight, kStandard, rawoff, dstoff);
 328     return rawoff + dstoff;
 329 }
 330
 331 /**
 332  * TimeZone API.
 333  */
 334 void OlsonTimeZone::getOffset(UDate date, UBool local, int32_t& rawoff,
 335                               int32_t& dstoff, UErrorCode& ec) const {
 336     if (U_FAILURE(ec)) {
 337         return;
 338     }
 339     // The check against finalMillis will suffice most of the time, except
 340     // for the case in which finalMillis == DBL_MAX, date == DBL_MAX,
 341     // and finalZone == 0.  For this case we add "&& finalZone != 0".
 342     if (date >= finalMillis && finalZone != 0) {
 343         finalZone->getOffset(date, local, rawoff, dstoff, ec);
 344     } else {
 345         getHistoricalOffset(date, local, kFormer, kLatter, rawoff, dstoff);
 346     }
 347 }
 348
 349 void
 350 OlsonTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
 351                                   int32_t& rawoff, int32_t& dstoff, UErrorCode& ec) /*const*/ {
 352     if (U_FAILURE(ec)) {
 353         return;
 354     }
 355     if (date >= finalMillis && finalZone != 0) {
 356         finalZone->getOffsetFromLocal(date, nonExistingTimeOpt, duplicatedTimeOpt, rawoff, dstoff, ec);
 357     } else {
 358         getHistoricalOffset(date, TRUE, nonExistingTimeOpt, duplicatedTimeOpt, rawoff, dstoff);
 359     }
 360 }
 361
 362
 363 /**
 364  * TimeZone API.
 365  */
 366 void OlsonTimeZone::setRawOffset(int32_t /*offsetMillis*/) {
 367     // We don't support this operation, since OlsonTimeZones are
 368     // immutable (except for the ID, which is in the base class).
 369
 370     // Nothing to do!
 371 }
 372
 373 /**
 374  * TimeZone API.
 375  */
 376 int32_t OlsonTimeZone::getRawOffset() const {
 377     UErrorCode ec = U_ZERO_ERROR;
 378     int32_t raw, dst;
 379     getOffset((double) uprv_getUTCtime() * U_MILLIS_PER_SECOND,
 380               FALSE, raw, dst, ec);
 381     return raw;
 382 }
 383
 384 #if defined U_DEBUG_TZ
 385 void printTime(double ms) {
 386             int32_t year, month, dom, dow;
 387             double millis=0;
 388             double days = Math::floorDivide(((double)ms), (double)U_MILLIS_PER_DAY, millis);
 389
 390             Grego::dayToFields(days, year, month, dom, dow);
 391             U_DEBUG_TZ_MSG(("   getHistoricalOffset:  time %.1f (%04d.%02d.%02d+%.1fh)\n", ms,
 392                             year, month+1, dom, (millis/kOneHour)));
 393     }
 394 #endif
 395
 396 void
 397 OlsonTimeZone::getHistoricalOffset(UDate date, UBool local,
 398                                    int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt,
 399                                    int32_t& rawoff, int32_t& dstoff) const {
 400     U_DEBUG_TZ_MSG(("getHistoricalOffset(%.1f, %s, %d, %d, raw, dst)\n",
 401         date, local?"T":"F", NonExistingTimeOpt, DuplicatedTimeOpt));
 402 #if defined U_DEBUG_TZ
 403         printTime(date*1000.0);
 404 #endif
 405     if (transitionCount != 0) {
 406         double sec = uprv_floor(date / U_MILLIS_PER_SECOND);
 407         // Linear search from the end is the fastest approach, since
 408         // most lookups will happen at/near the end.
 409         int16_t i;
 410         for (i = transitionCount - 1; i > 0; --i) {
 411             int32_t transition = transitionTimes[i];
 412
 413             if (local) {
 414                 int32_t offsetBefore = zoneOffset(typeData[i-1]);
 415                 UBool dstBefore = dstOffset(typeData[i-1]) != 0;
 416
 417                 int32_t offsetAfter = zoneOffset(typeData[i]);
 418                 UBool dstAfter = dstOffset(typeData[i]) != 0;
 419
 420                 UBool dstToStd = dstBefore && !dstAfter;
 421                 UBool stdToDst = !dstBefore && dstAfter;
 422
 423                 if (offsetAfter - offsetBefore >= 0) {
 424                     // Positive transition, which makes a non-existing local time range
 425                     if (((NonExistingTimeOpt & kStdDstMask) == kStandard && dstToStd)
 426                             || ((NonExistingTimeOpt & kStdDstMask) == kDaylight && stdToDst)) {
 427                         transition += offsetBefore;
 428                     } else if (((NonExistingTimeOpt & kStdDstMask) == kStandard && stdToDst)
 429                             || ((NonExistingTimeOpt & kStdDstMask) == kDaylight && dstToStd)) {
 430                         transition += offsetAfter;
 431                     } else if ((NonExistingTimeOpt & kFormerLatterMask) == kLatter) {
 432                         transition += offsetBefore;
 433                     } else {
 434                         // Interprets the time with rule before the transition,
 435                         // default for non-existing time range
 436                         transition += offsetAfter;
 437                     }
 438                 } else {
 439                     // Negative transition, which makes a duplicated local time range
 440                     if (((DuplicatedTimeOpt & kStdDstMask) == kStandard && dstToStd)
 441                             || ((DuplicatedTimeOpt & kStdDstMask) == kDaylight && stdToDst)) {
 442                         transition += offsetAfter;
 443                     } else if (((DuplicatedTimeOpt & kStdDstMask) == kStandard && stdToDst)
 444                             || ((DuplicatedTimeOpt & kStdDstMask) == kDaylight && dstToStd)) {
 445                         transition += offsetBefore;
 446                     } else if ((DuplicatedTimeOpt & kFormerLatterMask) == kFormer) {
 447                         transition += offsetBefore;
 448                     } else {
 449                         // Interprets the time with rule after the transition,
 450                         // default for duplicated local time range
 451                         transition += offsetAfter;
 452                     }
 453                 }
 454             }
 455             if (sec >= transition) {
 456                 U_DEBUG_TZ_MSG(("Found@%d: time=%.1f, localtransition=%d (orig %d) dz %d\n", i, sec, transition, transitionTimes[i],
 457                     zoneOffset(typeData[i-1])));
 458 #if defined U_DEBUG_TZ
 459                 printTime(transition*1000.0);
 460                 printTime(transitionTimes[i]*1000.0);
 461 #endif
 462                 break;
 463             } else {
 464                 U_DEBUG_TZ_MSG(("miss@%d: time=%.1f, localtransition=%d (orig %d) dz %d\n", i, sec, transition, transitionTimes[i],
 465                     zoneOffset(typeData[i-1])));
 466 #if defined U_DEBUG_TZ
 467                 printTime(transition*1000.0);
 468                 printTime(transitionTimes[i]*1000.0);
 469 #endif
 470             }
 471         }
 472
 473         U_ASSERT(i>=0 && i<transitionCount);
 474
 475         // Check invariants for GMT times; if these pass for GMT times
 476         // the local logic should be working too.
 477         U_ASSERT(local || sec < transitionTimes[0] || sec >= transitionTimes[i]);
 478         U_ASSERT(local || i == transitionCount-1 || sec < transitionTimes[i+1]);
 479
 480         U_DEBUG_TZ_MSG(("getHistoricalOffset(%.1f, %s, %d, %d, raw, dst) - trans %d\n",
 481             date, local?"T":"F", NonExistingTimeOpt, DuplicatedTimeOpt, i));
 482
 483         // Since ICU tzdata 2007c, the first transition data is actually not a
 484         // transition, but used for representing the initial offset.  So the code
 485         // below works even if i == 0.
 486         int16_t index = typeData[i];
 487         rawoff = rawOffset(index) * U_MILLIS_PER_SECOND;
 488         dstoff = dstOffset(index) * U_MILLIS_PER_SECOND;
 489     } else {
 490         // No transitions, single pair of offsets only
 491         rawoff = rawOffset(0) * U_MILLIS_PER_SECOND;
 492         dstoff = dstOffset(0) * U_MILLIS_PER_SECOND;
 493     }
 494     U_DEBUG_TZ_MSG(("getHistoricalOffset(%.1f, %s, %d, %d, raw, dst) - raw=%d, dst=%d\n",
 495         date, local?"T":"F", NonExistingTimeOpt, DuplicatedTimeOpt, rawoff, dstoff));
 496 }
 497
 498 /**
 499  * TimeZone API.
 500  */
 501 UBool OlsonTimeZone::useDaylightTime() const {
 502     // If DST was observed in 1942 (for example) but has never been
 503     // observed from 1943 to the present, most clients will expect
 504     // this method to return FALSE.  This method determines whether
 505     // DST is in use in the current year (at any point in the year)
 506     // and returns TRUE if so.
 507
 508     int32_t days = (int32_t)Math::floorDivide(uprv_getUTCtime(), (double)U_MILLIS_PER_DAY); // epoch days
 509
 510     int32_t year, month, dom, dow;
 511
 512     Grego::dayToFields(days, year, month, dom, dow);
 513
 514     if (year > finalYear) { // [sic] >, not >=; see above
 515         U_ASSERT(finalZone != 0 && finalZone->useDaylightTime());
 516         return TRUE;
 517     }
 518
 519     // Find start of this year, and start of next year
 520     int32_t start = (int32_t) Grego::fieldsToDay(year, 0, 1) * SECONDS_PER_DAY;
 521     int32_t limit = (int32_t) Grego::fieldsToDay(year+1, 0, 1) * SECONDS_PER_DAY;
 522
 523     // Return TRUE if DST is observed at any time during the current
 524     // year.
 525     for (int16_t i=0; i<transitionCount; ++i) {
 526         if (transitionTimes[i] >= limit) {
 527             break;
 528         }
 529         if ((transitionTimes[i] >= start && dstOffset(typeData[i]) != 0)
 530                 || (transitionTimes[i] > start && i > 0 && dstOffset(typeData[i - 1]) != 0)) {
 531             return TRUE;
 532         }
 533     }
 534     return FALSE;
 535 }
 536 int32_t
 537 OlsonTimeZone::getDSTSavings() const{
 538     if(finalZone!=NULL){
 539         return finalZone->getDSTSavings();
 540     }
 541     return TimeZone::getDSTSavings();
 542 }
 543 /**
 544  * TimeZone API.
 545  */
 546 UBool OlsonTimeZone::inDaylightTime(UDate date, UErrorCode& ec) const {
 547     int32_t raw, dst;
 548     getOffset(date, FALSE, raw, dst, ec);
 549     return dst != 0;
 550 }
 551
 552 UBool
 553 OlsonTimeZone::hasSameRules(const TimeZone &other) const {
 554     if (this == &other) {
 555         return TRUE;
 556     }
 557     if (other.getDynamicClassID() != OlsonTimeZone::getStaticClassID()) {
 558         return FALSE;
 559     }
 560     const OlsonTimeZone* z = (const OlsonTimeZone*) &other;
 561
 562     // [sic] pointer comparison: typeData points into
 563     // memory-mapped or DLL space, so if two zones have the same
 564     // pointer, they are equal.
 565     if (typeData == z->typeData) {
 566         return TRUE;
 567     }
 568
 569      // If the pointers are not equal, the zones may still
 570      // be equal if their rules and transitions are equal
 571     return
 572         (finalYear == z->finalYear &&
 573           // Don't compare finalMillis; if finalYear is ==, so is finalMillis
 574           ((finalZone == 0 && z->finalZone == 0) ||
 575             (finalZone != 0 && z->finalZone != 0 && *finalZone == *z->finalZone)) &&
 576
 577           transitionCount == z->transitionCount &&
 578           typeCount == z->typeCount &&
 579           uprv_memcmp(transitionTimes, z->transitionTimes,
 580                       sizeof(transitionTimes[0]) * transitionCount) == 0 &&
 581           uprv_memcmp(typeOffsets, z->typeOffsets,
 582                       (sizeof(typeOffsets[0]) * typeCount) << 1) == 0 &&
 583           uprv_memcmp(typeData, z->typeData,
 584                       (sizeof(typeData[0]) * typeCount)) == 0);
 585 }
 586
 587 void
 588 OlsonTimeZone::clearTransitionRules(void) {
 589     initialRule = NULL;
 590     firstTZTransition = NULL;
 591     firstFinalTZTransition = NULL;
 592     historicRules = NULL;
 593     historicRuleCount = 0;
 594     finalZoneWithStartYear = NULL;
 595     firstTZTransitionIdx = 0;
 596     transitionRulesInitialized = FALSE;
 597 }
 598
 599 void
 600 OlsonTimeZone::deleteTransitionRules(void) {
 601     if (initialRule != NULL) {
 602         delete initialRule;
 603     }
 604     if (firstTZTransition != NULL) {
 605         delete firstTZTransition;
 606     }
 607     if (firstFinalTZTransition != NULL) {
 608         delete firstFinalTZTransition;
 609     }
 610     if (finalZoneWithStartYear != NULL) {
 611         delete finalZoneWithStartYear;
 612     }
 613     if (historicRules != NULL) {
 614         for (int i = 0; i < historicRuleCount; i++) {
 615             if (historicRules[i] != NULL) {
 616                 delete historicRules[i];
 617             }
 618         }
 619         uprv_free(historicRules);
 620     }
 621     clearTransitionRules();
 622 }
 623
 624 void
 625 OlsonTimeZone::initTransitionRules(UErrorCode& status) {
 626     if(U_FAILURE(status)) {
 627         return;
 628     }
 629     if (transitionRulesInitialized) {
 630         return;
 631     }
 632     deleteTransitionRules();
 633     UnicodeString tzid;
 634     getID(tzid);
 635
 636     UnicodeString stdName = tzid + UNICODE_STRING_SIMPLE("(STD)");
 637     UnicodeString dstName = tzid + UNICODE_STRING_SIMPLE("(DST)");
 638
 639     int32_t raw, dst;
 640     if (transitionCount > 0) {
 641         int16_t transitionIdx, typeIdx;
 642
 643         // Note: Since 2007c, the very first transition data is a dummy entry
 644         //       added for resolving a offset calculation problem.
 645
 646         // Create initial rule
 647         typeIdx = (int16_t)typeData[0]; // initial type
 648         raw = rawOffset(typeIdx) * U_MILLIS_PER_SECOND;
 649         dst = dstOffset(typeIdx) * U_MILLIS_PER_SECOND;
 650         initialRule = new InitialTimeZoneRule((dst == 0 ? stdName : dstName), raw, dst);
 651         // Check to make sure initialRule was created
 652         if (initialRule == NULL) {
 653             status = U_MEMORY_ALLOCATION_ERROR;
 654             deleteTransitionRules();
 655             return;
 656         }
 657
 658         firstTZTransitionIdx = 0;
 659         for (transitionIdx = 1; transitionIdx < transitionCount; transitionIdx++) {
 660             firstTZTransitionIdx++;
 661             if (typeIdx != (int16_t)typeData[transitionIdx]) {
 662                 break;
 663             }
 664         }
 665         if (transitionIdx == transitionCount) {
 666             // Actually no transitions...
 667         } else {
 668             // Build historic rule array
 669             UDate* times = (UDate*)uprv_malloc(sizeof(UDate)*transitionCount); /* large enough to store all transition times */
 670             if (times == NULL) {
 671                 status = U_MEMORY_ALLOCATION_ERROR;
 672                 deleteTransitionRules();
 673                 return;
 674             }
 675             for (typeIdx = 0; typeIdx < typeCount; typeIdx++) {
 676                 // Gather all start times for each pair of offsets
 677                 int32_t nTimes = 0;
 678                 for (transitionIdx = firstTZTransitionIdx; transitionIdx < transitionCount; transitionIdx++) {
 679                     if (typeIdx == (int16_t)typeData[transitionIdx]) {
 680                         UDate tt = ((UDate)transitionTimes[transitionIdx]) * U_MILLIS_PER_SECOND;
 681                         if (tt < finalMillis) {
 682                             // Exclude transitions after finalMillis
 683                             times[nTimes++] = tt;
 684                         }
 685                     }
 686                 }
 687                 if (nTimes > 0) {
 688                     // Create a TimeArrayTimeZoneRule
 689                     raw = rawOffset(typeIdx) * U_MILLIS_PER_SECOND;
 690                     dst = dstOffset(typeIdx) * U_MILLIS_PER_SECOND;
 691                     if (historicRules == NULL) {
 692                         historicRuleCount = typeCount;
 693                         historicRules = (TimeArrayTimeZoneRule**)uprv_malloc(sizeof(TimeArrayTimeZoneRule*)*historicRuleCount);
 694                         if (historicRules == NULL) {
 695                             status = U_MEMORY_ALLOCATION_ERROR;
 696                             deleteTransitionRules();
 697                             uprv_free(times);
 698                             return;
 699                         }
 700                         for (int i = 0; i < historicRuleCount; i++) {
 701                             // Initialize TimeArrayTimeZoneRule pointers as NULL
 702                             historicRules[i] = NULL;
 703                         }
 704                     }
 705                     historicRules[typeIdx] = new TimeArrayTimeZoneRule((dst == 0 ? stdName : dstName),
 706                         raw, dst, times, nTimes, DateTimeRule::UTC_TIME);
 707                     // Check for memory allocation error
 708                     if (historicRules[typeIdx] == NULL) {
 709                         status = U_MEMORY_ALLOCATION_ERROR;
 710                         deleteTransitionRules();
 711                         return;
 712                     }
 713                 }
 714             }
 715             uprv_free(times);
 716
 717             // Create initial transition
 718             typeIdx = (int16_t)typeData[firstTZTransitionIdx];
 719             firstTZTransition = new TimeZoneTransition(((UDate)transitionTimes[firstTZTransitionIdx]) * U_MILLIS_PER_SECOND,
 720                     *initialRule, *historicRules[typeIdx]);
 721             // Check to make sure firstTZTransition was created.
 722             if (firstTZTransition == NULL) {
 723                 status = U_MEMORY_ALLOCATION_ERROR;
 724                 deleteTransitionRules();
 725                 return;
 726             }
 727         }
 728     }
 729     if (initialRule == NULL) {
 730         // No historic transitions
 731         raw = rawOffset(0) * U_MILLIS_PER_SECOND;
 732         dst = dstOffset(0) * U_MILLIS_PER_SECOND;
 733         initialRule = new InitialTimeZoneRule((dst == 0 ? stdName : dstName), raw, dst);
 734         // Check to make sure initialRule was created.
 735         if (initialRule == NULL) {
 736             status = U_MEMORY_ALLOCATION_ERROR;
 737             deleteTransitionRules();
 738             return;
 739         }
 740     }
 741     if (finalZone != NULL) {
 742         // Get the first occurence of final rule starts
 743         UDate startTime = (UDate)finalMillis;
 744         TimeZoneRule *firstFinalRule = NULL;
 745         if (finalZone->useDaylightTime()) {
 746             /*
 747              * Note: When an OlsonTimeZone is constructed, we should set the final year
 748              * as the start year of finalZone.  However, the bounday condition used for
 749              * getting offset from finalZone has some problems.  So setting the start year
 750              * in the finalZone will cause a problem.  For now, we do not set the valid
 751              * start year when the construction time and create a clone and set the
 752              * start year when extracting rules.
 753              */
 754             finalZoneWithStartYear = (SimpleTimeZone*)finalZone->clone();
 755             // Check to make sure finalZone was actually cloned.
 756             if (finalZoneWithStartYear == NULL) {
 757                 status = U_MEMORY_ALLOCATION_ERROR;
 758                 deleteTransitionRules();
 759                 return;
 760             }
 761             // finalYear is 1 year before the actual final year.
 762             // See the comment in the construction method.
 763             finalZoneWithStartYear->setStartYear(finalYear + 1);
 764
 765             TimeZoneTransition tzt;
 766             finalZoneWithStartYear->getNextTransition(startTime, false, tzt);
 767             firstFinalRule  = tzt.getTo()->clone();
 768             // Check to make sure firstFinalRule received proper clone.
 769             if (firstFinalRule == NULL) {
 770                 status = U_MEMORY_ALLOCATION_ERROR;
 771                 deleteTransitionRules();
 772                 return;
 773             }
 774             startTime = tzt.getTime();
 775         } else {
 776             finalZoneWithStartYear = (SimpleTimeZone*)finalZone->clone();
 777             // Check to make sure finalZoneWithStartYear received proper clone before dereference.
 778             if (finalZoneWithStartYear == NULL) {
 779                 status = U_MEMORY_ALLOCATION_ERROR;
 780                 deleteTransitionRules();
 781                 return;
 782             }
 783             finalZone->getID(tzid);
 784             firstFinalRule = new TimeArrayTimeZoneRule(tzid,
 785                 finalZone->getRawOffset(), 0, &startTime, 1, DateTimeRule::UTC_TIME);
 786             // Check firstFinalRule was properly created.
 787             if (firstFinalRule == NULL) {
 788                 status = U_MEMORY_ALLOCATION_ERROR;
 789                 deleteTransitionRules();
 790                 return;
 791             }
 792         }
 793         TimeZoneRule *prevRule = NULL;
 794         if (transitionCount > 0) {
 795             prevRule = historicRules[typeData[transitionCount - 1]];
 796         }
 797         if (prevRule == NULL) {
 798             // No historic transitions, but only finalZone available
 799             prevRule = initialRule;
 800         }
 801         firstFinalTZTransition = new TimeZoneTransition();
 802         // Check to make sure firstFinalTZTransition was created before dereferencing
 803         if (firstFinalTZTransition == NULL) {
 804             status = U_MEMORY_ALLOCATION_ERROR;
 805             deleteTransitionRules();
 806             return;
 807         }
 808         firstFinalTZTransition->setTime(startTime);
 809         firstFinalTZTransition->adoptFrom(prevRule->clone());
 810         firstFinalTZTransition->adoptTo(firstFinalRule);
 811     }
 812     transitionRulesInitialized = TRUE;
 813 }
 814
 815 UBool
 816 OlsonTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) /*const*/ {
 817     UErrorCode status = U_ZERO_ERROR;
 818     initTransitionRules(status);
 819     if (U_FAILURE(status)) {
 820         return FALSE;
 821     }
 822
 823     if (finalZone != NULL) {
 824         if (inclusive && base == firstFinalTZTransition->getTime()) {
 825             result = *firstFinalTZTransition;
 826             return TRUE;
 827         } else if (base >= firstFinalTZTransition->getTime()) {
 828             if (finalZone->useDaylightTime()) {
 829                 //return finalZone->getNextTransition(base, inclusive, result);
 830                 return finalZoneWithStartYear->getNextTransition(base, inclusive, result);
 831             } else {
 832                 // No more transitions
 833                 return FALSE;
 834             }
 835         }
 836     }
 837     if (historicRules != NULL) {
 838         // Find a historical transition
 839         int16_t ttidx = transitionCount - 1;
 840         for (; ttidx >= firstTZTransitionIdx; ttidx--) {
 841             UDate t = ((UDate)transitionTimes[ttidx]) * U_MILLIS_PER_SECOND;
 842             if (base > t || (!inclusive && base == t)) {
 843                 break;
 844             }
 845         }
 846         if (ttidx == transitionCount - 1)  {
 847             if (firstFinalTZTransition != NULL) {
 848                 result = *firstFinalTZTransition;
 849                 return TRUE;
 850             } else {
 851                 return FALSE;
 852             }
 853         } else if (ttidx < firstTZTransitionIdx) {
 854             result = *firstTZTransition;
 855             return TRUE;
 856         } else {
 857             // Create a TimeZoneTransition
 858             TimeZoneRule *to = historicRules[typeData[ttidx + 1]];
 859             TimeZoneRule *from = historicRules[typeData[ttidx]];
 860             UDate startTime = ((UDate)transitionTimes[ttidx+1]) * U_MILLIS_PER_SECOND;
 861
 862             // The transitions loaded from zoneinfo.res may contain non-transition data
 863             UnicodeString fromName, toName;
 864             from->getName(fromName);
 865             to->getName(toName);
 866             if (fromName == toName && from->getRawOffset() == to->getRawOffset()
 867                     && from->getDSTSavings() == to->getDSTSavings()) {
 868                 return getNextTransition(startTime, false, result);
 869             }
 870             result.setTime(startTime);
 871             result.adoptFrom(from->clone());
 872             result.adoptTo(to->clone());
 873             return TRUE;
 874         }
 875     }
 876     return FALSE;
 877 }
 878
 879 UBool
 880 OlsonTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) /*const*/ {
 881     UErrorCode status = U_ZERO_ERROR;
 882     initTransitionRules(status);
 883     if (U_FAILURE(status)) {
 884         return FALSE;
 885     }
 886
 887     if (finalZone != NULL) {
 888         if (inclusive && base == firstFinalTZTransition->getTime()) {
 889             result = *firstFinalTZTransition;
 890             return TRUE;
 891         } else if (base > firstFinalTZTransition->getTime()) {
 892             if (finalZone->useDaylightTime()) {
 893                 //return finalZone->getPreviousTransition(base, inclusive, result);
 894                 return finalZoneWithStartYear->getPreviousTransition(base, inclusive, result);
 895             } else {
 896                 result = *firstFinalTZTransition;
 897                 return TRUE;
 898             }
 899         }
 900     }
 901
 902     if (historicRules != NULL) {
 903         // Find a historical transition
 904         int16_t ttidx = transitionCount - 1;
 905         for (; ttidx >= firstTZTransitionIdx; ttidx--) {
 906             UDate t = ((UDate)transitionTimes[ttidx]) * U_MILLIS_PER_SECOND;
 907             if (base > t || (inclusive && base == t)) {
 908                 break;
 909             }
 910         }
 911         if (ttidx < firstTZTransitionIdx) {
 912             // No more transitions
 913             return FALSE;
 914         } else if (ttidx == firstTZTransitionIdx) {
 915             result = *firstTZTransition;
 916             return TRUE;
 917         } else {
 918             // Create a TimeZoneTransition
 919             TimeZoneRule *to = historicRules[typeData[ttidx]];
 920             TimeZoneRule *from = historicRules[typeData[ttidx-1]];
 921             UDate startTime = ((UDate)transitionTimes[ttidx]) * U_MILLIS_PER_SECOND;
 922
 923             // The transitions loaded from zoneinfo.res may contain non-transition data
 924             UnicodeString fromName, toName;
 925             from->getName(fromName);
 926             to->getName(toName);
 927             if (fromName == toName && from->getRawOffset() == to->getRawOffset()
 928                     && from->getDSTSavings() == to->getDSTSavings()) {
 929                 return getPreviousTransition(startTime, false, result);
 930             }
 931             result.setTime(startTime);
 932             result.adoptFrom(from->clone());
 933             result.adoptTo(to->clone());
 934             return TRUE;
 935         }
 936     }
 937     return FALSE;
 938 }
 939
 940 int32_t
 941 OlsonTimeZone::countTransitionRules(UErrorCode& status) /*const*/ {
 942     if (U_FAILURE(status)) {
 943         return 0;
 944     }
 945     initTransitionRules(status);
 946     if (U_FAILURE(status)) {
 947         return 0;
 948     }
 949
 950     int32_t count = 0;
 951     if (historicRules != NULL) {
 952         // historicRules may contain null entries when original zoneinfo data
 953         // includes non transition data.
 954         for (int32_t i = 0; i < historicRuleCount; i++) {
 955             if (historicRules[i] != NULL) {
 956                 count++;
 957             }
 958         }
 959     }
 960     if (finalZone != NULL) {
 961         if (finalZone->useDaylightTime()) {
 962             count += 2;
 963         } else {
 964             count++;
 965         }
 966     }
 967     return count;
 968 }
 969
 970 void
 971 OlsonTimeZone::getTimeZoneRules(const InitialTimeZoneRule*& initial,
 972                                 const TimeZoneRule* trsrules[],
 973                                 int32_t& trscount,
 974                                 UErrorCode& status) /*const*/ {
 975     if (U_FAILURE(status)) {
 976         return;
 977     }
 978     initTransitionRules(status);
 979     if (U_FAILURE(status)) {
 980         return;
 981     }
 982
 983     // Initial rule
 984     initial = initialRule;
 985
 986     // Transition rules
 987     int32_t cnt = 0;
 988     if (historicRules != NULL && trscount > cnt) {
 989         // historicRules may contain null entries when original zoneinfo data
 990         // includes non transition data.
 991         for (int32_t i = 0; i < historicRuleCount; i++) {
 992             if (historicRules[i] != NULL) {
 993                 trsrules[cnt++] = historicRules[i];
 994                 if (cnt >= trscount) {
 995                     break;
 996                 }
 997             }
 998         }
 999     }
1000     if (finalZoneWithStartYear != NULL && trscount > cnt) {
1001         const InitialTimeZoneRule *tmpini;
1002         int32_t tmpcnt = trscount - cnt;
1003         finalZoneWithStartYear->getTimeZoneRules(tmpini, &trsrules[cnt], tmpcnt, status);
1004         if (U_FAILURE(status)) {
1005             return;
1006         }
1007         cnt += tmpcnt;
1008     }
1009     // Set the result length
1010     trscount = cnt;
1011 }
1012
1013 U_NAMESPACE_END
1014
1015 #endif // !UCONFIG_NO_FORMATTING
1016
1017 //eof