The Tor Browser / file revision

 /*

  *******************************************************************************

  * Copyright (C) 1997-2013, International Business Machines Corporation and

  * others. All Rights Reserved.

  *******************************************************************************

  *

  * File SIMPLETZ.H

  *

  * Modification History:

  *

  *   Date        Name        Description

  *   12/05/96    clhuang     Creation.

  *   04/21/97    aliu        Fixed miscellaneous bugs found by inspection and

  *                           testing.

  *   07/29/97    aliu        Ported source bodies back from Java version with

  *                           numerous feature enhancements and bug fixes.

  *   08/10/98    stephen     JDK 1.2 sync.

  *   09/17/98    stephen     Fixed getOffset() for last hour of year and DST

  *   12/02/99    aliu        Added TimeMode and constructor and setStart/EndRule

  *                           methods that take TimeMode. Whitespace cleanup.

  ********************************************************************************

  */

 #include "utypeinfo.h"  // for 'typeid' to work

 #include "unicode/utypes.h"

 #if !UCONFIG_NO_FORMATTING

 #include "unicode/simpletz.h"

 #include "unicode/gregocal.h"

 #include "unicode/smpdtfmt.h"

 #include "gregoimp.h"

 #include "umutex.h"

 U_NAMESPACE_BEGIN

 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SimpleTimeZone)

 // Use only for decodeStartRule() and decodeEndRule() where the year is not

 // available. Set February to 29 days to accomodate rules with that date

 // and day-of-week-on-or-before-that-date mode (DOW_LE_DOM_MODE).

 // The compareToRule() method adjusts to February 28 in non-leap years.

 //

 // For actual getOffset() calculations, use Grego::monthLength() and

 // Grego::previousMonthLength() which take leap years into account.

 // We handle leap years assuming always

 // Gregorian, since we know they didn't have daylight time when

 // Gregorian calendar started.

 const int8_t SimpleTimeZone::STATICMONTHLENGTH[] = {31,29,31,30,31,30,31,31,30,31,30,31};

 static const UChar DST_STR[] = {0x0028,0x0044,0x0053,0x0054,0x0029,0}; // "(DST)"

 static const UChar STD_STR[] = {0x0028,0x0053,0x0054,0x0044,0x0029,0}; // "(STD)"

 // *****************************************************************************

 // class SimpleTimeZone

 // *****************************************************************************

 SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID)

 :   BasicTimeZone(ID),

     startMonth(0),

     startDay(0),

     startDayOfWeek(0),

     startTime(0),

     startTimeMode(WALL_TIME),

     endTimeMode(WALL_TIME),

     endMonth(0),

     endDay(0),

     endDayOfWeek(0),

     endTime(0),

     startYear(0),

     rawOffset(rawOffsetGMT),

     useDaylight(FALSE),

     startMode(DOM_MODE),

     endMode(DOM_MODE),

     dstSavings(U_MILLIS_PER_HOUR)

 {

     clearTransitionRules();

 }

 // -------------------------------------

 SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID,

     int8_t savingsStartMonth, int8_t savingsStartDay,

     int8_t savingsStartDayOfWeek, int32_t savingsStartTime,

     int8_t savingsEndMonth, int8_t savingsEndDay,

     int8_t savingsEndDayOfWeek, int32_t savingsEndTime,

     UErrorCode& status)

 :   BasicTimeZone(ID)

 {

     clearTransitionRules();

     construct(rawOffsetGMT,

               savingsStartMonth, savingsStartDay, savingsStartDayOfWeek,

               savingsStartTime, WALL_TIME,

               savingsEndMonth, savingsEndDay, savingsEndDayOfWeek,

               savingsEndTime, WALL_TIME,

               U_MILLIS_PER_HOUR, status);

 }

 // -------------------------------------

 SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID,

     int8_t savingsStartMonth, int8_t savingsStartDay,

     int8_t savingsStartDayOfWeek, int32_t savingsStartTime,

     int8_t savingsEndMonth, int8_t savingsEndDay,

     int8_t savingsEndDayOfWeek, int32_t savingsEndTime,

     int32_t savingsDST, UErrorCode& status)

 :   BasicTimeZone(ID)

 {

     clearTransitionRules();

     construct(rawOffsetGMT,

               savingsStartMonth, savingsStartDay, savingsStartDayOfWeek,

               savingsStartTime, WALL_TIME,

               savingsEndMonth, savingsEndDay, savingsEndDayOfWeek,

               savingsEndTime, WALL_TIME,

               savingsDST, status);

 }

 // -------------------------------------

 SimpleTimeZone::SimpleTimeZone(int32_t rawOffsetGMT, const UnicodeString& ID,

     int8_t savingsStartMonth, int8_t savingsStartDay,

     int8_t savingsStartDayOfWeek, int32_t savingsStartTime,

     TimeMode savingsStartTimeMode,

     int8_t savingsEndMonth, int8_t savingsEndDay,

     int8_t savingsEndDayOfWeek, int32_t savingsEndTime,

     TimeMode savingsEndTimeMode,

     int32_t savingsDST, UErrorCode& status)

 :   BasicTimeZone(ID)

 {

     clearTransitionRules();

     construct(rawOffsetGMT,

               savingsStartMonth, savingsStartDay, savingsStartDayOfWeek,

               savingsStartTime, savingsStartTimeMode,

               savingsEndMonth, savingsEndDay, savingsEndDayOfWeek,

               savingsEndTime, savingsEndTimeMode,

               savingsDST, status);

 }

 /**

  * Internal construction method.

  */

 void SimpleTimeZone::construct(int32_t rawOffsetGMT,

                                int8_t savingsStartMonth,

                                int8_t savingsStartDay,

                                int8_t savingsStartDayOfWeek,

                                int32_t savingsStartTime,

                                TimeMode savingsStartTimeMode,

                                int8_t savingsEndMonth,

                                int8_t savingsEndDay,

                                int8_t savingsEndDayOfWeek,

                                int32_t savingsEndTime,

                                TimeMode savingsEndTimeMode,

                                int32_t savingsDST,

                                UErrorCode& status)

 {

     this->rawOffset      = rawOffsetGMT;

     this->startMonth     = savingsStartMonth;

     this->startDay       = savingsStartDay;

     this->startDayOfWeek = savingsStartDayOfWeek;

     this->startTime      = savingsStartTime;

     this->startTimeMode  = savingsStartTimeMode;

     this->endMonth       = savingsEndMonth;

     this->endDay         = savingsEndDay;

     this->endDayOfWeek   = savingsEndDayOfWeek;

     this->endTime        = savingsEndTime;

     this->endTimeMode    = savingsEndTimeMode;

     this->dstSavings     = savingsDST;

     this->startYear      = 0;

     this->startMode      = DOM_MODE;

     this->endMode        = DOM_MODE;

     decodeRules(status);

     if (savingsDST <= 0) {

         status = U_ILLEGAL_ARGUMENT_ERROR;

     }

 }

 // -------------------------------------

 SimpleTimeZone::~SimpleTimeZone()

 {

     deleteTransitionRules();

 }

 // -------------------------------------

 // Called by TimeZone::createDefault(), then clone() inside a Mutex - be careful.

 SimpleTimeZone::SimpleTimeZone(const SimpleTimeZone &source)

 :   BasicTimeZone(source)

 {

     *this = source;

 }

 // -------------------------------------

 // Called by TimeZone::createDefault(), then clone() inside a Mutex - be careful.

 SimpleTimeZone &

 SimpleTimeZone::operator=(const SimpleTimeZone &right)

 {

     if (this != &right)

     {

         TimeZone::operator=(right);

         rawOffset      = right.rawOffset;

         startMonth     = right.startMonth;

         startDay       = right.startDay;

         startDayOfWeek = right.startDayOfWeek;

         startTime      = right.startTime;

         startTimeMode  = right.startTimeMode;

         startMode      = right.startMode;

         endMonth       = right.endMonth;

         endDay         = right.endDay;

         endDayOfWeek   = right.endDayOfWeek;

         endTime        = right.endTime;

         endTimeMode    = right.endTimeMode;

         endMode        = right.endMode;

         startYear      = right.startYear;

         dstSavings     = right.dstSavings;

         useDaylight    = right.useDaylight;

         clearTransitionRules();

     }

     return *this;

 }

 // -------------------------------------

 UBool

 SimpleTimeZone::operator==(const TimeZone& that) const

 {

     return ((this == &that) ||

             (typeid(*this) == typeid(that) &&

             TimeZone::operator==(that) &&

             hasSameRules(that)));

 }

 // -------------------------------------

 // Called by TimeZone::createDefault() inside a Mutex - be careful.

 TimeZone*

 SimpleTimeZone::clone() const

 {

     return new SimpleTimeZone(*this);

 }

 // -------------------------------------

 /**

  * Sets the daylight savings starting year, that is, the year this time zone began

  * observing its specified daylight savings time rules.  The time zone is considered

  * not to observe daylight savings time prior to that year; SimpleTimeZone doesn't

  * support historical daylight-savings-time rules.

  * @param year the daylight savings starting year.

  */

 void

 SimpleTimeZone::setStartYear(int32_t year)

 {

     startYear = year;

     transitionRulesInitialized = FALSE;

 }

 // -------------------------------------

 /**

  * Sets the daylight savings starting rule. For example, in the U.S., Daylight Savings

  * Time starts at the first Sunday in April, at 2 AM in standard time.

  * Therefore, you can set the start rule by calling:

  * setStartRule(TimeFields.APRIL, 1, TimeFields.SUNDAY, 2*60*60*1000);

  * The dayOfWeekInMonth and dayOfWeek parameters together specify how to calculate

  * the exact starting date.  Their exact meaning depend on their respective signs,

  * allowing various types of rules to be constructed, as follows:<ul>

  *   <li>If both dayOfWeekInMonth and dayOfWeek are positive, they specify the

  *       day of week in the month (e.g., (2, WEDNESDAY) is the second Wednesday

  *       of the month).

  *   <li>If dayOfWeek is positive and dayOfWeekInMonth is negative, they specify

  *       the day of week in the month counting backward from the end of the month.

  *       (e.g., (-1, MONDAY) is the last Monday in the month)

  *   <li>If dayOfWeek is zero and dayOfWeekInMonth is positive, dayOfWeekInMonth

  *       specifies the day of the month, regardless of what day of the week it is.

  *       (e.g., (10, 0) is the tenth day of the month)

  *   <li>If dayOfWeek is zero and dayOfWeekInMonth is negative, dayOfWeekInMonth

  *       specifies the day of the month counting backward from the end of the

  *       month, regardless of what day of the week it is (e.g., (-2, 0) is the

  *       next-to-last day of the month).

  *   <li>If dayOfWeek is negative and dayOfWeekInMonth is positive, they specify the

  *       first specified day of the week on or after the specfied day of the month.

  *       (e.g., (15, -SUNDAY) is the first Sunday after the 15th of the month

  *       [or the 15th itself if the 15th is a Sunday].)

  *   <li>If dayOfWeek and DayOfWeekInMonth are both negative, they specify the

  *       last specified day of the week on or before the specified day of the month.

  *       (e.g., (-20, -TUESDAY) is the last Tuesday before the 20th of the month

  *       [or the 20th itself if the 20th is a Tuesday].)</ul>

  * @param month the daylight savings starting month. Month is 0-based.

  * eg, 0 for January.

  * @param dayOfWeekInMonth the daylight savings starting

  * day-of-week-in-month. Please see the member description for an example.

  * @param dayOfWeek the daylight savings starting day-of-week. Please see

  * the member description for an example.

  * @param time the daylight savings starting time. Please see the member

  * description for an example.

  */

 void

 SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfWeekInMonth, int32_t dayOfWeek,

                              int32_t time, TimeMode mode, UErrorCode& status)

 {

     startMonth     = (int8_t)month;

     startDay       = (int8_t)dayOfWeekInMonth;

     startDayOfWeek = (int8_t)dayOfWeek;

     startTime      = time;

     startTimeMode  = mode;

     decodeStartRule(status);

     transitionRulesInitialized = FALSE;

 }

 // -------------------------------------

 void 

 SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfMonth, 

                              int32_t time, TimeMode mode, UErrorCode& status) 

 {

     setStartRule(month, dayOfMonth, 0, time, mode, status);

 }

 // -------------------------------------

 void 

 SimpleTimeZone::setStartRule(int32_t month, int32_t dayOfMonth, int32_t dayOfWeek, 

                              int32_t time, TimeMode mode, UBool after, UErrorCode& status)

 {

     setStartRule(month, after ? dayOfMonth : -dayOfMonth,

                  -dayOfWeek, time, mode, status);

 }

 // -------------------------------------

 /**

  * Sets the daylight savings ending rule. For example, in the U.S., Daylight

  * Savings Time ends at the last (-1) Sunday in October, at 2 AM in standard time.

  * Therefore, you can set the end rule by calling:

  * setEndRule(TimeFields.OCTOBER, -1, TimeFields.SUNDAY, 2*60*60*1000);

  * Various other types of rules can be specified by manipulating the dayOfWeek

  * and dayOfWeekInMonth parameters.  For complete details, see the documentation

  * for setStartRule().

  * @param month the daylight savings ending month. Month is 0-based.

  * eg, 0 for January.

  * @param dayOfWeekInMonth the daylight savings ending

  * day-of-week-in-month. See setStartRule() for a complete explanation.

  * @param dayOfWeek the daylight savings ending day-of-week. See setStartRule()

  * for a complete explanation.

  * @param time the daylight savings ending time. Please see the member

  * description for an example.

  */

 void

 SimpleTimeZone::setEndRule(int32_t month, int32_t dayOfWeekInMonth, int32_t dayOfWeek,

                            int32_t time, TimeMode mode, UErrorCode& status)

 {

     endMonth     = (int8_t)month;

     endDay       = (int8_t)dayOfWeekInMonth;

     endDayOfWeek = (int8_t)dayOfWeek;

     endTime      = time;

     endTimeMode  = mode;

     decodeEndRule(status);

     transitionRulesInitialized = FALSE;

 }

 // -------------------------------------

 void 

 SimpleTimeZone::setEndRule(int32_t month, int32_t dayOfMonth, 

                            int32_t time, TimeMode mode, UErrorCode& status)

 {

     setEndRule(month, dayOfMonth, 0, time, mode, status);

 }

 // -------------------------------------

 void 

 SimpleTimeZone::setEndRule(int32_t month, int32_t dayOfMonth, int32_t dayOfWeek, 

                            int32_t time, TimeMode mode, UBool after, UErrorCode& status)

 {

     setEndRule(month, after ? dayOfMonth : -dayOfMonth,

                -dayOfWeek, time, mode, status);

 }

 // -------------------------------------

 int32_t

 SimpleTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,

                           uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const

 {

     // Check the month before calling Grego::monthLength(). This

     // duplicates the test that occurs in the 7-argument getOffset(),

     // however, this is unavoidable. We don't mind because this method, in

     // fact, should not be called; internal code should always call the

     // 7-argument getOffset(), and outside code should use Calendar.get(int

     // field) with fields ZONE_OFFSET and DST_OFFSET. We can't get rid of

     // this method because it's public API. - liu 8/10/98

     if(month < UCAL_JANUARY || month > UCAL_DECEMBER) {

         status = U_ILLEGAL_ARGUMENT_ERROR;

         return 0;

     }

     return getOffset(era, year, month, day, dayOfWeek, millis, Grego::monthLength(year, month), status);

 }

 int32_t 

 SimpleTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,

                           uint8_t dayOfWeek, int32_t millis, 

                           int32_t /*monthLength*/, UErrorCode& status) const

 {

     // Check the month before calling Grego::monthLength(). This

     // duplicates a test that occurs in the 9-argument getOffset(),

     // however, this is unavoidable. We don't mind because this method, in

     // fact, should not be called; internal code should always call the

     // 9-argument getOffset(), and outside code should use Calendar.get(int

     // field) with fields ZONE_OFFSET and DST_OFFSET. We can't get rid of

     // this method because it's public API. - liu 8/10/98

     if (month < UCAL_JANUARY

         || month > UCAL_DECEMBER) {

         status = U_ILLEGAL_ARGUMENT_ERROR;

         return -1;

     }

     // We ignore monthLength because it can be derived from year and month.

     // This is so that February in leap years is calculated correctly.

     // We keep this argument in this function for backwards compatibility.

     return getOffset(era, year, month, day, dayOfWeek, millis,

                      Grego::monthLength(year, month),

                      Grego::previousMonthLength(year, month),

                      status);

 }

 int32_t 

 SimpleTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,

                           uint8_t dayOfWeek, int32_t millis, 

                           int32_t monthLength, int32_t prevMonthLength,

                           UErrorCode& status) const

 {

     if(U_FAILURE(status)) return 0;

     if ((era != GregorianCalendar::AD && era != GregorianCalendar::BC)

         || month < UCAL_JANUARY

         || month > UCAL_DECEMBER

         || day < 1

         || day > monthLength

         || dayOfWeek < UCAL_SUNDAY

         || dayOfWeek > UCAL_SATURDAY

         || millis < 0

         || millis >= U_MILLIS_PER_DAY

         || monthLength < 28

         || monthLength > 31

         || prevMonthLength < 28

         || prevMonthLength > 31) {

         status = U_ILLEGAL_ARGUMENT_ERROR;

         return -1;

     }

     int32_t result = rawOffset;

     // Bail out if we are before the onset of daylight savings time

     if(!useDaylight || year < startYear || era != GregorianCalendar::AD) 

         return result;

     // Check for southern hemisphere.  We assume that the start and end

     // month are different.

     UBool southern = (startMonth > endMonth);

     // Compare the date to the starting and ending rules.+1 = date>rule, -1

     // = date<rule, 0 = date==rule.

     int32_t startCompare = compareToRule((int8_t)month, (int8_t)monthLength, (int8_t)prevMonthLength,

                                          (int8_t)day, (int8_t)dayOfWeek, millis,

                                          startTimeMode == UTC_TIME ? -rawOffset : 0,

                                          startMode, (int8_t)startMonth, (int8_t)startDayOfWeek,

                                          (int8_t)startDay, startTime);

     int32_t endCompare = 0;

     /* We don't always have to compute endCompare.  For many instances,

      * startCompare is enough to determine if we are in DST or not.  In the

      * northern hemisphere, if we are before the start rule, we can't have

      * DST.  In the southern hemisphere, if we are after the start rule, we

      * must have DST.  This is reflected in the way the next if statement

      * (not the one immediately following) short circuits. */

     if(southern != (startCompare >= 0)) {

         endCompare = compareToRule((int8_t)month, (int8_t)monthLength, (int8_t)prevMonthLength,

                                    (int8_t)day, (int8_t)dayOfWeek, millis,

                                    endTimeMode == WALL_TIME ? dstSavings :

                                     (endTimeMode == UTC_TIME ? -rawOffset : 0),

                                    endMode, (int8_t)endMonth, (int8_t)endDayOfWeek,

                                    (int8_t)endDay, endTime);

     }

     // Check for both the northern and southern hemisphere cases.  We

     // assume that in the northern hemisphere, the start rule is before the

     // end rule within the calendar year, and vice versa for the southern

     // hemisphere.

     if ((!southern && (startCompare >= 0 && endCompare < 0)) ||

         (southern && (startCompare >= 0 || endCompare < 0)))

         result += dstSavings;

     return result;

 }

 void

 SimpleTimeZone::getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,

                                    int32_t& rawOffsetGMT, int32_t& savingsDST, UErrorCode& status) const {

     if (U_FAILURE(status)) {

         return;

     }

     rawOffsetGMT = getRawOffset();

     int32_t year, month, dom, dow;

     double day = uprv_floor(date / U_MILLIS_PER_DAY);

     int32_t millis = (int32_t) (date - day * U_MILLIS_PER_DAY);

     Grego::dayToFields(day, year, month, dom, dow);

     savingsDST = getOffset(GregorianCalendar::AD, year, month, dom,

                           (uint8_t) dow, millis,

                           Grego::monthLength(year, month),

                           status) - rawOffsetGMT;

     if (U_FAILURE(status)) {

         return;

     }

     UBool recalc = FALSE;

     // Now we need some adjustment

     if (savingsDST > 0) {

         if ((nonExistingTimeOpt & kStdDstMask) == kStandard

             || ((nonExistingTimeOpt & kStdDstMask) != kDaylight && (nonExistingTimeOpt & kFormerLatterMask) != kLatter)) {

             date -= getDSTSavings();

             recalc = TRUE;

         }

     } else {

         if ((duplicatedTimeOpt & kStdDstMask) == kDaylight

                 || ((duplicatedTimeOpt & kStdDstMask) != kStandard && (duplicatedTimeOpt & kFormerLatterMask) == kFormer)) {

             date -= getDSTSavings();

             recalc = TRUE;

         }

     }

     if (recalc) {

         day = uprv_floor(date / U_MILLIS_PER_DAY);

         millis = (int32_t) (date - day * U_MILLIS_PER_DAY);

         Grego::dayToFields(day, year, month, dom, dow);

         savingsDST = getOffset(GregorianCalendar::AD, year, month, dom,

                           (uint8_t) dow, millis,

                           Grego::monthLength(year, month),

                           status) - rawOffsetGMT;

     }

 }

 // -------------------------------------

 /**

  * Compare a given date in the year to a rule. Return 1, 0, or -1, depending

  * on whether the date is after, equal to, or before the rule date. The

  * millis are compared directly against the ruleMillis, so any

  * standard-daylight adjustments must be handled by the caller.

  *

  * @return  1 if the date is after the rule date, -1 if the date is before

  *          the rule date, or 0 if the date is equal to the rule date.

  */

 int32_t 

 SimpleTimeZone::compareToRule(int8_t month, int8_t monthLen, int8_t prevMonthLen,

                               int8_t dayOfMonth,

                               int8_t dayOfWeek, int32_t millis, int32_t millisDelta,

                               EMode ruleMode, int8_t ruleMonth, int8_t ruleDayOfWeek,

                               int8_t ruleDay, int32_t ruleMillis)

 {

     // Make adjustments for startTimeMode and endTimeMode

     millis += millisDelta;

     while (millis >= U_MILLIS_PER_DAY) {

         millis -= U_MILLIS_PER_DAY;

         ++dayOfMonth;

         dayOfWeek = (int8_t)(1 + (dayOfWeek % 7)); // dayOfWeek is one-based

         if (dayOfMonth > monthLen) {

             dayOfMonth = 1;

             /* When incrementing the month, it is desirible to overflow

              * from DECEMBER to DECEMBER+1, since we use the result to

              * compare against a real month. Wraparound of the value

              * leads to bug 4173604. */

             ++month;

         }

     }

     while (millis < 0) {

         millis += U_MILLIS_PER_DAY;

         --dayOfMonth;

         dayOfWeek = (int8_t)(1 + ((dayOfWeek+5) % 7)); // dayOfWeek is one-based

         if (dayOfMonth < 1) {

             dayOfMonth = prevMonthLen;

             --month;

         }

     }

     // first compare months.  If they're different, we don't have to worry about days

     // and times

     if (month < ruleMonth) return -1;

     else if (month > ruleMonth) return 1;

     // calculate the actual day of month for the rule

     int32_t ruleDayOfMonth = 0;

     // Adjust the ruleDay to the monthLen, for non-leap year February 29 rule days.

     if (ruleDay > monthLen) {

         ruleDay = monthLen;

     }

     switch (ruleMode)

     {

     // if the mode is day-of-month, the day of month is given

     case DOM_MODE:

         ruleDayOfMonth = ruleDay;

         break;

     // if the mode is day-of-week-in-month, calculate the day-of-month from it

     case DOW_IN_MONTH_MODE:

         // In this case ruleDay is the day-of-week-in-month (this code is using

         // the dayOfWeek and dayOfMonth parameters to figure out the day-of-week

         // of the first day of the month, so it's trusting that they're really

         // consistent with each other)

         if (ruleDay > 0)

             ruleDayOfMonth = 1 + (ruleDay - 1) * 7 +

                 (7 + ruleDayOfWeek - (dayOfWeek - dayOfMonth + 1)) % 7;

         // if ruleDay is negative (we assume it's not zero here), we have to do

         // the same calculation figuring backward from the last day of the month.

         else

         {

             // (again, this code is trusting that dayOfWeek and dayOfMonth are

             // consistent with each other here, since we're using them to figure

             // the day of week of the first of the month)

             ruleDayOfMonth = monthLen + (ruleDay + 1) * 7 -

                 (7 + (dayOfWeek + monthLen - dayOfMonth) - ruleDayOfWeek) % 7;

         }

         break;

     case DOW_GE_DOM_MODE:

         ruleDayOfMonth = ruleDay +

             (49 + ruleDayOfWeek - ruleDay - dayOfWeek + dayOfMonth) % 7;

         break;

     case DOW_LE_DOM_MODE:

         ruleDayOfMonth = ruleDay -

             (49 - ruleDayOfWeek + ruleDay + dayOfWeek - dayOfMonth) % 7;

         // Note at this point ruleDayOfMonth may be <1, although it will

         // be >=1 for well-formed rules.

         break;

     }

     // now that we have a real day-in-month for the rule, we can compare days...

     if (dayOfMonth < ruleDayOfMonth) return -1;

     else if (dayOfMonth > ruleDayOfMonth) return 1;

     // ...and if they're equal, we compare times

     if (millis < ruleMillis) return -1;

     else if (millis > ruleMillis) return 1;

     else return 0;

 }

 // -------------------------------------

 int32_t

 SimpleTimeZone::getRawOffset() const

 {

     return rawOffset;

 }

 // -------------------------------------

 void

 SimpleTimeZone::setRawOffset(int32_t offsetMillis)

 {

     rawOffset = offsetMillis;

     transitionRulesInitialized = FALSE;

 }

 // -------------------------------------

 void 

 SimpleTimeZone::setDSTSavings(int32_t millisSavedDuringDST, UErrorCode& status) 

 {

     if (millisSavedDuringDST <= 0) {

         status = U_ILLEGAL_ARGUMENT_ERROR;

     }

     else {

         dstSavings = millisSavedDuringDST;

     }

     transitionRulesInitialized = FALSE;

 }

 // -------------------------------------

 int32_t 

 SimpleTimeZone::getDSTSavings() const

 {

     return dstSavings;

 }

 // -------------------------------------

 UBool

 SimpleTimeZone::useDaylightTime() const

 {

     return useDaylight;

 }

 // -------------------------------------

 /**

  * Overrides TimeZone

  * Queries if the given date is in Daylight Savings Time.

  */

 UBool SimpleTimeZone::inDaylightTime(UDate date, UErrorCode& status) const

 {

     // This method is wasteful since it creates a new GregorianCalendar and

     // deletes it each time it is called.  However, this is a deprecated method

     // and provided only for Java compatibility as of 8/6/97 [LIU].

     if (U_FAILURE(status)) return FALSE;

     GregorianCalendar *gc = new GregorianCalendar(*this, status);

     /* test for NULL */

     if (gc == 0) {

         status = U_MEMORY_ALLOCATION_ERROR;

         return FALSE;

     }

     gc->setTime(date, status);

     UBool result = gc->inDaylightTime(status);

     delete gc;

     return result;

 }

 // -------------------------------------

 /**

  * Return true if this zone has the same rules and offset as another zone.

  * @param other the TimeZone object to be compared with

  * @return true if the given zone has the same rules and offset as this one

  */

 UBool 

 SimpleTimeZone::hasSameRules(const TimeZone& other) const

 {

     if (this == &other) return TRUE;

     if (typeid(*this) != typeid(other)) return FALSE;

     SimpleTimeZone *that = (SimpleTimeZone*)&other;

     return rawOffset     == that->rawOffset &&

         useDaylight     == that->useDaylight &&

         (!useDaylight

          // Only check rules if using DST

          || (dstSavings     == that->dstSavings &&

              startMode      == that->startMode &&

              startMonth     == that->startMonth &&

              startDay       == that->startDay &&

              startDayOfWeek == that->startDayOfWeek &&

              startTime      == that->startTime &&

              startTimeMode  == that->startTimeMode &&

              endMode        == that->endMode &&

              endMonth       == that->endMonth &&

              endDay         == that->endDay &&

              endDayOfWeek   == that->endDayOfWeek &&

              endTime        == that->endTime &&

              endTimeMode    == that->endTimeMode &&

              startYear      == that->startYear));

 }

 // -------------------------------------

 //----------------------------------------------------------------------

 // Rule representation

 //

 // We represent the following flavors of rules:

 //       5        the fifth of the month

 //       lastSun  the last Sunday in the month

 //       lastMon  the last Monday in the month

 //       Sun>=8   first Sunday on or after the eighth

 //       Sun<=25  last Sunday on or before the 25th

 // This is further complicated by the fact that we need to remain

 // backward compatible with the 1.1 FCS.  Finally, we need to minimize

 // API changes.  In order to satisfy these requirements, we support

 // three representation systems, and we translate between them.

 //

 // INTERNAL REPRESENTATION

 // This is the format SimpleTimeZone objects take after construction or

 // streaming in is complete.  Rules are represented directly, using an

 // unencoded format.  We will discuss the start rule only below; the end

 // rule is analogous.

 //   startMode      Takes on enumerated values DAY_OF_MONTH,

 //                  DOW_IN_MONTH, DOW_AFTER_DOM, or DOW_BEFORE_DOM.

 //   startDay       The day of the month, or for DOW_IN_MONTH mode, a

 //                  value indicating which DOW, such as +1 for first,

 //                  +2 for second, -1 for last, etc.

 //   startDayOfWeek The day of the week.  Ignored for DAY_OF_MONTH.

 //

 // ENCODED REPRESENTATION

 // This is the format accepted by the constructor and by setStartRule()

 // and setEndRule().  It uses various combinations of positive, negative,

 // and zero values to encode the different rules.  This representation

 // allows us to specify all the different rule flavors without altering

 // the API.

 //   MODE              startMonth    startDay    startDayOfWeek

 //   DOW_IN_MONTH_MODE >=0           !=0         >0

 //   DOM_MODE          >=0           >0          ==0

 //   DOW_GE_DOM_MODE   >=0           >0          <0

 //   DOW_LE_DOM_MODE   >=0           <0          <0

 //   (no DST)          don't care    ==0         don't care

 //

 // STREAMED REPRESENTATION

 // We must retain binary compatibility with the 1.1 FCS.  The 1.1 code only

 // handles DOW_IN_MONTH_MODE and non-DST mode, the latter indicated by the

 // flag useDaylight.  When we stream an object out, we translate into an

 // approximate DOW_IN_MONTH_MODE representation so the object can be parsed

 // and used by 1.1 code.  Following that, we write out the full

 // representation separately so that contemporary code can recognize and

 // parse it.  The full representation is written in a "packed" format,

 // consisting of a version number, a length, and an array of bytes.  Future

 // versions of this class may specify different versions.  If they wish to

 // include additional data, they should do so by storing them after the

 // packed representation below.

 //----------------------------------------------------------------------

 /**

  * Given a set of encoded rules in startDay and startDayOfMonth, decode

  * them and set the startMode appropriately.  Do the same for endDay and

  * endDayOfMonth.  Upon entry, the day of week variables may be zero or

  * negative, in order to indicate special modes.  The day of month

  * variables may also be negative.  Upon exit, the mode variables will be

  * set, and the day of week and day of month variables will be positive.

  * This method also recognizes a startDay or endDay of zero as indicating

  * no DST.

  */

 void 

 SimpleTimeZone::decodeRules(UErrorCode& status)

 {

     decodeStartRule(status);

     decodeEndRule(status);

 }

 /**

  * Decode the start rule and validate the parameters.  The parameters are

  * expected to be in encoded form, which represents the various rule modes

  * by negating or zeroing certain values.  Representation formats are:

  * <p>

  * <pre>

  *            DOW_IN_MONTH  DOM    DOW>=DOM  DOW<=DOM  no DST

  *            ------------  -----  --------  --------  ----------

  * month       0..11        same    same      same     don't care

  * day        -5..5         1..31   1..31    -1..-31   0

  * dayOfWeek   1..7         0      -1..-7    -1..-7    don't care

  * time        0..ONEDAY    same    same      same     don't care

  * </pre>

  * The range for month does not include UNDECIMBER since this class is

  * really specific to GregorianCalendar, which does not use that month.

  * The range for time includes ONEDAY (vs. ending at ONEDAY-1) because the

  * end rule is an exclusive limit point.  That is, the range of times that

  * are in DST include those >= the start and < the end.  For this reason,

  * it should be possible to specify an end of ONEDAY in order to include the

  * entire day.  Although this is equivalent to time 0 of the following day,

  * it's not always possible to specify that, for example, on December 31.

  * While arguably the start range should still be 0..ONEDAY-1, we keep

  * the start and end ranges the same for consistency.

  */

 void 

 SimpleTimeZone::decodeStartRule(UErrorCode& status) 

 {

     if(U_FAILURE(status)) return;

     useDaylight = (UBool)((startDay != 0) && (endDay != 0) ? TRUE : FALSE);

     if (useDaylight && dstSavings == 0) {

         dstSavings = U_MILLIS_PER_HOUR;

     }

     if (startDay != 0) {

         if (startMonth < UCAL_JANUARY || startMonth > UCAL_DECEMBER) {

             status = U_ILLEGAL_ARGUMENT_ERROR;

             return;

         }

         if (startTime < 0 || startTime > U_MILLIS_PER_DAY ||

             startTimeMode < WALL_TIME || startTimeMode > UTC_TIME) {

             status = U_ILLEGAL_ARGUMENT_ERROR;

             return;

         }

         if (startDayOfWeek == 0) {

             startMode = DOM_MODE;

         } else {

             if (startDayOfWeek > 0) {

                 startMode = DOW_IN_MONTH_MODE;

             } else {

                 startDayOfWeek = (int8_t)-startDayOfWeek;

                 if (startDay > 0) {

                     startMode = DOW_GE_DOM_MODE;

                 } else {

                     startDay = (int8_t)-startDay;

                     startMode = DOW_LE_DOM_MODE;

                 }

             }

             if (startDayOfWeek > UCAL_SATURDAY) {

                 status = U_ILLEGAL_ARGUMENT_ERROR;

                 return;

             }

         }

         if (startMode == DOW_IN_MONTH_MODE) {

             if (startDay < -5 || startDay > 5) {

                 status = U_ILLEGAL_ARGUMENT_ERROR;

                 return;

             }

         } else if (startDay<1 || startDay > STATICMONTHLENGTH[startMonth]) {

             status = U_ILLEGAL_ARGUMENT_ERROR;

             return;

         }

     }

 }

 /**

  * Decode the end rule and validate the parameters.  This method is exactly

  * analogous to decodeStartRule().

  * @see decodeStartRule

  */

 void 

 SimpleTimeZone::decodeEndRule(UErrorCode& status) 

 {

     if(U_FAILURE(status)) return;

     useDaylight = (UBool)((startDay != 0) && (endDay != 0) ? TRUE : FALSE);

     if (useDaylight && dstSavings == 0) {

         dstSavings = U_MILLIS_PER_HOUR;

     }

     if (endDay != 0) {

         if (endMonth < UCAL_JANUARY || endMonth > UCAL_DECEMBER) {

             status = U_ILLEGAL_ARGUMENT_ERROR;

             return;

         }

         if (endTime < 0 || endTime > U_MILLIS_PER_DAY ||

             endTimeMode < WALL_TIME || endTimeMode > UTC_TIME) {

             status = U_ILLEGAL_ARGUMENT_ERROR;

             return;

         }

         if (endDayOfWeek == 0) {

             endMode = DOM_MODE;

         } else {

             if (endDayOfWeek > 0) {

                 endMode = DOW_IN_MONTH_MODE;

             } else {

                 endDayOfWeek = (int8_t)-endDayOfWeek;

                 if (endDay > 0) {

                     endMode = DOW_GE_DOM_MODE;

                 } else {

                     endDay = (int8_t)-endDay;

                     endMode = DOW_LE_DOM_MODE;

                 }

             }

             if (endDayOfWeek > UCAL_SATURDAY) {

                 status = U_ILLEGAL_ARGUMENT_ERROR;

                 return;

             }

         }

         if (endMode == DOW_IN_MONTH_MODE) {

             if (endDay < -5 || endDay > 5) {

                 status = U_ILLEGAL_ARGUMENT_ERROR;

                 return;

             }

         } else if (endDay<1 || endDay > STATICMONTHLENGTH[endMonth]) {

             status = U_ILLEGAL_ARGUMENT_ERROR;

             return;

         }

     }

 }

 UBool

 SimpleTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {

     if (!useDaylight) {

         return FALSE;

     }

     UErrorCode status = U_ZERO_ERROR;

     checkTransitionRules(status);

     if (U_FAILURE(status)) {

         return FALSE;

     }

     UDate firstTransitionTime = firstTransition->getTime();

     if (base < firstTransitionTime || (inclusive && base == firstTransitionTime)) {

         result = *firstTransition;

     }

     UDate stdDate, dstDate;

     UBool stdAvail = stdRule->getNextStart(base, dstRule->getRawOffset(), dstRule->getDSTSavings(), inclusive, stdDate);

     UBool dstAvail = dstRule->getNextStart(base, stdRule->getRawOffset(), stdRule->getDSTSavings(), inclusive, dstDate);

     if (stdAvail && (!dstAvail || stdDate < dstDate)) {

         result.setTime(stdDate);

         result.setFrom((const TimeZoneRule&)*dstRule);

         result.setTo((const TimeZoneRule&)*stdRule);

         return TRUE;

     }

     if (dstAvail && (!stdAvail || dstDate < stdDate)) {

         result.setTime(dstDate);

         result.setFrom((const TimeZoneRule&)*stdRule);

         result.setTo((const TimeZoneRule&)*dstRule);

         return TRUE;

     }

     return FALSE;

 }

 UBool

 SimpleTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {

     if (!useDaylight) {

         return FALSE;

     }

     UErrorCode status = U_ZERO_ERROR;

     checkTransitionRules(status);

     if (U_FAILURE(status)) {

         return FALSE;

     }

     UDate firstTransitionTime = firstTransition->getTime();

     if (base < firstTransitionTime || (!inclusive && base == firstTransitionTime)) {

         return FALSE;

     }

     UDate stdDate, dstDate;

     UBool stdAvail = stdRule->getPreviousStart(base, dstRule->getRawOffset(), dstRule->getDSTSavings(), inclusive, stdDate);

     UBool dstAvail = dstRule->getPreviousStart(base, stdRule->getRawOffset(), stdRule->getDSTSavings(), inclusive, dstDate);

     if (stdAvail && (!dstAvail || stdDate > dstDate)) {

         result.setTime(stdDate);

         result.setFrom((const TimeZoneRule&)*dstRule);

         result.setTo((const TimeZoneRule&)*stdRule);

         return TRUE;

     }

     if (dstAvail && (!stdAvail || dstDate > stdDate)) {

         result.setTime(dstDate);

         result.setFrom((const TimeZoneRule&)*stdRule);

         result.setTo((const TimeZoneRule&)*dstRule);

         return TRUE;

     }

     return FALSE;

 }

 void

 SimpleTimeZone::clearTransitionRules(void) {

     initialRule = NULL;

     firstTransition = NULL;

     stdRule = NULL;

     dstRule = NULL;

     transitionRulesInitialized = FALSE;

 }

 void

 SimpleTimeZone::deleteTransitionRules(void) {

     if (initialRule != NULL) {

         delete initialRule;

     }

     if (firstTransition != NULL) {

         delete firstTransition;

     }

     if (stdRule != NULL) {

         delete stdRule;

     }

     if (dstRule != NULL) {

         delete dstRule;

     }

     clearTransitionRules();

  }

 /*

  * Lazy transition rules initializer

  *

  *    Note On the removal of UMTX_CHECK from checkTransitionRules():

  *

  *         It would be faster to have a UInitOnce as part of a SimpleTimeZone object,

  *         which would avoid needing to lock a mutex to check the initialization state.

  *         But we can't easily because simpletz.h is a public header, and including

  *         a UInitOnce as a member of SimpleTimeZone would publicly expose internal ICU headers.

  *

  *         Alternatively we could have a pointer to a UInitOnce in the SimpleTimeZone object,

  *         allocate it in the constructors. This would be a more intrusive change, but doable

  *         if performance turns out to be an issue.

  */

 static UMutex gLock = U_MUTEX_INITIALIZER;

 void

 SimpleTimeZone::checkTransitionRules(UErrorCode& status) const {

     if (U_FAILURE(status)) {

         return;

     }

     umtx_lock(&gLock);

     if (!transitionRulesInitialized) {

         SimpleTimeZone *ncThis = const_cast<SimpleTimeZone*>(this);

         ncThis->initTransitionRules(status);

     }

     umtx_unlock(&gLock);

 }

 void

 SimpleTimeZone::initTransitionRules(UErrorCode& status) {

     if (U_FAILURE(status)) {

         return;

     }

     if (transitionRulesInitialized) {

         return;

     }

     deleteTransitionRules();

     UnicodeString tzid;

     getID(tzid);

     if (useDaylight) {

         DateTimeRule* dtRule;

         DateTimeRule::TimeRuleType timeRuleType;

         UDate firstStdStart, firstDstStart;

         // Create a TimeZoneRule for daylight saving time

         timeRuleType = (startTimeMode == STANDARD_TIME) ? DateTimeRule::STANDARD_TIME :

             ((startTimeMode == UTC_TIME) ? DateTimeRule::UTC_TIME : DateTimeRule::WALL_TIME);

         switch (startMode) {

         case DOM_MODE:

             dtRule = new DateTimeRule(startMonth, startDay, startTime, timeRuleType);

             break;

         case DOW_IN_MONTH_MODE:

             dtRule = new DateTimeRule(startMonth, startDay, startDayOfWeek, startTime, timeRuleType);

             break;

         case DOW_GE_DOM_MODE:

             dtRule = new DateTimeRule(startMonth, startDay, startDayOfWeek, true, startTime, timeRuleType);

             break;

         case DOW_LE_DOM_MODE:

             dtRule = new DateTimeRule(startMonth, startDay, startDayOfWeek, false, startTime, timeRuleType);

             break;

         default:

             status = U_INVALID_STATE_ERROR;

             return;

         }

         // Check for Null pointer

         if (dtRule == NULL) {

             status = U_MEMORY_ALLOCATION_ERROR;

             return;

         }

         // For now, use ID + "(DST)" as the name

         dstRule = new AnnualTimeZoneRule(tzid+UnicodeString(DST_STR), getRawOffset(), getDSTSavings(),

             dtRule, startYear, AnnualTimeZoneRule::MAX_YEAR);

         // Check for Null pointer

         if (dstRule == NULL) {

             status = U_MEMORY_ALLOCATION_ERROR;

             deleteTransitionRules();

             return;

         }

         // Calculate the first DST start time

         dstRule->getFirstStart(getRawOffset(), 0, firstDstStart);

         // Create a TimeZoneRule for standard time

         timeRuleType = (endTimeMode == STANDARD_TIME) ? DateTimeRule::STANDARD_TIME :

             ((endTimeMode == UTC_TIME) ? DateTimeRule::UTC_TIME : DateTimeRule::WALL_TIME);

         switch (endMode) {

         case DOM_MODE:

             dtRule = new DateTimeRule(endMonth, endDay, endTime, timeRuleType);

             break;

         case DOW_IN_MONTH_MODE:

             dtRule = new DateTimeRule(endMonth, endDay, endDayOfWeek, endTime, timeRuleType);

             break;

         case DOW_GE_DOM_MODE:

             dtRule = new DateTimeRule(endMonth, endDay, endDayOfWeek, true, endTime, timeRuleType);

             break;

         case DOW_LE_DOM_MODE:

             dtRule = new DateTimeRule(endMonth, endDay, endDayOfWeek, false, endTime, timeRuleType);

             break;

         }

         // Check for Null pointer

         if (dtRule == NULL) {

             status = U_MEMORY_ALLOCATION_ERROR;

             deleteTransitionRules();

             return;

         }

         // For now, use ID + "(STD)" as the name

         stdRule = new AnnualTimeZoneRule(tzid+UnicodeString(STD_STR), getRawOffset(), 0,

             dtRule, startYear, AnnualTimeZoneRule::MAX_YEAR);

         //Check for Null pointer

         if (stdRule == NULL) {

             status = U_MEMORY_ALLOCATION_ERROR;

             deleteTransitionRules();

             return;

         }

         // Calculate the first STD start time

         stdRule->getFirstStart(getRawOffset(), dstRule->getDSTSavings(), firstStdStart);

         // Create a TimeZoneRule for initial time

         if (firstStdStart < firstDstStart) {

             initialRule = new InitialTimeZoneRule(tzid+UnicodeString(DST_STR), getRawOffset(), dstRule->getDSTSavings());

             firstTransition = new TimeZoneTransition(firstStdStart, *initialRule, *stdRule);

         } else {

             initialRule = new InitialTimeZoneRule(tzid+UnicodeString(STD_STR), getRawOffset(), 0);

             firstTransition = new TimeZoneTransition(firstDstStart, *initialRule, *dstRule);

         }

         // Check for null pointers.

         if (initialRule == NULL || firstTransition == NULL) {

             status = U_MEMORY_ALLOCATION_ERROR;

             deleteTransitionRules();

             return;

         }

     } else {

         // Create a TimeZoneRule for initial time

         initialRule = new InitialTimeZoneRule(tzid, getRawOffset(), 0);

         // Check for null pointer.

         if (initialRule == NULL) {

             status = U_MEMORY_ALLOCATION_ERROR;

             deleteTransitionRules();

             return;

         }

     }

     transitionRulesInitialized = TRUE;

 }

 int32_t

 SimpleTimeZone::countTransitionRules(UErrorCode& /*status*/) const {

     return (useDaylight) ? 2 : 0;

 }

 void

 SimpleTimeZone::getTimeZoneRules(const InitialTimeZoneRule*& initial,

                                  const TimeZoneRule* trsrules[],

                                  int32_t& trscount,

                                  UErrorCode& status) const {

     if (U_FAILURE(status)) {

         return;

     }

     checkTransitionRules(status);

     if (U_FAILURE(status)) {

         return;

     }

     initial = initialRule;

     int32_t cnt = 0;

     if (stdRule != NULL) {

         if (cnt < trscount) {

             trsrules[cnt++] = stdRule;

         }

         if (cnt < trscount) {

             trsrules[cnt++] = dstRule;

         }

     }

     trscount = cnt;

 }

 U_NAMESPACE_END

 #endif /* #if !UCONFIG_NO_FORMATTING */

 //eof