| 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 | |