icuSources/i18n/simpletz.cpp

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