| /* | |
| ******************************************************************************* | |
| * Copyright (C) 2007-2013, International Business Machines Corporation and | |
| * others. All Rights Reserved. | |
| ******************************************************************************* | |
| */ | |
| #include "utypeinfo.h" // for 'typeid' to work | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #include "unicode/vtzone.h" | |
| #include "unicode/rbtz.h" | |
| #include "unicode/ucal.h" | |
| #include "unicode/ures.h" | |
| #include "cmemory.h" | |
| #include "uvector.h" | |
| #include "gregoimp.h" | |
| #include "uassert.h" | |
| U_NAMESPACE_BEGIN | |
| // This is the deleter that will be use to remove TimeZoneRule | |
| U_CDECL_BEGIN | |
| static void U_CALLCONV | |
| deleteTimeZoneRule(void* obj) { | |
| delete (TimeZoneRule*) obj; | |
| } | |
| U_CDECL_END | |
| // Smybol characters used by RFC2445 VTIMEZONE | |
| static const UChar COLON = 0x3A; /* : */ | |
| static const UChar SEMICOLON = 0x3B; /* ; */ | |
| static const UChar EQUALS_SIGN = 0x3D; /* = */ | |
| static const UChar COMMA = 0x2C; /* , */ | |
| static const UChar PLUS = 0x2B; /* + */ | |
| static const UChar MINUS = 0x2D; /* - */ | |
| // RFC2445 VTIMEZONE tokens | |
| static const UChar ICAL_BEGIN_VTIMEZONE[] = {0x42, 0x45, 0x47, 0x49, 0x4E, 0x3A, 0x56, 0x54, 0x49, 0x4D, 0x45, 0x5A, 0x4F, 0x4E, 0x45, 0}; /* "BEGIN:VTIMEZONE" */ | |
| static const UChar ICAL_END_VTIMEZONE[] = {0x45, 0x4E, 0x44, 0x3A, 0x56, 0x54, 0x49, 0x4D, 0x45, 0x5A, 0x4F, 0x4E, 0x45, 0}; /* "END:VTIMEZONE" */ | |
| static const UChar ICAL_BEGIN[] = {0x42, 0x45, 0x47, 0x49, 0x4E, 0}; /* "BEGIN" */ | |
| static const UChar ICAL_END[] = {0x45, 0x4E, 0x44, 0}; /* "END" */ | |
| static const UChar ICAL_VTIMEZONE[] = {0x56, 0x54, 0x49, 0x4D, 0x45, 0x5A, 0x4F, 0x4E, 0x45, 0}; /* "VTIMEZONE" */ | |
| static const UChar ICAL_TZID[] = {0x54, 0x5A, 0x49, 0x44, 0}; /* "TZID" */ | |
| static const UChar ICAL_STANDARD[] = {0x53, 0x54, 0x41, 0x4E, 0x44, 0x41, 0x52, 0x44, 0}; /* "STANDARD" */ | |
| static const UChar ICAL_DAYLIGHT[] = {0x44, 0x41, 0x59, 0x4C, 0x49, 0x47, 0x48, 0x54, 0}; /* "DAYLIGHT" */ | |
| static const UChar ICAL_DTSTART[] = {0x44, 0x54, 0x53, 0x54, 0x41, 0x52, 0x54, 0}; /* "DTSTART" */ | |
| static const UChar ICAL_TZOFFSETFROM[] = {0x54, 0x5A, 0x4F, 0x46, 0x46, 0x53, 0x45, 0x54, 0x46, 0x52, 0x4F, 0x4D, 0}; /* "TZOFFSETFROM" */ | |
| static const UChar ICAL_TZOFFSETTO[] = {0x54, 0x5A, 0x4F, 0x46, 0x46, 0x53, 0x45, 0x54, 0x54, 0x4F, 0}; /* "TZOFFSETTO" */ | |
| static const UChar ICAL_RDATE[] = {0x52, 0x44, 0x41, 0x54, 0x45, 0}; /* "RDATE" */ | |
| static const UChar ICAL_RRULE[] = {0x52, 0x52, 0x55, 0x4C, 0x45, 0}; /* "RRULE" */ | |
| static const UChar ICAL_TZNAME[] = {0x54, 0x5A, 0x4E, 0x41, 0x4D, 0x45, 0}; /* "TZNAME" */ | |
| static const UChar ICAL_TZURL[] = {0x54, 0x5A, 0x55, 0x52, 0x4C, 0}; /* "TZURL" */ | |
| static const UChar ICAL_LASTMOD[] = {0x4C, 0x41, 0x53, 0x54, 0x2D, 0x4D, 0x4F, 0x44, 0x49, 0x46, 0x49, 0x45, 0x44, 0}; /* "LAST-MODIFIED" */ | |
| static const UChar ICAL_FREQ[] = {0x46, 0x52, 0x45, 0x51, 0}; /* "FREQ" */ | |
| static const UChar ICAL_UNTIL[] = {0x55, 0x4E, 0x54, 0x49, 0x4C, 0}; /* "UNTIL" */ | |
| static const UChar ICAL_YEARLY[] = {0x59, 0x45, 0x41, 0x52, 0x4C, 0x59, 0}; /* "YEARLY" */ | |
| static const UChar ICAL_BYMONTH[] = {0x42, 0x59, 0x4D, 0x4F, 0x4E, 0x54, 0x48, 0}; /* "BYMONTH" */ | |
| static const UChar ICAL_BYDAY[] = {0x42, 0x59, 0x44, 0x41, 0x59, 0}; /* "BYDAY" */ | |
| static const UChar ICAL_BYMONTHDAY[] = {0x42, 0x59, 0x4D, 0x4F, 0x4E, 0x54, 0x48, 0x44, 0x41, 0x59, 0}; /* "BYMONTHDAY" */ | |
| static const UChar ICAL_NEWLINE[] = {0x0D, 0x0A, 0}; /* CRLF */ | |
| static const UChar ICAL_DOW_NAMES[7][3] = { | |
| {0x53, 0x55, 0}, /* "SU" */ | |
| {0x4D, 0x4F, 0}, /* "MO" */ | |
| {0x54, 0x55, 0}, /* "TU" */ | |
| {0x57, 0x45, 0}, /* "WE" */ | |
| {0x54, 0x48, 0}, /* "TH" */ | |
| {0x46, 0x52, 0}, /* "FR" */ | |
| {0x53, 0x41, 0} /* "SA" */}; | |
| // Month length for non-leap year | |
| static const int32_t MONTHLENGTH[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; | |
| // ICU custom property | |
| static const UChar ICU_TZINFO_PROP[] = {0x58, 0x2D, 0x54, 0x5A, 0x49, 0x4E, 0x46, 0x4F, 0x3A, 0}; /* "X-TZINFO:" */ | |
| static const UChar ICU_TZINFO_PARTIAL[] = {0x2F, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6C, 0x40, 0}; /* "/Partial@" */ | |
| static const UChar ICU_TZINFO_SIMPLE[] = {0x2F, 0x53, 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x40, 0}; /* "/Simple@" */ | |
| /* | |
| * Simple fixed digit ASCII number to integer converter | |
| */ | |
| static int32_t parseAsciiDigits(const UnicodeString& str, int32_t start, int32_t length, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return 0; | |
| } | |
| if (length <= 0 || str.length() < start || (start + length) > str.length()) { | |
| status = U_INVALID_FORMAT_ERROR; | |
| return 0; | |
| } | |
| int32_t sign = 1; | |
| if (str.charAt(start) == PLUS) { | |
| start++; | |
| length--; | |
| } else if (str.charAt(start) == MINUS) { | |
| sign = -1; | |
| start++; | |
| length--; | |
| } | |
| int32_t num = 0; | |
| for (int32_t i = 0; i < length; i++) { | |
| int32_t digit = str.charAt(start + i) - 0x0030; | |
| if (digit < 0 || digit > 9) { | |
| status = U_INVALID_FORMAT_ERROR; | |
| return 0; | |
| } | |
| num = 10 * num + digit; | |
| } | |
| return sign * num; | |
| } | |
| static UnicodeString& appendAsciiDigits(int32_t number, uint8_t length, UnicodeString& str) { | |
| UBool negative = FALSE; | |
| int32_t digits[10]; // max int32_t is 10 decimal digits | |
| int32_t i; | |
| if (number < 0) { | |
| negative = TRUE; | |
| number *= -1; | |
| } | |
| length = length > 10 ? 10 : length; | |
| if (length == 0) { | |
| // variable length | |
| i = 0; | |
| do { | |
| digits[i++] = number % 10; | |
| number /= 10; | |
| } while (number != 0); | |
| length = i; | |
| } else { | |
| // fixed digits | |
| for (i = 0; i < length; i++) { | |
| digits[i] = number % 10; | |
| number /= 10; | |
| } | |
| } | |
| if (negative) { | |
| str.append(MINUS); | |
| } | |
| for (i = length - 1; i >= 0; i--) { | |
| str.append((UChar)(digits[i] + 0x0030)); | |
| } | |
| return str; | |
| } | |
| static UnicodeString& appendMillis(UDate date, UnicodeString& str) { | |
| UBool negative = FALSE; | |
| int32_t digits[20]; // max int64_t is 20 decimal digits | |
| int32_t i; | |
| int64_t number; | |
| if (date < MIN_MILLIS) { | |
| number = (int64_t)MIN_MILLIS; | |
| } else if (date > MAX_MILLIS) { | |
| number = (int64_t)MAX_MILLIS; | |
| } else { | |
| number = (int64_t)date; | |
| } | |
| if (number < 0) { | |
| negative = TRUE; | |
| number *= -1; | |
| } | |
| i = 0; | |
| do { | |
| digits[i++] = (int32_t)(number % 10); | |
| number /= 10; | |
| } while (number != 0); | |
| if (negative) { | |
| str.append(MINUS); | |
| } | |
| i--; | |
| while (i >= 0) { | |
| str.append((UChar)(digits[i--] + 0x0030)); | |
| } | |
| return str; | |
| } | |
| /* | |
| * Convert date/time to RFC2445 Date-Time form #1 DATE WITH LOCAL TIME | |
| */ | |
| static UnicodeString& getDateTimeString(UDate time, UnicodeString& str) { | |
| int32_t year, month, dom, dow, doy, mid; | |
| Grego::timeToFields(time, year, month, dom, dow, doy, mid); | |
| str.remove(); | |
| appendAsciiDigits(year, 4, str); | |
| appendAsciiDigits(month + 1, 2, str); | |
| appendAsciiDigits(dom, 2, str); | |
| str.append((UChar)0x0054 /*'T'*/); | |
| int32_t t = mid; | |
| int32_t hour = t / U_MILLIS_PER_HOUR; | |
| t %= U_MILLIS_PER_HOUR; | |
| int32_t min = t / U_MILLIS_PER_MINUTE; | |
| t %= U_MILLIS_PER_MINUTE; | |
| int32_t sec = t / U_MILLIS_PER_SECOND; | |
| appendAsciiDigits(hour, 2, str); | |
| appendAsciiDigits(min, 2, str); | |
| appendAsciiDigits(sec, 2, str); | |
| return str; | |
| } | |
| /* | |
| * Convert date/time to RFC2445 Date-Time form #2 DATE WITH UTC TIME | |
| */ | |
| static UnicodeString& getUTCDateTimeString(UDate time, UnicodeString& str) { | |
| getDateTimeString(time, str); | |
| str.append((UChar)0x005A /*'Z'*/); | |
| return str; | |
| } | |
| /* | |
| * Parse RFC2445 Date-Time form #1 DATE WITH LOCAL TIME and | |
| * #2 DATE WITH UTC TIME | |
| */ | |
| static UDate parseDateTimeString(const UnicodeString& str, int32_t offset, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return 0.0; | |
| } | |
| int32_t year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0; | |
| UBool isUTC = FALSE; | |
| UBool isValid = FALSE; | |
| do { | |
| int length = str.length(); | |
| if (length != 15 && length != 16) { | |
| // FORM#1 15 characters, such as "20060317T142115" | |
| // FORM#2 16 characters, such as "20060317T142115Z" | |
| break; | |
| } | |
| if (str.charAt(8) != 0x0054) { | |
| // charcter "T" must be used for separating date and time | |
| break; | |
| } | |
| if (length == 16) { | |
| if (str.charAt(15) != 0x005A) { | |
| // invalid format | |
| break; | |
| } | |
| isUTC = TRUE; | |
| } | |
| year = parseAsciiDigits(str, 0, 4, status); | |
| month = parseAsciiDigits(str, 4, 2, status) - 1; // 0-based | |
| day = parseAsciiDigits(str, 6, 2, status); | |
| hour = parseAsciiDigits(str, 9, 2, status); | |
| min = parseAsciiDigits(str, 11, 2, status); | |
| sec = parseAsciiDigits(str, 13, 2, status); | |
| if (U_FAILURE(status)) { | |
| break; | |
| } | |
| // check valid range | |
| int32_t maxDayOfMonth = Grego::monthLength(year, month); | |
| if (year < 0 || month < 0 || month > 11 || day < 1 || day > maxDayOfMonth || | |
| hour < 0 || hour >= 24 || min < 0 || min >= 60 || sec < 0 || sec >= 60) { | |
| break; | |
| } | |
| isValid = TRUE; | |
| } while(false); | |
| if (!isValid) { | |
| status = U_INVALID_FORMAT_ERROR; | |
| return 0.0; | |
| } | |
| // Calculate the time | |
| UDate time = Grego::fieldsToDay(year, month, day) * U_MILLIS_PER_DAY; | |
| time += (hour * U_MILLIS_PER_HOUR + min * U_MILLIS_PER_MINUTE + sec * U_MILLIS_PER_SECOND); | |
| if (!isUTC) { | |
| time -= offset; | |
| } | |
| return time; | |
| } | |
| /* | |
| * Convert RFC2445 utc-offset string to milliseconds | |
| */ | |
| static int32_t offsetStrToMillis(const UnicodeString& str, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return 0; | |
| } | |
| UBool isValid = FALSE; | |
| int32_t sign = 0, hour = 0, min = 0, sec = 0; | |
| do { | |
| int length = str.length(); | |
| if (length != 5 && length != 7) { | |
| // utf-offset must be 5 or 7 characters | |
| break; | |
| } | |
| // sign | |
| UChar s = str.charAt(0); | |
| if (s == PLUS) { | |
| sign = 1; | |
| } else if (s == MINUS) { | |
| sign = -1; | |
| } else { | |
| // utf-offset must start with "+" or "-" | |
| break; | |
| } | |
| hour = parseAsciiDigits(str, 1, 2, status); | |
| min = parseAsciiDigits(str, 3, 2, status); | |
| if (length == 7) { | |
| sec = parseAsciiDigits(str, 5, 2, status); | |
| } | |
| if (U_FAILURE(status)) { | |
| break; | |
| } | |
| isValid = true; | |
| } while(false); | |
| if (!isValid) { | |
| status = U_INVALID_FORMAT_ERROR; | |
| return 0; | |
| } | |
| int32_t millis = sign * ((hour * 60 + min) * 60 + sec) * 1000; | |
| return millis; | |
| } | |
| /* | |
| * Convert milliseconds to RFC2445 utc-offset string | |
| */ | |
| static void millisToOffset(int32_t millis, UnicodeString& str) { | |
| str.remove(); | |
| if (millis >= 0) { | |
| str.append(PLUS); | |
| } else { | |
| str.append(MINUS); | |
| millis = -millis; | |
| } | |
| int32_t hour, min, sec; | |
| int32_t t = millis / 1000; | |
| sec = t % 60; | |
| t = (t - sec) / 60; | |
| min = t % 60; | |
| hour = t / 60; | |
| appendAsciiDigits(hour, 2, str); | |
| appendAsciiDigits(min, 2, str); | |
| appendAsciiDigits(sec, 2, str); | |
| } | |
| /* | |
| * Create a default TZNAME from TZID | |
| */ | |
| static void getDefaultTZName(const UnicodeString tzid, UBool isDST, UnicodeString& zonename) { | |
| zonename = tzid; | |
| if (isDST) { | |
| zonename += UNICODE_STRING_SIMPLE("(DST)"); | |
| } else { | |
| zonename += UNICODE_STRING_SIMPLE("(STD)"); | |
| } | |
| } | |
| /* | |
| * Parse individual RRULE | |
| * | |
| * On return - | |
| * | |
| * month calculated by BYMONTH-1, or -1 when not found | |
| * dow day of week in BYDAY, or 0 when not found | |
| * wim day of week ordinal number in BYDAY, or 0 when not found | |
| * dom an array of day of month | |
| * domCount number of availble days in dom (domCount is specifying the size of dom on input) | |
| * until time defined by UNTIL attribute or MIN_MILLIS if not available | |
| */ | |
| static void parseRRULE(const UnicodeString& rrule, int32_t& month, int32_t& dow, int32_t& wim, | |
| int32_t* dom, int32_t& domCount, UDate& until, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| int32_t numDom = 0; | |
| month = -1; | |
| dow = 0; | |
| wim = 0; | |
| until = MIN_MILLIS; | |
| UBool yearly = FALSE; | |
| //UBool parseError = FALSE; | |
| int32_t prop_start = 0; | |
| int32_t prop_end; | |
| UnicodeString prop, attr, value; | |
| UBool nextProp = TRUE; | |
| while (nextProp) { | |
| prop_end = rrule.indexOf(SEMICOLON, prop_start); | |
| if (prop_end == -1) { | |
| prop.setTo(rrule, prop_start); | |
| nextProp = FALSE; | |
| } else { | |
| prop.setTo(rrule, prop_start, prop_end - prop_start); | |
| prop_start = prop_end + 1; | |
| } | |
| int32_t eql = prop.indexOf(EQUALS_SIGN); | |
| if (eql != -1) { | |
| attr.setTo(prop, 0, eql); | |
| value.setTo(prop, eql + 1); | |
| } else { | |
| goto rruleParseError; | |
| } | |
| if (attr.compare(ICAL_FREQ, -1) == 0) { | |
| // only support YEARLY frequency type | |
| if (value.compare(ICAL_YEARLY, -1) == 0) { | |
| yearly = TRUE; | |
| } else { | |
| goto rruleParseError; | |
| } | |
| } else if (attr.compare(ICAL_UNTIL, -1) == 0) { | |
| // ISO8601 UTC format, for example, "20060315T020000Z" | |
| until = parseDateTimeString(value, 0, status); | |
| if (U_FAILURE(status)) { | |
| goto rruleParseError; | |
| } | |
| } else if (attr.compare(ICAL_BYMONTH, -1) == 0) { | |
| // Note: BYMONTH may contain multiple months, but only single month make sense for | |
| // VTIMEZONE property. | |
| if (value.length() > 2) { | |
| goto rruleParseError; | |
| } | |
| month = parseAsciiDigits(value, 0, value.length(), status) - 1; | |
| if (U_FAILURE(status) || month < 0 || month >= 12) { | |
| goto rruleParseError; | |
| } | |
| } else if (attr.compare(ICAL_BYDAY, -1) == 0) { | |
| // Note: BYDAY may contain multiple day of week separated by comma. It is unlikely used for | |
| // VTIMEZONE property. We do not support the case. | |
| // 2-letter format is used just for representing a day of week, for example, "SU" for Sunday | |
| // 3 or 4-letter format is used for represeinging Nth day of week, for example, "-1SA" for last Saturday | |
| int32_t length = value.length(); | |
| if (length < 2 || length > 4) { | |
| goto rruleParseError; | |
| } | |
| if (length > 2) { | |
| // Nth day of week | |
| int32_t sign = 1; | |
| if (value.charAt(0) == PLUS) { | |
| sign = 1; | |
| } else if (value.charAt(0) == MINUS) { | |
| sign = -1; | |
| } else if (length == 4) { | |
| goto rruleParseError; | |
| } | |
| int32_t n = parseAsciiDigits(value, length - 3, 1, status); | |
| if (U_FAILURE(status) || n == 0 || n > 4) { | |
| goto rruleParseError; | |
| } | |
| wim = n * sign; | |
| value.remove(0, length - 2); | |
| } | |
| int32_t wday; | |
| for (wday = 0; wday < 7; wday++) { | |
| if (value.compare(ICAL_DOW_NAMES[wday], 2) == 0) { | |
| break; | |
| } | |
| } | |
| if (wday < 7) { | |
| // Sunday(1) - Saturday(7) | |
| dow = wday + 1; | |
| } else { | |
| goto rruleParseError; | |
| } | |
| } else if (attr.compare(ICAL_BYMONTHDAY, -1) == 0) { | |
| // Note: BYMONTHDAY may contain multiple days delimitted by comma | |
| // | |
| // A value of BYMONTHDAY could be negative, for example, -1 means | |
| // the last day in a month | |
| int32_t dom_idx = 0; | |
| int32_t dom_start = 0; | |
| int32_t dom_end; | |
| UBool nextDOM = TRUE; | |
| while (nextDOM) { | |
| dom_end = value.indexOf(COMMA, dom_start); | |
| if (dom_end == -1) { | |
| dom_end = value.length(); | |
| nextDOM = FALSE; | |
| } | |
| if (dom_idx < domCount) { | |
| dom[dom_idx] = parseAsciiDigits(value, dom_start, dom_end - dom_start, status); | |
| if (U_FAILURE(status)) { | |
| goto rruleParseError; | |
| } | |
| dom_idx++; | |
| } else { | |
| status = U_BUFFER_OVERFLOW_ERROR; | |
| goto rruleParseError; | |
| } | |
| dom_start = dom_end + 1; | |
| } | |
| numDom = dom_idx; | |
| } | |
| } | |
| if (!yearly) { | |
| // FREQ=YEARLY must be set | |
| goto rruleParseError; | |
| } | |
| // Set actual number of parsed DOM (ICAL_BYMONTHDAY) | |
| domCount = numDom; | |
| return; | |
| rruleParseError: | |
| if (U_SUCCESS(status)) { | |
| // Set error status | |
| status = U_INVALID_FORMAT_ERROR; | |
| } | |
| } | |
| static TimeZoneRule* createRuleByRRULE(const UnicodeString& zonename, int rawOffset, int dstSavings, UDate start, | |
| UVector* dates, int fromOffset, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| if (dates == NULL || dates->size() == 0) { | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return NULL; | |
| } | |
| int32_t i, j; | |
| DateTimeRule *adtr = NULL; | |
| // Parse the first rule | |
| UnicodeString rrule = *((UnicodeString*)dates->elementAt(0)); | |
| int32_t month, dayOfWeek, nthDayOfWeek, dayOfMonth = 0; | |
| int32_t days[7]; | |
| int32_t daysCount = sizeof(days)/sizeof(days[0]); | |
| UDate until; | |
| parseRRULE(rrule, month, dayOfWeek, nthDayOfWeek, days, daysCount, until, status); | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| if (dates->size() == 1) { | |
| // No more rules | |
| if (daysCount > 1) { | |
| // Multiple BYMONTHDAY values | |
| if (daysCount != 7 || month == -1 || dayOfWeek == 0) { | |
| // Only support the rule using 7 continuous days | |
| // BYMONTH and BYDAY must be set at the same time | |
| goto unsupportedRRule; | |
| } | |
| int32_t firstDay = 31; // max possible number of dates in a month | |
| for (i = 0; i < 7; i++) { | |
| // Resolve negative day numbers. A negative day number should | |
| // not be used in February, but if we see such case, we use 28 | |
| // as the base. | |
| if (days[i] < 0) { | |
| days[i] = MONTHLENGTH[month] + days[i] + 1; | |
| } | |
| if (days[i] < firstDay) { | |
| firstDay = days[i]; | |
| } | |
| } | |
| // Make sure days are continuous | |
| for (i = 1; i < 7; i++) { | |
| UBool found = FALSE; | |
| for (j = 0; j < 7; j++) { | |
| if (days[j] == firstDay + i) { | |
| found = TRUE; | |
| break; | |
| } | |
| } | |
| if (!found) { | |
| // days are not continuous | |
| goto unsupportedRRule; | |
| } | |
| } | |
| // Use DOW_GEQ_DOM rule with firstDay as the start date | |
| dayOfMonth = firstDay; | |
| } | |
| } else { | |
| // Check if BYMONTH + BYMONTHDAY + BYDAY rule with multiple RRULE lines. | |
| // Otherwise, not supported. | |
| if (month == -1 || dayOfWeek == 0 || daysCount == 0) { | |
| // This is not the case | |
| goto unsupportedRRule; | |
| } | |
| // Parse the rest of rules if number of rules is not exceeding 7. | |
| // We can only support 7 continuous days starting from a day of month. | |
| if (dates->size() > 7) { | |
| goto unsupportedRRule; | |
| } | |
| // Note: To check valid date range across multiple rule is a little | |
| // bit complicated. For now, this code is not doing strict range | |
| // checking across month boundary | |
| int32_t earliestMonth = month; | |
| int32_t earliestDay = 31; | |
| for (i = 0; i < daysCount; i++) { | |
| int32_t dom = days[i]; | |
| dom = dom > 0 ? dom : MONTHLENGTH[month] + dom + 1; | |
| earliestDay = dom < earliestDay ? dom : earliestDay; | |
| } | |
| int32_t anotherMonth = -1; | |
| for (i = 1; i < dates->size(); i++) { | |
| rrule = *((UnicodeString*)dates->elementAt(i)); | |
| UDate tmp_until; | |
| int32_t tmp_month, tmp_dayOfWeek, tmp_nthDayOfWeek; | |
| int32_t tmp_days[7]; | |
| int32_t tmp_daysCount = sizeof(tmp_days)/sizeof(tmp_days[0]); | |
| parseRRULE(rrule, tmp_month, tmp_dayOfWeek, tmp_nthDayOfWeek, tmp_days, tmp_daysCount, tmp_until, status); | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| // If UNTIL is newer than previous one, use the one | |
| if (tmp_until > until) { | |
| until = tmp_until; | |
| } | |
| // Check if BYMONTH + BYMONTHDAY + BYDAY rule | |
| if (tmp_month == -1 || tmp_dayOfWeek == 0 || tmp_daysCount == 0) { | |
| goto unsupportedRRule; | |
| } | |
| // Count number of BYMONTHDAY | |
| if (daysCount + tmp_daysCount > 7) { | |
| // We cannot support BYMONTHDAY more than 7 | |
| goto unsupportedRRule; | |
| } | |
| // Check if the same BYDAY is used. Otherwise, we cannot | |
| // support the rule | |
| if (tmp_dayOfWeek != dayOfWeek) { | |
| goto unsupportedRRule; | |
| } | |
| // Check if the month is same or right next to the primary month | |
| if (tmp_month != month) { | |
| if (anotherMonth == -1) { | |
| int32_t diff = tmp_month - month; | |
| if (diff == -11 || diff == -1) { | |
| // Previous month | |
| anotherMonth = tmp_month; | |
| earliestMonth = anotherMonth; | |
| // Reset earliest day | |
| earliestDay = 31; | |
| } else if (diff == 11 || diff == 1) { | |
| // Next month | |
| anotherMonth = tmp_month; | |
| } else { | |
| // The day range cannot exceed more than 2 months | |
| goto unsupportedRRule; | |
| } | |
| } else if (tmp_month != month && tmp_month != anotherMonth) { | |
| // The day range cannot exceed more than 2 months | |
| goto unsupportedRRule; | |
| } | |
| } | |
| // If ealier month, go through days to find the earliest day | |
| if (tmp_month == earliestMonth) { | |
| for (j = 0; j < tmp_daysCount; j++) { | |
| tmp_days[j] = tmp_days[j] > 0 ? tmp_days[j] : MONTHLENGTH[tmp_month] + tmp_days[j] + 1; | |
| earliestDay = tmp_days[j] < earliestDay ? tmp_days[j] : earliestDay; | |
| } | |
| } | |
| daysCount += tmp_daysCount; | |
| } | |
| if (daysCount != 7) { | |
| // Number of BYMONTHDAY entries must be 7 | |
| goto unsupportedRRule; | |
| } | |
| month = earliestMonth; | |
| dayOfMonth = earliestDay; | |
| } | |
| // Calculate start/end year and missing fields | |
| int32_t startYear, startMonth, startDOM, startDOW, startDOY, startMID; | |
| Grego::timeToFields(start + fromOffset, startYear, startMonth, startDOM, | |
| startDOW, startDOY, startMID); | |
| if (month == -1) { | |
| // If BYMONTH is not set, use the month of DTSTART | |
| month = startMonth; | |
| } | |
| if (dayOfWeek == 0 && nthDayOfWeek == 0 && dayOfMonth == 0) { | |
| // If only YEARLY is set, use the day of DTSTART as BYMONTHDAY | |
| dayOfMonth = startDOM; | |
| } | |
| int32_t endYear; | |
| if (until != MIN_MILLIS) { | |
| int32_t endMonth, endDOM, endDOW, endDOY, endMID; | |
| Grego::timeToFields(until, endYear, endMonth, endDOM, endDOW, endDOY, endMID); | |
| } else { | |
| endYear = AnnualTimeZoneRule::MAX_YEAR; | |
| } | |
| // Create the AnnualDateTimeRule | |
| if (dayOfWeek == 0 && nthDayOfWeek == 0 && dayOfMonth != 0) { | |
| // Day in month rule, for example, 15th day in the month | |
| adtr = new DateTimeRule(month, dayOfMonth, startMID, DateTimeRule::WALL_TIME); | |
| } else if (dayOfWeek != 0 && nthDayOfWeek != 0 && dayOfMonth == 0) { | |
| // Nth day of week rule, for example, last Sunday | |
| adtr = new DateTimeRule(month, nthDayOfWeek, dayOfWeek, startMID, DateTimeRule::WALL_TIME); | |
| } else if (dayOfWeek != 0 && nthDayOfWeek == 0 && dayOfMonth != 0) { | |
| // First day of week after day of month rule, for example, | |
| // first Sunday after 15th day in the month | |
| adtr = new DateTimeRule(month, dayOfMonth, dayOfWeek, TRUE, startMID, DateTimeRule::WALL_TIME); | |
| } | |
| if (adtr == NULL) { | |
| goto unsupportedRRule; | |
| } | |
| return new AnnualTimeZoneRule(zonename, rawOffset, dstSavings, adtr, startYear, endYear); | |
| unsupportedRRule: | |
| status = U_INVALID_STATE_ERROR; | |
| return NULL; | |
| } | |
| /* | |
| * Create a TimeZoneRule by the RDATE definition | |
| */ | |
| static TimeZoneRule* createRuleByRDATE(const UnicodeString& zonename, int32_t rawOffset, int32_t dstSavings, | |
| UDate start, UVector* dates, int32_t fromOffset, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| TimeArrayTimeZoneRule *retVal = NULL; | |
| if (dates == NULL || dates->size() == 0) { | |
| // When no RDATE line is provided, use start (DTSTART) | |
| // as the transition time | |
| retVal = new TimeArrayTimeZoneRule(zonename, rawOffset, dstSavings, | |
| &start, 1, DateTimeRule::UTC_TIME); | |
| } else { | |
| // Create an array of transition times | |
| int32_t size = dates->size(); | |
| UDate* times = (UDate*)uprv_malloc(sizeof(UDate) * size); | |
| if (times == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return NULL; | |
| } | |
| for (int32_t i = 0; i < size; i++) { | |
| UnicodeString *datestr = (UnicodeString*)dates->elementAt(i); | |
| times[i] = parseDateTimeString(*datestr, fromOffset, status); | |
| if (U_FAILURE(status)) { | |
| uprv_free(times); | |
| return NULL; | |
| } | |
| } | |
| retVal = new TimeArrayTimeZoneRule(zonename, rawOffset, dstSavings, | |
| times, size, DateTimeRule::UTC_TIME); | |
| uprv_free(times); | |
| } | |
| return retVal; | |
| } | |
| /* | |
| * Check if the DOW rule specified by month, weekInMonth and dayOfWeek is equivalent | |
| * to the DateTimerule. | |
| */ | |
| static UBool isEquivalentDateRule(int32_t month, int32_t weekInMonth, int32_t dayOfWeek, const DateTimeRule *dtrule) { | |
| if (month != dtrule->getRuleMonth() || dayOfWeek != dtrule->getRuleDayOfWeek()) { | |
| return FALSE; | |
| } | |
| if (dtrule->getTimeRuleType() != DateTimeRule::WALL_TIME) { | |
| // Do not try to do more intelligent comparison for now. | |
| return FALSE; | |
| } | |
| if (dtrule->getDateRuleType() == DateTimeRule::DOW | |
| && dtrule->getRuleWeekInMonth() == weekInMonth) { | |
| return TRUE; | |
| } | |
| int32_t ruleDOM = dtrule->getRuleDayOfMonth(); | |
| if (dtrule->getDateRuleType() == DateTimeRule::DOW_GEQ_DOM) { | |
| if (ruleDOM%7 == 1 && (ruleDOM + 6)/7 == weekInMonth) { | |
| return TRUE; | |
| } | |
| if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - ruleDOM)%7 == 6 | |
| && weekInMonth == -1*((MONTHLENGTH[month]-ruleDOM+1)/7)) { | |
| return TRUE; | |
| } | |
| } | |
| if (dtrule->getDateRuleType() == DateTimeRule::DOW_LEQ_DOM) { | |
| if (ruleDOM%7 == 0 && ruleDOM/7 == weekInMonth) { | |
| return TRUE; | |
| } | |
| if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - ruleDOM)%7 == 0 | |
| && weekInMonth == -1*((MONTHLENGTH[month] - ruleDOM)/7 + 1)) { | |
| return TRUE; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| /* | |
| * Convert the rule to its equivalent rule using WALL_TIME mode. | |
| * This function returns NULL when the specified DateTimeRule is already | |
| * using WALL_TIME mode. | |
| */ | |
| static DateTimeRule* toWallTimeRule(const DateTimeRule* rule, int32_t rawOffset, int32_t dstSavings) { | |
| if (rule->getTimeRuleType() == DateTimeRule::WALL_TIME) { | |
| return NULL; | |
| } | |
| int32_t wallt = rule->getRuleMillisInDay(); | |
| if (rule->getTimeRuleType() == DateTimeRule::UTC_TIME) { | |
| wallt += (rawOffset + dstSavings); | |
| } else if (rule->getTimeRuleType() == DateTimeRule::STANDARD_TIME) { | |
| wallt += dstSavings; | |
| } | |
| int32_t month = -1, dom = 0, dow = 0; | |
| DateTimeRule::DateRuleType dtype; | |
| int32_t dshift = 0; | |
| if (wallt < 0) { | |
| dshift = -1; | |
| wallt += U_MILLIS_PER_DAY; | |
| } else if (wallt >= U_MILLIS_PER_DAY) { | |
| dshift = 1; | |
| wallt -= U_MILLIS_PER_DAY; | |
| } | |
| month = rule->getRuleMonth(); | |
| dom = rule->getRuleDayOfMonth(); | |
| dow = rule->getRuleDayOfWeek(); | |
| dtype = rule->getDateRuleType(); | |
| if (dshift != 0) { | |
| if (dtype == DateTimeRule::DOW) { | |
| // Convert to DOW_GEW_DOM or DOW_LEQ_DOM rule first | |
| int32_t wim = rule->getRuleWeekInMonth(); | |
| if (wim > 0) { | |
| dtype = DateTimeRule::DOW_GEQ_DOM; | |
| dom = 7 * (wim - 1) + 1; | |
| } else { | |
| dtype = DateTimeRule::DOW_LEQ_DOM; | |
| dom = MONTHLENGTH[month] + 7 * (wim + 1); | |
| } | |
| } | |
| // Shift one day before or after | |
| dom += dshift; | |
| if (dom == 0) { | |
| month--; | |
| month = month < UCAL_JANUARY ? UCAL_DECEMBER : month; | |
| dom = MONTHLENGTH[month]; | |
| } else if (dom > MONTHLENGTH[month]) { | |
| month++; | |
| month = month > UCAL_DECEMBER ? UCAL_JANUARY : month; | |
| dom = 1; | |
| } | |
| if (dtype != DateTimeRule::DOM) { | |
| // Adjust day of week | |
| dow += dshift; | |
| if (dow < UCAL_SUNDAY) { | |
| dow = UCAL_SATURDAY; | |
| } else if (dow > UCAL_SATURDAY) { | |
| dow = UCAL_SUNDAY; | |
| } | |
| } | |
| } | |
| // Create a new rule | |
| DateTimeRule *modifiedRule; | |
| if (dtype == DateTimeRule::DOM) { | |
| modifiedRule = new DateTimeRule(month, dom, wallt, DateTimeRule::WALL_TIME); | |
| } else { | |
| modifiedRule = new DateTimeRule(month, dom, dow, | |
| (dtype == DateTimeRule::DOW_GEQ_DOM), wallt, DateTimeRule::WALL_TIME); | |
| } | |
| return modifiedRule; | |
| } | |
| /* | |
| * Minumum implementations of stream writer/reader, writing/reading | |
| * UnicodeString. For now, we do not want to introduce the dependency | |
| * on the ICU I/O stream in this module. But we want to keep the code | |
| * equivalent to the ICU4J implementation, which utilizes java.io.Writer/ | |
| * Reader. | |
| */ | |
| class VTZWriter { | |
| public: | |
| VTZWriter(UnicodeString& out); | |
| ~VTZWriter(); | |
| void write(const UnicodeString& str); | |
| void write(UChar ch); | |
| void write(const UChar* str); | |
| //void write(const UChar* str, int32_t length); | |
| private: | |
| UnicodeString* out; | |
| }; | |
| VTZWriter::VTZWriter(UnicodeString& output) { | |
| out = &output; | |
| } | |
| VTZWriter::~VTZWriter() { | |
| } | |
| void | |
| VTZWriter::write(const UnicodeString& str) { | |
| out->append(str); | |
| } | |
| void | |
| VTZWriter::write(UChar ch) { | |
| out->append(ch); | |
| } | |
| void | |
| VTZWriter::write(const UChar* str) { | |
| out->append(str, -1); | |
| } | |
| /* | |
| void | |
| VTZWriter::write(const UChar* str, int32_t length) { | |
| out->append(str, length); | |
| } | |
| */ | |
| class VTZReader { | |
| public: | |
| VTZReader(const UnicodeString& input); | |
| ~VTZReader(); | |
| UChar read(void); | |
| private: | |
| const UnicodeString* in; | |
| int32_t index; | |
| }; | |
| VTZReader::VTZReader(const UnicodeString& input) { | |
| in = &input; | |
| index = 0; | |
| } | |
| VTZReader::~VTZReader() { | |
| } | |
| UChar | |
| VTZReader::read(void) { | |
| UChar ch = 0xFFFF; | |
| if (index < in->length()) { | |
| ch = in->charAt(index); | |
| } | |
| index++; | |
| return ch; | |
| } | |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(VTimeZone) | |
| VTimeZone::VTimeZone() | |
| : BasicTimeZone(), tz(NULL), vtzlines(NULL), | |
| lastmod(MAX_MILLIS) { | |
| } | |
| VTimeZone::VTimeZone(const VTimeZone& source) | |
| : BasicTimeZone(source), tz(NULL), vtzlines(NULL), | |
| tzurl(source.tzurl), lastmod(source.lastmod), | |
| olsonzid(source.olsonzid), icutzver(source.icutzver) { | |
| if (source.tz != NULL) { | |
| tz = (BasicTimeZone*)source.tz->clone(); | |
| } | |
| if (source.vtzlines != NULL) { | |
| UErrorCode status = U_ZERO_ERROR; | |
| int32_t size = source.vtzlines->size(); | |
| vtzlines = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, size, status); | |
| if (U_SUCCESS(status)) { | |
| for (int32_t i = 0; i < size; i++) { | |
| UnicodeString *line = (UnicodeString*)source.vtzlines->elementAt(i); | |
| vtzlines->addElement(line->clone(), status); | |
| if (U_FAILURE(status)) { | |
| break; | |
| } | |
| } | |
| } | |
| if (U_FAILURE(status) && vtzlines != NULL) { | |
| delete vtzlines; | |
| } | |
| } | |
| } | |
| VTimeZone::~VTimeZone() { | |
| if (tz != NULL) { | |
| delete tz; | |
| } | |
| if (vtzlines != NULL) { | |
| delete vtzlines; | |
| } | |
| } | |
| VTimeZone& | |
| VTimeZone::operator=(const VTimeZone& right) { | |
| if (this == &right) { | |
| return *this; | |
| } | |
| if (*this != right) { | |
| BasicTimeZone::operator=(right); | |
| if (tz != NULL) { | |
| delete tz; | |
| tz = NULL; | |
| } | |
| if (right.tz != NULL) { | |
| tz = (BasicTimeZone*)right.tz->clone(); | |
| } | |
| if (vtzlines != NULL) { | |
| delete vtzlines; | |
| } | |
| if (right.vtzlines != NULL) { | |
| UErrorCode status = U_ZERO_ERROR; | |
| int32_t size = right.vtzlines->size(); | |
| vtzlines = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, size, status); | |
| if (U_SUCCESS(status)) { | |
| for (int32_t i = 0; i < size; i++) { | |
| UnicodeString *line = (UnicodeString*)right.vtzlines->elementAt(i); | |
| vtzlines->addElement(line->clone(), status); | |
| if (U_FAILURE(status)) { | |
| break; | |
| } | |
| } | |
| } | |
| if (U_FAILURE(status) && vtzlines != NULL) { | |
| delete vtzlines; | |
| vtzlines = NULL; | |
| } | |
| } | |
| tzurl = right.tzurl; | |
| lastmod = right.lastmod; | |
| olsonzid = right.olsonzid; | |
| icutzver = right.icutzver; | |
| } | |
| return *this; | |
| } | |
| UBool | |
| VTimeZone::operator==(const TimeZone& that) const { | |
| if (this == &that) { | |
| return TRUE; | |
| } | |
| if (typeid(*this) != typeid(that) || !BasicTimeZone::operator==(that)) { | |
| return FALSE; | |
| } | |
| VTimeZone *vtz = (VTimeZone*)&that; | |
| if (*tz == *(vtz->tz) | |
| && tzurl == vtz->tzurl | |
| && lastmod == vtz->lastmod | |
| /* && olsonzid = that.olsonzid */ | |
| /* && icutzver = that.icutzver */) { | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| UBool | |
| VTimeZone::operator!=(const TimeZone& that) const { | |
| return !operator==(that); | |
| } | |
| VTimeZone* | |
| VTimeZone::createVTimeZoneByID(const UnicodeString& ID) { | |
| VTimeZone *vtz = new VTimeZone(); | |
| vtz->tz = (BasicTimeZone*)TimeZone::createTimeZone(ID); | |
| vtz->tz->getID(vtz->olsonzid); | |
| // Set ICU tzdata version | |
| UErrorCode status = U_ZERO_ERROR; | |
| UResourceBundle *bundle = NULL; | |
| const UChar* versionStr = NULL; | |
| int32_t len = 0; | |
| bundle = ures_openDirect(NULL, "zoneinfo64", &status); | |
| versionStr = ures_getStringByKey(bundle, "TZVersion", &len, &status); | |
| if (U_SUCCESS(status)) { | |
| vtz->icutzver.setTo(versionStr, len); | |
| } | |
| ures_close(bundle); | |
| return vtz; | |
| } | |
| VTimeZone* | |
| VTimeZone::createVTimeZoneFromBasicTimeZone(const BasicTimeZone& basic_time_zone, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| VTimeZone *vtz = new VTimeZone(); | |
| if (vtz == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return NULL; | |
| } | |
| vtz->tz = (BasicTimeZone *)basic_time_zone.clone(); | |
| if (vtz->tz == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| delete vtz; | |
| return NULL; | |
| } | |
| vtz->tz->getID(vtz->olsonzid); | |
| // Set ICU tzdata version | |
| UResourceBundle *bundle = NULL; | |
| const UChar* versionStr = NULL; | |
| int32_t len = 0; | |
| bundle = ures_openDirect(NULL, "zoneinfo64", &status); | |
| versionStr = ures_getStringByKey(bundle, "TZVersion", &len, &status); | |
| if (U_SUCCESS(status)) { | |
| vtz->icutzver.setTo(versionStr, len); | |
| } | |
| ures_close(bundle); | |
| return vtz; | |
| } | |
| VTimeZone* | |
| VTimeZone::createVTimeZone(const UnicodeString& vtzdata, UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| VTZReader reader(vtzdata); | |
| VTimeZone *vtz = new VTimeZone(); | |
| vtz->load(reader, status); | |
| if (U_FAILURE(status)) { | |
| delete vtz; | |
| return NULL; | |
| } | |
| return vtz; | |
| } | |
| UBool | |
| VTimeZone::getTZURL(UnicodeString& url) const { | |
| if (tzurl.length() > 0) { | |
| url = tzurl; | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| void | |
| VTimeZone::setTZURL(const UnicodeString& url) { | |
| tzurl = url; | |
| } | |
| UBool | |
| VTimeZone::getLastModified(UDate& lastModified) const { | |
| if (lastmod != MAX_MILLIS) { | |
| lastModified = lastmod; | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| void | |
| VTimeZone::setLastModified(UDate lastModified) { | |
| lastmod = lastModified; | |
| } | |
| void | |
| VTimeZone::write(UnicodeString& result, UErrorCode& status) const { | |
| result.remove(); | |
| VTZWriter writer(result); | |
| write(writer, status); | |
| } | |
| void | |
| VTimeZone::write(UDate start, UnicodeString& result, UErrorCode& status) const { | |
| result.remove(); | |
| VTZWriter writer(result); | |
| write(start, writer, status); | |
| } | |
| void | |
| VTimeZone::writeSimple(UDate time, UnicodeString& result, UErrorCode& status) const { | |
| result.remove(); | |
| VTZWriter writer(result); | |
| writeSimple(time, writer, status); | |
| } | |
| TimeZone* | |
| VTimeZone::clone(void) const { | |
| return new VTimeZone(*this); | |
| } | |
| int32_t | |
| VTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day, | |
| uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const { | |
| return tz->getOffset(era, year, month, day, dayOfWeek, millis, status); | |
| } | |
| int32_t | |
| VTimeZone::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 { | |
| return tz->getOffset(era, year, month, day, dayOfWeek, millis, monthLength, status); | |
| } | |
| void | |
| VTimeZone::getOffset(UDate date, UBool local, int32_t& rawOffset, | |
| int32_t& dstOffset, UErrorCode& status) const { | |
| return tz->getOffset(date, local, rawOffset, dstOffset, status); | |
| } | |
| void | |
| VTimeZone::setRawOffset(int32_t offsetMillis) { | |
| tz->setRawOffset(offsetMillis); | |
| } | |
| int32_t | |
| VTimeZone::getRawOffset(void) const { | |
| return tz->getRawOffset(); | |
| } | |
| UBool | |
| VTimeZone::useDaylightTime(void) const { | |
| return tz->useDaylightTime(); | |
| } | |
| UBool | |
| VTimeZone::inDaylightTime(UDate date, UErrorCode& status) const { | |
| return tz->inDaylightTime(date, status); | |
| } | |
| UBool | |
| VTimeZone::hasSameRules(const TimeZone& other) const { | |
| return tz->hasSameRules(other); | |
| } | |
| UBool | |
| VTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const { | |
| return tz->getNextTransition(base, inclusive, result); | |
| } | |
| UBool | |
| VTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const { | |
| return tz->getPreviousTransition(base, inclusive, result); | |
| } | |
| int32_t | |
| VTimeZone::countTransitionRules(UErrorCode& status) const { | |
| return tz->countTransitionRules(status); | |
| } | |
| void | |
| VTimeZone::getTimeZoneRules(const InitialTimeZoneRule*& initial, | |
| const TimeZoneRule* trsrules[], int32_t& trscount, | |
| UErrorCode& status) const { | |
| tz->getTimeZoneRules(initial, trsrules, trscount, status); | |
| } | |
| void | |
| VTimeZone::load(VTZReader& reader, UErrorCode& status) { | |
| vtzlines = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, DEFAULT_VTIMEZONE_LINES, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| UBool eol = FALSE; | |
| UBool start = FALSE; | |
| UBool success = FALSE; | |
| UnicodeString line; | |
| while (TRUE) { | |
| UChar ch = reader.read(); | |
| if (ch == 0xFFFF) { | |
| // end of file | |
| if (start && line.startsWith(ICAL_END_VTIMEZONE, -1)) { | |
| vtzlines->addElement(new UnicodeString(line), status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupVtzlines; | |
| } | |
| success = TRUE; | |
| } | |
| break; | |
| } | |
| if (ch == 0x000D) { | |
| // CR, must be followed by LF according to the definition in RFC2445 | |
| continue; | |
| } | |
| if (eol) { | |
| if (ch != 0x0009 && ch != 0x0020) { | |
| // NOT followed by TAB/SP -> new line | |
| if (start) { | |
| if (line.length() > 0) { | |
| vtzlines->addElement(new UnicodeString(line), status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupVtzlines; | |
| } | |
| } | |
| } | |
| line.remove(); | |
| if (ch != 0x000A) { | |
| line.append(ch); | |
| } | |
| } | |
| eol = FALSE; | |
| } else { | |
| if (ch == 0x000A) { | |
| // LF | |
| eol = TRUE; | |
| if (start) { | |
| if (line.startsWith(ICAL_END_VTIMEZONE, -1)) { | |
| vtzlines->addElement(new UnicodeString(line), status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupVtzlines; | |
| } | |
| success = TRUE; | |
| break; | |
| } | |
| } else { | |
| if (line.startsWith(ICAL_BEGIN_VTIMEZONE, -1)) { | |
| vtzlines->addElement(new UnicodeString(line), status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupVtzlines; | |
| } | |
| line.remove(); | |
| start = TRUE; | |
| eol = FALSE; | |
| } | |
| } | |
| } else { | |
| line.append(ch); | |
| } | |
| } | |
| } | |
| if (!success) { | |
| if (U_SUCCESS(status)) { | |
| status = U_INVALID_STATE_ERROR; | |
| } | |
| goto cleanupVtzlines; | |
| } | |
| parse(status); | |
| return; | |
| cleanupVtzlines: | |
| delete vtzlines; | |
| vtzlines = NULL; | |
| } | |
| // parser state | |
| #define INI 0 // Initial state | |
| #define VTZ 1 // In VTIMEZONE | |
| #define TZI 2 // In STANDARD or DAYLIGHT | |
| #define DEF_DSTSAVINGS (60*60*1000) | |
| #define DEF_TZSTARTTIME (0.0) | |
| void | |
| VTimeZone::parse(UErrorCode& status) { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if (vtzlines == NULL || vtzlines->size() == 0) { | |
| status = U_INVALID_STATE_ERROR; | |
| return; | |
| } | |
| InitialTimeZoneRule *initialRule = NULL; | |
| RuleBasedTimeZone *rbtz = NULL; | |
| // timezone ID | |
| UnicodeString tzid; | |
| int32_t state = INI; | |
| int32_t n = 0; | |
| UBool dst = FALSE; // current zone type | |
| UnicodeString from; // current zone from offset | |
| UnicodeString to; // current zone offset | |
| UnicodeString zonename; // current zone name | |
| UnicodeString dtstart; // current zone starts | |
| UBool isRRULE = FALSE; // true if the rule is described by RRULE | |
| int32_t initialRawOffset = 0; // initial offset | |
| int32_t initialDSTSavings = 0; // initial offset | |
| UDate firstStart = MAX_MILLIS; // the earliest rule start time | |
| UnicodeString name; // RFC2445 prop name | |
| UnicodeString value; // RFC2445 prop value | |
| UVector *dates = NULL; // list of RDATE or RRULE strings | |
| UVector *rules = NULL; // list of TimeZoneRule instances | |
| int32_t finalRuleIdx = -1; | |
| int32_t finalRuleCount = 0; | |
| rules = new UVector(status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| // Set the deleter to remove TimeZoneRule vectors to avoid memory leaks due to unowned TimeZoneRules. | |
| rules->setDeleter(deleteTimeZoneRule); | |
| dates = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| if (rules == NULL || dates == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| goto cleanupParse; | |
| } | |
| for (n = 0; n < vtzlines->size(); n++) { | |
| UnicodeString *line = (UnicodeString*)vtzlines->elementAt(n); | |
| int32_t valueSep = line->indexOf(COLON); | |
| if (valueSep < 0) { | |
| continue; | |
| } | |
| name.setTo(*line, 0, valueSep); | |
| value.setTo(*line, valueSep + 1); | |
| switch (state) { | |
| case INI: | |
| if (name.compare(ICAL_BEGIN, -1) == 0 | |
| && value.compare(ICAL_VTIMEZONE, -1) == 0) { | |
| state = VTZ; | |
| } | |
| break; | |
| case VTZ: | |
| if (name.compare(ICAL_TZID, -1) == 0) { | |
| tzid = value; | |
| } else if (name.compare(ICAL_TZURL, -1) == 0) { | |
| tzurl = value; | |
| } else if (name.compare(ICAL_LASTMOD, -1) == 0) { | |
| // Always in 'Z' format, so the offset argument for the parse method | |
| // can be any value. | |
| lastmod = parseDateTimeString(value, 0, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| } else if (name.compare(ICAL_BEGIN, -1) == 0) { | |
| UBool isDST = (value.compare(ICAL_DAYLIGHT, -1) == 0); | |
| if (value.compare(ICAL_STANDARD, -1) == 0 || isDST) { | |
| // tzid must be ready at this point | |
| if (tzid.length() == 0) { | |
| goto cleanupParse; | |
| } | |
| // initialize current zone properties | |
| if (dates->size() != 0) { | |
| dates->removeAllElements(); | |
| } | |
| isRRULE = FALSE; | |
| from.remove(); | |
| to.remove(); | |
| zonename.remove(); | |
| dst = isDST; | |
| state = TZI; | |
| } else { | |
| // BEGIN property other than STANDARD/DAYLIGHT | |
| // must not be there. | |
| goto cleanupParse; | |
| } | |
| } else if (name.compare(ICAL_END, -1) == 0) { | |
| break; | |
| } | |
| break; | |
| case TZI: | |
| if (name.compare(ICAL_DTSTART, -1) == 0) { | |
| dtstart = value; | |
| } else if (name.compare(ICAL_TZNAME, -1) == 0) { | |
| zonename = value; | |
| } else if (name.compare(ICAL_TZOFFSETFROM, -1) == 0) { | |
| from = value; | |
| } else if (name.compare(ICAL_TZOFFSETTO, -1) == 0) { | |
| to = value; | |
| } else if (name.compare(ICAL_RDATE, -1) == 0) { | |
| // RDATE mixed with RRULE is not supported | |
| if (isRRULE) { | |
| goto cleanupParse; | |
| } | |
| // RDATE value may contain multiple date delimited | |
| // by comma | |
| UBool nextDate = TRUE; | |
| int32_t dstart = 0; | |
| UnicodeString *dstr; | |
| while (nextDate) { | |
| int32_t dend = value.indexOf(COMMA, dstart); | |
| if (dend == -1) { | |
| dstr = new UnicodeString(value, dstart); | |
| nextDate = FALSE; | |
| } else { | |
| dstr = new UnicodeString(value, dstart, dend - dstart); | |
| } | |
| dates->addElement(dstr, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| dstart = dend + 1; | |
| } | |
| } else if (name.compare(ICAL_RRULE, -1) == 0) { | |
| // RRULE mixed with RDATE is not supported | |
| if (!isRRULE && dates->size() != 0) { | |
| goto cleanupParse; | |
| } | |
| isRRULE = true; | |
| dates->addElement(new UnicodeString(value), status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| } else if (name.compare(ICAL_END, -1) == 0) { | |
| // Mandatory properties | |
| if (dtstart.length() == 0 || from.length() == 0 || to.length() == 0) { | |
| goto cleanupParse; | |
| } | |
| // if zonename is not available, create one from tzid | |
| if (zonename.length() == 0) { | |
| getDefaultTZName(tzid, dst, zonename); | |
| } | |
| // create a time zone rule | |
| TimeZoneRule *rule = NULL; | |
| int32_t fromOffset = 0; | |
| int32_t toOffset = 0; | |
| int32_t rawOffset = 0; | |
| int32_t dstSavings = 0; | |
| UDate start = 0; | |
| // Parse TZOFFSETFROM/TZOFFSETTO | |
| fromOffset = offsetStrToMillis(from, status); | |
| toOffset = offsetStrToMillis(to, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| if (dst) { | |
| // If daylight, use the previous offset as rawoffset if positive | |
| if (toOffset - fromOffset > 0) { | |
| rawOffset = fromOffset; | |
| dstSavings = toOffset - fromOffset; | |
| } else { | |
| // This is rare case.. just use 1 hour DST savings | |
| rawOffset = toOffset - DEF_DSTSAVINGS; | |
| dstSavings = DEF_DSTSAVINGS; | |
| } | |
| } else { | |
| rawOffset = toOffset; | |
| dstSavings = 0; | |
| } | |
| // start time | |
| start = parseDateTimeString(dtstart, fromOffset, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| // Create the rule | |
| UDate actualStart = MAX_MILLIS; | |
| if (isRRULE) { | |
| rule = createRuleByRRULE(zonename, rawOffset, dstSavings, start, dates, fromOffset, status); | |
| } else { | |
| rule = createRuleByRDATE(zonename, rawOffset, dstSavings, start, dates, fromOffset, status); | |
| } | |
| if (U_FAILURE(status) || rule == NULL) { | |
| goto cleanupParse; | |
| } else { | |
| UBool startAvail = rule->getFirstStart(fromOffset, 0, actualStart); | |
| if (startAvail && actualStart < firstStart) { | |
| // save from offset information for the earliest rule | |
| firstStart = actualStart; | |
| // If this is STD, assume the time before this transtion | |
| // is DST when the difference is 1 hour. This might not be | |
| // accurate, but VTIMEZONE data does not have such info. | |
| if (dstSavings > 0) { | |
| initialRawOffset = fromOffset; | |
| initialDSTSavings = 0; | |
| } else { | |
| if (fromOffset - toOffset == DEF_DSTSAVINGS) { | |
| initialRawOffset = fromOffset - DEF_DSTSAVINGS; | |
| initialDSTSavings = DEF_DSTSAVINGS; | |
| } else { | |
| initialRawOffset = fromOffset; | |
| initialDSTSavings = 0; | |
| } | |
| } | |
| } | |
| } | |
| rules->addElement(rule, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| state = VTZ; | |
| } | |
| break; | |
| } | |
| } | |
| // Must have at least one rule | |
| if (rules->size() == 0) { | |
| goto cleanupParse; | |
| } | |
| // Create a initial rule | |
| getDefaultTZName(tzid, FALSE, zonename); | |
| initialRule = new InitialTimeZoneRule(zonename, | |
| initialRawOffset, initialDSTSavings); | |
| if (initialRule == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| goto cleanupParse; | |
| } | |
| // Finally, create the RuleBasedTimeZone | |
| rbtz = new RuleBasedTimeZone(tzid, initialRule); | |
| if (rbtz == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| goto cleanupParse; | |
| } | |
| initialRule = NULL; // already adopted by RBTZ, no need to delete | |
| for (n = 0; n < rules->size(); n++) { | |
| TimeZoneRule *r = (TimeZoneRule*)rules->elementAt(n); | |
| AnnualTimeZoneRule *atzrule = dynamic_cast<AnnualTimeZoneRule *>(r); | |
| if (atzrule != NULL) { | |
| if (atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR) { | |
| finalRuleCount++; | |
| finalRuleIdx = n; | |
| } | |
| } | |
| } | |
| if (finalRuleCount > 2) { | |
| // Too many final rules | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| goto cleanupParse; | |
| } | |
| if (finalRuleCount == 1) { | |
| if (rules->size() == 1) { | |
| // Only one final rule, only governs the initial rule, | |
| // which is already initialized, thus, we do not need to | |
| // add this transition rule | |
| rules->removeAllElements(); | |
| } else { | |
| // Normalize the final rule | |
| AnnualTimeZoneRule *finalRule = (AnnualTimeZoneRule*)rules->elementAt(finalRuleIdx); | |
| int32_t tmpRaw = finalRule->getRawOffset(); | |
| int32_t tmpDST = finalRule->getDSTSavings(); | |
| // Find the last non-final rule | |
| UDate finalStart, start; | |
| finalRule->getFirstStart(initialRawOffset, initialDSTSavings, finalStart); | |
| start = finalStart; | |
| for (n = 0; n < rules->size(); n++) { | |
| if (finalRuleIdx == n) { | |
| continue; | |
| } | |
| TimeZoneRule *r = (TimeZoneRule*)rules->elementAt(n); | |
| UDate lastStart; | |
| r->getFinalStart(tmpRaw, tmpDST, lastStart); | |
| if (lastStart > start) { | |
| finalRule->getNextStart(lastStart, | |
| r->getRawOffset(), | |
| r->getDSTSavings(), | |
| FALSE, | |
| start); | |
| } | |
| } | |
| TimeZoneRule *newRule; | |
| UnicodeString tznam; | |
| if (start == finalStart) { | |
| // Transform this into a single transition | |
| newRule = new TimeArrayTimeZoneRule( | |
| finalRule->getName(tznam), | |
| finalRule->getRawOffset(), | |
| finalRule->getDSTSavings(), | |
| &finalStart, | |
| 1, | |
| DateTimeRule::UTC_TIME); | |
| } else { | |
| // Update the end year | |
| int32_t y, m, d, dow, doy, mid; | |
| Grego::timeToFields(start, y, m, d, dow, doy, mid); | |
| newRule = new AnnualTimeZoneRule( | |
| finalRule->getName(tznam), | |
| finalRule->getRawOffset(), | |
| finalRule->getDSTSavings(), | |
| *(finalRule->getRule()), | |
| finalRule->getStartYear(), | |
| y); | |
| } | |
| if (newRule == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| goto cleanupParse; | |
| } | |
| rules->removeElementAt(finalRuleIdx); | |
| rules->addElement(newRule, status); | |
| if (U_FAILURE(status)) { | |
| delete newRule; | |
| goto cleanupParse; | |
| } | |
| } | |
| } | |
| while (!rules->isEmpty()) { | |
| TimeZoneRule *tzr = (TimeZoneRule*)rules->orphanElementAt(0); | |
| rbtz->addTransitionRule(tzr, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| } | |
| rbtz->complete(status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupParse; | |
| } | |
| delete rules; | |
| delete dates; | |
| tz = rbtz; | |
| setID(tzid); | |
| return; | |
| cleanupParse: | |
| if (rules != NULL) { | |
| while (!rules->isEmpty()) { | |
| TimeZoneRule *r = (TimeZoneRule*)rules->orphanElementAt(0); | |
| delete r; | |
| } | |
| delete rules; | |
| } | |
| if (dates != NULL) { | |
| delete dates; | |
| } | |
| if (initialRule != NULL) { | |
| delete initialRule; | |
| } | |
| if (rbtz != NULL) { | |
| delete rbtz; | |
| } | |
| return; | |
| } | |
| void | |
| VTimeZone::write(VTZWriter& writer, UErrorCode& status) const { | |
| if (vtzlines != NULL) { | |
| for (int32_t i = 0; i < vtzlines->size(); i++) { | |
| UnicodeString *line = (UnicodeString*)vtzlines->elementAt(i); | |
| if (line->startsWith(ICAL_TZURL, -1) | |
| && line->charAt(u_strlen(ICAL_TZURL)) == COLON) { | |
| writer.write(ICAL_TZURL); | |
| writer.write(COLON); | |
| writer.write(tzurl); | |
| writer.write(ICAL_NEWLINE); | |
| } else if (line->startsWith(ICAL_LASTMOD, -1) | |
| && line->charAt(u_strlen(ICAL_LASTMOD)) == COLON) { | |
| UnicodeString utcString; | |
| writer.write(ICAL_LASTMOD); | |
| writer.write(COLON); | |
| writer.write(getUTCDateTimeString(lastmod, utcString)); | |
| writer.write(ICAL_NEWLINE); | |
| } else { | |
| writer.write(*line); | |
| writer.write(ICAL_NEWLINE); | |
| } | |
| } | |
| } else { | |
| UVector *customProps = NULL; | |
| if (olsonzid.length() > 0 && icutzver.length() > 0) { | |
| customProps = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| UnicodeString *icutzprop = new UnicodeString(ICU_TZINFO_PROP); | |
| icutzprop->append(olsonzid); | |
| icutzprop->append((UChar)0x005B/*'['*/); | |
| icutzprop->append(icutzver); | |
| icutzprop->append((UChar)0x005D/*']'*/); | |
| customProps->addElement(icutzprop, status); | |
| if (U_FAILURE(status)) { | |
| delete icutzprop; | |
| delete customProps; | |
| return; | |
| } | |
| } | |
| writeZone(writer, *tz, customProps, status); | |
| delete customProps; | |
| } | |
| } | |
| void | |
| VTimeZone::write(UDate start, VTZWriter& writer, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| InitialTimeZoneRule *initial = NULL; | |
| UVector *transitionRules = NULL; | |
| UVector customProps(uprv_deleteUObject, uhash_compareUnicodeString, status); | |
| UnicodeString tzid; | |
| // Extract rules applicable to dates after the start time | |
| getTimeZoneRulesAfter(start, initial, transitionRules, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // Create a RuleBasedTimeZone with the subset rule | |
| getID(tzid); | |
| RuleBasedTimeZone rbtz(tzid, initial); | |
| if (transitionRules != NULL) { | |
| while (!transitionRules->isEmpty()) { | |
| TimeZoneRule *tr = (TimeZoneRule*)transitionRules->orphanElementAt(0); | |
| rbtz.addTransitionRule(tr, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupWritePartial; | |
| } | |
| } | |
| delete transitionRules; | |
| transitionRules = NULL; | |
| } | |
| rbtz.complete(status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupWritePartial; | |
| } | |
| if (olsonzid.length() > 0 && icutzver.length() > 0) { | |
| UnicodeString *icutzprop = new UnicodeString(ICU_TZINFO_PROP); | |
| icutzprop->append(olsonzid); | |
| icutzprop->append((UChar)0x005B/*'['*/); | |
| icutzprop->append(icutzver); | |
| icutzprop->append(ICU_TZINFO_PARTIAL, -1); | |
| appendMillis(start, *icutzprop); | |
| icutzprop->append((UChar)0x005D/*']'*/); | |
| customProps.addElement(icutzprop, status); | |
| if (U_FAILURE(status)) { | |
| delete icutzprop; | |
| goto cleanupWritePartial; | |
| } | |
| } | |
| writeZone(writer, rbtz, &customProps, status); | |
| return; | |
| cleanupWritePartial: | |
| if (initial != NULL) { | |
| delete initial; | |
| } | |
| if (transitionRules != NULL) { | |
| while (!transitionRules->isEmpty()) { | |
| TimeZoneRule *tr = (TimeZoneRule*)transitionRules->orphanElementAt(0); | |
| delete tr; | |
| } | |
| delete transitionRules; | |
| } | |
| } | |
| void | |
| VTimeZone::writeSimple(UDate time, VTZWriter& writer, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| UVector customProps(uprv_deleteUObject, uhash_compareUnicodeString, status); | |
| UnicodeString tzid; | |
| // Extract simple rules | |
| InitialTimeZoneRule *initial = NULL; | |
| AnnualTimeZoneRule *std = NULL, *dst = NULL; | |
| getSimpleRulesNear(time, initial, std, dst, status); | |
| if (U_SUCCESS(status)) { | |
| // Create a RuleBasedTimeZone with the subset rule | |
| getID(tzid); | |
| RuleBasedTimeZone rbtz(tzid, initial); | |
| if (std != NULL && dst != NULL) { | |
| rbtz.addTransitionRule(std, status); | |
| rbtz.addTransitionRule(dst, status); | |
| } | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteSimple; | |
| } | |
| if (olsonzid.length() > 0 && icutzver.length() > 0) { | |
| UnicodeString *icutzprop = new UnicodeString(ICU_TZINFO_PROP); | |
| icutzprop->append(olsonzid); | |
| icutzprop->append((UChar)0x005B/*'['*/); | |
| icutzprop->append(icutzver); | |
| icutzprop->append(ICU_TZINFO_SIMPLE, -1); | |
| appendMillis(time, *icutzprop); | |
| icutzprop->append((UChar)0x005D/*']'*/); | |
| customProps.addElement(icutzprop, status); | |
| if (U_FAILURE(status)) { | |
| delete icutzprop; | |
| goto cleanupWriteSimple; | |
| } | |
| } | |
| writeZone(writer, rbtz, &customProps, status); | |
| } | |
| return; | |
| cleanupWriteSimple: | |
| if (initial != NULL) { | |
| delete initial; | |
| } | |
| if (std != NULL) { | |
| delete std; | |
| } | |
| if (dst != NULL) { | |
| delete dst; | |
| } | |
| } | |
| void | |
| VTimeZone::writeZone(VTZWriter& w, BasicTimeZone& basictz, | |
| UVector* customProps, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| writeHeaders(w, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if (customProps != NULL) { | |
| for (int32_t i = 0; i < customProps->size(); i++) { | |
| UnicodeString *custprop = (UnicodeString*)customProps->elementAt(i); | |
| w.write(*custprop); | |
| w.write(ICAL_NEWLINE); | |
| } | |
| } | |
| UDate t = MIN_MILLIS; | |
| UnicodeString dstName; | |
| int32_t dstFromOffset = 0; | |
| int32_t dstFromDSTSavings = 0; | |
| int32_t dstToOffset = 0; | |
| int32_t dstStartYear = 0; | |
| int32_t dstMonth = 0; | |
| int32_t dstDayOfWeek = 0; | |
| int32_t dstWeekInMonth = 0; | |
| int32_t dstMillisInDay = 0; | |
| UDate dstStartTime = 0.0; | |
| UDate dstUntilTime = 0.0; | |
| int32_t dstCount = 0; | |
| AnnualTimeZoneRule *finalDstRule = NULL; | |
| UnicodeString stdName; | |
| int32_t stdFromOffset = 0; | |
| int32_t stdFromDSTSavings = 0; | |
| int32_t stdToOffset = 0; | |
| int32_t stdStartYear = 0; | |
| int32_t stdMonth = 0; | |
| int32_t stdDayOfWeek = 0; | |
| int32_t stdWeekInMonth = 0; | |
| int32_t stdMillisInDay = 0; | |
| UDate stdStartTime = 0.0; | |
| UDate stdUntilTime = 0.0; | |
| int32_t stdCount = 0; | |
| AnnualTimeZoneRule *finalStdRule = NULL; | |
| int32_t year, month, dom, dow, doy, mid; | |
| UBool hasTransitions = FALSE; | |
| TimeZoneTransition tzt; | |
| UBool tztAvail; | |
| UnicodeString name; | |
| UBool isDst; | |
| // Going through all transitions | |
| while (TRUE) { | |
| tztAvail = basictz.getNextTransition(t, FALSE, tzt); | |
| if (!tztAvail) { | |
| break; | |
| } | |
| hasTransitions = TRUE; | |
| t = tzt.getTime(); | |
| tzt.getTo()->getName(name); | |
| isDst = (tzt.getTo()->getDSTSavings() != 0); | |
| int32_t fromOffset = tzt.getFrom()->getRawOffset() + tzt.getFrom()->getDSTSavings(); | |
| int32_t fromDSTSavings = tzt.getFrom()->getDSTSavings(); | |
| int32_t toOffset = tzt.getTo()->getRawOffset() + tzt.getTo()->getDSTSavings(); | |
| Grego::timeToFields(tzt.getTime() + fromOffset, year, month, dom, dow, doy, mid); | |
| int32_t weekInMonth = Grego::dayOfWeekInMonth(year, month, dom); | |
| UBool sameRule = FALSE; | |
| const AnnualTimeZoneRule *atzrule; | |
| if (isDst) { | |
| if (finalDstRule == NULL | |
| && (atzrule = dynamic_cast<const AnnualTimeZoneRule *>(tzt.getTo())) != NULL | |
| && atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR | |
| ) { | |
| finalDstRule = (AnnualTimeZoneRule*)tzt.getTo()->clone(); | |
| } | |
| if (dstCount > 0) { | |
| if (year == dstStartYear + dstCount | |
| && name.compare(dstName) == 0 | |
| && dstFromOffset == fromOffset | |
| && dstToOffset == toOffset | |
| && dstMonth == month | |
| && dstDayOfWeek == dow | |
| && dstWeekInMonth == weekInMonth | |
| && dstMillisInDay == mid) { | |
| // Update until time | |
| dstUntilTime = t; | |
| dstCount++; | |
| sameRule = TRUE; | |
| } | |
| if (!sameRule) { | |
| if (dstCount == 1) { | |
| writeZonePropsByTime(w, TRUE, dstName, dstFromOffset, dstToOffset, dstStartTime, | |
| TRUE, status); | |
| } else { | |
| writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset, | |
| dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime, status); | |
| } | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| } | |
| } | |
| if (!sameRule) { | |
| // Reset this DST information | |
| dstName = name; | |
| dstFromOffset = fromOffset; | |
| dstFromDSTSavings = fromDSTSavings; | |
| dstToOffset = toOffset; | |
| dstStartYear = year; | |
| dstMonth = month; | |
| dstDayOfWeek = dow; | |
| dstWeekInMonth = weekInMonth; | |
| dstMillisInDay = mid; | |
| dstStartTime = dstUntilTime = t; | |
| dstCount = 1; | |
| } | |
| if (finalStdRule != NULL && finalDstRule != NULL) { | |
| break; | |
| } | |
| } else { | |
| if (finalStdRule == NULL | |
| && (atzrule = dynamic_cast<const AnnualTimeZoneRule *>(tzt.getTo())) != NULL | |
| && atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR | |
| ) { | |
| finalStdRule = (AnnualTimeZoneRule*)tzt.getTo()->clone(); | |
| } | |
| if (stdCount > 0) { | |
| if (year == stdStartYear + stdCount | |
| && name.compare(stdName) == 0 | |
| && stdFromOffset == fromOffset | |
| && stdToOffset == toOffset | |
| && stdMonth == month | |
| && stdDayOfWeek == dow | |
| && stdWeekInMonth == weekInMonth | |
| && stdMillisInDay == mid) { | |
| // Update until time | |
| stdUntilTime = t; | |
| stdCount++; | |
| sameRule = TRUE; | |
| } | |
| if (!sameRule) { | |
| if (stdCount == 1) { | |
| writeZonePropsByTime(w, FALSE, stdName, stdFromOffset, stdToOffset, stdStartTime, | |
| TRUE, status); | |
| } else { | |
| writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset, | |
| stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime, status); | |
| } | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| } | |
| } | |
| if (!sameRule) { | |
| // Reset this STD information | |
| stdName = name; | |
| stdFromOffset = fromOffset; | |
| stdFromDSTSavings = fromDSTSavings; | |
| stdToOffset = toOffset; | |
| stdStartYear = year; | |
| stdMonth = month; | |
| stdDayOfWeek = dow; | |
| stdWeekInMonth = weekInMonth; | |
| stdMillisInDay = mid; | |
| stdStartTime = stdUntilTime = t; | |
| stdCount = 1; | |
| } | |
| if (finalStdRule != NULL && finalDstRule != NULL) { | |
| break; | |
| } | |
| } | |
| } | |
| if (!hasTransitions) { | |
| // No transition - put a single non transition RDATE | |
| int32_t raw, dst, offset; | |
| basictz.getOffset(0.0/*any time*/, FALSE, raw, dst, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| offset = raw + dst; | |
| isDst = (dst != 0); | |
| UnicodeString tzid; | |
| basictz.getID(tzid); | |
| getDefaultTZName(tzid, isDst, name); | |
| writeZonePropsByTime(w, isDst, name, | |
| offset, offset, DEF_TZSTARTTIME - offset, FALSE, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| } else { | |
| if (dstCount > 0) { | |
| if (finalDstRule == NULL) { | |
| if (dstCount == 1) { | |
| writeZonePropsByTime(w, TRUE, dstName, dstFromOffset, dstToOffset, dstStartTime, | |
| TRUE, status); | |
| } else { | |
| writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset, | |
| dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime, status); | |
| } | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| } else { | |
| if (dstCount == 1) { | |
| writeFinalRule(w, TRUE, finalDstRule, | |
| dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, dstStartTime, status); | |
| } else { | |
| // Use a single rule if possible | |
| if (isEquivalentDateRule(dstMonth, dstWeekInMonth, dstDayOfWeek, finalDstRule->getRule())) { | |
| writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset, | |
| dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, MAX_MILLIS, status); | |
| } else { | |
| // Not equivalent rule - write out two different rules | |
| writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset, | |
| dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| UDate nextStart; | |
| UBool nextStartAvail = finalDstRule->getNextStart(dstUntilTime, dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, false, nextStart); | |
| U_ASSERT(nextStartAvail); | |
| if (nextStartAvail) { | |
| writeFinalRule(w, TRUE, finalDstRule, | |
| dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, nextStart, status); | |
| } | |
| } | |
| } | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| } | |
| } | |
| if (stdCount > 0) { | |
| if (finalStdRule == NULL) { | |
| if (stdCount == 1) { | |
| writeZonePropsByTime(w, FALSE, stdName, stdFromOffset, stdToOffset, stdStartTime, | |
| TRUE, status); | |
| } else { | |
| writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset, | |
| stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime, status); | |
| } | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| } else { | |
| if (stdCount == 1) { | |
| writeFinalRule(w, FALSE, finalStdRule, | |
| stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, stdStartTime, status); | |
| } else { | |
| // Use a single rule if possible | |
| if (isEquivalentDateRule(stdMonth, stdWeekInMonth, stdDayOfWeek, finalStdRule->getRule())) { | |
| writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset, | |
| stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, MAX_MILLIS, status); | |
| } else { | |
| // Not equivalent rule - write out two different rules | |
| writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset, | |
| stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime, status); | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| UDate nextStart; | |
| UBool nextStartAvail = finalStdRule->getNextStart(stdUntilTime, stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, false, nextStart); | |
| U_ASSERT(nextStartAvail); | |
| if (nextStartAvail) { | |
| writeFinalRule(w, FALSE, finalStdRule, | |
| stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, nextStart, status); | |
| } | |
| } | |
| } | |
| if (U_FAILURE(status)) { | |
| goto cleanupWriteZone; | |
| } | |
| } | |
| } | |
| } | |
| writeFooter(w, status); | |
| cleanupWriteZone: | |
| if (finalStdRule != NULL) { | |
| delete finalStdRule; | |
| } | |
| if (finalDstRule != NULL) { | |
| delete finalDstRule; | |
| } | |
| } | |
| void | |
| VTimeZone::writeHeaders(VTZWriter& writer, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| UnicodeString tzid; | |
| tz->getID(tzid); | |
| writer.write(ICAL_BEGIN); | |
| writer.write(COLON); | |
| writer.write(ICAL_VTIMEZONE); | |
| writer.write(ICAL_NEWLINE); | |
| writer.write(ICAL_TZID); | |
| writer.write(COLON); | |
| writer.write(tzid); | |
| writer.write(ICAL_NEWLINE); | |
| if (tzurl.length() != 0) { | |
| writer.write(ICAL_TZURL); | |
| writer.write(COLON); | |
| writer.write(tzurl); | |
| writer.write(ICAL_NEWLINE); | |
| } | |
| if (lastmod != MAX_MILLIS) { | |
| UnicodeString lastmodStr; | |
| writer.write(ICAL_LASTMOD); | |
| writer.write(COLON); | |
| writer.write(getUTCDateTimeString(lastmod, lastmodStr)); | |
| writer.write(ICAL_NEWLINE); | |
| } | |
| } | |
| /* | |
| * Write the closing section of the VTIMEZONE definition block | |
| */ | |
| void | |
| VTimeZone::writeFooter(VTZWriter& writer, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| writer.write(ICAL_END); | |
| writer.write(COLON); | |
| writer.write(ICAL_VTIMEZONE); | |
| writer.write(ICAL_NEWLINE); | |
| } | |
| /* | |
| * Write a single start time | |
| */ | |
| void | |
| VTimeZone::writeZonePropsByTime(VTZWriter& writer, UBool isDst, const UnicodeString& zonename, | |
| int32_t fromOffset, int32_t toOffset, UDate time, UBool withRDATE, | |
| UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, time, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if (withRDATE) { | |
| writer.write(ICAL_RDATE); | |
| writer.write(COLON); | |
| UnicodeString timestr; | |
| writer.write(getDateTimeString(time + fromOffset, timestr)); | |
| writer.write(ICAL_NEWLINE); | |
| } | |
| endZoneProps(writer, isDst, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| } | |
| /* | |
| * Write start times defined by a DOM rule using VTIMEZONE RRULE | |
| */ | |
| void | |
| VTimeZone::writeZonePropsByDOM(VTZWriter& writer, UBool isDst, const UnicodeString& zonename, | |
| int32_t fromOffset, int32_t toOffset, | |
| int32_t month, int32_t dayOfMonth, UDate startTime, UDate untilTime, | |
| UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, startTime, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| beginRRULE(writer, month, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| writer.write(ICAL_BYMONTHDAY); | |
| writer.write(EQUALS_SIGN); | |
| UnicodeString dstr; | |
| appendAsciiDigits(dayOfMonth, 0, dstr); | |
| writer.write(dstr); | |
| if (untilTime != MAX_MILLIS) { | |
| appendUNTIL(writer, getDateTimeString(untilTime + fromOffset, dstr), status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| } | |
| writer.write(ICAL_NEWLINE); | |
| endZoneProps(writer, isDst, status); | |
| } | |
| /* | |
| * Write start times defined by a DOW rule using VTIMEZONE RRULE | |
| */ | |
| void | |
| VTimeZone::writeZonePropsByDOW(VTZWriter& writer, UBool isDst, const UnicodeString& zonename, | |
| int32_t fromOffset, int32_t toOffset, | |
| int32_t month, int32_t weekInMonth, int32_t dayOfWeek, | |
| UDate startTime, UDate untilTime, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, startTime, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| beginRRULE(writer, month, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| writer.write(ICAL_BYDAY); | |
| writer.write(EQUALS_SIGN); | |
| UnicodeString dstr; | |
| appendAsciiDigits(weekInMonth, 0, dstr); | |
| writer.write(dstr); // -4, -3, -2, -1, 1, 2, 3, 4 | |
| writer.write(ICAL_DOW_NAMES[dayOfWeek - 1]); // SU, MO, TU... | |
| if (untilTime != MAX_MILLIS) { | |
| appendUNTIL(writer, getDateTimeString(untilTime + fromOffset, dstr), status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| } | |
| writer.write(ICAL_NEWLINE); | |
| endZoneProps(writer, isDst, status); | |
| } | |
| /* | |
| * Write start times defined by a DOW_GEQ_DOM rule using VTIMEZONE RRULE | |
| */ | |
| void | |
| VTimeZone::writeZonePropsByDOW_GEQ_DOM(VTZWriter& writer, UBool isDst, const UnicodeString& zonename, | |
| int32_t fromOffset, int32_t toOffset, | |
| int32_t month, int32_t dayOfMonth, int32_t dayOfWeek, | |
| UDate startTime, UDate untilTime, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // Check if this rule can be converted to DOW rule | |
| if (dayOfMonth%7 == 1) { | |
| // Can be represented by DOW rule | |
| writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset, | |
| month, (dayOfMonth + 6)/7, dayOfWeek, startTime, untilTime, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| } else if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - dayOfMonth)%7 == 6) { | |
| // Can be represented by DOW rule with negative week number | |
| writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset, | |
| month, -1*((MONTHLENGTH[month] - dayOfMonth + 1)/7), dayOfWeek, startTime, untilTime, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| } else { | |
| // Otherwise, use BYMONTHDAY to include all possible dates | |
| beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, startTime, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // Check if all days are in the same month | |
| int32_t startDay = dayOfMonth; | |
| int32_t currentMonthDays = 7; | |
| if (dayOfMonth <= 0) { | |
| // The start day is in previous month | |
| int32_t prevMonthDays = 1 - dayOfMonth; | |
| currentMonthDays -= prevMonthDays; | |
| int32_t prevMonth = (month - 1) < 0 ? 11 : month - 1; | |
| // Note: When a rule is separated into two, UNTIL attribute needs to be | |
| // calculated for each of them. For now, we skip this, because we basically use this method | |
| // only for final rules, which does not have the UNTIL attribute | |
| writeZonePropsByDOW_GEQ_DOM_sub(writer, prevMonth, -prevMonthDays, dayOfWeek, prevMonthDays, | |
| MAX_MILLIS /* Do not use UNTIL */, fromOffset, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // Start from 1 for the rest | |
| startDay = 1; | |
| } else if (dayOfMonth + 6 > MONTHLENGTH[month]) { | |
| // Note: This code does not actually work well in February. For now, days in month in | |
| // non-leap year. | |
| int32_t nextMonthDays = dayOfMonth + 6 - MONTHLENGTH[month]; | |
| currentMonthDays -= nextMonthDays; | |
| int32_t nextMonth = (month + 1) > 11 ? 0 : month + 1; | |
| writeZonePropsByDOW_GEQ_DOM_sub(writer, nextMonth, 1, dayOfWeek, nextMonthDays, | |
| MAX_MILLIS /* Do not use UNTIL */, fromOffset, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| } | |
| writeZonePropsByDOW_GEQ_DOM_sub(writer, month, startDay, dayOfWeek, currentMonthDays, | |
| untilTime, fromOffset, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| endZoneProps(writer, isDst, status); | |
| } | |
| } | |
| /* | |
| * Called from writeZonePropsByDOW_GEQ_DOM | |
| */ | |
| void | |
| VTimeZone::writeZonePropsByDOW_GEQ_DOM_sub(VTZWriter& writer, int32_t month, int32_t dayOfMonth, | |
| int32_t dayOfWeek, int32_t numDays, | |
| UDate untilTime, int32_t fromOffset, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| int32_t startDayNum = dayOfMonth; | |
| UBool isFeb = (month == UCAL_FEBRUARY); | |
| if (dayOfMonth < 0 && !isFeb) { | |
| // Use positive number if possible | |
| startDayNum = MONTHLENGTH[month] + dayOfMonth + 1; | |
| } | |
| beginRRULE(writer, month, status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| writer.write(ICAL_BYDAY); | |
| writer.write(EQUALS_SIGN); | |
| writer.write(ICAL_DOW_NAMES[dayOfWeek - 1]); // SU, MO, TU... | |
| writer.write(SEMICOLON); | |
| writer.write(ICAL_BYMONTHDAY); | |
| writer.write(EQUALS_SIGN); | |
| UnicodeString dstr; | |
| appendAsciiDigits(startDayNum, 0, dstr); | |
| writer.write(dstr); | |
| for (int32_t i = 1; i < numDays; i++) { | |
| writer.write(COMMA); | |
| dstr.remove(); | |
| appendAsciiDigits(startDayNum + i, 0, dstr); | |
| writer.write(dstr); | |
| } | |
| if (untilTime != MAX_MILLIS) { | |
| appendUNTIL(writer, getDateTimeString(untilTime + fromOffset, dstr), status); | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| } | |
| writer.write(ICAL_NEWLINE); | |
| } | |
| /* | |
| * Write start times defined by a DOW_LEQ_DOM rule using VTIMEZONE RRULE | |
| */ | |
| void | |
| VTimeZone::writeZonePropsByDOW_LEQ_DOM(VTZWriter& writer, UBool isDst, const UnicodeString& zonename, | |
| int32_t fromOffset, int32_t toOffset, | |
| int32_t month, int32_t dayOfMonth, int32_t dayOfWeek, | |
| UDate startTime, UDate untilTime, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // Check if this rule can be converted to DOW rule | |
| if (dayOfMonth%7 == 0) { | |
| // Can be represented by DOW rule | |
| writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset, | |
| month, dayOfMonth/7, dayOfWeek, startTime, untilTime, status); | |
| } else if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - dayOfMonth)%7 == 0){ | |
| // Can be represented by DOW rule with negative week number | |
| writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset, | |
| month, -1*((MONTHLENGTH[month] - dayOfMonth)/7 + 1), dayOfWeek, startTime, untilTime, status); | |
| } else if (month == UCAL_FEBRUARY && dayOfMonth == 29) { | |
| // Specical case for February | |
| writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset, | |
| UCAL_FEBRUARY, -1, dayOfWeek, startTime, untilTime, status); | |
| } else { | |
| // Otherwise, convert this to DOW_GEQ_DOM rule | |
| writeZonePropsByDOW_GEQ_DOM(writer, isDst, zonename, fromOffset, toOffset, | |
| month, dayOfMonth - 6, dayOfWeek, startTime, untilTime, status); | |
| } | |
| } | |
| /* | |
| * Write the final time zone rule using RRULE, with no UNTIL attribute | |
| */ | |
| void | |
| VTimeZone::writeFinalRule(VTZWriter& writer, UBool isDst, const AnnualTimeZoneRule* rule, | |
| int32_t fromRawOffset, int32_t fromDSTSavings, | |
| UDate startTime, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| UBool modifiedRule = TRUE; | |
| const DateTimeRule *dtrule = toWallTimeRule(rule->getRule(), fromRawOffset, fromDSTSavings); | |
| if (dtrule == NULL) { | |
| modifiedRule = FALSE; | |
| dtrule = rule->getRule(); | |
| } | |
| // If the rule's mills in a day is out of range, adjust start time. | |
| // Olson tzdata supports 24:00 of a day, but VTIMEZONE does not. | |
| // See ticket#7008/#7518 | |
| int32_t timeInDay = dtrule->getRuleMillisInDay(); | |
| if (timeInDay < 0) { | |
| startTime = startTime + (0 - timeInDay); | |
| } else if (timeInDay >= U_MILLIS_PER_DAY) { | |
| startTime = startTime - (timeInDay - (U_MILLIS_PER_DAY - 1)); | |
| } | |
| int32_t toOffset = rule->getRawOffset() + rule->getDSTSavings(); | |
| UnicodeString name; | |
| rule->getName(name); | |
| switch (dtrule->getDateRuleType()) { | |
| case DateTimeRule::DOM: | |
| writeZonePropsByDOM(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset, | |
| dtrule->getRuleMonth(), dtrule->getRuleDayOfMonth(), startTime, MAX_MILLIS, status); | |
| break; | |
| case DateTimeRule::DOW: | |
| writeZonePropsByDOW(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset, | |
| dtrule->getRuleMonth(), dtrule->getRuleWeekInMonth(), dtrule->getRuleDayOfWeek(), startTime, MAX_MILLIS, status); | |
| break; | |
| case DateTimeRule::DOW_GEQ_DOM: | |
| writeZonePropsByDOW_GEQ_DOM(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset, | |
| dtrule->getRuleMonth(), dtrule->getRuleDayOfMonth(), dtrule->getRuleDayOfWeek(), startTime, MAX_MILLIS, status); | |
| break; | |
| case DateTimeRule::DOW_LEQ_DOM: | |
| writeZonePropsByDOW_LEQ_DOM(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset, | |
| dtrule->getRuleMonth(), dtrule->getRuleDayOfMonth(), dtrule->getRuleDayOfWeek(), startTime, MAX_MILLIS, status); | |
| break; | |
| } | |
| if (modifiedRule) { | |
| delete dtrule; | |
| } | |
| } | |
| /* | |
| * Write the opening section of zone properties | |
| */ | |
| void | |
| VTimeZone::beginZoneProps(VTZWriter& writer, UBool isDst, const UnicodeString& zonename, | |
| int32_t fromOffset, int32_t toOffset, UDate startTime, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| writer.write(ICAL_BEGIN); | |
| writer.write(COLON); | |
| if (isDst) { | |
| writer.write(ICAL_DAYLIGHT); | |
| } else { | |
| writer.write(ICAL_STANDARD); | |
| } | |
| writer.write(ICAL_NEWLINE); | |
| UnicodeString dstr; | |
| // TZOFFSETTO | |
| writer.write(ICAL_TZOFFSETTO); | |
| writer.write(COLON); | |
| millisToOffset(toOffset, dstr); | |
| writer.write(dstr); | |
| writer.write(ICAL_NEWLINE); | |
| // TZOFFSETFROM | |
| writer.write(ICAL_TZOFFSETFROM); | |
| writer.write(COLON); | |
| millisToOffset(fromOffset, dstr); | |
| writer.write(dstr); | |
| writer.write(ICAL_NEWLINE); | |
| // TZNAME | |
| writer.write(ICAL_TZNAME); | |
| writer.write(COLON); | |
| writer.write(zonename); | |
| writer.write(ICAL_NEWLINE); | |
| // DTSTART | |
| writer.write(ICAL_DTSTART); | |
| writer.write(COLON); | |
| writer.write(getDateTimeString(startTime + fromOffset, dstr)); | |
| writer.write(ICAL_NEWLINE); | |
| } | |
| /* | |
| * Writes the closing section of zone properties | |
| */ | |
| void | |
| VTimeZone::endZoneProps(VTZWriter& writer, UBool isDst, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| // END:STANDARD or END:DAYLIGHT | |
| writer.write(ICAL_END); | |
| writer.write(COLON); | |
| if (isDst) { | |
| writer.write(ICAL_DAYLIGHT); | |
| } else { | |
| writer.write(ICAL_STANDARD); | |
| } | |
| writer.write(ICAL_NEWLINE); | |
| } | |
| /* | |
| * Write the beggining part of RRULE line | |
| */ | |
| void | |
| VTimeZone::beginRRULE(VTZWriter& writer, int32_t month, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| UnicodeString dstr; | |
| writer.write(ICAL_RRULE); | |
| writer.write(COLON); | |
| writer.write(ICAL_FREQ); | |
| writer.write(EQUALS_SIGN); | |
| writer.write(ICAL_YEARLY); | |
| writer.write(SEMICOLON); | |
| writer.write(ICAL_BYMONTH); | |
| writer.write(EQUALS_SIGN); | |
| appendAsciiDigits(month + 1, 0, dstr); | |
| writer.write(dstr); | |
| writer.write(SEMICOLON); | |
| } | |
| /* | |
| * Append the UNTIL attribute after RRULE line | |
| */ | |
| void | |
| VTimeZone::appendUNTIL(VTZWriter& writer, const UnicodeString& until, UErrorCode& status) const { | |
| if (U_FAILURE(status)) { | |
| return; | |
| } | |
| if (until.length() > 0) { | |
| writer.write(SEMICOLON); | |
| writer.write(ICAL_UNTIL); | |
| writer.write(EQUALS_SIGN); | |
| writer.write(until); | |
| } | |
| } | |
| U_NAMESPACE_END | |
| #endif /* #if !UCONFIG_NO_FORMATTING */ | |
| //eof |