diff options
Diffstat (limited to 'deps/node/deps/icu-small/source/i18n/simpletz.cpp')
| -rw-r--r-- | deps/node/deps/icu-small/source/i18n/simpletz.cpp | 1262 |
1 files changed, 0 insertions, 1262 deletions
diff --git a/deps/node/deps/icu-small/source/i18n/simpletz.cpp b/deps/node/deps/icu-small/source/i18n/simpletz.cpp deleted file mode 100644 index 9bce8ed5..00000000 --- a/deps/node/deps/icu-small/source/i18n/simpletz.cpp +++ /dev/null @@ -1,1262 +0,0 @@ -// © 2016 and later: Unicode, Inc. and others. -// License & terms of use: http://www.unicode.org/copyright.html -/* - ******************************************************************************* - * 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()); - if (initialRule == NULL) { - status = U_MEMORY_ALLOCATION_ERROR; - deleteTransitionRules(); - return; - } - firstTransition = new TimeZoneTransition(firstStdStart, *initialRule, *stdRule); - } else { - initialRule = new InitialTimeZoneRule(tzid+UnicodeString(STD_STR), getRawOffset(), 0); - if (initialRule == NULL) { - status = U_MEMORY_ALLOCATION_ERROR; - deleteTransitionRules(); - return; - } - firstTransition = new TimeZoneTransition(firstDstStart, *initialRule, *dstRule); - } - if (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 |