diff options
Diffstat (limited to 'deps/icu-small/source/i18n/simpletz.cpp')
| -rw-r--r-- | deps/icu-small/source/i18n/simpletz.cpp | 1251 |
1 files changed, 1251 insertions, 0 deletions
diff --git a/deps/icu-small/source/i18n/simpletz.cpp b/deps/icu-small/source/i18n/simpletz.cpp new file mode 100644 index 0000000000..3696d21073 --- /dev/null +++ b/deps/icu-small/source/i18n/simpletz.cpp @@ -0,0 +1,1251 @@ +/* + ******************************************************************************* + * 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 |