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