icuSources/i18n/rbtz.cpp

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