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