icuSources/i18n/tzrule.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007, 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/tzrule.h"
  13 #include "unicode/ucal.h"
  14 #include "gregoimp.h"
  15 #include "cmemory.h"
  16 #include "uarrsort.h"
  17
  18 U_CDECL_BEGIN
  19 // UComparator function for sorting start times
  20 static int32_t U_CALLCONV
  21 compareDates(const void * /*context*/, const void *left, const void *right) {
  22     UDate l = *((UDate*)left);
  23     UDate r = *((UDate*)right);
  24     int32_t res = l < r ? -1 : (l == r ? 0 : 1);
  25     return res;
  26 }
  27 U_CDECL_END
  28
  29 U_NAMESPACE_BEGIN
  30
  31 TimeZoneRule::TimeZoneRule(const UnicodeString& name, int32_t rawOffset, int32_t dstSavings)
  32 : UObject(), fName(name), fRawOffset(rawOffset), fDSTSavings(dstSavings) {
  33 }
  34
  35 TimeZoneRule::TimeZoneRule(const TimeZoneRule& source)
  36 : UObject(source), fName(source.fName), fRawOffset(source.fRawOffset), fDSTSavings(source.fDSTSavings) {
  37 }
  38
  39 TimeZoneRule::~TimeZoneRule() {
  40 }
  41
  42 TimeZoneRule&
  43 TimeZoneRule::operator=(const TimeZoneRule& right) {
  44     if (this != &right) {
  45         fName = right.fName;
  46         fRawOffset = right.fRawOffset;
  47         fDSTSavings = right.fDSTSavings;
  48     }
  49     return *this;
  50 }
  51
  52 UBool
  53 TimeZoneRule::operator==(const TimeZoneRule& that) const {
  54     return ((this == &that) ||
  55             (getDynamicClassID() == that.getDynamicClassID() &&
  56             fName == that.fName &&
  57             fRawOffset == that.fRawOffset &&
  58             fDSTSavings == that.fDSTSavings));
  59 }
  60
  61 UBool
  62 TimeZoneRule::operator!=(const TimeZoneRule& that) const {
  63     return !operator==(that);
  64 }
  65
  66 UnicodeString&
  67 TimeZoneRule::getName(UnicodeString& name) const {
  68     name = fName;
  69     return name;
  70 }
  71
  72 int32_t
  73 TimeZoneRule::getRawOffset(void) const {
  74     return fRawOffset;
  75 }
  76
  77 int32_t
  78 TimeZoneRule::getDSTSavings(void) const {
  79     return fDSTSavings;
  80 }
  81
  82 UBool
  83 TimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
  84     return ((this == &other) ||
  85             (getDynamicClassID() == other.getDynamicClassID() &&
  86             fRawOffset == other.fRawOffset &&
  87             fDSTSavings == other.fDSTSavings));
  88 }
  89
  90
  91 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(InitialTimeZoneRule)
  92
  93 InitialTimeZoneRule::InitialTimeZoneRule(const UnicodeString& name,
  94                                          int32_t rawOffset,
  95                                          int32_t dstSavings)
  96 : TimeZoneRule(name, rawOffset, dstSavings) {
  97 }
  98
  99 InitialTimeZoneRule::InitialTimeZoneRule(const InitialTimeZoneRule& source)
 100 : TimeZoneRule(source) {
 101 }
 102
 103 InitialTimeZoneRule::~InitialTimeZoneRule() {
 104 }
 105
 106 InitialTimeZoneRule*
 107 InitialTimeZoneRule::clone(void) const {
 108     return new InitialTimeZoneRule(*this);
 109 }
 110
 111 InitialTimeZoneRule&
 112 InitialTimeZoneRule::operator=(const InitialTimeZoneRule& right) {
 113     if (this != &right) {
 114         TimeZoneRule::operator=(right);
 115     }
 116     return *this;
 117 }
 118
 119 UBool
 120 InitialTimeZoneRule::operator==(const TimeZoneRule& that) const {
 121     return ((this == &that) ||
 122             (getDynamicClassID() == that.getDynamicClassID() &&
 123             TimeZoneRule::operator==(that)));
 124 }
 125
 126 UBool
 127 InitialTimeZoneRule::operator!=(const TimeZoneRule& that) const {
 128     return !operator==(that);
 129 }
 130
 131 UBool
 132 InitialTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
 133     if (this == &other) {
 134         return TRUE;
 135     }
 136     if (getDynamicClassID() != other.getDynamicClassID() ||
 137         TimeZoneRule::isEquivalentTo(other) == FALSE) {
 138         return FALSE;
 139     }
 140     return TRUE;
 141 }
 142
 143 UBool
 144 InitialTimeZoneRule::getFirstStart(int32_t /*prevRawOffset*/,
 145                                   int32_t /*prevDSTSavings*/,
 146                                   UDate& /*result*/) const {
 147     return FALSE;
 148 }
 149
 150 UBool
 151 InitialTimeZoneRule::getFinalStart(int32_t /*prevRawOffset*/,
 152                                   int32_t /*prevDSTSavings*/,
 153                                   UDate& /*result*/) const {
 154     return FALSE;
 155 }
 156
 157 UBool
 158 InitialTimeZoneRule::getNextStart(const UDate /*base*/,
 159                                  int32_t /*prevRawOffset*/,
 160                                  int32_t /*prevDSTSavings*/,
 161                                  UBool /*inclusive*/,
 162                                  UDate& /*result*/) const {
 163     return FALSE;
 164 }
 165
 166 UBool
 167 InitialTimeZoneRule::getPreviousStart(const UDate /*base*/,
 168                                      int32_t /*prevRawOffset*/,
 169                                      int32_t /*prevDSTSavings*/,
 170                                      UBool /*inclusive*/,
 171                                      UDate& /*result*/) const {
 172     return FALSE;
 173 }
 174
 175
 176 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(AnnualTimeZoneRule)
 177
 178 const int32_t AnnualTimeZoneRule::MAX_YEAR = 0x7FFFFFFF; /* max signed int32 */
 179
 180 AnnualTimeZoneRule::AnnualTimeZoneRule(const UnicodeString& name,
 181                                        int32_t rawOffset,
 182                                        int32_t dstSavings,
 183                                        const DateTimeRule& dateTimeRule,
 184                                        int32_t startYear,
 185                                        int32_t endYear)
 186 : TimeZoneRule(name, rawOffset, dstSavings), fDateTimeRule(new DateTimeRule(dateTimeRule)),
 187   fStartYear(startYear), fEndYear(endYear) {
 188 }
 189
 190 AnnualTimeZoneRule::AnnualTimeZoneRule(const UnicodeString& name,
 191                                        int32_t rawOffset,
 192                                        int32_t dstSavings,
 193                                        DateTimeRule* dateTimeRule,
 194                                        int32_t startYear,
 195                                        int32_t endYear)
 196 : TimeZoneRule(name, rawOffset, dstSavings), fDateTimeRule(dateTimeRule),
 197   fStartYear(startYear), fEndYear(endYear) {
 198 }
 199
 200 AnnualTimeZoneRule::AnnualTimeZoneRule(const AnnualTimeZoneRule& source)
 201 : TimeZoneRule(source), fDateTimeRule(new DateTimeRule(*(source.fDateTimeRule))),
 202   fStartYear(source.fStartYear), fEndYear(source.fEndYear) {
 203 }
 204
 205 AnnualTimeZoneRule::~AnnualTimeZoneRule() {
 206     delete fDateTimeRule;
 207 }
 208
 209 AnnualTimeZoneRule*
 210 AnnualTimeZoneRule::clone(void) const {
 211     return new AnnualTimeZoneRule(*this);
 212 }
 213
 214 AnnualTimeZoneRule&
 215 AnnualTimeZoneRule::operator=(const AnnualTimeZoneRule& right) {
 216     if (this != &right) {
 217         TimeZoneRule::operator=(right);
 218         delete fDateTimeRule;
 219         fDateTimeRule = right.fDateTimeRule->clone();
 220         fStartYear = right.fStartYear;
 221         fEndYear = right.fEndYear;
 222     }
 223     return *this;
 224 }
 225
 226 UBool
 227 AnnualTimeZoneRule::operator==(const TimeZoneRule& that) const {
 228     if (this == &that) {
 229         return TRUE;
 230     }
 231     if (getDynamicClassID() != that.getDynamicClassID()) {
 232         return FALSE;
 233     }
 234     AnnualTimeZoneRule *atzr = (AnnualTimeZoneRule*)&that;
 235     return (*fDateTimeRule == *(atzr->fDateTimeRule) &&
 236             fStartYear == atzr->fStartYear &&
 237             fEndYear == atzr->fEndYear);
 238 }
 239
 240 UBool
 241 AnnualTimeZoneRule::operator!=(const TimeZoneRule& that) const {
 242     return !operator==(that);
 243 }
 244
 245 const DateTimeRule*
 246 AnnualTimeZoneRule::getRule() const {
 247     return fDateTimeRule;
 248 }
 249
 250 int32_t
 251 AnnualTimeZoneRule::getStartYear() const {
 252     return fStartYear;
 253 }
 254
 255 int32_t
 256 AnnualTimeZoneRule::getEndYear() const {
 257     return fEndYear;
 258 }
 259
 260 UBool
 261 AnnualTimeZoneRule::getStartInYear(int32_t year,
 262                                    int32_t prevRawOffset,
 263                                    int32_t prevDSTSavings,
 264                                    UDate &result) const {
 265     if (year < fStartYear || year > fEndYear) {
 266         return FALSE;
 267     }
 268     double ruleDay;
 269     DateTimeRule::DateRuleType type = fDateTimeRule->getDateRuleType();
 270     if (type == DateTimeRule::DOM) {
 271         ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(), fDateTimeRule->getRuleDayOfMonth());
 272     } else {
 273         UBool after = TRUE;
 274         if (type == DateTimeRule::DOW) {
 275             // Normalize DOW rule into DOW_GEQ_DOM or DOW_LEQ_DOM
 276             int32_t weeks = fDateTimeRule->getRuleWeekInMonth();
 277             if (weeks > 0) {
 278                 ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(), 1);
 279                 ruleDay += 7 * (weeks - 1);
 280             } else {
 281                 after = FALSE;
 282                 ruleDay = Grego::fieldsToDay(year, fDateTimeRule->getRuleMonth(),
 283                     Grego::monthLength(year, fDateTimeRule->getRuleMonth()));
 284                 ruleDay += 7 * (weeks + 1);
 285            }
 286         } else {
 287             int32_t month = fDateTimeRule->getRuleMonth();
 288             int32_t dom = fDateTimeRule->getRuleDayOfMonth();
 289             if (type == DateTimeRule::DOW_LEQ_DOM) {
 290                 after = FALSE;
 291                 // Handle Feb <=29
 292                 if (month == UCAL_FEBRUARY && dom == 29 && !Grego::isLeapYear(year)) {
 293                     dom--;
 294                 }
 295             }
 296             ruleDay = Grego::fieldsToDay(year, month, dom);
 297         }
 298         int32_t dow = Grego::dayOfWeek(ruleDay);
 299         int32_t delta = fDateTimeRule->getRuleDayOfWeek() - dow;
 300         if (after) {
 301             delta = delta < 0 ? delta + 7 : delta;
 302         } else {
 303             delta = delta > 0 ? delta - 7 : delta;
 304         }
 305         ruleDay += delta;
 306     }
 307
 308     result = ruleDay*U_MILLIS_PER_DAY + fDateTimeRule->getRuleMillisInDay();
 309     if (fDateTimeRule->getTimeRuleType() != DateTimeRule::UTC_TIME) {
 310         result -= prevRawOffset;
 311     }
 312     if (fDateTimeRule->getTimeRuleType() == DateTimeRule::WALL_TIME) {
 313         result -= prevDSTSavings;
 314     }
 315     return TRUE;
 316 }
 317
 318 UBool
 319 AnnualTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
 320     if (this == &other) {
 321         return TRUE;
 322     }
 323     if (getDynamicClassID() != other.getDynamicClassID() ||
 324         TimeZoneRule::isEquivalentTo(other) == FALSE) {
 325         return FALSE;
 326     }
 327     AnnualTimeZoneRule* that = (AnnualTimeZoneRule*)&other;
 328     return (*fDateTimeRule == *(that->fDateTimeRule) &&
 329             fStartYear == that->fStartYear &&
 330             fEndYear == that->fEndYear);
 331 }
 332
 333 UBool
 334 AnnualTimeZoneRule::getFirstStart(int32_t prevRawOffset,
 335                                   int32_t prevDSTSavings,
 336                                   UDate& result) const {
 337     return getStartInYear(fStartYear, prevRawOffset, prevDSTSavings, result);
 338 }
 339
 340 UBool
 341 AnnualTimeZoneRule::getFinalStart(int32_t prevRawOffset,
 342                                   int32_t prevDSTSavings,
 343                                   UDate& result) const {
 344     if (fEndYear == MAX_YEAR) {
 345         return FALSE;
 346     }
 347     return getStartInYear(fEndYear, prevRawOffset, prevDSTSavings, result);
 348 }
 349
 350 UBool
 351 AnnualTimeZoneRule::getNextStart(const UDate base,
 352                                  int32_t prevRawOffset,
 353                                  int32_t prevDSTSavings,
 354                                  UBool inclusive,
 355                                  UDate& result) const {
 356     int32_t year, month, dom, dow, doy, mid;
 357     Grego::timeToFields(base, year, month, dom, dow, doy, mid);
 358     if (year < fStartYear) {
 359         return getFirstStart(prevRawOffset, prevDSTSavings, result);
 360     }
 361     UDate tmp;
 362     if (getStartInYear(year, prevRawOffset, prevDSTSavings, tmp)) {
 363         if (tmp < base || (!inclusive && (tmp == base))) {
 364             // Return the next one
 365             return getStartInYear(year + 1, prevRawOffset, prevDSTSavings, result);
 366         } else {
 367             result = tmp;
 368             return TRUE;
 369         }
 370     }
 371     return FALSE;
 372 }
 373
 374 UBool
 375 AnnualTimeZoneRule::getPreviousStart(const UDate base,
 376                                      int32_t prevRawOffset,
 377                                      int32_t prevDSTSavings,
 378                                      UBool inclusive,
 379                                      UDate& result) const {
 380     int32_t year, month, dom, dow, doy, mid;
 381     Grego::timeToFields(base, year, month, dom, dow, doy, mid);
 382     if (year > fEndYear) {
 383         return getFinalStart(prevRawOffset, prevDSTSavings, result);
 384     }
 385     UDate tmp;
 386     if (getStartInYear(year, prevRawOffset, prevDSTSavings, tmp)) {
 387         if (tmp > base || (!inclusive && (tmp == base))) {
 388             // Return the previous one
 389             return getStartInYear(year - 1, prevRawOffset, prevDSTSavings, result);
 390         } else {
 391             result = tmp;
 392             return TRUE;
 393         }
 394     }
 395     return FALSE;
 396 }
 397
 398 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeArrayTimeZoneRule)
 399
 400 TimeArrayTimeZoneRule::TimeArrayTimeZoneRule(const UnicodeString& name,
 401                                              int32_t rawOffset,
 402                                              int32_t dstSavings,
 403                                              const UDate* startTimes,
 404                                              int32_t numStartTimes,
 405                                              DateTimeRule::TimeRuleType timeRuleType)
 406 : TimeZoneRule(name, rawOffset, dstSavings), fTimeRuleType(timeRuleType),
 407   fStartTimes(NULL) {
 408     UErrorCode status = U_ZERO_ERROR;
 409     initStartTimes(startTimes, numStartTimes, status);
 410     //TODO - status?
 411 }
 412
 413
 414 TimeArrayTimeZoneRule::TimeArrayTimeZoneRule(const TimeArrayTimeZoneRule& source)
 415 : TimeZoneRule(source), fTimeRuleType(source.fTimeRuleType), fStartTimes(NULL) {
 416     UErrorCode status = U_ZERO_ERROR;
 417     initStartTimes(source.fStartTimes, source.fNumStartTimes, status);
 418     //TODO - status?
 419 }
 420
 421
 422 TimeArrayTimeZoneRule::~TimeArrayTimeZoneRule() {
 423     if (fStartTimes != NULL && fStartTimes != fLocalStartTimes) {
 424         uprv_free(fStartTimes);
 425     }
 426 }
 427
 428 TimeArrayTimeZoneRule*
 429 TimeArrayTimeZoneRule::clone(void) const {
 430     return new TimeArrayTimeZoneRule(*this);
 431 }
 432
 433
 434 TimeArrayTimeZoneRule&
 435 TimeArrayTimeZoneRule::operator=(const TimeArrayTimeZoneRule& right) {
 436     if (this != &right) {
 437         TimeZoneRule::operator=(right);
 438         UErrorCode status = U_ZERO_ERROR;
 439         initStartTimes(right.fStartTimes, right.fNumStartTimes, status);
 440         //TODO - status?
 441         fTimeRuleType = right.fTimeRuleType;
 442     }
 443     return *this;
 444 }
 445
 446 UBool
 447 TimeArrayTimeZoneRule::operator==(const TimeZoneRule& that) const {
 448     if (this == &that) {
 449         return TRUE;
 450     }
 451     if (getDynamicClassID() != that.getDynamicClassID()
 452         || TimeZoneRule::operator==(that) == FALSE) {
 453         return FALSE;
 454     }
 455     TimeArrayTimeZoneRule *tatzr = (TimeArrayTimeZoneRule*)&that;
 456     if (fTimeRuleType != tatzr->fTimeRuleType ||
 457         fNumStartTimes != tatzr->fNumStartTimes) {
 458         return FALSE;
 459     }
 460     // Compare start times
 461     UBool res = TRUE;
 462     for (int32_t i = 0; i < fNumStartTimes; i++) {
 463         if (fStartTimes[i] != tatzr->fStartTimes[i]) {
 464             res = FALSE;
 465             break;
 466         }
 467     }
 468     return res;
 469 }
 470
 471 UBool
 472 TimeArrayTimeZoneRule::operator!=(const TimeZoneRule& that) const {
 473     return !operator==(that);
 474 }
 475
 476 DateTimeRule::TimeRuleType
 477 TimeArrayTimeZoneRule::getTimeType(void) const {
 478     return fTimeRuleType;
 479 }
 480
 481 UBool
 482 TimeArrayTimeZoneRule::getStartTimeAt(int32_t index, UDate& result) const {
 483     if (index >= fNumStartTimes || index < 0) {
 484         return FALSE;
 485     }
 486     result = fStartTimes[index];
 487     return TRUE;
 488 }
 489
 490 int32_t
 491 TimeArrayTimeZoneRule::countStartTimes(void) const {
 492     return fNumStartTimes;
 493 }
 494
 495 UBool
 496 TimeArrayTimeZoneRule::isEquivalentTo(const TimeZoneRule& other) const {
 497     if (this == &other) {
 498         return TRUE;
 499     }
 500     if (getDynamicClassID() != other.getDynamicClassID()
 501         || 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(const 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(const 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