icuSources/i18n/rbtz.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007-2013, International Business Machines Corporation and
   4 * others. All Rights Reserved.
   5 *******************************************************************************
   6 */
   7
   8 #include "utypeinfo.h"  // for 'typeid' to work
   9
  10 #include "unicode/utypes.h"
  11
  12 #if !UCONFIG_NO_FORMATTING
  13
  14 #include "unicode/rbtz.h"
  15 #include "unicode/gregocal.h"
  16 #include "uvector.h"
  17 #include "gregoimp.h"
  18 #include "cmemory.h"
  19 #include "umutex.h"
  20
  21 U_NAMESPACE_BEGIN
  22
  23 /**
  24  * A struct representing a time zone transition
  25  */
  26 struct Transition {
  27     UDate time;
  28     TimeZoneRule* from;
  29     TimeZoneRule* to;
  30 };
  31
  32 static UBool compareRules(UVector* rules1, UVector* rules2) {
  33     if (rules1 == NULL && rules2 == NULL) {
  34         return TRUE;
  35     } else if (rules1 == NULL || rules2 == NULL) {
  36         return FALSE;
  37     }
  38     int32_t size = rules1->size();
  39     if (size != rules2->size()) {
  40         return FALSE;
  41     }
  42     for (int32_t i = 0; i < size; i++) {
  43         TimeZoneRule *r1 = (TimeZoneRule*)rules1->elementAt(i);
  44         TimeZoneRule *r2 = (TimeZoneRule*)rules2->elementAt(i);
  45         if (*r1 != *r2) {
  46             return FALSE;
  47         }
  48     }
  49     return TRUE;
  50 }
  51
  52 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedTimeZone)
  53
  54 RuleBasedTimeZone::RuleBasedTimeZone(const UnicodeString& id, InitialTimeZoneRule* initialRule)
  55 : BasicTimeZone(id), fInitialRule(initialRule), fHistoricRules(NULL), fFinalRules(NULL),
  56   fHistoricTransitions(NULL), fUpToDate(FALSE) {
  57 }
  58
  59 RuleBasedTimeZone::RuleBasedTimeZone(const RuleBasedTimeZone& source)
  60 : BasicTimeZone(source), fInitialRule(source.fInitialRule->clone()),
  61   fHistoricTransitions(NULL), fUpToDate(FALSE) {
  62     fHistoricRules = copyRules(source.fHistoricRules);
  63     fFinalRules = copyRules(source.fFinalRules);
  64     if (source.fUpToDate) {
  65         UErrorCode status = U_ZERO_ERROR;
  66         complete(status);
  67     }
  68 }
  69
  70 RuleBasedTimeZone::~RuleBasedTimeZone() {
  71     deleteTransitions();
  72     deleteRules();
  73 }
  74
  75 RuleBasedTimeZone&
  76 RuleBasedTimeZone::operator=(const RuleBasedTimeZone& right) {
  77     if (*this != right) {
  78         BasicTimeZone::operator=(right);
  79         deleteRules();
  80         fInitialRule = right.fInitialRule->clone();
  81         fHistoricRules = copyRules(right.fHistoricRules);
  82         fFinalRules = copyRules(right.fFinalRules);
  83         deleteTransitions();
  84         fUpToDate = FALSE;
  85     }
  86     return *this;
  87 }
  88
  89 UBool
  90 RuleBasedTimeZone::operator==(const TimeZone& that) const {
  91     if (this == &that) {
  92         return TRUE;
  93     }
  94     if (typeid(*this) != typeid(that)
  95         || BasicTimeZone::operator==(that) == FALSE) {
  96         return FALSE;
  97     }
  98     RuleBasedTimeZone *rbtz = (RuleBasedTimeZone*)&that;
  99     if (*fInitialRule != *(rbtz->fInitialRule)) {
 100         return FALSE;
 101     }
 102     if (compareRules(fHistoricRules, rbtz->fHistoricRules)
 103         && compareRules(fFinalRules, rbtz->fFinalRules)) {
 104         return TRUE;
 105     }
 106     return FALSE;
 107 }
 108
 109 UBool
 110 RuleBasedTimeZone::operator!=(const TimeZone& that) const {
 111     return !operator==(that);
 112 }
 113
 114 void
 115 RuleBasedTimeZone::addTransitionRule(TimeZoneRule* rule, UErrorCode& status) {
 116     if (U_FAILURE(status)) {
 117         return;
 118     }
 119     AnnualTimeZoneRule* atzrule = dynamic_cast<AnnualTimeZoneRule*>(rule);
 120     if (atzrule != NULL && atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR) {
 121         // A final rule
 122         if (fFinalRules == NULL) {
 123             fFinalRules = new UVector(status);
 124             if (U_FAILURE(status)) {
 125                 return;
 126             }
 127         } else if (fFinalRules->size() >= 2) {
 128             // Cannot handle more than two final rules
 129             status = U_INVALID_STATE_ERROR;
 130             return;
 131         }
 132         fFinalRules->addElement((void*)rule, status);
 133     } else {
 134         // Non-final rule
 135         if (fHistoricRules == NULL) {
 136             fHistoricRules = new UVector(status);
 137             if (U_FAILURE(status)) {
 138                 return;
 139             }
 140         }
 141         fHistoricRules->addElement((void*)rule, status);
 142     }
 143     // Mark dirty, so transitions are recalculated at next complete() call
 144     fUpToDate = FALSE;
 145 }
 146
 147 static UMutex gLock = U_MUTEX_INITIALIZER;
 148
 149 void
 150 RuleBasedTimeZone::completeConst(UErrorCode& status) const {
 151     if (U_FAILURE(status)) {
 152         return;
 153     }
 154     UBool updated;
 155     UMTX_CHECK(&gLock, fUpToDate, updated);
 156     if (!updated) {
 157         umtx_lock(&gLock);
 158         if (!fUpToDate) {
 159             RuleBasedTimeZone *ncThis = const_cast<RuleBasedTimeZone*>(this);
 160             ncThis->complete(status);
 161         }
 162         umtx_unlock(&gLock);
 163     }
 164 }
 165
 166 void
 167 RuleBasedTimeZone::complete(UErrorCode& status) {
 168     if (U_FAILURE(status)) {
 169         return;
 170     }
 171     if (fUpToDate) {
 172         return;
 173     }
 174     // Make sure either no final rules or a pair of AnnualTimeZoneRules
 175     // are available.
 176     if (fFinalRules != NULL && fFinalRules->size() != 2) {
 177         status = U_INVALID_STATE_ERROR;
 178         return;
 179     }
 180
 181     UBool *done = NULL;
 182     // Create a TimezoneTransition and add to the list
 183     if (fHistoricRules != NULL || fFinalRules != NULL) {
 184         TimeZoneRule *curRule = fInitialRule;
 185         UDate lastTransitionTime = MIN_MILLIS;
 186
 187         // Build the transition array which represents historical time zone
 188         // transitions.
 189         if (fHistoricRules != NULL && fHistoricRules->size() > 0) {
 190             int32_t i;
 191             int32_t historicCount = fHistoricRules->size();
 192             done = (UBool*)uprv_malloc(sizeof(UBool) * historicCount);
 193             if (done == NULL) {
 194                 status = U_MEMORY_ALLOCATION_ERROR;
 195                 goto cleanup;
 196             }
 197             for (i = 0; i < historicCount; i++) {
 198                 done[i] = FALSE;
 199             }
 200             while (TRUE) {
 201                 int32_t curStdOffset = curRule->getRawOffset();
 202                 int32_t curDstSavings = curRule->getDSTSavings();
 203                 UDate nextTransitionTime = MAX_MILLIS;
 204                 TimeZoneRule *nextRule = NULL;
 205                 TimeZoneRule *r = NULL;
 206                 UBool avail;
 207                 UDate tt;
 208                 UnicodeString curName, name;
 209                 curRule->getName(curName);
 210
 211                 for (i = 0; i < historicCount; i++) {
 212                     if (done[i]) {
 213                         continue;
 214                     }
 215                     r = (TimeZoneRule*)fHistoricRules->elementAt(i);
 216                     avail = r->getNextStart(lastTransitionTime, curStdOffset, curDstSavings, false, tt);
 217                     if (!avail) {
 218                         // No more transitions from this rule - skip this rule next time
 219                         done[i] = TRUE;
 220                     } else {
 221                         r->getName(name);
 222                         if (*r == *curRule ||
 223                             (name == curName && r->getRawOffset() == curRule->getRawOffset()
 224                             && r->getDSTSavings() == curRule->getDSTSavings())) {
 225                             continue;
 226                         }
 227                         if (tt < nextTransitionTime) {
 228                             nextTransitionTime = tt;
 229                             nextRule = r;
 230                         }
 231                     }
 232                 }
 233
 234                 if (nextRule ==  NULL) {
 235                     // Check if all historic rules are done
 236                     UBool bDoneAll = TRUE;
 237                     for (int32_t j = 0; j < historicCount; j++) {
 238                         if (!done[j]) {
 239                             bDoneAll = FALSE;
 240                             break;
 241                         }
 242                     }
 243                     if (bDoneAll) {
 244                         break;
 245                     }
 246                 }
 247
 248                 if (fFinalRules != NULL) {
 249                     // Check if one of final rules has earlier transition date
 250                     for (i = 0; i < 2 /* fFinalRules->size() */; i++) {
 251                         TimeZoneRule *fr = (TimeZoneRule*)fFinalRules->elementAt(i);
 252                         if (*fr == *curRule) {
 253                             continue;
 254                         }
 255                         r = (TimeZoneRule*)fFinalRules->elementAt(i);
 256                         avail = r->getNextStart(lastTransitionTime, curStdOffset, curDstSavings, false, tt);
 257                         if (avail) {
 258                             if (tt < nextTransitionTime) {
 259                                 nextTransitionTime = tt;
 260                                 nextRule = r;
 261                             }
 262                         }
 263                     }
 264                 }
 265
 266                 if (nextRule == NULL) {
 267                     // Nothing more
 268                     break;
 269                 }
 270
 271                 if (fHistoricTransitions == NULL) {
 272                     fHistoricTransitions = new UVector(status);
 273                     if (U_FAILURE(status)) {
 274                         goto cleanup;
 275                     }
 276                 }
 277                 Transition *trst = (Transition*)uprv_malloc(sizeof(Transition));
 278                 if (trst == NULL) {
 279                     status = U_MEMORY_ALLOCATION_ERROR;
 280                     goto cleanup;
 281                 }
 282                 trst->time = nextTransitionTime;
 283                 trst->from = curRule;
 284                 trst->to = nextRule;
 285                 fHistoricTransitions->addElement(trst, status);
 286                 if (U_FAILURE(status)) {
 287                     goto cleanup;
 288                 }
 289                 lastTransitionTime = nextTransitionTime;
 290                 curRule = nextRule;
 291             }
 292         }
 293         if (fFinalRules != NULL) {
 294             if (fHistoricTransitions == NULL) {
 295                 fHistoricTransitions = new UVector(status);
 296                 if (U_FAILURE(status)) {
 297                     goto cleanup;
 298                 }
 299             }
 300             // Append the first transition for each
 301             TimeZoneRule *rule0 = (TimeZoneRule*)fFinalRules->elementAt(0);
 302             TimeZoneRule *rule1 = (TimeZoneRule*)fFinalRules->elementAt(1);
 303             UDate tt0, tt1;
 304             UBool avail0 = rule0->getNextStart(lastTransitionTime, curRule->getRawOffset(), curRule->getDSTSavings(), false, tt0);
 305             UBool avail1 = rule1->getNextStart(lastTransitionTime, curRule->getRawOffset(), curRule->getDSTSavings(), false, tt1);
 306             if (!avail0 || !avail1) {
 307                 // Should not happen, because both rules are permanent
 308                 status = U_INVALID_STATE_ERROR;
 309                 goto cleanup;
 310             }
 311             Transition *final0 = (Transition*)uprv_malloc(sizeof(Transition));
 312             if (final0 == NULL) {
 313                 status = U_MEMORY_ALLOCATION_ERROR;
 314                 goto cleanup;
 315             }
 316             Transition *final1 = (Transition*)uprv_malloc(sizeof(Transition));
 317             if (final1 == NULL) {
 318                 uprv_free(final0);
 319                 status = U_MEMORY_ALLOCATION_ERROR;
 320                 goto cleanup;
 321             }
 322             if (tt0 < tt1) {
 323                 final0->time = tt0;
 324                 final0->from = curRule;
 325                 final0->to = rule0;
 326                 rule1->getNextStart(tt0, rule0->getRawOffset(), rule0->getDSTSavings(), false, final1->time);
 327                 final1->from = rule0;
 328                 final1->to = rule1;
 329             } else {
 330                 final0->time = tt1;
 331                 final0->from = curRule;
 332                 final0->to = rule1;
 333                 rule0->getNextStart(tt1, rule1->getRawOffset(), rule1->getDSTSavings(), false, final1->time);
 334                 final1->from = rule1;
 335                 final1->to = rule0;
 336             }
 337             fHistoricTransitions->addElement(final0, status);
 338             if (U_FAILURE(status)) {
 339                 goto cleanup;
 340             }
 341             fHistoricTransitions->addElement(final1, status);
 342             if (U_FAILURE(status)) {
 343                 goto cleanup;
 344             }
 345         }
 346     }
 347     fUpToDate = TRUE;
 348     if (done != NULL) {
 349         uprv_free(done);
 350     }
 351     return;
 352
 353 cleanup:
 354     deleteTransitions();
 355     if (done != NULL) {
 356         uprv_free(done);
 357     }
 358     fUpToDate = FALSE;
 359 }
 360
 361 TimeZone*
 362 RuleBasedTimeZone::clone(void) const {
 363     return new RuleBasedTimeZone(*this);
 364 }
 365
 366 int32_t
 367 RuleBasedTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
 368                              uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const {
 369     if (U_FAILURE(status)) {
 370         return 0;
 371     }
 372     if (month < UCAL_JANUARY || month > UCAL_DECEMBER) {
 373         status = U_ILLEGAL_ARGUMENT_ERROR;
 374         return 0;
 375     } else {
 376         return getOffset(era, year, month, day, dayOfWeek, millis,
 377                          Grego::monthLength(year, month), status);
 378     }
 379 }
 380
 381 int32_t
 382 RuleBasedTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
 383                              uint8_t /*dayOfWeek*/, int32_t millis,
 384                              int32_t /*monthLength*/, UErrorCode& status) const {
 385     // dayOfWeek and monthLength are unused
 386     if (U_FAILURE(status)) {
 387         return 0;
 388     }
 389     if (era == GregorianCalendar::BC) {
 390         // Convert to extended year
 391         year = 1 - year;
 392     }
 393     int32_t rawOffset, dstOffset;
 394     UDate time = (UDate)Grego::fieldsToDay(year, month, day) * U_MILLIS_PER_DAY + millis;
 395     getOffsetInternal(time, TRUE, kDaylight, kStandard, rawOffset, dstOffset, status);
 396     if (U_FAILURE(status)) {
 397         return 0;
 398     }
 399     return (rawOffset + dstOffset);
 400 }
 401
 402 void
 403 RuleBasedTimeZone::getOffset(UDate date, UBool local, int32_t& rawOffset,
 404                              int32_t& dstOffset, UErrorCode& status) const {
 405     getOffsetInternal(date, local, kFormer, kLatter, rawOffset, dstOffset, status);
 406 }
 407
 408 void
 409 RuleBasedTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
 410                                       int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) const {
 411     getOffsetInternal(date, TRUE, nonExistingTimeOpt, duplicatedTimeOpt, rawOffset, dstOffset, status);
 412 }
 413
 414
 415 /*
 416  * The internal getOffset implementation
 417  */
 418 void
 419 RuleBasedTimeZone::getOffsetInternal(UDate date, UBool local,
 420                                      int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt,
 421                                      int32_t& rawOffset, int32_t& dstOffset,
 422                                      UErrorCode& status) const {
 423     rawOffset = 0;
 424     dstOffset = 0;
 425
 426     if (U_FAILURE(status)) {
 427         return;
 428     }
 429     if (!fUpToDate) {
 430         // Transitions are not yet resolved.  We cannot do it here
 431         // because this method is const.  Thus, do nothing and return
 432         // error status.
 433         status = U_INVALID_STATE_ERROR;
 434         return;
 435     }
 436     const TimeZoneRule *rule = NULL;
 437     if (fHistoricTransitions == NULL) {
 438         rule = fInitialRule;
 439     } else {
 440         UDate tstart = getTransitionTime((Transition*)fHistoricTransitions->elementAt(0),
 441             local, NonExistingTimeOpt, DuplicatedTimeOpt);
 442         if (date < tstart) {
 443             rule = fInitialRule;
 444         } else {
 445             int32_t idx = fHistoricTransitions->size() - 1;
 446             UDate tend = getTransitionTime((Transition*)fHistoricTransitions->elementAt(idx),
 447                 local, NonExistingTimeOpt, DuplicatedTimeOpt);
 448             if (date > tend) {
 449                 if (fFinalRules != NULL) {
 450                     rule = findRuleInFinal(date, local, NonExistingTimeOpt, DuplicatedTimeOpt);
 451                 }
 452                 if (rule == NULL) {
 453                     // no final rules or the given time is before the first transition
 454                     // specified by the final rules -> use the last rule
 455                     rule = ((Transition*)fHistoricTransitions->elementAt(idx))->to;
 456                 }
 457             } else {
 458                 // Find a historical transition
 459                 while (idx >= 0) {
 460                     if (date >= getTransitionTime((Transition*)fHistoricTransitions->elementAt(idx),
 461                         local, NonExistingTimeOpt, DuplicatedTimeOpt)) {
 462                         break;
 463                     }
 464                     idx--;
 465                 }
 466                 rule = ((Transition*)fHistoricTransitions->elementAt(idx))->to;
 467             }
 468         }
 469     }
 470     if (rule != NULL) {
 471         rawOffset = rule->getRawOffset();
 472         dstOffset = rule->getDSTSavings();
 473     }
 474 }
 475
 476 void
 477 RuleBasedTimeZone::setRawOffset(int32_t /*offsetMillis*/) {
 478     // We don't support this operation at this moment.
 479     // Nothing to do!
 480 }
 481
 482 int32_t
 483 RuleBasedTimeZone::getRawOffset(void) const {
 484     // Note: This implementation returns standard GMT offset
 485     // as of current time.
 486     UErrorCode status = U_ZERO_ERROR;
 487     int32_t raw, dst;
 488     getOffset(uprv_getUTCtime() * U_MILLIS_PER_SECOND,
 489         FALSE, raw, dst, status);
 490     return raw;
 491 }
 492
 493 UBool
 494 RuleBasedTimeZone::useDaylightTime(void) const {
 495     // Note: This implementation returns true when
 496     // daylight saving time is used as of now or
 497     // after the next transition.
 498     UErrorCode status = U_ZERO_ERROR;
 499     UDate now = uprv_getUTCtime() * U_MILLIS_PER_SECOND;
 500     int32_t raw, dst;
 501     getOffset(now, FALSE, raw, dst, status);
 502     if (dst != 0) {
 503         return TRUE;
 504     }
 505     // If DST is not used now, check if DST is used after the next transition
 506     UDate time;
 507     TimeZoneRule *from, *to;
 508     UBool avail = findNext(now, FALSE, time, from, to);
 509     if (avail && to->getDSTSavings() != 0) {
 510         return TRUE;
 511     }
 512     return FALSE;
 513 }
 514
 515 UBool
 516 RuleBasedTimeZone::inDaylightTime(UDate date, UErrorCode& status) const {
 517     if (U_FAILURE(status)) {
 518         return FALSE;
 519     }
 520     int32_t raw, dst;
 521     getOffset(date, FALSE, raw, dst, status);
 522     if (dst != 0) {
 523         return TRUE;
 524     }
 525     return FALSE;
 526 }
 527
 528 UBool
 529 RuleBasedTimeZone::hasSameRules(const TimeZone& other) const {
 530     if (this == &other) {
 531         return TRUE;
 532     }
 533     if (typeid(*this) != typeid(other)) {
 534         return FALSE;
 535     }
 536     const RuleBasedTimeZone& that = (const RuleBasedTimeZone&)other;
 537     if (*fInitialRule != *(that.fInitialRule)) {
 538         return FALSE;
 539     }
 540     if (compareRules(fHistoricRules, that.fHistoricRules)
 541         && compareRules(fFinalRules, that.fFinalRules)) {
 542         return TRUE;
 543     }
 544     return FALSE;
 545 }
 546
 547 UBool
 548 RuleBasedTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
 549     UErrorCode status = U_ZERO_ERROR;
 550     completeConst(status);
 551     if (U_FAILURE(status)) {
 552         return FALSE;
 553     }
 554     UDate transitionTime;
 555     TimeZoneRule *fromRule, *toRule;
 556     UBool found = findNext(base, inclusive, transitionTime, fromRule, toRule);
 557     if (found) {
 558         result.setTime(transitionTime);
 559         result.setFrom((const TimeZoneRule&)*fromRule);
 560         result.setTo((const TimeZoneRule&)*toRule);
 561         return TRUE;
 562     }
 563     return FALSE;
 564 }
 565
 566 UBool
 567 RuleBasedTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
 568     UErrorCode status = U_ZERO_ERROR;
 569     completeConst(status);
 570     if (U_FAILURE(status)) {
 571         return FALSE;
 572     }
 573     UDate transitionTime;
 574     TimeZoneRule *fromRule, *toRule;
 575     UBool found = findPrev(base, inclusive, transitionTime, fromRule, toRule);
 576     if (found) {
 577         result.setTime(transitionTime);
 578         result.setFrom((const TimeZoneRule&)*fromRule);
 579         result.setTo((const TimeZoneRule&)*toRule);
 580         return TRUE;
 581     }
 582     return FALSE;
 583 }
 584
 585 int32_t
 586 RuleBasedTimeZone::countTransitionRules(UErrorCode& /*status*/) const {
 587     int32_t count = 0;
 588     if (fHistoricRules != NULL) {
 589         count += fHistoricRules->size();
 590     }
 591     if (fFinalRules != NULL) {
 592         count += fFinalRules->size();
 593     }
 594     return count;
 595 }
 596
 597 void
 598 RuleBasedTimeZone::getTimeZoneRules(const InitialTimeZoneRule*& initial,
 599                                     const TimeZoneRule* trsrules[],
 600                                     int32_t& trscount,
 601                                     UErrorCode& status) const {
 602     if (U_FAILURE(status)) {
 603         return;
 604     }
 605     // Initial rule
 606     initial = fInitialRule;
 607
 608     // Transition rules
 609     int32_t cnt = 0;
 610     int32_t idx;
 611     if (fHistoricRules != NULL && cnt < trscount) {
 612         int32_t historicCount = fHistoricRules->size();
 613         idx = 0;
 614         while (cnt < trscount && idx < historicCount) {
 615             trsrules[cnt++] = (const TimeZoneRule*)fHistoricRules->elementAt(idx++);
 616         }
 617     }
 618     if (fFinalRules != NULL && cnt < trscount) {
 619         int32_t finalCount = fFinalRules->size();
 620         idx = 0;
 621         while (cnt < trscount && idx < finalCount) {
 622             trsrules[cnt++] = (const TimeZoneRule*)fFinalRules->elementAt(idx++);
 623         }
 624     }
 625     // Set the result length
 626     trscount = cnt;
 627 }
 628
 629 void
 630 RuleBasedTimeZone::deleteRules(void) {
 631     delete fInitialRule;
 632     fInitialRule = NULL;
 633     if (fHistoricRules != NULL) {
 634         while (!fHistoricRules->isEmpty()) {
 635             delete (TimeZoneRule*)(fHistoricRules->orphanElementAt(0));
 636         }
 637         delete fHistoricRules;
 638         fHistoricRules = NULL;
 639     }
 640     if (fFinalRules != NULL) {
 641         while (!fFinalRules->isEmpty()) {
 642             delete (AnnualTimeZoneRule*)(fFinalRules->orphanElementAt(0));
 643         }
 644         delete fFinalRules;
 645         fFinalRules = NULL;
 646     }
 647 }
 648
 649 void
 650 RuleBasedTimeZone::deleteTransitions(void) {
 651     if (fHistoricTransitions != NULL) {
 652         while (!fHistoricTransitions->isEmpty()) {
 653             Transition *trs = (Transition*)fHistoricTransitions->orphanElementAt(0);
 654             uprv_free(trs);
 655         }
 656         delete fHistoricTransitions;
 657     }
 658     fHistoricTransitions = NULL;
 659 }
 660
 661 UVector*
 662 RuleBasedTimeZone::copyRules(UVector* source) {
 663     if (source == NULL) {
 664         return NULL;
 665     }
 666     UErrorCode ec = U_ZERO_ERROR;
 667     int32_t size = source->size();
 668     UVector *rules = new UVector(size, ec);
 669     if (U_FAILURE(ec)) {
 670         return NULL;
 671     }
 672     int32_t i;
 673     for (i = 0; i < size; i++) {
 674         rules->addElement(((TimeZoneRule*)source->elementAt(i))->clone(), ec);
 675         if (U_FAILURE(ec)) {
 676             break;
 677         }
 678     }
 679     if (U_FAILURE(ec)) {
 680         // In case of error, clean up
 681         for (i = 0; i < rules->size(); i++) {
 682             TimeZoneRule *rule = (TimeZoneRule*)rules->orphanElementAt(i);
 683             delete rule;
 684         }
 685         delete rules;
 686         return NULL;
 687     }
 688     return rules;
 689 }
 690
 691 TimeZoneRule*
 692 RuleBasedTimeZone::findRuleInFinal(UDate date, UBool local,
 693                                    int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const {
 694     if (fFinalRules == NULL) {
 695         return NULL;
 696     }
 697
 698     AnnualTimeZoneRule* fr0 = (AnnualTimeZoneRule*)fFinalRules->elementAt(0);
 699     AnnualTimeZoneRule* fr1 = (AnnualTimeZoneRule*)fFinalRules->elementAt(1);
 700     if (fr0 == NULL || fr1 == NULL) {
 701         return NULL;
 702     }
 703
 704     UDate start0, start1;
 705     UDate base;
 706     int32_t localDelta;
 707
 708     base = date;
 709     if (local) {
 710         localDelta = getLocalDelta(fr1->getRawOffset(), fr1->getDSTSavings(),
 711                                    fr0->getRawOffset(), fr0->getDSTSavings(),
 712                                    NonExistingTimeOpt, DuplicatedTimeOpt);
 713         base -= localDelta;
 714     }
 715     UBool avail0 = fr0->getPreviousStart(base, fr1->getRawOffset(), fr1->getDSTSavings(), TRUE, start0);
 716
 717     base = date;
 718     if (local) {
 719         localDelta = getLocalDelta(fr0->getRawOffset(), fr0->getDSTSavings(),
 720                                    fr1->getRawOffset(), fr1->getDSTSavings(),
 721                                    NonExistingTimeOpt, DuplicatedTimeOpt);
 722         base -= localDelta;
 723     }
 724     UBool avail1 = fr1->getPreviousStart(base, fr0->getRawOffset(), fr0->getDSTSavings(), TRUE, start1);
 725
 726     if (!avail0 || !avail1) {
 727         if (avail0) {
 728             return fr0;
 729         } else if (avail1) {
 730             return fr1;
 731         }
 732         // Both rules take effect after the given time
 733         return NULL;
 734     }
 735
 736     return (start0 > start1) ? fr0 : fr1;
 737 }
 738
 739 UBool
 740 RuleBasedTimeZone::findNext(UDate base, UBool inclusive, UDate& transitionTime,
 741                             TimeZoneRule*& fromRule, TimeZoneRule*& toRule) const {
 742     if (fHistoricTransitions == NULL) {
 743         return FALSE;
 744     }
 745     UBool isFinal = FALSE;
 746     UBool found = FALSE;
 747     Transition result;
 748     Transition *tzt = (Transition*)fHistoricTransitions->elementAt(0);
 749     UDate tt = tzt->time;
 750     if (tt > base || (inclusive && tt == base)) {
 751         result = *tzt;
 752         found = TRUE;
 753     } else {
 754         int32_t idx = fHistoricTransitions->size() - 1;
 755         tzt = (Transition*)fHistoricTransitions->elementAt(idx);
 756         tt = tzt->time;
 757         if (inclusive && tt == base) {
 758             result = *tzt;
 759             found = TRUE;
 760         } else if (tt <= base) {
 761             if (fFinalRules != NULL) {
 762                 // Find a transion time with finalRules
 763                 TimeZoneRule *r0 = (TimeZoneRule*)fFinalRules->elementAt(0);
 764                 TimeZoneRule *r1 = (TimeZoneRule*)fFinalRules->elementAt(1);
 765                 UDate start0, start1;
 766                 UBool avail0 = r0->getNextStart(base, r1->getRawOffset(), r1->getDSTSavings(), inclusive, start0);
 767                 UBool avail1 = r1->getNextStart(base, r0->getRawOffset(), r0->getDSTSavings(), inclusive, start1);
 768                 //  avail0/avail1 should be always TRUE
 769                 if (!avail0 && !avail1) {
 770                     return FALSE;
 771                 }
 772                 if (!avail1 || start0 < start1) {
 773                     result.time = start0;
 774                     result.from = r1;
 775                     result.to = r0;
 776                 } else {
 777                     result.time = start1;
 778                     result.from = r0;
 779                     result.to = r1;
 780                 }
 781                 isFinal = TRUE;
 782                 found = TRUE;
 783             }
 784         } else {
 785             // Find a transition within the historic transitions
 786             idx--;
 787             Transition *prev = tzt;
 788             while (idx > 0) {
 789                 tzt = (Transition*)fHistoricTransitions->elementAt(idx);
 790                 tt = tzt->time;
 791                 if (tt < base || (!inclusive && tt == base)) {
 792                     break;
 793                 }
 794                 idx--;
 795                 prev = tzt;
 796             }
 797             result.time = prev->time;
 798             result.from = prev->from;
 799             result.to = prev->to;
 800             found = TRUE;
 801         }
 802     }
 803     if (found) {
 804         // For now, this implementation ignore transitions with only zone name changes.
 805         if (result.from->getRawOffset() == result.to->getRawOffset()
 806             && result.from->getDSTSavings() == result.to->getDSTSavings()) {
 807             if (isFinal) {
 808                 return FALSE;
 809             } else {
 810                 // No offset changes.  Try next one if not final
 811                 return findNext(result.time, FALSE /* always exclusive */,
 812                     transitionTime, fromRule, toRule);
 813             }
 814         }
 815         transitionTime = result.time;
 816         fromRule = result.from;
 817         toRule = result.to;
 818         return TRUE;
 819     }
 820     return FALSE;
 821 }
 822
 823 UBool
 824 RuleBasedTimeZone::findPrev(UDate base, UBool inclusive, UDate& transitionTime,
 825                             TimeZoneRule*& fromRule, TimeZoneRule*& toRule) const {
 826     if (fHistoricTransitions == NULL) {
 827         return FALSE;
 828     }
 829     UBool found = FALSE;
 830     Transition result;
 831     Transition *tzt = (Transition*)fHistoricTransitions->elementAt(0);
 832     UDate tt = tzt->time;
 833     if (inclusive && tt == base) {
 834         result = *tzt;
 835         found = TRUE;
 836     } else if (tt < base) {
 837         int32_t idx = fHistoricTransitions->size() - 1;
 838         tzt = (Transition*)fHistoricTransitions->elementAt(idx);
 839         tt = tzt->time;
 840         if (inclusive && tt == base) {
 841             result = *tzt;
 842             found = TRUE;
 843         } else if (tt < base) {
 844             if (fFinalRules != NULL) {
 845                 // Find a transion time with finalRules
 846                 TimeZoneRule *r0 = (TimeZoneRule*)fFinalRules->elementAt(0);
 847                 TimeZoneRule *r1 = (TimeZoneRule*)fFinalRules->elementAt(1);
 848                 UDate start0, start1;
 849                 UBool avail0 = r0->getPreviousStart(base, r1->getRawOffset(), r1->getDSTSavings(), inclusive, start0);
 850                 UBool avail1 = r1->getPreviousStart(base, r0->getRawOffset(), r0->getDSTSavings(), inclusive, start1);
 851                 //  avail0/avail1 should be always TRUE
 852                 if (!avail0 && !avail1) {
 853                     return FALSE;
 854                 }
 855                 if (!avail1 || start0 > start1) {
 856                     result.time = start0;
 857                     result.from = r1;
 858                     result.to = r0;
 859                 } else {
 860                     result.time = start1;
 861                     result.from = r0;
 862                     result.to = r1;
 863                 }
 864             } else {
 865                 result = *tzt;
 866             }
 867             found = TRUE;
 868         } else {
 869             // Find a transition within the historic transitions
 870             idx--;
 871             while (idx >= 0) {
 872                 tzt = (Transition*)fHistoricTransitions->elementAt(idx);
 873                 tt = tzt->time;
 874                 if (tt < base || (inclusive && tt == base)) {
 875                     break;
 876                 }
 877                 idx--;
 878             }
 879             result = *tzt;
 880             found = TRUE;
 881         }
 882     }
 883     if (found) {
 884         // For now, this implementation ignore transitions with only zone name changes.
 885         if (result.from->getRawOffset() == result.to->getRawOffset()
 886             && result.from->getDSTSavings() == result.to->getDSTSavings()) {
 887             // No offset changes.  Try next one if not final
 888             return findPrev(result.time, FALSE /* always exclusive */,
 889                 transitionTime, fromRule, toRule);
 890         }
 891         transitionTime = result.time;
 892         fromRule = result.from;
 893         toRule = result.to;
 894         return TRUE;
 895     }
 896     return FALSE;
 897 }
 898
 899 UDate
 900 RuleBasedTimeZone::getTransitionTime(Transition* transition, UBool local,
 901                                      int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const {
 902     UDate time = transition->time;
 903     if (local) {
 904         time += getLocalDelta(transition->from->getRawOffset(), transition->from->getDSTSavings(),
 905                               transition->to->getRawOffset(), transition->to->getDSTSavings(),
 906                               NonExistingTimeOpt, DuplicatedTimeOpt);
 907     }
 908     return time;
 909 }
 910
 911 int32_t
 912 RuleBasedTimeZone::getLocalDelta(int32_t rawBefore, int32_t dstBefore, int32_t rawAfter, int32_t dstAfter,
 913                              int32_t NonExistingTimeOpt, int32_t DuplicatedTimeOpt) const {
 914     int32_t delta = 0;
 915
 916     int32_t offsetBefore = rawBefore + dstBefore;
 917     int32_t offsetAfter = rawAfter + dstAfter;
 918
 919     UBool dstToStd = (dstBefore != 0) && (dstAfter == 0);
 920     UBool stdToDst = (dstBefore == 0) && (dstAfter != 0);
 921
 922     if (offsetAfter - offsetBefore >= 0) {
 923         // Positive transition, which makes a non-existing local time range
 924         if (((NonExistingTimeOpt & kStdDstMask) == kStandard && dstToStd)
 925                 || ((NonExistingTimeOpt & kStdDstMask) == kDaylight && stdToDst)) {
 926             delta = offsetBefore;
 927         } else if (((NonExistingTimeOpt & kStdDstMask) == kStandard && stdToDst)
 928                 || ((NonExistingTimeOpt & kStdDstMask) == kDaylight && dstToStd)) {
 929             delta = offsetAfter;
 930         } else if ((NonExistingTimeOpt & kFormerLatterMask) == kLatter) {
 931             delta = offsetBefore;
 932         } else {
 933             // Interprets the time with rule before the transition,
 934             // default for non-existing time range
 935             delta = offsetAfter;
 936         }
 937     } else {
 938         // Negative transition, which makes a duplicated local time range
 939         if (((DuplicatedTimeOpt & kStdDstMask) == kStandard && dstToStd)
 940                 || ((DuplicatedTimeOpt & kStdDstMask) == kDaylight && stdToDst)) {
 941             delta = offsetAfter;
 942         } else if (((DuplicatedTimeOpt & kStdDstMask) == kStandard && stdToDst)
 943                 || ((DuplicatedTimeOpt & kStdDstMask) == kDaylight && dstToStd)) {
 944             delta = offsetBefore;
 945         } else if ((DuplicatedTimeOpt & kFormerLatterMask) == kFormer) {
 946             delta = offsetBefore;
 947         } else {
 948             // Interprets the time with rule after the transition,
 949             // default for duplicated local time range
 950             delta = offsetAfter;
 951         }
 952     }
 953     return delta;
 954 }
 955
 956 U_NAMESPACE_END
 957
 958 #endif /* #if !UCONFIG_NO_FORMATTING */
 959
 960 //eof
 961