| /* |
| ******************************************************************************* |
| * 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 |
