summaryrefslogtreecommitdiffstats
path: root/intl/icu/source/i18n/simpletz.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /intl/icu/source/i18n/simpletz.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'intl/icu/source/i18n/simpletz.cpp')
-rw-r--r--intl/icu/source/i18n/simpletz.cpp1253
1 files changed, 1253 insertions, 0 deletions
diff --git a/intl/icu/source/i18n/simpletz.cpp b/intl/icu/source/i18n/simpletz.cpp
new file mode 100644
index 000000000..a06a80fc4
--- /dev/null
+++ b/intl/icu/source/i18n/simpletz.cpp
@@ -0,0 +1,1253 @@
+// Copyright (C) 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());
+ 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