1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ******************************************************************************* 5 * Copyright (C) 2007-2012, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ******************************************************************************* 8 */ 9 10 #include "utypeinfo.h" // for 'typeid' to work 11 12 #include "unicode/utypes.h" 13 14 #if !UCONFIG_NO_FORMATTING 15 16 #include "unicode/tzrule.h" 17 #include "unicode/ucal.h" 18 #include "gregoimp.h" 19 #include "cmemory.h" 20 #include "uarrsort.h" 21 22 U_CDECL_BEGIN 23 // UComparator function for sorting start times 24 static int32_t U_CALLCONV 25 compareDates(const void * /*context*/, const void *left, const void *right) { 26 UDate l = *((UDate*)left); 27 UDate r = *((UDate*)right); 28 int32_t res = l < r ? -1 : (l == r ? 0 : 1); 29 return res; 30 } 31 U_CDECL_END 32 33 U_NAMESPACE_BEGIN 34 35 TimeZoneRule::TimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSavings) 36 : UObject(), fName(name), fRawOffset(rawOffset), fDSTSavings(dstSavings) { 37 } 38 39 TimeZoneRule::TimeZoneRule(const TimeZoneRule& source) 40 : UObject(source), fName(source.fName), fRawOffset(source.fRawOffset), fDSTSavings(source.fDSTSavings) { 41 } 42 43 TimeZoneRule::~TimeZoneRule() { 44 } 45 46 TimeZoneRule& 47 TimeZoneRule::operator=(const TimeZoneRule& right) { 48 if (this != &right) { 49 fName = right.fName; 50 fRawOffset = right.fRawOffset; 51 fDSTSavings = right.fDSTSavings; 52 } 53 return *this; 54 } 55 56 UBool 57 TimeZoneRule::operator==(const TimeZoneRule& that) const { 58 return ((this == &that) || 59 (typeid(*this) == typeid(that) && 60 fName == that.fName && 61 fRawOffset == that.fRawOffset && 62 fDSTSavings == that.fDSTSavings)); 63 } 64 65 UBool 66 TimeZoneRule::operator!=(const TimeZoneRule& that) const { 67 return !operator==(that); 68 } 69 70 UnicodeString& 71 TimeZoneRule::getName(UnicodeString& name) const { 72 name = fName; 73 return name; 74 } 75 76 int32_t 77 TimeZoneRule::getRawOffset(void) const { 78 return fRawOffset; 79 } 80 81 int32_t 82 TimeZoneRule::getDSTSavings(void) const { 83 return fDSTSavings; 84 } 85 86 UBool 87 TimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const { 88 return ((this == &other) || 89 (typeid(*this) == typeid(other) && 90 fRawOffset == other.fRawOffset && 91 fDSTSavings == other.fDSTSavings)); 92 } 93 94 95 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(InitialTimeZoneRule) 96 97 InitialTimeZoneRule::InitialTimeZoneRule(const UnicodeString& name, 98 int32_t rawOffset, 99 int32_t dstSavings) 100 : TimeZoneRule(name, rawOffset, dstSavings) { 101 } 102 103 InitialTimeZoneRule::InitialTimeZoneRule(const InitialTimeZoneRule& source) 104 : TimeZoneRule(source) { 105 } 106 107 InitialTimeZoneRule::~InitialTimeZoneRule() { 108 } 109 110 InitialTimeZoneRule* 111 InitialTimeZoneRule::clone(void) const { 112 return new InitialTimeZoneRule(*this); 113 } 114 115 InitialTimeZoneRule& 116 InitialTimeZoneRule::operator=(const InitialTimeZoneRule& right) { 117 if (this != &right) { 118 TimeZoneRule::operator=(right); 119 } 120 return *this; 121 } 122 123 UBool 124 InitialTimeZoneRule::operator==(const TimeZoneRule& that) const { 125 return ((this == &that) || 126 (typeid(*this) == typeid(that) && 127 TimeZoneRule::operator==(that))); 128 } 129 130 UBool 131 InitialTimeZoneRule::operator!=(const TimeZoneRule& that) const { 132 return !operator==(that); 133 } 134 135 UBool 136 InitialTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const { 137 if (this == &other) { 138 return TRUE; 139 } 140 if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) { 141 return FALSE; 142 } 143 return TRUE; 144 } 145 146 UBool 147 InitialTimeZoneRule::getFirstStart(int32_t /*prevRawOffset*/, 148 int32_t /*prevDSTSavings*/, 149 UDate& /*result*/) const { 150 return FALSE; 151 } 152 153 UBool 154 InitialTimeZoneRule::getFinalStart(int32_t /*prevRawOffset*/, 155 int32_t /*prevDSTSavings*/, 156 UDate& /*result*/) const { 157 return FALSE; 158 } 159 160 UBool 161 InitialTimeZoneRule::getNextStart(UDate /*base*/, 162 int32_t /*prevRawOffset*/, 163 int32_t /*prevDSTSavings*/, 164 UBool /*inclusive*/, 165 UDate& /*result*/) const { 166 return FALSE; 167 } 168 169 UBool 170 InitialTimeZoneRule::getPreviousStart(UDate /*base*/, 171 int32_t /*prevRawOffset*/, 172 int32_t /*prevDSTSavings*/, 173 UBool /*inclusive*/, 174 UDate& /*result*/) const { 175 return FALSE; 176 } 177 178 179 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(AnnualTimeZoneRule) 180 181 const int32_t AnnualTimeZoneRule::MAX_YEAR = 0x7FFFFFFF; /* max signed int32 */ 182 183 AnnualTimeZoneRule::AnnualTimeZoneRule(const UnicodeString& name, 184 int32_t rawOffset, 185 int32_t dstSavings, 186 const DateTimeRule& dateTimeRule, 187 int32_t startYear, 188 int32_t endYear) 189 : TimeZoneRule(name, rawOffset, dstSavings), fDateTimeRule(new DateTimeRule(dateTimeRule)), 190 fStartYear(startYear), fEndYear(endYear) { 191 } 192 193 AnnualTimeZoneRule::AnnualTimeZoneRule(const UnicodeString& name, 194 int32_t rawOffset, 195 int32_t dstSavings, 196 DateTimeRule* dateTimeRule, 197 int32_t startYear, 198 int32_t endYear) 199 : TimeZoneRule(name, rawOffset, dstSavings), fDateTimeRule(dateTimeRule), 200 fStartYear(startYear), fEndYear(endYear) { 201 } 202 203 AnnualTimeZoneRule::AnnualTimeZoneRule(const AnnualTimeZoneRule& source) 204 : TimeZoneRule(source), fDateTimeRule(new DateTimeRule(*(source.fDateTimeRule))), 205 fStartYear(source.fStartYear), fEndYear(source.fEndYear) { 206 } 207 208 AnnualTimeZoneRule::~AnnualTimeZoneRule() { 209 delete fDateTimeRule; 210 } 211 212 AnnualTimeZoneRule* 213 AnnualTimeZoneRule::clone(void) const { 214 return new AnnualTimeZoneRule(*this); 215 } 216 217 AnnualTimeZoneRule& 218 AnnualTimeZoneRule::operator=(const AnnualTimeZoneRule& right) { 219 if (this != &right) { 220 TimeZoneRule::operator=(right); 221 delete fDateTimeRule; 222 fDateTimeRule = right.fDateTimeRule->clone(); 223 fStartYear = right.fStartYear; 224 fEndYear = right.fEndYear; 225 } 226 return *this; 227 } 228 229 UBool 230 AnnualTimeZoneRule::operator==(const TimeZoneRule& that) const { 231 if (this == &that) { 232 return TRUE; 233 } 234 if (typeid(*this) != typeid(that)) { 235 return FALSE; 236 } 237 AnnualTimeZoneRule *atzr = (AnnualTimeZoneRule*)&that; 238 return (*fDateTimeRule == *(atzr->fDateTimeRule) && 239 fStartYear == atzr->fStartYear && 240 fEndYear == atzr->fEndYear); 241 } 242 243 UBool 244 AnnualTimeZoneRule::operator!=(const TimeZoneRule& that) const { 245 return !operator==(that); 246 } 247 248 const DateTimeRule* 249 AnnualTimeZoneRule::getRule() const { 250 return fDateTimeRule; 251 } 252 253 int32_t 254 AnnualTimeZoneRule::getStartYear() const { 255 return fStartYear; 256 } 257 258 int32_t 259 AnnualTimeZoneRule::getEndYear() const { 260 return fEndYear; 261 } 262 263 UBool 264 AnnualTimeZoneRule::getStartInYear(int32_t year, 265 int32_t prevRawOffset, 266 int32_t prevDSTSavings, 267 UDate &result) const { 268 if (year < fStartYear || year > fEndYear) { 269 return FALSE; 270 } 271 double ruleDay; 272 DateTimeRule::DateRuleType type = fDateTimeRule->getDateRuleType(); 273 if (type == DateTimeRule::DOM) { 274 ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(), fDateTimeRule->getRuleDayOfMonth()); 275 } else { 276 UBool after = TRUE; 277 if (type == DateTimeRule::DOW) { 278 // Normalize DOW rule into DOW_GEQ_DOM or DOW_LEQ_DOM 279 int32_t weeks = fDateTimeRule->getRuleWeekInMonth(); 280 if (weeks > 0) { 281 ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(), 1); 282 ruleDay += 7 * (weeks - 1); 283 } else { 284 after = FALSE; 285 ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(), 286 Grego::monthLength(year, fDateTimeRule->getRuleMonth())); 287 ruleDay += 7 * (weeks + 1); 288 } 289 } else { 290 int32_t month = fDateTimeRule->getRuleMonth(); 291 int32_t dom = fDateTimeRule->getRuleDayOfMonth(); 292 if (type == DateTimeRule::DOW_LEQ_DOM) { 293 after = FALSE; 294 // Handle Feb <=29 295 if (month == UCAL_FEBRUARY && dom == 29 && !Grego::isLeapYear(year)) { 296 dom--; 297 } 298 } 299 ruleDay = Grego::fieldsToDay(year, month, dom); 300 } 301 int32_t dow = Grego::dayOfWeek(ruleDay); 302 int32_t delta = fDateTimeRule->getRuleDayOfWeek() - dow; 303 if (after) { 304 delta = delta < 0 ? delta + 7 : delta; 305 } else { 306 delta = delta > 0 ? delta - 7 : delta; 307 } 308 ruleDay += delta; 309 } 310 311 result = ruleDay*U_MILLIS_PER_DAY + fDateTimeRule->getRuleMillisInDay(); 312 if (fDateTimeRule->getTimeRuleType() != DateTimeRule::UTC_TIME) { 313 result -= prevRawOffset; 314 } 315 if (fDateTimeRule->getTimeRuleType() == DateTimeRule::WALL_TIME) { 316 result -= prevDSTSavings; 317 } 318 return TRUE; 319 } 320 321 UBool 322 AnnualTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const { 323 if (this == &other) { 324 return TRUE; 325 } 326 if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) { 327 return FALSE; 328 } 329 AnnualTimeZoneRule* that = (AnnualTimeZoneRule*)&other; 330 return (*fDateTimeRule == *(that->fDateTimeRule) && 331 fStartYear == that->fStartYear && 332 fEndYear == that->fEndYear); 333 } 334 335 UBool 336 AnnualTimeZoneRule::getFirstStart(int32_t prevRawOffset, 337 int32_t prevDSTSavings, 338 UDate& result) const { 339 return getStartInYear(fStartYear, prevRawOffset, prevDSTSavings, result); 340 } 341 342 UBool 343 AnnualTimeZoneRule::getFinalStart(int32_t prevRawOffset, 344 int32_t prevDSTSavings, 345 UDate& result) const { 346 if (fEndYear == MAX_YEAR) { 347 return FALSE; 348 } 349 return getStartInYear(fEndYear, prevRawOffset, prevDSTSavings, result); 350 } 351 352 UBool 353 AnnualTimeZoneRule::getNextStart(UDate base, 354 int32_t prevRawOffset, 355 int32_t prevDSTSavings, 356 UBool inclusive, 357 UDate& result) const { 358 int32_t year, month, dom, dow, doy, mid; 359 Grego::timeToFields(base, year, month, dom, dow, doy, mid); 360 if (year < fStartYear) { 361 return getFirstStart(prevRawOffset, prevDSTSavings, result); 362 } 363 UDate tmp; 364 if (getStartInYear(year, prevRawOffset, prevDSTSavings, tmp)) { 365 if (tmp < base || (!inclusive && (tmp == base))) { 366 // Return the next one 367 return getStartInYear(year + 1, prevRawOffset, prevDSTSavings, result); 368 } else { 369 result = tmp; 370 return TRUE; 371 } 372 } 373 return FALSE; 374 } 375 376 UBool 377 AnnualTimeZoneRule::getPreviousStart(UDate base, 378 int32_t prevRawOffset, 379 int32_t prevDSTSavings, 380 UBool inclusive, 381 UDate& result) const { 382 int32_t year, month, dom, dow, doy, mid; 383 Grego::timeToFields(base, year, month, dom, dow, doy, mid); 384 if (year > fEndYear) { 385 return getFinalStart(prevRawOffset, prevDSTSavings, result); 386 } 387 UDate tmp; 388 if (getStartInYear(year, prevRawOffset, prevDSTSavings, tmp)) { 389 if (tmp > base || (!inclusive && (tmp == base))) { 390 // Return the previous one 391 return getStartInYear(year - 1, prevRawOffset, prevDSTSavings, result); 392 } else { 393 result = tmp; 394 return TRUE; 395 } 396 } 397 return FALSE; 398 } 399 400 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeArrayTimeZoneRule) 401 402 TimeArrayTimeZoneRule::TimeArrayTimeZoneRule(const UnicodeString& name, 403 int32_t rawOffset, 404 int32_t dstSavings, 405 const UDate* startTimes, 406 int32_t numStartTimes, 407 DateTimeRule::TimeRuleType timeRuleType) 408 : TimeZoneRule(name, rawOffset, dstSavings), fTimeRuleType(timeRuleType), 409 fStartTimes(NULL) { 410 UErrorCode status = U_ZERO_ERROR; 411 initStartTimes(startTimes, numStartTimes, status); 412 //TODO - status? 413 } 414 415 416 TimeArrayTimeZoneRule::TimeArrayTimeZoneRule(const TimeArrayTimeZoneRule& source) 417 : TimeZoneRule(source), fTimeRuleType(source.fTimeRuleType), fStartTimes(NULL) { 418 UErrorCode status = U_ZERO_ERROR; 419 initStartTimes(source.fStartTimes, source.fNumStartTimes, status); 420 //TODO - status? 421 } 422 423 424 TimeArrayTimeZoneRule::~TimeArrayTimeZoneRule() { 425 if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) { 426 uprv_free(fStartTimes); 427 } 428 } 429 430 TimeArrayTimeZoneRule* 431 TimeArrayTimeZoneRule::clone(void) const { 432 return new TimeArrayTimeZoneRule(*this); 433 } 434 435 436 TimeArrayTimeZoneRule& 437 TimeArrayTimeZoneRule::operator=(const TimeArrayTimeZoneRule& right) { 438 if (this != &right) { 439 TimeZoneRule::operator=(right); 440 UErrorCode status = U_ZERO_ERROR; 441 initStartTimes(right.fStartTimes, right.fNumStartTimes, status); 442 //TODO - status? 443 fTimeRuleType = right.fTimeRuleType; 444 } 445 return *this; 446 } 447 448 UBool 449 TimeArrayTimeZoneRule::operator==(const TimeZoneRule& that) const { 450 if (this == &that) { 451 return TRUE; 452 } 453 if (typeid(*this) != typeid(that) || TimeZoneRule::operator==(that) == FALSE) { 454 return FALSE; 455 } 456 TimeArrayTimeZoneRule *tatzr = (TimeArrayTimeZoneRule*)&that; 457 if (fTimeRuleType != tatzr->fTimeRuleType || 458 fNumStartTimes != tatzr->fNumStartTimes) { 459 return FALSE; 460 } 461 // Compare start times 462 UBool res = TRUE; 463 for (int32_t i = 0; i < fNumStartTimes; i++) { 464 if (fStartTimes[i] != tatzr->fStartTimes[i]) { 465 res = FALSE; 466 break; 467 } 468 } 469 return res; 470 } 471 472 UBool 473 TimeArrayTimeZoneRule::operator!=(const TimeZoneRule& that) const { 474 return !operator==(that); 475 } 476 477 DateTimeRule::TimeRuleType 478 TimeArrayTimeZoneRule::getTimeType(void) const { 479 return fTimeRuleType; 480 } 481 482 UBool 483 TimeArrayTimeZoneRule::getStartTimeAt(int32_t index, UDate& result) const { 484 if (index >= fNumStartTimes || index < 0) { 485 return FALSE; 486 } 487 result = fStartTimes[index]; 488 return TRUE; 489 } 490 491 int32_t 492 TimeArrayTimeZoneRule::countStartTimes(void) const { 493 return fNumStartTimes; 494 } 495 496 UBool 497 TimeArrayTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const { 498 if (this == &other) { 499 return TRUE; 500 } 501 if (typeid(*this) != typeid(other) || TimeZoneRule::isEquivalentTo(other) == FALSE) { 502 return FALSE; 503 } 504 TimeArrayTimeZoneRule* that = (TimeArrayTimeZoneRule*)&other; 505 if (fTimeRuleType != that->fTimeRuleType || 506 fNumStartTimes != that->fNumStartTimes) { 507 return FALSE; 508 } 509 // Compare start times 510 UBool res = TRUE; 511 for (int32_t i = 0; i < fNumStartTimes; i++) { 512 if (fStartTimes[i] != that->fStartTimes[i]) { 513 res = FALSE; 514 break; 515 } 516 } 517 return res; 518 } 519 520 UBool 521 TimeArrayTimeZoneRule::getFirstStart(int32_t prevRawOffset, 522 int32_t prevDSTSavings, 523 UDate& result) const { 524 if (fNumStartTimes <= 0 || fStartTimes == NULL) { 525 return FALSE; 526 } 527 result = getUTC(fStartTimes[0], prevRawOffset, prevDSTSavings); 528 return TRUE; 529 } 530 531 UBool 532 TimeArrayTimeZoneRule::getFinalStart(int32_t prevRawOffset, 533 int32_t prevDSTSavings, 534 UDate& result) const { 535 if (fNumStartTimes <= 0 || fStartTimes == NULL) { 536 return FALSE; 537 } 538 result = getUTC(fStartTimes[fNumStartTimes - 1], prevRawOffset, prevDSTSavings); 539 return TRUE; 540 } 541 542 UBool 543 TimeArrayTimeZoneRule::getNextStart(UDate base, 544 int32_t prevRawOffset, 545 int32_t prevDSTSavings, 546 UBool inclusive, 547 UDate& result) const { 548 int32_t i = fNumStartTimes - 1; 549 for (; i >= 0; i--) { 550 UDate time = getUTC(fStartTimes[i], prevRawOffset, prevDSTSavings); 551 if (time < base || (!inclusive && time == base)) { 552 break; 553 } 554 result = time; 555 } 556 if (i == fNumStartTimes - 1) { 557 return FALSE; 558 } 559 return TRUE; 560 } 561 562 UBool 563 TimeArrayTimeZoneRule::getPreviousStart(UDate base, 564 int32_t prevRawOffset, 565 int32_t prevDSTSavings, 566 UBool inclusive, 567 UDate& result) const { 568 int32_t i = fNumStartTimes - 1; 569 for (; i >= 0; i--) { 570 UDate time = getUTC(fStartTimes[i], prevRawOffset, prevDSTSavings); 571 if (time < base || (inclusive && time == base)) { 572 result = time; 573 return TRUE; 574 } 575 } 576 return FALSE; 577 } 578 579 580 // ---- private methods ------ 581 582 UBool 583 TimeArrayTimeZoneRule::initStartTimes(const UDate source[], int32_t size, UErrorCode& status) { 584 // Free old array 585 if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) { 586 uprv_free(fStartTimes); 587 } 588 // Allocate new one if needed 589 if (size > TIMEARRAY_STACK_BUFFER_SIZE) { 590 fStartTimes = (UDate*)uprv_malloc(sizeof(UDate)*size); 591 if (fStartTimes == NULL) { 592 status = U_MEMORY_ALLOCATION_ERROR; 593 fNumStartTimes = 0; 594 return FALSE; 595 } 596 } else { 597 fStartTimes = (UDate*)fLocalStartTimes; 598 } 599 uprv_memcpy(fStartTimes, source, sizeof(UDate)*size); 600 fNumStartTimes = size; 601 // Sort dates 602 uprv_sortArray(fStartTimes, fNumStartTimes, (int32_t)sizeof(UDate), compareDates, NULL, TRUE, &status); 603 if (U_FAILURE(status)) { 604 if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) { 605 uprv_free(fStartTimes); 606 } 607 fNumStartTimes = 0; 608 return FALSE; 609 } 610 return TRUE; 611 } 612 613 UDate 614 TimeArrayTimeZoneRule::getUTC(UDate time, int32_t raw, int32_t dst) const { 615 if (fTimeRuleType != DateTimeRule::UTC_TIME) { 616 time -= raw; 617 } 618 if (fTimeRuleType == DateTimeRule::WALL_TIME) { 619 time -= dst; 620 } 621 return time; 622 } 623 624 U_NAMESPACE_END 625 626 #endif /* #if !UCONFIG_NO_FORMATTING */ 627 628 //eof 629 630
