icuSources/i18n/simpletz.cpp

   1 /*
   2  *******************************************************************************
   3  * Copyright (C) 1997-2013, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  *******************************************************************************
   6  *
   7  * File SIMPLETZ.H
   8  *
   9  * Modification History:
  10  *
  11  *   Date        Name        Description
  12  *   12/05/96    clhuang     Creation.
  13  *   04/21/97    aliu        Fixed miscellaneous bugs found by inspection and
  14  *                           testing.
  15  *   07/29/97    aliu        Ported source bodies back from Java version with
  16  *                           numerous feature enhancements and bug fixes.
  17  *   08/10/98    stephen     JDK 1.2 sync.
  18  *   09/17/98    stephen     Fixed getOffset() for last hour of year and DST
  19  *   12/02/99    aliu        Added TimeMode and constructor and setStart/EndRule
  20  *                           methods that take TimeMode. Whitespace cleanup.
  21  ********************************************************************************
  22  */
  23
  24 #include "utypeinfo.h"  // for 'typeid' to work
  25
  26 #include "unicode/utypes.h"
  27
  28 #if !UCONFIG_NO_FORMATTING
  29
  30 #include "unicode/simpletz.h"
  31 #include "unicode/gregocal.h"
  32 #include "unicode/smpdtfmt.h"
  33
  34 #include "gregoimp.h"
  35 #include "umutex.h"
  36
  37 U_NAMESPACE_BEGIN
  38
  39 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SimpleTimeZone)
  40
  41 // Use only for decodeStartRule() and decodeEndRule() where the year is not
  42 // available. Set February to 29 days to accomodate rules with that date
  43 // and day-of-week-on-or-before-that-date mode (DOW_LE_DOM_MODE).
  44 // The compareToRule() method adjusts to February 28 in non-leap years.
  45 //
  46 // For actual getOffset() calculations, use Grego::monthLength() and
  47 // Grego::previousMonthLength() which take leap years into account.
  48 // We handle leap years assuming always
  49 // Gregorian, since we know they didn't have daylight time when
  50 // Gregorian calendar started.
  51 const int8_t SimpleTimeZone::STATICMONTHLENGTH[] = {31,29,31,30,31,30,31,31,30,31,30,31};
  52
  53 static const UChar DST_STR[] = {0x0028,0x0044,0x0053,0x0054,0x0029,0}; // "(DST)"
  54 static const UChar STD_STR[] = {0x0028,0x0053,0x0054,0x0044,0x0029,0}; // "(STD)"
  55
  56
  57 // *****************************************************************************
  58 // class SimpleTimeZone
  59 // *****************************************************************************
  60
  61
  62 SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID)
  63 :   BasicTimeZone(ID),
  64     startMonth(0),
  65     startDay(0),
  66     startDayOfWeek(0),
  67     startTime(0),
  68     startTimeMode(WALL_TIME),
  69     endTimeMode(WALL_TIME),
  70     endMonth(0),
  71     endDay(0),
  72     endDayOfWeek(0),
  73     endTime(0),
  74     startYear(0),
  75     rawOffset(rawOffsetGMT),
  76     useDaylight(FALSE),
  77     startMode(DOM_MODE),
  78     endMode(DOM_MODE),
  79     dstSavings(U_MILLIS_PER_HOUR)
  80 {
  81     clearTransitionRules();
  82 }
  83
  84 // -------------------------------------
  85
  86 SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID,
  87     int8_t savingsStartMonth, int8_t savingsStartDay,
  88     int8_t savingsStartDayOfWeek, int32_t savingsStartTime,
  89     int8_t savingsEndMonth, int8_t savingsEndDay,
  90     int8_t savingsEndDayOfWeek, int32_t savingsEndTime,
  91     UErrorCode& status)
  92 :   BasicTimeZone(ID)
  93 {
  94     clearTransitionRules();
  95     construct(rawOffsetGMT,
  96               savingsStartMonth, savingsStartDay, savingsStartDayOfWeek,
  97               savingsStartTime, WALL_TIME,
  98               savingsEndMonth, savingsEndDay, savingsEndDayOfWeek,
  99               savingsEndTime, WALL_TIME,
 100               U_MILLIS_PER_HOUR, status);
 101 }
 102
 103 // -------------------------------------
 104
 105 SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID,
 106     int8_t savingsStartMonth, int8_t savingsStartDay,
 107     int8_t savingsStartDayOfWeek, int32_t savingsStartTime,
 108     int8_t savingsEndMonth, int8_t savingsEndDay,
 109     int8_t savingsEndDayOfWeek, int32_t savingsEndTime,
 110     int32_t savingsDST, UErrorCode& status)
 111 :   BasicTimeZone(ID)
 112 {
 113     clearTransitionRules();
 114     construct(rawOffsetGMT,
 115               savingsStartMonth, savingsStartDay, savingsStartDayOfWeek,
 116               savingsStartTime, WALL_TIME,
 117               savingsEndMonth, savingsEndDay, savingsEndDayOfWeek,
 118               savingsEndTime, WALL_TIME,
 119               savingsDST, status);
 120 }
 121
 122 // -------------------------------------
 123
 124 SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID,
 125     int8_t savingsStartMonth, int8_t savingsStartDay,
 126     int8_t savingsStartDayOfWeek, int32_t savingsStartTime,
 127     TimeMode savingsStartTimeMode,
 128     int8_t savingsEndMonth, int8_t savingsEndDay,
 129     int8_t savingsEndDayOfWeek, int32_t savingsEndTime,
 130     TimeMode savingsEndTimeMode,
 131     int32_t savingsDST, UErrorCode& status)
 132 :   BasicTimeZone(ID)
 133 {
 134     clearTransitionRules();
 135     construct(rawOffsetGMT,
 136               savingsStartMonth, savingsStartDay, savingsStartDayOfWeek,
 137               savingsStartTime, savingsStartTimeMode,
 138               savingsEndMonth, savingsEndDay, savingsEndDayOfWeek,
 139               savingsEndTime, savingsEndTimeMode,
 140               savingsDST, status);
 141 }
 142
 143 /**
 144  * Internal construction method.
 145  */
 146 void SimpleTimeZone::construct(int32_t rawOffsetGMT,
 147                                int8_t savingsStartMonth,
 148                                int8_t savingsStartDay,
 149                                int8_t savingsStartDayOfWeek,
 150                                int32_t savingsStartTime,
 151                                TimeMode savingsStartTimeMode,
 152                                int8_t savingsEndMonth,
 153                                int8_t savingsEndDay,
 154                                int8_t savingsEndDayOfWeek,
 155                                int32_t savingsEndTime,
 156                                TimeMode savingsEndTimeMode,
 157                                int32_t savingsDST,
 158                                UErrorCode& status)
 159 {
 160     this->rawOffset      = rawOffsetGMT;
 161     this->startMonth     = savingsStartMonth;
 162     this->startDay       = savingsStartDay;
 163     this->startDayOfWeek = savingsStartDayOfWeek;
 164     this->startTime      = savingsStartTime;
 165     this->startTimeMode  = savingsStartTimeMode;
 166     this->endMonth       = savingsEndMonth;
 167     this->endDay         = savingsEndDay;
 168     this->endDayOfWeek   = savingsEndDayOfWeek;
 169     this->endTime        = savingsEndTime;
 170     this->endTimeMode    = savingsEndTimeMode;
 171     this->dstSavings     = savingsDST;
 172     this->startYear      = 0;
 173     this->startMode      = DOM_MODE;
 174     this->endMode        = DOM_MODE;
 175
 176     decodeRules(status);
 177
 178     if (savingsDST <= 0) {
 179         status = U_ILLEGAL_ARGUMENT_ERROR;
 180     }
 181 }
 182
 183 // -------------------------------------
 184
 185 SimpleTimeZone::~SimpleTimeZone()
 186 {
 187     deleteTransitionRules();
 188 }
 189
 190 // -------------------------------------
 191
 192 // Called by TimeZone::createDefault(), then clone() inside a Mutex - be careful.
 193 SimpleTimeZone::SimpleTimeZone(const SimpleTimeZone &source)
 194 :   BasicTimeZone(source)
 195 {
 196     *this = source;
 197 }
 198
 199 // -------------------------------------
 200
 201 // Called by TimeZone::createDefault(), then clone() inside a Mutex - be careful.
 202 SimpleTimeZone &
 203 SimpleTimeZone::operator=(const SimpleTimeZone &right)
 204 {
 205     if (this != &right)
 206     {
 207         TimeZone::operator=(right);
 208         rawOffset      = right.rawOffset;
 209         startMonth     = right.startMonth;
 210         startDay       = right.startDay;
 211         startDayOfWeek = right.startDayOfWeek;
 212         startTime      = right.startTime;
 213         startTimeMode  = right.startTimeMode;
 214         startMode      = right.startMode;
 215         endMonth       = right.endMonth;
 216         endDay         = right.endDay;
 217         endDayOfWeek   = right.endDayOfWeek;
 218         endTime        = right.endTime;
 219         endTimeMode    = right.endTimeMode;
 220         endMode        = right.endMode;
 221         startYear      = right.startYear;
 222         dstSavings     = right.dstSavings;
 223         useDaylight    = right.useDaylight;
 224         clearTransitionRules();
 225     }
 226     return *this;
 227 }
 228
 229 // -------------------------------------
 230
 231 UBool
 232 SimpleTimeZone::operator==(const TimeZone& that) const
 233 {
 234     return ((this == &that) ||
 235             (typeid(*this) == typeid(that) &&
 236             TimeZone::operator==(that) &&
 237             hasSameRules(that)));
 238 }
 239
 240 // -------------------------------------
 241
 242 // Called by TimeZone::createDefault() inside a Mutex - be careful.
 243 TimeZone*
 244 SimpleTimeZone::clone() const
 245 {
 246     return new SimpleTimeZone(*this);
 247 }
 248
 249 // -------------------------------------
 250
 251 /**
 252  * Sets the daylight savings starting year, that is, the year this time zone began
 253  * observing its specified daylight savings time rules.  The time zone is considered
 254  * not to observe daylight savings time prior to that year; SimpleTimeZone doesn't
 255  * support historical daylight-savings-time rules.
 256  * @param year the daylight savings starting year.
 257  */
 258 void
 259 SimpleTimeZone::setStartYear(int32_t year)
 260 {
 261     startYear = year;
 262     transitionRulesInitialized = FALSE;
 263 }
 264
 265 // -------------------------------------
 266
 267 /**
 268  * Sets the daylight savings starting rule. For example, in the U.S., Daylight Savings
 269  * Time starts at the first Sunday in April, at 2 AM in standard time.
 270  * Therefore, you can set the start rule by calling:
 271  * setStartRule(TimeFields.APRIL, 1, TimeFields.SUNDAY, 2*60*60*1000);
 272  * The dayOfWeekInMonth and dayOfWeek parameters together specify how to calculate
 273  * the exact starting date.  Their exact meaning depend on their respective signs,
 274  * allowing various types of rules to be constructed, as follows:<ul>
 275  *   <li>If both dayOfWeekInMonth and dayOfWeek are positive, they specify the
 276  *       day of week in the month (e.g., (2, WEDNESDAY) is the second Wednesday
 277  *       of the month).
 278  *   <li>If dayOfWeek is positive and dayOfWeekInMonth is negative, they specify
 279  *       the day of week in the month counting backward from the end of the month.
 280  *       (e.g., (-1, MONDAY) is the last Monday in the month)
 281  *   <li>If dayOfWeek is zero and dayOfWeekInMonth is positive, dayOfWeekInMonth
 282  *       specifies the day of the month, regardless of what day of the week it is.
 283  *       (e.g., (10, 0) is the tenth day of the month)
 284  *   <li>If dayOfWeek is zero and dayOfWeekInMonth is negative, dayOfWeekInMonth
 285  *       specifies the day of the month counting backward from the end of the
 286  *       month, regardless of what day of the week it is (e.g., (-2, 0) is the
 287  *       next-to-last day of the month).
 288  *   <li>If dayOfWeek is negative and dayOfWeekInMonth is positive, they specify the
 289  *       first specified day of the week on or after the specfied day of the month.
 290  *       (e.g., (15, -SUNDAY) is the first Sunday after the 15th of the month
 291  *       [or the 15th itself if the 15th is a Sunday].)
 292  *   <li>If dayOfWeek and DayOfWeekInMonth are both negative, they specify the
 293  *       last specified day of the week on or before the specified day of the month.
 294  *       (e.g., (-20, -TUESDAY) is the last Tuesday before the 20th of the month
 295  *       [or the 20th itself if the 20th is a Tuesday].)</ul>
 296  * @param month the daylight savings starting month. Month is 0-based.
 297  * eg, 0 for January.
 298  * @param dayOfWeekInMonth the daylight savings starting
 299  * day-of-week-in-month. Please see the member description for an example.
 300  * @param dayOfWeek the daylight savings starting day-of-week. Please see
 301  * the member description for an example.
 302  * @param time the daylight savings starting time. Please see the member
 303  * description for an example.
 304  */
 305
 306 void
 307 SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfWeekInMonth, int32_t dayOfWeek,
 308                              int32_t time, TimeMode mode, UErrorCode& status)
 309 {
 310     startMonth     = (int8_t)month;
 311     startDay       = (int8_t)dayOfWeekInMonth;
 312     startDayOfWeek = (int8_t)dayOfWeek;
 313     startTime      = time;
 314     startTimeMode  = mode;
 315     decodeStartRule(status);
 316     transitionRulesInitialized = FALSE;
 317 }
 318
 319 // -------------------------------------
 320
 321 void
 322 SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfMonth,
 323                              int32_t time, TimeMode mode, UErrorCode& status)
 324 {
 325     setStartRule(month, dayOfMonth, 0, time, mode, status);
 326 }
 327
 328 // -------------------------------------
 329
 330 void
 331 SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfMonth, int32_t dayOfWeek,
 332                              int32_t time, TimeMode mode, UBool after, UErrorCode& status)
 333 {
 334     setStartRule(month, after ? dayOfMonth : -dayOfMonth,
 335                  -dayOfWeek, time, mode, status);
 336 }
 337
 338 // -------------------------------------
 339
 340 /**
 341  * Sets the daylight savings ending rule. For example, in the U.S., Daylight
 342  * Savings Time ends at the last (-1) Sunday in October, at 2 AM in standard time.
 343  * Therefore, you can set the end rule by calling:
 344  * setEndRule(TimeFields.OCTOBER, -1, TimeFields.SUNDAY, 2*60*60*1000);
 345  * Various other types of rules can be specified by manipulating the dayOfWeek
 346  * and dayOfWeekInMonth parameters.  For complete details, see the documentation
 347  * for setStartRule().
 348  * @param month the daylight savings ending month. Month is 0-based.
 349  * eg, 0 for January.
 350  * @param dayOfWeekInMonth the daylight savings ending
 351  * day-of-week-in-month. See setStartRule() for a complete explanation.
 352  * @param dayOfWeek the daylight savings ending day-of-week. See setStartRule()
 353  * for a complete explanation.
 354  * @param time the daylight savings ending time. Please see the member
 355  * description for an example.
 356  */
 357
 358 void
 359 SimpleTimeZone::setEndRule(int32_t month, int32_t dayOfWeekInMonth, int32_t dayOfWeek,
 360                            int32_t time, TimeMode mode, UErrorCode& status)
 361 {
 362     endMonth     = (int8_t)month;
 363     endDay       = (int8_t)dayOfWeekInMonth;
 364     endDayOfWeek = (int8_t)dayOfWeek;
 365     endTime      = time;
 366     endTimeMode  = mode;
 367     decodeEndRule(status);
 368     transitionRulesInitialized = FALSE;
 369 }
 370
 371 // -------------------------------------
 372
 373 void
 374 SimpleTimeZone::setEndRule(int32_t month, int32_t dayOfMonth,
 375                            int32_t time, TimeMode mode, UErrorCode& status)
 376 {
 377     setEndRule(month, dayOfMonth, 0, time, mode, status);
 378 }
 379
 380 // -------------------------------------
 381
 382 void
 383 SimpleTimeZone::setEndRule(int32_t month, int32_t dayOfMonth, int32_t dayOfWeek,
 384                            int32_t time, TimeMode mode, UBool after, UErrorCode& status)
 385 {
 386     setEndRule(month, after ? dayOfMonth : -dayOfMonth,
 387                -dayOfWeek, time, mode, status);
 388 }
 389
 390 // -------------------------------------
 391
 392 int32_t
 393 SimpleTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
 394                           uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const
 395 {
 396     // Check the month before calling Grego::monthLength(). This
 397     // duplicates the test that occurs in the 7-argument getOffset(),
 398     // however, this is unavoidable. We don't mind because this method, in
 399     // fact, should not be called; internal code should always call the
 400     // 7-argument getOffset(), and outside code should use Calendar.get(int
 401     // field) with fields ZONE_OFFSET and DST_OFFSET. We can't get rid of
 402     // this method because it's public API. - liu 8/10/98
 403     if(month < UCAL_JANUARY || month > UCAL_DECEMBER) {
 404         status = U_ILLEGAL_ARGUMENT_ERROR;
 405         return 0;
 406     }
 407
 408     return getOffset(era, year, month, day, dayOfWeek, millis, Grego::monthLength(year, month), status);
 409 }
 410
 411 int32_t
 412 SimpleTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
 413                           uint8_t dayOfWeek, int32_t millis,
 414                           int32_t /*monthLength*/, UErrorCode& status) const
 415 {
 416     // Check the month before calling Grego::monthLength(). This
 417     // duplicates a test that occurs in the 9-argument getOffset(),
 418     // however, this is unavoidable. We don't mind because this method, in
 419     // fact, should not be called; internal code should always call the
 420     // 9-argument getOffset(), and outside code should use Calendar.get(int
 421     // field) with fields ZONE_OFFSET and DST_OFFSET. We can't get rid of
 422     // this method because it's public API. - liu 8/10/98
 423     if (month < UCAL_JANUARY
 424         || month > UCAL_DECEMBER) {
 425         status = U_ILLEGAL_ARGUMENT_ERROR;
 426         return -1;
 427     }
 428
 429     // We ignore monthLength because it can be derived from year and month.
 430     // This is so that February in leap years is calculated correctly.
 431     // We keep this argument in this function for backwards compatibility.
 432     return getOffset(era, year, month, day, dayOfWeek, millis,
 433                      Grego::monthLength(year, month),
 434                      Grego::previousMonthLength(year, month),
 435                      status);
 436 }
 437
 438 int32_t
 439 SimpleTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
 440                           uint8_t dayOfWeek, int32_t millis,
 441                           int32_t monthLength, int32_t prevMonthLength,
 442                           UErrorCode& status) const
 443 {
 444     if(U_FAILURE(status)) return 0;
 445
 446     if ((era != GregorianCalendar::AD && era != GregorianCalendar::BC)
 447         || month < UCAL_JANUARY
 448         || month > UCAL_DECEMBER
 449         || day < 1
 450         || day > monthLength
 451         || dayOfWeek < UCAL_SUNDAY
 452         || dayOfWeek > UCAL_SATURDAY
 453         || millis < 0
 454         || millis >= U_MILLIS_PER_DAY
 455         || monthLength < 28
 456         || monthLength > 31
 457         || prevMonthLength < 28
 458         || prevMonthLength > 31) {
 459         status = U_ILLEGAL_ARGUMENT_ERROR;
 460         return -1;
 461     }
 462
 463     int32_t result = rawOffset;
 464
 465     // Bail out if we are before the onset of daylight savings time
 466     if(!useDaylight || year < startYear || era != GregorianCalendar::AD)
 467         return result;
 468
 469     // Check for southern hemisphere.  We assume that the start and end
 470     // month are different.
 471     UBool southern = (startMonth > endMonth);
 472
 473     // Compare the date to the starting and ending rules.+1 = date>rule, -1
 474     // = date<rule, 0 = date==rule.
 475     int32_t startCompare = compareToRule((int8_t)month, (int8_t)monthLength, (int8_t)prevMonthLength,
 476                                          (int8_t)day, (int8_t)dayOfWeek, millis,
 477                                          startTimeMode == UTC_TIME ? -rawOffset : 0,
 478                                          startMode, (int8_t)startMonth, (int8_t)startDayOfWeek,
 479                                          (int8_t)startDay, startTime);
 480     int32_t endCompare = 0;
 481
 482     /* We don't always have to compute endCompare.  For many instances,
 483      * startCompare is enough to determine if we are in DST or not.  In the
 484      * northern hemisphere, if we are before the start rule, we can't have
 485      * DST.  In the southern hemisphere, if we are after the start rule, we
 486      * must have DST.  This is reflected in the way the next if statement
 487      * (not the one immediately following) short circuits. */
 488     if(southern != (startCompare >= 0)) {
 489         endCompare = compareToRule((int8_t)month, (int8_t)monthLength, (int8_t)prevMonthLength,
 490                                    (int8_t)day, (int8_t)dayOfWeek, millis,
 491                                    endTimeMode == WALL_TIME ? dstSavings :
 492                                     (endTimeMode == UTC_TIME ? -rawOffset : 0),
 493                                    endMode, (int8_t)endMonth, (int8_t)endDayOfWeek,
 494                                    (int8_t)endDay, endTime);
 495     }
 496
 497     // Check for both the northern and southern hemisphere cases.  We
 498     // assume that in the northern hemisphere, the start rule is before the
 499     // end rule within the calendar year, and vice versa for the southern
 500     // hemisphere.
 501     if ((!southern && (startCompare >= 0 && endCompare < 0)) ||
 502         (southern && (startCompare >= 0 || endCompare < 0)))
 503         result += dstSavings;
 504
 505     return result;
 506 }
 507
 508 void
 509 SimpleTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
 510                                    int32_t& rawOffsetGMT, int32_t& savingsDST, UErrorCode& status) const {
 511     if (U_FAILURE(status)) {
 512         return;
 513     }
 514
 515     rawOffsetGMT = getRawOffset();
 516     int32_t year, month, dom, dow;
 517     double day = uprv_floor(date / U_MILLIS_PER_DAY);
 518     int32_t millis = (int32_t) (date - day * U_MILLIS_PER_DAY);
 519
 520     Grego::dayToFields(day, year, month, dom, dow);
 521
 522     savingsDST = getOffset(GregorianCalendar::AD, year, month, dom,
 523                           (uint8_t) dow, millis,
 524                           Grego::monthLength(year, month),
 525                           status) - rawOffsetGMT;
 526     if (U_FAILURE(status)) {
 527         return;
 528     }
 529
 530     UBool recalc = FALSE;
 531
 532     // Now we need some adjustment
 533     if (savingsDST > 0) {
 534         if ((nonExistingTimeOpt & kStdDstMask) == kStandard
 535             || ((nonExistingTimeOpt & kStdDstMask) != kDaylight && (nonExistingTimeOpt & kFormerLatterMask) != kLatter)) {
 536             date -= getDSTSavings();
 537             recalc = TRUE;
 538         }
 539     } else {
 540         if ((duplicatedTimeOpt & kStdDstMask) == kDaylight
 541                 || ((duplicatedTimeOpt & kStdDstMask) != kStandard && (duplicatedTimeOpt & kFormerLatterMask) == kFormer)) {
 542             date -= getDSTSavings();
 543             recalc = TRUE;
 544         }
 545     }
 546     if (recalc) {
 547         day = uprv_floor(date / U_MILLIS_PER_DAY);
 548         millis = (int32_t) (date - day * U_MILLIS_PER_DAY);
 549         Grego::dayToFields(day, year, month, dom, dow);
 550         savingsDST = getOffset(GregorianCalendar::AD, year, month, dom,
 551                           (uint8_t) dow, millis,
 552                           Grego::monthLength(year, month),
 553                           status) - rawOffsetGMT;
 554     }
 555 }
 556
 557 // -------------------------------------
 558
 559 /**
 560  * Compare a given date in the year to a rule. Return 1, 0, or -1, depending
 561  * on whether the date is after, equal to, or before the rule date. The
 562  * millis are compared directly against the ruleMillis, so any
 563  * standard-daylight adjustments must be handled by the caller.
 564  *
 565  * @return  1 if the date is after the rule date, -1 if the date is before
 566  *          the rule date, or 0 if the date is equal to the rule date.
 567  */
 568 int32_t
 569 SimpleTimeZone::compareToRule(int8_t month, int8_t monthLen, int8_t prevMonthLen,
 570                               int8_t dayOfMonth,
 571                               int8_t dayOfWeek, int32_t millis, int32_t millisDelta,
 572                               EMode ruleMode, int8_t ruleMonth, int8_t ruleDayOfWeek,
 573                               int8_t ruleDay, int32_t ruleMillis)
 574 {
 575     // Make adjustments for startTimeMode and endTimeMode
 576     millis += millisDelta;
 577     while (millis >= U_MILLIS_PER_DAY) {
 578         millis -= U_MILLIS_PER_DAY;
 579         ++dayOfMonth;
 580         dayOfWeek = (int8_t)(1 + (dayOfWeek % 7)); // dayOfWeek is one-based
 581         if (dayOfMonth > monthLen) {
 582             dayOfMonth = 1;
 583             /* When incrementing the month, it is desirible to overflow
 584              * from DECEMBER to DECEMBER+1, since we use the result to
 585              * compare against a real month. Wraparound of the value
 586              * leads to bug 4173604. */
 587             ++month;
 588         }
 589     }
 590     while (millis < 0) {
 591         millis += U_MILLIS_PER_DAY;
 592         --dayOfMonth;
 593         dayOfWeek = (int8_t)(1 + ((dayOfWeek+5) % 7)); // dayOfWeek is one-based
 594         if (dayOfMonth < 1) {
 595             dayOfMonth = prevMonthLen;
 596             --month;
 597         }
 598     }
 599
 600     // first compare months.  If they're different, we don't have to worry about days
 601     // and times
 602     if (month < ruleMonth) return -1;
 603     else if (month > ruleMonth) return 1;
 604
 605     // calculate the actual day of month for the rule
 606     int32_t ruleDayOfMonth = 0;
 607
 608     // Adjust the ruleDay to the monthLen, for non-leap year February 29 rule days.
 609     if (ruleDay > monthLen) {
 610         ruleDay = monthLen;
 611     }
 612
 613     switch (ruleMode)
 614     {
 615     // if the mode is day-of-month, the day of month is given
 616     case DOM_MODE:
 617         ruleDayOfMonth = ruleDay;
 618         break;
 619
 620     // if the mode is day-of-week-in-month, calculate the day-of-month from it
 621     case DOW_IN_MONTH_MODE:
 622         // In this case ruleDay is the day-of-week-in-month (this code is using
 623         // the dayOfWeek and dayOfMonth parameters to figure out the day-of-week
 624         // of the first day of the month, so it's trusting that they're really
 625         // consistent with each other)
 626         if (ruleDay > 0)
 627             ruleDayOfMonth = 1 + (ruleDay - 1) * 7 +
 628                 (7 + ruleDayOfWeek - (dayOfWeek - dayOfMonth + 1)) % 7;
 629
 630         // if ruleDay is negative (we assume it's not zero here), we have to do
 631         // the same calculation figuring backward from the last day of the month.
 632         else
 633         {
 634             // (again, this code is trusting that dayOfWeek and dayOfMonth are
 635             // consistent with each other here, since we're using them to figure
 636             // the day of week of the first of the month)
 637             ruleDayOfMonth = monthLen + (ruleDay + 1) * 7 -
 638                 (7 + (dayOfWeek + monthLen - dayOfMonth) - ruleDayOfWeek) % 7;
 639         }
 640         break;
 641
 642     case DOW_GE_DOM_MODE:
 643         ruleDayOfMonth = ruleDay +
 644             (49 + ruleDayOfWeek - ruleDay - dayOfWeek + dayOfMonth) % 7;
 645         break;
 646
 647     case DOW_LE_DOM_MODE:
 648         ruleDayOfMonth = ruleDay -
 649             (49 - ruleDayOfWeek + ruleDay + dayOfWeek - dayOfMonth) % 7;
 650         // Note at this point ruleDayOfMonth may be <1, although it will
 651         // be >=1 for well-formed rules.
 652         break;
 653     }
 654
 655     // now that we have a real day-in-month for the rule, we can compare days...
 656     if (dayOfMonth < ruleDayOfMonth) return -1;
 657     else if (dayOfMonth > ruleDayOfMonth) return 1;
 658
 659     // ...and if they're equal, we compare times
 660     if (millis < ruleMillis) return -1;
 661     else if (millis > ruleMillis) return 1;
 662     else return 0;
 663 }
 664
 665 // -------------------------------------
 666
 667 int32_t
 668 SimpleTimeZone::getRawOffset() const
 669 {
 670     return rawOffset;
 671 }
 672
 673 // -------------------------------------
 674
 675 void
 676 SimpleTimeZone::setRawOffset(int32_t offsetMillis)
 677 {
 678     rawOffset = offsetMillis;
 679     transitionRulesInitialized = FALSE;
 680 }
 681
 682 // -------------------------------------
 683
 684 void
 685 SimpleTimeZone::setDSTSavings(int32_t millisSavedDuringDST, UErrorCode& status)
 686 {
 687     if (millisSavedDuringDST <= 0) {
 688         status = U_ILLEGAL_ARGUMENT_ERROR;
 689     }
 690     else {
 691         dstSavings = millisSavedDuringDST;
 692     }
 693     transitionRulesInitialized = FALSE;
 694 }
 695
 696 // -------------------------------------
 697
 698 int32_t
 699 SimpleTimeZone::getDSTSavings() const
 700 {
 701     return dstSavings;
 702 }
 703
 704 // -------------------------------------
 705
 706 UBool
 707 SimpleTimeZone::useDaylightTime() const
 708 {
 709     return useDaylight;
 710 }
 711
 712 // -------------------------------------
 713
 714 /**
 715  * Overrides TimeZone
 716  * Queries if the given date is in Daylight Savings Time.
 717  */
 718 UBool SimpleTimeZone::inDaylightTime(UDate date, UErrorCode& status) const
 719 {
 720     // This method is wasteful since it creates a new GregorianCalendar and
 721     // deletes it each time it is called.  However, this is a deprecated method
 722     // and provided only for Java compatibility as of 8/6/97 [LIU].
 723     if (U_FAILURE(status)) return FALSE;
 724     GregorianCalendar *gc = new GregorianCalendar(*this, status);
 725     /* test for NULL */
 726     if (gc == 0) {
 727         status = U_MEMORY_ALLOCATION_ERROR;
 728         return FALSE;
 729     }
 730     gc->setTime(date, status);
 731     UBool result = gc->inDaylightTime(status);
 732     delete gc;
 733     return result;
 734 }
 735
 736 // -------------------------------------
 737
 738 /**
 739  * Return true if this zone has the same rules and offset as another zone.
 740  * @param other the TimeZone object to be compared with
 741  * @return true if the given zone has the same rules and offset as this one
 742  */
 743 UBool
 744 SimpleTimeZone::hasSameRules(const TimeZone& other) const
 745 {
 746     if (this == &other) return TRUE;
 747     if (typeid(*this) != typeid(other)) return FALSE;
 748     SimpleTimeZone *that = (SimpleTimeZone*)&other;
 749     return rawOffset     == that->rawOffset &&
 750         useDaylight     == that->useDaylight &&
 751         (!useDaylight
 752          // Only check rules if using DST
 753          || (dstSavings     == that->dstSavings &&
 754              startMode      == that->startMode &&
 755              startMonth     == that->startMonth &&
 756              startDay       == that->startDay &&
 757              startDayOfWeek == that->startDayOfWeek &&
 758              startTime      == that->startTime &&
 759              startTimeMode  == that->startTimeMode &&
 760              endMode        == that->endMode &&
 761              endMonth       == that->endMonth &&
 762              endDay         == that->endDay &&
 763              endDayOfWeek   == that->endDayOfWeek &&
 764              endTime        == that->endTime &&
 765              endTimeMode    == that->endTimeMode &&
 766              startYear      == that->startYear));
 767 }
 768
 769 // -------------------------------------
 770
 771 //----------------------------------------------------------------------
 772 // Rule representation
 773 //
 774 // We represent the following flavors of rules:
 775 //       5        the fifth of the month
 776 //       lastSun  the last Sunday in the month
 777 //       lastMon  the last Monday in the month
 778 //       Sun>=8   first Sunday on or after the eighth
 779 //       Sun<=25  last Sunday on or before the 25th
 780 // This is further complicated by the fact that we need to remain
 781 // backward compatible with the 1.1 FCS.  Finally, we need to minimize
 782 // API changes.  In order to satisfy these requirements, we support
 783 // three representation systems, and we translate between them.
 784 //
 785 // INTERNAL REPRESENTATION
 786 // This is the format SimpleTimeZone objects take after construction or
 787 // streaming in is complete.  Rules are represented directly, using an
 788 // unencoded format.  We will discuss the start rule only below; the end
 789 // rule is analogous.
 790 //   startMode      Takes on enumerated values DAY_OF_MONTH,
 791 //                  DOW_IN_MONTH, DOW_AFTER_DOM, or DOW_BEFORE_DOM.
 792 //   startDay       The day of the month, or for DOW_IN_MONTH mode, a
 793 //                  value indicating which DOW, such as +1 for first,
 794 //                  +2 for second, -1 for last, etc.
 795 //   startDayOfWeek The day of the week.  Ignored for DAY_OF_MONTH.
 796 //
 797 // ENCODED REPRESENTATION
 798 // This is the format accepted by the constructor and by setStartRule()
 799 // and setEndRule().  It uses various combinations of positive, negative,
 800 // and zero values to encode the different rules.  This representation
 801 // allows us to specify all the different rule flavors without altering
 802 // the API.
 803 //   MODE              startMonth    startDay    startDayOfWeek
 804 //   DOW_IN_MONTH_MODE >=0           !=0         >0
 805 //   DOM_MODE          >=0           >0          ==0
 806 //   DOW_GE_DOM_MODE   >=0           >0          <0
 807 //   DOW_LE_DOM_MODE   >=0           <0          <0
 808 //   (no DST)          don't care    ==0         don't care
 809 //
 810 // STREAMED REPRESENTATION
 811 // We must retain binary compatibility with the 1.1 FCS.  The 1.1 code only
 812 // handles DOW_IN_MONTH_MODE and non-DST mode, the latter indicated by the
 813 // flag useDaylight.  When we stream an object out, we translate into an
 814 // approximate DOW_IN_MONTH_MODE representation so the object can be parsed
 815 // and used by 1.1 code.  Following that, we write out the full
 816 // representation separately so that contemporary code can recognize and
 817 // parse it.  The full representation is written in a "packed" format,
 818 // consisting of a version number, a length, and an array of bytes.  Future
 819 // versions of this class may specify different versions.  If they wish to
 820 // include additional data, they should do so by storing them after the
 821 // packed representation below.
 822 //----------------------------------------------------------------------
 823
 824 /**
 825  * Given a set of encoded rules in startDay and startDayOfMonth, decode
 826  * them and set the startMode appropriately.  Do the same for endDay and
 827  * endDayOfMonth.  Upon entry, the day of week variables may be zero or
 828  * negative, in order to indicate special modes.  The day of month
 829  * variables may also be negative.  Upon exit, the mode variables will be
 830  * set, and the day of week and day of month variables will be positive.
 831  * This method also recognizes a startDay or endDay of zero as indicating
 832  * no DST.
 833  */
 834 void
 835 SimpleTimeZone::decodeRules(UErrorCode& status)
 836 {
 837     decodeStartRule(status);
 838     decodeEndRule(status);
 839 }
 840
 841 /**
 842  * Decode the start rule and validate the parameters.  The parameters are
 843  * expected to be in encoded form, which represents the various rule modes
 844  * by negating or zeroing certain values.  Representation formats are:
 845  * <p>
 846  * <pre>
 847  *            DOW_IN_MONTH  DOM    DOW>=DOM  DOW<=DOM  no DST
 848  *            ------------  -----  --------  --------  ----------
 849  * month       0..11        same    same      same     don't care
 850  * day        -5..5         1..31   1..31    -1..-31   0
 851  * dayOfWeek   1..7         0      -1..-7    -1..-7    don't care
 852  * time        0..ONEDAY    same    same      same     don't care
 853  * </pre>
 854  * The range for month does not include UNDECIMBER since this class is
 855  * really specific to GregorianCalendar, which does not use that month.
 856  * The range for time includes ONEDAY (vs. ending at ONEDAY-1) because the
 857  * end rule is an exclusive limit point.  That is, the range of times that
 858  * are in DST include those >= the start and < the end.  For this reason,
 859  * it should be possible to specify an end of ONEDAY in order to include the
 860  * entire day.  Although this is equivalent to time 0 of the following day,
 861  * it's not always possible to specify that, for example, on December 31.
 862  * While arguably the start range should still be 0..ONEDAY-1, we keep
 863  * the start and end ranges the same for consistency.
 864  */
 865 void
 866 SimpleTimeZone::decodeStartRule(UErrorCode& status)
 867 {
 868     if(U_FAILURE(status)) return;
 869
 870     useDaylight = (UBool)((startDay != 0) && (endDay != 0) ? TRUE : FALSE);
 871     if (useDaylight && dstSavings == 0) {
 872         dstSavings = U_MILLIS_PER_HOUR;
 873     }
 874     if (startDay != 0) {
 875         if (startMonth < UCAL_JANUARY || startMonth > UCAL_DECEMBER) {
 876             status = U_ILLEGAL_ARGUMENT_ERROR;
 877             return;
 878         }
 879         if (startTime < 0 || startTime > U_MILLIS_PER_DAY ||
 880             startTimeMode < WALL_TIME || startTimeMode > UTC_TIME) {
 881             status = U_ILLEGAL_ARGUMENT_ERROR;
 882             return;
 883         }
 884         if (startDayOfWeek == 0) {
 885             startMode = DOM_MODE;
 886         } else {
 887             if (startDayOfWeek > 0) {
 888                 startMode = DOW_IN_MONTH_MODE;
 889             } else {
 890                 startDayOfWeek = (int8_t)-startDayOfWeek;
 891                 if (startDay > 0) {
 892                     startMode = DOW_GE_DOM_MODE;
 893                 } else {
 894                     startDay = (int8_t)-startDay;
 895                     startMode = DOW_LE_DOM_MODE;
 896                 }
 897             }
 898             if (startDayOfWeek > UCAL_SATURDAY) {
 899                 status = U_ILLEGAL_ARGUMENT_ERROR;
 900                 return;
 901             }
 902         }
 903         if (startMode == DOW_IN_MONTH_MODE) {
 904             if (startDay < -5 || startDay > 5) {
 905                 status = U_ILLEGAL_ARGUMENT_ERROR;
 906                 return;
 907             }
 908         } else if (startDay<1 || startDay > STATICMONTHLENGTH[startMonth]) {
 909             status = U_ILLEGAL_ARGUMENT_ERROR;
 910             return;
 911         }
 912     }
 913 }
 914
 915 /**
 916  * Decode the end rule and validate the parameters.  This method is exactly
 917  * analogous to decodeStartRule().
 918  * @see decodeStartRule
 919  */
 920 void
 921 SimpleTimeZone::decodeEndRule(UErrorCode& status)
 922 {
 923     if(U_FAILURE(status)) return;
 924
 925     useDaylight = (UBool)((startDay != 0) && (endDay != 0) ? TRUE : FALSE);
 926     if (useDaylight && dstSavings == 0) {
 927         dstSavings = U_MILLIS_PER_HOUR;
 928     }
 929     if (endDay != 0) {
 930         if (endMonth < UCAL_JANUARY || endMonth > UCAL_DECEMBER) {
 931             status = U_ILLEGAL_ARGUMENT_ERROR;
 932             return;
 933         }
 934         if (endTime < 0 || endTime > U_MILLIS_PER_DAY ||
 935             endTimeMode < WALL_TIME || endTimeMode > UTC_TIME) {
 936             status = U_ILLEGAL_ARGUMENT_ERROR;
 937             return;
 938         }
 939         if (endDayOfWeek == 0) {
 940             endMode = DOM_MODE;
 941         } else {
 942             if (endDayOfWeek > 0) {
 943                 endMode = DOW_IN_MONTH_MODE;
 944             } else {
 945                 endDayOfWeek = (int8_t)-endDayOfWeek;
 946                 if (endDay > 0) {
 947                     endMode = DOW_GE_DOM_MODE;
 948                 } else {
 949                     endDay = (int8_t)-endDay;
 950                     endMode = DOW_LE_DOM_MODE;
 951                 }
 952             }
 953             if (endDayOfWeek > UCAL_SATURDAY) {
 954                 status = U_ILLEGAL_ARGUMENT_ERROR;
 955                 return;
 956             }
 957         }
 958         if (endMode == DOW_IN_MONTH_MODE) {
 959             if (endDay < -5 || endDay > 5) {
 960                 status = U_ILLEGAL_ARGUMENT_ERROR;
 961                 return;
 962             }
 963         } else if (endDay<1 || endDay > STATICMONTHLENGTH[endMonth]) {
 964             status = U_ILLEGAL_ARGUMENT_ERROR;
 965             return;
 966         }
 967     }
 968 }
 969
 970 UBool
 971 SimpleTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
 972     if (!useDaylight) {
 973         return FALSE;
 974     }
 975
 976     UErrorCode status = U_ZERO_ERROR;
 977     checkTransitionRules(status);
 978     if (U_FAILURE(status)) {
 979         return FALSE;
 980     }
 981
 982     UDate firstTransitionTime = firstTransition->getTime();
 983     if (base < firstTransitionTime || (inclusive && base == firstTransitionTime)) {
 984         result = *firstTransition;
 985     }
 986     UDate stdDate, dstDate;
 987     UBool stdAvail = stdRule->getNextStart(base, dstRule->getRawOffset(), dstRule->getDSTSavings(), inclusive, stdDate);
 988     UBool dstAvail = dstRule->getNextStart(base, stdRule->getRawOffset(), stdRule->getDSTSavings(), inclusive, dstDate);
 989     if (stdAvail && (!dstAvail || stdDate < dstDate)) {
 990         result.setTime(stdDate);
 991         result.setFrom((const TimeZoneRule&)*dstRule);
 992         result.setTo((const TimeZoneRule&)*stdRule);
 993         return TRUE;
 994     }
 995     if (dstAvail && (!stdAvail || dstDate < stdDate)) {
 996         result.setTime(dstDate);
 997         result.setFrom((const TimeZoneRule&)*stdRule);
 998         result.setTo((const TimeZoneRule&)*dstRule);
 999         return TRUE;
1000     }
1001     return FALSE;
1002 }
1003
1004 UBool
1005 SimpleTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
1006     if (!useDaylight) {
1007         return FALSE;
1008     }
1009
1010     UErrorCode status = U_ZERO_ERROR;
1011     checkTransitionRules(status);
1012     if (U_FAILURE(status)) {
1013         return FALSE;
1014     }
1015
1016     UDate firstTransitionTime = firstTransition->getTime();
1017     if (base < firstTransitionTime || (!inclusive && base == firstTransitionTime)) {
1018         return FALSE;
1019     }
1020     UDate stdDate, dstDate;
1021     UBool stdAvail = stdRule->getPreviousStart(base, dstRule->getRawOffset(), dstRule->getDSTSavings(), inclusive, stdDate);
1022     UBool dstAvail = dstRule->getPreviousStart(base, stdRule->getRawOffset(), stdRule->getDSTSavings(), inclusive, dstDate);
1023     if (stdAvail && (!dstAvail || stdDate > dstDate)) {
1024         result.setTime(stdDate);
1025         result.setFrom((const TimeZoneRule&)*dstRule);
1026         result.setTo((const TimeZoneRule&)*stdRule);
1027         return TRUE;
1028     }
1029     if (dstAvail && (!stdAvail || dstDate > stdDate)) {
1030         result.setTime(dstDate);
1031         result.setFrom((const TimeZoneRule&)*stdRule);
1032         result.setTo((const TimeZoneRule&)*dstRule);
1033         return TRUE;
1034     }
1035     return FALSE;
1036 }
1037
1038 void
1039 SimpleTimeZone::clearTransitionRules(void) {
1040     initialRule = NULL;
1041     firstTransition = NULL;
1042     stdRule = NULL;
1043     dstRule = NULL;
1044     transitionRulesInitialized = FALSE;
1045 }
1046
1047 void
1048 SimpleTimeZone::deleteTransitionRules(void) {
1049     if (initialRule != NULL) {
1050         delete initialRule;
1051     }
1052     if (firstTransition != NULL) {
1053         delete firstTransition;
1054     }
1055     if (stdRule != NULL) {
1056         delete stdRule;
1057     }
1058     if (dstRule != NULL) {
1059         delete dstRule;
1060     }
1061     clearTransitionRules();
1062  }
1063
1064 /*
1065  * Lazy transition rules initializer
1066  *
1067  *    Note On the removal of UMTX_CHECK from checkTransitionRules():
1068  *
1069  *         It would be faster to have a UInitOnce as part of a SimpleTimeZone object,
1070  *         which would avoid needing to lock a mutex to check the initialization state.
1071  *         But we can't easily because simpletz.h is a public header, and including
1072  *         a UInitOnce as a member of SimpleTimeZone would publicly expose internal ICU headers.
1073  *
1074  *         Alternatively we could have a pointer to a UInitOnce in the SimpleTimeZone object,
1075  *         allocate it in the constructors. This would be a more intrusive change, but doable
1076  *         if performance turns out to be an issue.
1077  */
1078 static UMutex gLock = U_MUTEX_INITIALIZER;
1079
1080 void
1081 SimpleTimeZone::checkTransitionRules(UErrorCode& status) const {
1082     if (U_FAILURE(status)) {
1083         return;
1084     }
1085     umtx_lock(&gLock);
1086     if (!transitionRulesInitialized) {
1087         SimpleTimeZone *ncThis = const_cast<SimpleTimeZone*>(this);
1088         ncThis->initTransitionRules(status);
1089     }
1090     umtx_unlock(&gLock);
1091 }
1092
1093 void
1094 SimpleTimeZone::initTransitionRules(UErrorCode& status) {
1095     if (U_FAILURE(status)) {
1096         return;
1097     }
1098     if (transitionRulesInitialized) {
1099         return;
1100     }
1101     deleteTransitionRules();
1102     UnicodeString tzid;
1103     getID(tzid);
1104
1105     if (useDaylight) {
1106         DateTimeRule* dtRule;
1107         DateTimeRule::TimeRuleType timeRuleType;
1108         UDate firstStdStart, firstDstStart;
1109
1110         // Create a TimeZoneRule for daylight saving time
1111         timeRuleType = (startTimeMode == STANDARD_TIME) ? DateTimeRule::STANDARD_TIME :
1112             ((startTimeMode == UTC_TIME) ? DateTimeRule::UTC_TIME : DateTimeRule::WALL_TIME);
1113         switch (startMode) {
1114         case DOM_MODE:
1115             dtRule = new DateTimeRule(startMonth, startDay, startTime, timeRuleType);
1116             break;
1117         case DOW_IN_MONTH_MODE:
1118             dtRule = new DateTimeRule(startMonth, startDay, startDayOfWeek, startTime, timeRuleType);
1119             break;
1120         case DOW_GE_DOM_MODE:
1121             dtRule = new DateTimeRule(startMonth, startDay, startDayOfWeek, true, startTime, timeRuleType);
1122             break;
1123         case DOW_LE_DOM_MODE:
1124             dtRule = new DateTimeRule(startMonth, startDay, startDayOfWeek, false, startTime, timeRuleType);
1125             break;
1126         default:
1127             status = U_INVALID_STATE_ERROR;
1128             return;
1129         }
1130         // Check for Null pointer
1131         if (dtRule == NULL) {
1132             status = U_MEMORY_ALLOCATION_ERROR;
1133             return;
1134         }
1135         // For now, use ID + "(DST)" as the name
1136         dstRule = new AnnualTimeZoneRule(tzid+UnicodeString(DST_STR), getRawOffset(), getDSTSavings(),
1137             dtRule, startYear, AnnualTimeZoneRule::MAX_YEAR);
1138
1139         // Check for Null pointer
1140         if (dstRule == NULL) {
1141             status = U_MEMORY_ALLOCATION_ERROR;
1142             deleteTransitionRules();
1143             return;
1144         }
1145
1146         // Calculate the first DST start time
1147         dstRule->getFirstStart(getRawOffset(), 0, firstDstStart);
1148
1149         // Create a TimeZoneRule for standard time
1150         timeRuleType = (endTimeMode == STANDARD_TIME) ? DateTimeRule::STANDARD_TIME :
1151             ((endTimeMode == UTC_TIME) ? DateTimeRule::UTC_TIME : DateTimeRule::WALL_TIME);
1152         switch (endMode) {
1153         case DOM_MODE:
1154             dtRule = new DateTimeRule(endMonth, endDay, endTime, timeRuleType);
1155             break;
1156         case DOW_IN_MONTH_MODE:
1157             dtRule = new DateTimeRule(endMonth, endDay, endDayOfWeek, endTime, timeRuleType);
1158             break;
1159         case DOW_GE_DOM_MODE:
1160             dtRule = new DateTimeRule(endMonth, endDay, endDayOfWeek, true, endTime, timeRuleType);
1161             break;
1162         case DOW_LE_DOM_MODE:
1163             dtRule = new DateTimeRule(endMonth, endDay, endDayOfWeek, false, endTime, timeRuleType);
1164             break;
1165         }
1166
1167         // Check for Null pointer
1168         if (dtRule == NULL) {
1169             status = U_MEMORY_ALLOCATION_ERROR;
1170             deleteTransitionRules();
1171             return;
1172         }
1173         // For now, use ID + "(STD)" as the name
1174         stdRule = new AnnualTimeZoneRule(tzid+UnicodeString(STD_STR), getRawOffset(), 0,
1175             dtRule, startYear, AnnualTimeZoneRule::MAX_YEAR);
1176
1177         //Check for Null pointer
1178         if (stdRule == NULL) {
1179             status = U_MEMORY_ALLOCATION_ERROR;
1180             deleteTransitionRules();
1181             return;
1182         }
1183
1184         // Calculate the first STD start time
1185         stdRule->getFirstStart(getRawOffset(), dstRule->getDSTSavings(), firstStdStart);
1186
1187         // Create a TimeZoneRule for initial time
1188         if (firstStdStart < firstDstStart) {
1189             initialRule = new InitialTimeZoneRule(tzid+UnicodeString(DST_STR), getRawOffset(), dstRule->getDSTSavings());
1190             firstTransition = new TimeZoneTransition(firstStdStart, *initialRule, *stdRule);
1191         } else {
1192             initialRule = new InitialTimeZoneRule(tzid+UnicodeString(STD_STR), getRawOffset(), 0);
1193             firstTransition = new TimeZoneTransition(firstDstStart, *initialRule, *dstRule);
1194         }
1195         // Check for null pointers.
1196         if (initialRule == NULL || firstTransition == NULL) {
1197             status = U_MEMORY_ALLOCATION_ERROR;
1198             deleteTransitionRules();
1199             return;
1200         }
1201
1202     } else {
1203         // Create a TimeZoneRule for initial time
1204         initialRule = new InitialTimeZoneRule(tzid, getRawOffset(), 0);
1205         // Check for null pointer.
1206         if (initialRule == NULL) {
1207             status = U_MEMORY_ALLOCATION_ERROR;
1208             deleteTransitionRules();
1209             return;
1210         }
1211     }
1212
1213     transitionRulesInitialized = TRUE;
1214 }
1215
1216 int32_t
1217 SimpleTimeZone::countTransitionRules(UErrorCode& /*status*/) const {
1218     return (useDaylight) ? 2 : 0;
1219 }
1220
1221 void
1222 SimpleTimeZone::getTimeZoneRules(const InitialTimeZoneRule*& initial,
1223                                  const TimeZoneRule* trsrules[],
1224                                  int32_t& trscount,
1225                                  UErrorCode& status) const {
1226     if (U_FAILURE(status)) {
1227         return;
1228     }
1229     checkTransitionRules(status);
1230     if (U_FAILURE(status)) {
1231         return;
1232     }
1233     initial = initialRule;
1234     int32_t cnt = 0;
1235     if (stdRule != NULL) {
1236         if (cnt < trscount) {
1237             trsrules[cnt++] = stdRule;
1238         }
1239         if (cnt < trscount) {
1240             trsrules[cnt++] = dstRule;
1241         }
1242     }
1243     trscount = cnt;
1244 }
1245
1246
1247 U_NAMESPACE_END
1248
1249 #endif /* #if !UCONFIG_NO_FORMATTING */
1250
1251 //eof