0001: /*
0002: *
0003: *
0004: * Copyright 1990-2007 Sun Microsystems, Inc. All Rights Reserved.
0005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
0006: *
0007: * This program is free software; you can redistribute it and/or
0008: * modify it under the terms of the GNU General Public License version
0009: * 2 only, as published by the Free Software Foundation.
0010: *
0011: * This program is distributed in the hope that it will be useful, but
0012: * WITHOUT ANY WARRANTY; without even the implied warranty of
0013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
0014: * General Public License version 2 for more details (a copy is
0015: * included at /legal/license.txt).
0016: *
0017: * You should have received a copy of the GNU General Public License
0018: * version 2 along with this work; if not, write to the Free Software
0019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
0020: * 02110-1301 USA
0021: *
0022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
0023: * Clara, CA 95054 or visit www.sun.com if you need additional
0024: * information or have any questions.
0025: */
0026:
0027: package com.sun.cldc.util.j2me;
0028:
0029: import java.util.*;
0030:
0031: /**
0032: * This class provides the time zone implementations
0033: * for J2ME CLDC/MIDP. By default, the only supported
0034: * time zone is UTC/GMT. Vendor-specific implementations
0035: * may provide additional time zones.
0036: *
0037: * @see java.util.TimeZone
0038: */
0039:
0040: public class TimeZoneImpl extends TimeZone {
0041:
0042: static String HOME_ID = null;
0043:
0044: public TimeZoneImpl() {
0045: }
0046:
0047: /**
0048: * Constructs a TimeZone with the given base time zone offset from GMT
0049: * and time zone ID. Timezone IDs can be obtained from
0050: * TimeZone.getAvailableIDs. Normally you should use TimeZone.getDefault to
0051: * construct a TimeZone.
0052: *
0053: * @param rawOffset The given base time zone offset to GMT.
0054: * @param ID The time zone ID which is obtained from
0055: * TimeZone.getAvailableIDs.
0056: */
0057: private TimeZoneImpl(int rawOffset, String ID) {
0058: this .rawOffset = rawOffset;
0059: this .ID = ID;
0060: dstSavings = millisPerHour; // In case user sets rules later
0061: }
0062:
0063: /**
0064: * Constructor. This constructor is identical to the 10-argument
0065: * constructor, but also takes a dstSavings parameter.
0066: * @param dstSavings The amount of time in ms saved during DST.
0067: * @exception IllegalArgumentException the month, day, dayOfWeek, or time
0068: * parameters are out of range for the start or end rule
0069: */
0070: private TimeZoneImpl(int rawOffset, String ID, int startMonth,
0071: int startDay, int startDayOfWeek, int startTime,
0072: int endMonth, int endDay, int endDayOfWeek, int endTime,
0073: int dstSavings) {
0074: this .ID = ID;
0075: this .rawOffset = rawOffset;
0076: this .startMonth = startMonth;
0077: this .startDay = startDay;
0078: this .startDayOfWeek = startDayOfWeek;
0079: this .startTime = startTime;
0080: this .endMonth = endMonth;
0081: this .endDay = endDay;
0082: this .endDayOfWeek = endDayOfWeek;
0083: this .endTime = endTime;
0084: this .dstSavings = dstSavings;
0085: decodeRules();
0086: if (dstSavings <= 0) {
0087: throw new IllegalArgumentException(
0088: /* #ifdef VERBOSE_EXCEPTIONS */
0089: /// skipped "Illegal DST savings"
0090: /* #endif */
0091: );
0092: }
0093: }
0094:
0095: /* Constants used internally; unit is milliseconds */
0096: private static final int ONE_MINUTE = 60 * 1000;
0097: private static final int ONE_HOUR = 60 * ONE_MINUTE;
0098: private static final int ONE_DAY = 24 * ONE_HOUR;
0099:
0100: /**
0101: * Gets offset, for current date, modified in case of
0102: * daylight savings. This is the offset to add *to* GMT to get local time.
0103: * Gets the time zone offset, for current date, modified in case of daylight
0104: * savings. This is the offset to add *to* GMT to get local time. Assume
0105: * that the start and end month are distinct. This method may return incorrect
0106: * results for rules that start at the end of February (e.g., last Sunday in
0107: * February) or the beginning of March (e.g., March 1).
0108: *
0109: * @param era The era of the given date (0 = BC, 1 = AD).
0110: * @param year The year in the given date.
0111: * @param month The month in the given date. Month is 0-based. e.g.,
0112: * 0 for January.
0113: * @param day The day-in-month of the given date.
0114: * @param dayOfWeek The day-of-week of the given date.
0115: * @param millis The milliseconds in day in <em>standard</em> local time.
0116: * @return The offset to add *to* GMT to get local time.
0117: * @exception IllegalArgumentException the era, month, day,
0118: * dayOfWeek, or millis parameters are out of range
0119: */
0120: public int getOffset(int era, int year, int month, int day,
0121: int dayOfWeek, int millis) {
0122: if (month < Calendar.JANUARY || month > Calendar.DECEMBER) {
0123: throw new IllegalArgumentException(
0124: /* #ifdef VERBOSE_EXCEPTIONS */
0125: /// skipped "Illegal month " + month
0126: /* #endif */
0127: );
0128: }
0129: return getOffset(era, year, month, day, dayOfWeek, millis,
0130: staticMonthLength[month]);
0131: }
0132:
0133: /**
0134: * Gets offset, for current date, modified in case of
0135: * daylight savings. This is the offset to add <em>to</em> GMT to get local time.
0136: * Gets the time zone offset, for current date, modified in case of daylight
0137: * savings. This is the offset to add *to* GMT to get local time. Assume
0138: * that the start and end month are distinct.
0139: * @param era The era of the given date (0 = BC, 1 = AD).
0140: * @param year The year in the given date.
0141: * @param month The month in the given date. Month is 0-based. e.g.,
0142: * 0 for January.
0143: * @param day The day-in-month of the given date.
0144: * @param dayOfWeek The day-of-week of the given date.
0145: * @param millis The milliseconds in day in <em>standard</em> local time.
0146: * @param monthLength The length of the given month in days.
0147: * @return The offset to add *to* GMT to get local time.
0148: * @exception IllegalArgumentException the era, month, day,
0149: * dayOfWeek, millis, or monthLength parameters are out of range
0150: */
0151: int getOffset(int era, int year, int month, int day, int dayOfWeek,
0152: int millis, int monthLength) {
0153: if (true) {
0154: // Use this parameter checking code for normal operation. Only one
0155: // of these two blocks should actually get compiled into the class
0156: // file.
0157: if ((era != 0 && era != 1) || month < Calendar.JANUARY
0158: || month > Calendar.DECEMBER || day < 1
0159: || day > monthLength || dayOfWeek < Calendar.SUNDAY
0160: || dayOfWeek > Calendar.SATURDAY || millis < 0
0161: || millis >= millisPerDay || monthLength < 28
0162: || monthLength > 31) {
0163:
0164: throw new IllegalArgumentException();
0165: }
0166: } else {
0167: // This parameter checking code is better for debugging, but
0168: // overkill for normal operation. Only one of these two blocks
0169: // should actually get compiled into the class file.
0170: if (era != 0 && era != 1) {
0171: throw new IllegalArgumentException(
0172: /* #ifdef VERBOSE_EXCEPTIONS */
0173: /// skipped "Illegal era " + era
0174: /* #endif */
0175: );
0176: }
0177: if (month < Calendar.JANUARY || month > Calendar.DECEMBER) {
0178: throw new IllegalArgumentException(
0179: /* #ifdef VERBOSE_EXCEPTIONS */
0180: /// skipped "Illegal month " + month
0181: /* #endif */
0182: );
0183: }
0184: if (day < 1 || day > monthLength) {
0185: throw new IllegalArgumentException(
0186: /* #ifdef VERBOSE_EXCEPTIONS */
0187: /// skipped "Illegal day " + day
0188: /* #endif */
0189: );
0190: }
0191: if (dayOfWeek < Calendar.SUNDAY
0192: || dayOfWeek > Calendar.SATURDAY) {
0193: throw new IllegalArgumentException(
0194: /* #ifdef VERBOSE_EXCEPTIONS */
0195: /// skipped "Illegal day of week " + dayOfWeek
0196: /* #endif */
0197: );
0198: }
0199: if (millis < 0 || millis >= millisPerDay) {
0200: throw new IllegalArgumentException(
0201: /* #ifdef VERBOSE_EXCEPTIONS */
0202: /// skipped "Illegal millis " + millis
0203: /* #endif */
0204: );
0205: }
0206: if (monthLength < 28 || monthLength > 31) {
0207: throw new IllegalArgumentException(
0208: /* #ifdef VERBOSE_EXCEPTIONS */
0209: /// skipped "Illegal month length " + monthLength
0210: /* #endif */
0211: );
0212: }
0213: }
0214:
0215: int result = rawOffset;
0216:
0217: // Bail out if we are before the onset of daylight savings time
0218: if (!useDaylight || year < startYear || era != 1)
0219: return result;
0220:
0221: // Check for southern hemisphere. We assume that the start and end
0222: // month are different.
0223: boolean southern = (startMonth > endMonth);
0224:
0225: // Compare the date to the starting and ending rules.+1 = date>rule, -1
0226: // = date<rule, 0 = date==rule.
0227: int startCompare = compareToRule(month, monthLength, day,
0228: dayOfWeek, millis, startMode, startMonth,
0229: startDayOfWeek, startDay, startTime);
0230: int endCompare = 0;
0231:
0232: // We don't always have to compute endCompare. For many instances,
0233: // startCompare is enough to determine if we are in DST or not. In the
0234: // northern hemisphere, if we are before the start rule, we can't have
0235: // DST. In the southern hemisphere, if we are after the start rule, we
0236: // must have DST. This is reflected in the way the next if statement
0237: // (not the one immediately following) short circuits.
0238: if (southern != (startCompare >= 0)) {
0239: // For the ending rule comparison, we add the dstSavings to the millis
0240: // passed in to convert them from standard to wall time. We then must
0241: // normalize the millis to the range 0..millisPerDay-1.
0242: millis += dstSavings; // Assume dstSavings > 0
0243: while (millis >= millisPerDay) {
0244: millis -= millisPerDay;
0245: ++day;
0246: dayOfWeek = 1 + (dayOfWeek % 7); // Assume dayOfWeek is one-based
0247: if (day > monthLength) {
0248: day = 1;
0249: // When incrementing the month, it is desirable to overflow
0250: // from DECEMBER to DECEMBER+1, since we use the result to
0251: // compare against a real month. Wraparound of the value
0252: // leads to CR 4173604.
0253: ++month;
0254: }
0255: }
0256: endCompare = compareToRule(month, monthLength, day,
0257: dayOfWeek, millis, endMode, endMonth, endDayOfWeek,
0258: endDay, endTime);
0259: }
0260:
0261: // Check for both the northern and southern hemisphere cases. We
0262: // assume that in the northern hemisphere, the start rule is before the
0263: // end rule within the calendar year, and vice versa for the southern
0264: // hemisphere.
0265: if ((!southern && (startCompare >= 0 && endCompare < 0))
0266: || (southern && (startCompare >= 0 || endCompare < 0))) {
0267:
0268: result += dstSavings;
0269: }
0270:
0271: return result;
0272: }
0273:
0274: /**
0275: * Compare a given date in the year to a rule. Return 1, 0, or -1, depending
0276: * on whether the date is after, equal to, or before the rule date. The
0277: * millis are compared directly against the ruleMillis, so any
0278: * standard-daylight adjustments must be handled by the caller.
0279: *
0280: * @return 1 if the date is after the rule date, -1 if the date is before
0281: * the rule date, or 0 if the date is equal to the rule date.
0282: */
0283: private static int compareToRule(int month, int monthLen,
0284: int dayOfMonth, int dayOfWeek, int millis, int ruleMode,
0285: int ruleMonth, int ruleDayOfWeek, int ruleDay,
0286: int ruleMillis) {
0287: if (month < ruleMonth)
0288: return -1;
0289: else if (month > ruleMonth)
0290: return 1;
0291:
0292: int ruleDayOfMonth = 0;
0293: switch (ruleMode) {
0294: case DOM_MODE:
0295: ruleDayOfMonth = ruleDay;
0296: break;
0297: case DOW_IN_MONTH_MODE:
0298: // In this case ruleDay is the day-of-week-in-month
0299: if (ruleDay > 0) {
0300: ruleDayOfMonth = 1
0301: + (ruleDay - 1)
0302: * 7
0303: + (7 + ruleDayOfWeek - (dayOfWeek - dayOfMonth + 1))
0304: % 7;
0305: } else {
0306: // Assume ruleDay < 0 here
0307: ruleDayOfMonth = monthLen
0308: + (ruleDay + 1)
0309: * 7
0310: - (7 + (dayOfWeek + monthLen - dayOfMonth) - ruleDayOfWeek)
0311: % 7;
0312: }
0313: break;
0314: case DOW_GE_DOM_MODE:
0315: ruleDayOfMonth = ruleDay
0316: + (49 + ruleDayOfWeek - ruleDay - dayOfWeek + dayOfMonth)
0317: % 7;
0318: break;
0319: case DOW_LE_DOM_MODE:
0320: ruleDayOfMonth = ruleDay
0321: - (49 - ruleDayOfWeek + ruleDay + dayOfWeek - dayOfMonth)
0322: % 7;
0323: // Note at this point ruleDayOfMonth may be <1, although it will
0324: // be >=1 for well-formed rules.
0325: break;
0326: }
0327:
0328: if (dayOfMonth < ruleDayOfMonth)
0329: return -1;
0330: else if (dayOfMonth > ruleDayOfMonth)
0331: return 1;
0332:
0333: if (millis < ruleMillis)
0334: return -1;
0335: else if (millis > ruleMillis)
0336: return 1;
0337: else
0338: return 0;
0339: }
0340:
0341: /**
0342: * Gets the GMT offset for this time zone.
0343: */
0344: public int getRawOffset() {
0345: // The given date will be taken into account while
0346: // we have the historical time zone data in place.
0347: return rawOffset;
0348: }
0349:
0350: /**
0351: * Queries if this time zone uses Daylight Savings Time.
0352: */
0353: public boolean useDaylightTime() {
0354: return useDaylight;
0355: }
0356:
0357: /**
0358: * Gets the ID of this time zone.
0359: * @return the ID of this time zone.
0360: */
0361: public String getID() {
0362: if (!isCustom) {
0363: return ID;
0364: }
0365: /*
0366: * mandated format is: (e.g.)
0367: * GMT+08:00
0368: * 3 for GMT
0369: * + 1 for sign
0370: * + 2 for hours
0371: * + 1 for colon
0372: * + 2 for minutes
0373: * = 9 characters in StringBuffer
0374: */
0375: StringBuffer result = new StringBuffer(9);
0376: int offset = getRawOffset();
0377: int minutes = offset / (60 * 1000);
0378: int hours;
0379:
0380: minutes = (minutes < 0) ? -minutes : minutes;
0381:
0382: hours = minutes / 60;
0383: minutes = minutes % 60;
0384:
0385: result.append(GMT_ID);
0386:
0387: if (offset < 0) {
0388: result.append('-');
0389: } else {
0390: result.append('+');
0391: }
0392:
0393: appendTwoDigits(result, hours);
0394: result.append(":");
0395: appendTwoDigits(result, minutes);
0396:
0397: return result.toString();
0398:
0399: }
0400:
0401: /**
0402: * Gets the <code>TimeZone</code> for the given ID.
0403: * @param ID the ID for a <code>TimeZone</code>, either an abbreviation such as
0404: * "GMT", or a full name such as "America/Los_Angeles".
0405: * <p> The only time zone ID that is required to be supported is "GMT",
0406: * though typically, the timezones for the regions where the device is
0407: * sold should be supported.
0408: * @return the specified <code>TimeZone</code>, or null if the given ID
0409: * cannot be understood.
0410: */
0411: public synchronized TimeZone getInstance(String ID) {
0412: if (ID == null) {
0413: if (HOME_ID == null) {
0414: HOME_ID = System
0415: .getProperty("com.sun.cldc.util.j2me.TimeZoneImpl.timezone");
0416: if (HOME_ID == null)
0417: HOME_ID = "UTC";
0418: }
0419: ID = HOME_ID;
0420: }
0421:
0422: // check the id string, not the computed string
0423: for (int i = 0; i < zones.length; i++) {
0424: TimeZoneImpl tzi = (TimeZoneImpl) zones[i];
0425:
0426: if (tzi.ID.equals(ID))
0427: return zones[i];
0428: }
0429:
0430: return parseCustomTimeZone(ID);
0431: }
0432:
0433: static final String GMT_ID = "GMT";
0434: private static final int GMT_ID_LENGTH = 3;
0435:
0436: /**
0437: * Parses a custom time zone identifier and returns a corresponding zone.
0438: * This method doesn't support the RFC 822 time zone format. (e.g., +hhmm)
0439: *
0440: * @param id a string of the <a href="#CustomID">custom ID form</a>.
0441: * @return a newly created TimeZone with the given offset and
0442: * no daylight saving time, or null if the id cannot be parsed.
0443: */
0444:
0445: private static final TimeZone parseCustomTimeZone(String id) {
0446: int length;
0447:
0448: // Error if the length of id isn't long enough or id doesn't
0449: // start with "GMT".
0450: if ((length = id.length()) < (GMT_ID_LENGTH + 2)
0451: || id.indexOf(GMT_ID) != 0) {
0452: return null;
0453: }
0454:
0455: int index = GMT_ID_LENGTH;
0456: boolean negative = false;
0457: char c = id.charAt(index++);
0458: if (c == '-') {
0459: negative = true;
0460: } else if (c != '+') {
0461: return null;
0462: }
0463:
0464: int hours = 0;
0465: int num = 0;
0466: int countDelim = 0;
0467: int len = 0;
0468: while (index < length) {
0469: c = id.charAt(index++);
0470: if (c == ':') {
0471: if (countDelim > 0) {
0472: return null;
0473: }
0474: if (len > 2) {
0475: return null;
0476: }
0477: hours = num;
0478: countDelim++;
0479: num = 0;
0480: len = 0;
0481: continue;
0482: }
0483: if (c < '0' || c > '9') {
0484: return null;
0485: }
0486: num = num * 10 + (c - '0');
0487: len++;
0488: }
0489: if (index != length) {
0490: return null;
0491: }
0492: if (countDelim == 0) {
0493: if (len <= 2) {
0494: hours = num;
0495: num = 0;
0496: } else {
0497: hours = num / 100;
0498: num %= 100;
0499: }
0500: } else {
0501: if (len != 2) {
0502: return null;
0503: }
0504: }
0505: if (len > 4) {
0506: return null;
0507: }
0508:
0509: if (hours > 23 || num > 59) {
0510: return null;
0511: }
0512:
0513: // compute in minutes
0514: int gmtOffset = hours * 60 + num;
0515:
0516: // now adjust to milliseconds
0517: gmtOffset *= 60 * 1000;
0518:
0519: TimeZoneImpl custom = new TimeZoneImpl(negative ? -gmtOffset
0520: : gmtOffset, id);
0521: custom.isCustom = true;
0522: return custom;
0523: }
0524:
0525: /** Gets all the available IDs supported.
0526: * @return an array of IDs.
0527: */
0528: public synchronized String[] getIDs() {
0529: if (ids == null) {
0530: ids = new String[zones.length];
0531:
0532: // use the actual String, rather than the
0533: // derived TimeZone ID
0534: for (int i = 0; i < zones.length; i++) {
0535: TimeZoneImpl tzi = (TimeZoneImpl) zones[i];
0536: ids[i] = tzi.ID;
0537: }
0538: }
0539: return ids;
0540: }
0541:
0542: // =======================privates===============================
0543:
0544: /**
0545: * The string identifier of this <code>TimeZone</code>. This is a
0546: * programmatic identifier used internally to look up <code>TimeZone</code>
0547: * objects from the system table and also to map them to their localized
0548: * display names. <code>ID</code> values are unique in the system
0549: * table but may not be for dynamically created zones.
0550: * @serial
0551: */
0552: private String ID;
0553:
0554: private boolean isCustom;
0555:
0556: static String[] ids = null;
0557:
0558: /**
0559: * The month in which daylight savings time starts. This value must be
0560: * between <code>Calendar.JANUARY</code> and
0561: * <code>Calendar.DECEMBER</code> inclusive. This value must not equal
0562: * <code>endMonth</code>.
0563: * <p>If <code>useDaylight</code> is false, this value is ignored.
0564: * @serial
0565: */
0566: private int startMonth;
0567:
0568: /**
0569: * This field has two possible interpretations:
0570: * <dl>
0571: * <dt><code>startMode == DOW_IN_MONTH</code></dt>
0572: * <dd>
0573: * <code>startDay</code> indicates the day of the month of
0574: * <code>startMonth</code> on which daylight
0575: * savings time starts, from 1 to 28, 30, or 31, depending on the
0576: * <code>startMonth</code>.
0577: * </dd>
0578: * <dt><code>startMode != DOW_IN_MONTH</code></dt>
0579: * <dd>
0580: * <code>startDay</code> indicates which <code>startDayOfWeek</code> in th
0581: * month <code>startMonth</code> daylight
0582: * savings time starts on. For example, a value of +1 and a
0583: * <code>startDayOfWeek</code> of <code>Calendar.SUNDAY</code> indicates the
0584: * first Sunday of <code>startMonth</code>. Likewise, +2 would indicate the
0585: * second Sunday, and -1 the last Sunday. A value of 0 is illegal.
0586: * </dd>
0587: * </ul>
0588: * <p>If <code>useDaylight</code> is false, this value is ignored.
0589: * @serial
0590: */
0591: private int startDay;
0592:
0593: /**
0594: * The day of the week on which daylight savings time starts. This value
0595: * must be between <code>Calendar.SUNDAY</code> and
0596: * <code>Calendar.SATURDAY</code> inclusive.
0597: * <p>If <code>useDaylight</code> is false or
0598: * <code>startMode == DAY_OF_MONTH</code>, this value is ignored.
0599: * @serial
0600: */
0601: private int startDayOfWeek;
0602:
0603: /**
0604: * The time in milliseconds after midnight at which daylight savings
0605: * time starts. This value is expressed as <em>wall time</em>, which means
0606: * it is compared to <em>standard</em> time for the daylight savings start.
0607: * <p>If <code>useDaylight</code> is false, this value is ignored.
0608: * @serial
0609: */
0610: private int startTime;
0611:
0612: /**
0613: * The month in which daylight savings time ends. This value must be
0614: * between <code>Calendar.JANUARY</code> and
0615: * <code>Calendar.UNDECIMBER</code>. This value must not equal
0616: * <code>startMonth</code>.
0617: * <p>If <code>useDaylight</code> is false, this value is ignored.
0618: * @serial
0619: */
0620: private int endMonth;
0621:
0622: /**
0623: * This field has two possible interpretations:
0624: * <dl>
0625: * <dt><code>endMode == DOW_IN_MONTH</code></dt>
0626: * <dd>
0627: * <code>endDay</code> indicates the day of the month of
0628: * <code>endMonth</code> on which daylight
0629: * savings time ends, from 1 to 28, 30, or 31, depending on the
0630: * <code>endMonth</code>.
0631: * </dd>
0632: * <dt><code>endMode != DOW_IN_MONTH</code></dt>
0633: * <dd>
0634: * <code>endDay</code> indicates which <code>endDayOfWeek</code> in th
0635: * month <code>endMonth</code> daylight
0636: * savings time ends on. For example, a value of +1 and a
0637: * <code>endDayOfWeek</code> of <code>Calendar.SUNDAY</code> indicates the
0638: * first Sunday of <code>endMonth</code>. Likewise, +2 would indicate the
0639: * second Sunday, and -1 the last Sunday. A value of 0 is illegal.
0640: * </dd>
0641: * </ul>
0642: * <p>If <code>useDaylight</code> is false, this value is ignored.
0643: * @serial
0644: */
0645: private int endDay;
0646:
0647: /**
0648: * The day of the week on which daylight savings time ends. This value
0649: * must be between <code>Calendar.SUNDAY</code> and
0650: * <code>Calendar.SATURDAY</code> inclusive.
0651: * <p>If <code>useDaylight</code> is false or
0652: * <code>endMode == DAY_OF_MONTH</code>, this value is ignored.
0653: * @serial
0654: */
0655: private int endDayOfWeek;
0656:
0657: /**
0658: * The time in milliseconds after midnight at which daylight savings
0659: * time ends. This value is expressed as <em>wall time</em>, which means
0660: * it is compared to <em>daylight</em> time for the daylight savings end.
0661: * <p>If <code>useDaylight</code> is false, this value is ignored.
0662: * @serial
0663: */
0664: private int endTime;
0665:
0666: /**
0667: * The year in which daylight savings time is first observed. This is an AD
0668: * value. If this value is less than 1 then daylight savings is observed
0669: * for all AD years.
0670: * <p>If <code>useDaylight</code> is false, this value is ignored.
0671: * @serial
0672: */
0673: private int startYear;
0674:
0675: /**
0676: * The offset in milliseconds between this zone and GMT. Negative offsets
0677: * are to the west of Greenwich. To obtain local <em>standard</em> time,
0678: * add the offset to GMT time. To obtain local wall time it may also be
0679: * necessary to add <code>dstSavings</code>.
0680: * @serial
0681: */
0682: private int rawOffset;
0683:
0684: /**
0685: * A boolean value which is true if and only if this zone uses daylight
0686: * savings time. If this value is false, several other fields are ignored.
0687: * @serial
0688: */
0689: private boolean useDaylight = false; // indicate if this time zone uses DST
0690:
0691: private static final int millisPerHour = 60 * 60 * 1000;
0692: private static final int millisPerDay = 24 * millisPerHour;
0693:
0694: /**
0695: * This field was serialized in JDK 1.1, so we have to keep it that way
0696: * to maintain serialization compatibility. However, there's no need to
0697: * recreate the array each time we create a new time zone.
0698: * @serial An array of bytes containing the values {31, 28, 31, 30, 31, 30,
0699: * 31, 31, 30, 31, 30, 31}. This is ignored as of JDK 1.2, however, it must
0700: * be streamed out for compatibility with JDK 1.1.
0701: */
0702: private final static byte staticMonthLength[] = { 31, 29, 31, 30,
0703: 31, 30, 31, 31, 30, 31, 30, 31 }; //**NS**
0704:
0705: /**
0706: * Variables specifying the mode of the start rule. Takes the following
0707: * values:
0708: * <dl>
0709: * <dt><code>DOM_MODE</code></dt>
0710: * <dd>
0711: * Exact day of week; e.g., March 1.
0712: * </dd>
0713: * <dt><code>DOW_IN_MONTH_MODE</code></dt>
0714: * <dd>
0715: * Day of week in month; e.g., last Sunday in March.
0716: * </dd>
0717: * <dt><code>DOW_GE_DOM_MODE</code></dt>
0718: * <dd>
0719: * Day of week after day of month; e.g., Sunday on or after March 15.
0720: * </dd>
0721: * <dt><code>DOW_LE_DOM_MODE</code></dt>
0722: * <dd>
0723: * Day of week before day of month; e.g., Sunday on or before March 15.
0724: * </dd>
0725: * </dl>
0726: * The setting of this field affects the interpretation of the
0727: * <code>startDay</code> field.
0728: * <p>If <code>useDaylight</code> is false, this value is ignored.
0729: * @serial
0730: * @since JDK1.1.4
0731: */
0732: private int startMode;
0733:
0734: /**
0735: * Variables specifying the mode of the end rule. Takes the following
0736: * values:
0737: * <dl>
0738: * <dt><code>DOM_MODE</code></dt>
0739: * <dd>
0740: * Exact day of week; e.g., March 1.
0741: * </dd>
0742: * <dt><code>DOW_IN_MONTH_MODE</code></dt>
0743: * <dd>
0744: * Day of week in month; e.g., last Sunday in March.
0745: * </dd>
0746: * <dt><code>DOW_GE_DOM_MODE</code></dt>
0747: * <dd>
0748: * Day of week after day of month; e.g., Sunday on or after March 15.
0749: * </dd>
0750: * <dt><code>DOW_LE_DOM_MODE</code></dt>
0751: * <dd>
0752: * Day of week before day of month; e.g., Sunday on or before March 15.
0753: * </dd>
0754: * </dl>
0755: * The setting of this field affects the interpretation of the
0756: * <code>endDay</code> field.
0757: * <p>If <code>useDaylight</code> is false, this value is ignored.
0758: * @serial
0759: * @since JDK1.1.4
0760: */
0761: private int endMode;
0762:
0763: /**
0764: * A positive value indicating the amount of time saved during DST in
0765: * milliseconds.
0766: * Typically one hour (3600000); sometimes 30 minutes (1800000).
0767: * <p>If <code>useDaylight</code> is false, this value is ignored.
0768: * @serial
0769: * @since JDK1.1.4
0770: */
0771: private int dstSavings;
0772:
0773: /**
0774: * Constants specifying values of startMode and endMode.
0775: */
0776: private static final int DOM_MODE = 1; // Exact day of month, "Mar 1"
0777: private static final int DOW_IN_MONTH_MODE = 2; // Day of week in month, "lastSun"
0778: private static final int DOW_GE_DOM_MODE = 3; // Day of week after day of month, "Sun>=15"
0779: private static final int DOW_LE_DOM_MODE = 4; // Day of week before day of month, "Sun<=21"
0780:
0781: //----------------------------------------------------------------------
0782: // Rule representation
0783: //
0784: // We represent the following flavors of rules:
0785: // 5 the fifth of the month
0786: // lastSun the last Sunday in the month
0787: // lastMon the last Monday in the month
0788: // Sun>=8 first Sunday on or after the eighth
0789: // Sun<=25 last Sunday on or before the 25th
0790: // This is further complicated by the fact that we need to remain
0791: // backward compatible with the 1.1 FCS. Finally, we need to minimize
0792: // API changes. In order to satisfy these requirements, we support
0793: // three representation systems, and we translate between them.
0794: //
0795: // INTERNAL REPRESENTATION
0796: // This is the format TimeZone objects take after construction or
0797: // streaming in is complete. Rules are represented directly, using an
0798: // unencoded format. We will discuss the start rule only below; the end
0799: // rule is analogous.
0800: // startMode Takes on enumerated values DAY_OF_MONTH,
0801: // DOW_IN_MONTH, DOW_AFTER_DOM, or DOW_BEFORE_DOM.
0802: // startDay The day of the month, or for DOW_IN_MONTH mode, a
0803: // value indicating which DOW, such as +1 for first,
0804: // +2 for second, -1 for last, etc.
0805: // startDayOfWeek The day of the week. Ignored for DAY_OF_MONTH.
0806: //
0807: // ENCODED REPRESENTATION
0808: // This is the format accepted by the constructor and by setStartRule()
0809: // and setEndRule(). It uses various combinations of positive, negative,
0810: // and zero values to encode the different rules. This representation
0811: // allows us to specify all the different rule flavors without altering
0812: // the API.
0813: // MODE startMonth startDay startDayOfWeek
0814: // DOW_IN_MONTH_MODE >=0 !=0 >0
0815: // DOM_MODE >=0 >0 ==0
0816: // DOW_GE_DOM_MODE >=0 >0 <0
0817: // DOW_LE_DOM_MODE >=0 <0 <0
0818: // (no DST) don't care ==0 don't care
0819: //
0820: // STREAMED REPRESENTATION
0821: // We must retain binary compatibility with the 1.1 FCS. The 1.1 code only
0822: // handles DOW_IN_MONTH_MODE and non-DST mode, the latter indicated by the
0823: // flag useDaylight. When we stream an object out, we translate into an
0824: // approximate DOW_IN_MONTH_MODE representation so the object can be parsed
0825: // and used by 1.1 code. Following that, we write out the full
0826: // representation separately so that contemporary code can recognize and
0827: // parse it. The full representation is written in a "packed" format,
0828: // consisting of a version number, a length, and an array of bytes. Future
0829: // versions of this class may specify different versions. If they wish to
0830: // include additional data, they should do so by storing them after the
0831: // packed representation below.
0832: //----------------------------------------------------------------------
0833:
0834: /**
0835: * Given a set of encoded rules in startDay and startDayOfMonth, decode
0836: * them and set the startMode appropriately. Do the same for endDay and
0837: * endDayOfMonth. Upon entry, the day of week variables may be zero or
0838: * negative, in order to indicate special modes. The day of month
0839: * variables may also be negative. Upon exit, the mode variables will be
0840: * set, and the day of week and day of month variables will be positive.
0841: * This method also recognizes a startDay or endDay of zero as indicating
0842: * no DST.
0843: */
0844: private void decodeRules() {
0845: decodeStartRule();
0846: decodeEndRule();
0847: }
0848:
0849: /**
0850: * Decode the start rule and validate the parameters. The parameters are
0851: * expected to be in encoded form, which represents the various rule modes
0852: * by negating or zeroing certain values. Representation formats are:
0853: * <p>
0854: * <pre>
0855: * DOW_IN_MONTH DOM DOW>=DOM DOW<=DOM no DST
0856: * ------------ ----- -------- -------- ----------
0857: * month 0..11 same same same don't care
0858: * day -5..5 1..31 1..31 -1..-31 0
0859: * dayOfWeek 1..7 0 -1..-7 -1..-7 don't care
0860: * time 0..ONEDAY same same same don't care
0861: * </pre>
0862: * The range for month does not include UNDECIMBER since this class is
0863: * really specific to Calendar, which does not use that month.
0864: * The range for time includes ONEDAY (vs. ending at ONEDAY-1) because the
0865: * end rule is an exclusive limit point. That is, the range of times that
0866: * are in DST include those >= the start and < the end. For this reason,
0867: * it should be possible to specify an end of ONEDAY in order to include the
0868: * entire day. Although this is equivalent to time 0 of the following day,
0869: * it's not always possible to specify that, for example, on December 31.
0870: * While arguably the start range should still be 0..ONEDAY-1, we keep
0871: * the start and end ranges the same for consistency.
0872: */
0873: private void decodeStartRule() {
0874: useDaylight = (startDay != 0) && (endDay != 0);
0875: if (startDay != 0) {
0876: if (startMonth < Calendar.JANUARY
0877: || startMonth > Calendar.DECEMBER) {
0878: throw new IllegalArgumentException(
0879: /* #ifdef VERBOSE_EXCEPTIONS */
0880: /// skipped "Illegal start month " + startMonth
0881: /* #endif */
0882: );
0883: }
0884: if (startTime < 0 || startTime > millisPerDay) {
0885: throw new IllegalArgumentException(
0886: /* #ifdef VERBOSE_EXCEPTIONS */
0887: /// skipped "Illegal start time " + startTime
0888: /* #endif */
0889: );
0890: }
0891: if (startDayOfWeek == 0) {
0892: startMode = DOM_MODE;
0893: } else {
0894: if (startDayOfWeek > 0) {
0895: startMode = DOW_IN_MONTH_MODE;
0896: } else {
0897: startDayOfWeek = -startDayOfWeek;
0898: if (startDay > 0) {
0899: startMode = DOW_GE_DOM_MODE;
0900: } else {
0901: startDay = -startDay;
0902: startMode = DOW_LE_DOM_MODE;
0903: }
0904: }
0905: if (startDayOfWeek > Calendar.SATURDAY) {
0906: throw new IllegalArgumentException(
0907: /* #ifdef VERBOSE_EXCEPTIONS */
0908: /// skipped "Illegal start day of week " + startDayOfWeek
0909: /* #endif */
0910: );
0911: }
0912: }
0913: if (startMode == DOW_IN_MONTH_MODE) {
0914: if (startDay < -5 || startDay > 5) {
0915: throw new IllegalArgumentException(
0916: /* #ifdef VERBOSE_EXCEPTIONS */
0917: /// skipped "Illegal start day of week in month " + startDay
0918: /* #endif */
0919: );
0920: }
0921: } else if (startDay > staticMonthLength[startMonth]) {
0922: throw new IllegalArgumentException(
0923: /* #ifdef VERBOSE_EXCEPTIONS */
0924: /// skipped "Illegal start day " + startDay
0925: /* #endif */
0926: );
0927: }
0928: }
0929: }
0930:
0931: /**
0932: * Decode the end rule and validate the parameters. This method is exactly
0933: * analogous to decodeStartRule().
0934: * @see decodeStartRule
0935: */
0936: private void decodeEndRule() {
0937: useDaylight = (startDay != 0) && (endDay != 0);
0938: if (endDay != 0) {
0939: if (endMonth < Calendar.JANUARY
0940: || endMonth > Calendar.DECEMBER) {
0941: throw new IllegalArgumentException(
0942: /* #ifdef VERBOSE_EXCEPTIONS */
0943: /// skipped "Illegal end month " + endMonth
0944: /* #endif */
0945: );
0946: }
0947: if (endTime < 0 || endTime > millisPerDay) {
0948: throw new IllegalArgumentException(
0949: /* #ifdef VERBOSE_EXCEPTIONS */
0950: /// skipped "Illegal end time " + endTime
0951: /* #endif */
0952: );
0953: }
0954: if (endDayOfWeek == 0) {
0955: endMode = DOM_MODE;
0956: } else {
0957: if (endDayOfWeek > 0) {
0958: endMode = DOW_IN_MONTH_MODE;
0959: } else {
0960: endDayOfWeek = -endDayOfWeek;
0961: if (endDay > 0) {
0962: endMode = DOW_GE_DOM_MODE;
0963: } else {
0964: endDay = -endDay;
0965: endMode = DOW_LE_DOM_MODE;
0966: }
0967: }
0968: if (endDayOfWeek > Calendar.SATURDAY) {
0969: throw new IllegalArgumentException(
0970: /* #ifdef VERBOSE_EXCEPTIONS */
0971: /// skipped "Illegal end day of week " + endDayOfWeek
0972: /* #endif */
0973: );
0974: }
0975: }
0976: if (endMode == DOW_IN_MONTH_MODE) {
0977: if (endDay < -5 || endDay > 5) {
0978: throw new IllegalArgumentException(
0979: /* #ifdef VERBOSE_EXCEPTIONS */
0980: /// skipped "Illegal end day of week in month " + endDay
0981: /* #endif */
0982: );
0983: }
0984: } else if (endDay > staticMonthLength[endMonth]) {
0985: throw new IllegalArgumentException(
0986: /* #ifdef VERBOSE_EXCEPTIONS */
0987: /// skipped "Illegal end day " + endDay
0988: /* #endif */
0989: );
0990: }
0991: }
0992: }
0993:
0994: static TimeZone zones[] = {
0995:
0996: //----------------------------------------------------------
0997: new TimeZoneImpl(0 * ONE_HOUR, "GMT"),
0998: // GMT -(-) 0:00 - GMT
0999: new TimeZoneImpl(0 * ONE_HOUR, "UTC"),
1000: /**
1001: * NOTE: as in this example, most implementations will only include
1002: * a handful of timezones
1003: * look for the closing comment which has a string of '*' asterisks
1004: *************
1005:
1006: ////////////////////////////////////////////////////////////
1007: // America
1008: //----------------------------------------------------------
1009: new TimeZoneImpl(-10*ONE_HOUR, "America/Adak",
1010: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1011: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1012: // Rule US 1967 max - Oct lastSun 2:00 0 S
1013: // Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
1014: // America/Adak Alaska(US) -10:00 US HA%sT
1015: //----------------------------------------------------------
1016: new TimeZoneImpl(-9*ONE_HOUR, "America/Anchorage",
1017: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1018: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1019: // Rule US 1967 max - Oct lastSun 2:00 0 S
1020: // Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
1021: // America/Anchorage Alaska(US) -9:00 US AK%sT
1022: new TimeZoneImpl(-9*ONE_HOUR, "AST",
1023: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1024: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1025: //----------------------------------------------------------
1026: new TimeZoneImpl(-8*ONE_HOUR, "America/Vancouver",
1027: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1028: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1029: // Rule Vanc 1962 max - Oct lastSun 2:00 0 S
1030: // Rule Vanc 1987 max - Apr Sun>=1 2:00 1:00 D
1031: // America/Vancouver British Columbia(CA) -8:00 Vanc P%sT
1032: //----------------------------------------------------------
1033: new TimeZoneImpl(-8*ONE_HOUR, "America/Tijuana",
1034: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1035: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1036: // Rule Mexico 1996 max - Apr Sun>=1 2:00 1:00 D
1037: // Rule Mexico 1996 max - Oct lastSun 2:00 0 S
1038: // America/Tijuana Mexico(MX) -8:00 Mexico P%sT
1039: //----------------------------------------------------------
1040: new TimeZoneImpl(-8*ONE_HOUR, "America/Los_Angeles",
1041: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1042: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1043: // Rule US 1967 max - Oct lastSun 2:00 0 S
1044: // Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
1045: // America/Los_Angeles US Pacific time, represented by Los Angeles(US) -8:00 US P%sT
1046:
1047: new TimeZoneImpl(-8*ONE_HOUR, "PST",
1048: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1049: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1050: //----------------------------------------------------------
1051: new TimeZoneImpl(-7*ONE_HOUR, "America/Dawson_Creek"),
1052: // America/Dawson_Creek British Columbia(CA) -7:00 - MST
1053: //----------------------------------------------------------
1054: new TimeZoneImpl(-7*ONE_HOUR, "America/Phoenix"),
1055: // America/Phoenix ?(US) -7:00 - MST
1056: new TimeZoneImpl(-7*ONE_HOUR, "PNT"),
1057: //----------------------------------------------------------
1058: new TimeZoneImpl(-7*ONE_HOUR, "America/Edmonton",
1059: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1060: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1061: // Rule Edm 1972 max - Oct lastSun 2:00 0 S
1062: // Rule Edm 1987 max - Apr Sun>=1 2:00 1:00 D
1063: // America/Edmonton Alberta(CA) -7:00 Edm M%sT
1064: //----------------------------------------------------------
1065: new TimeZoneImpl(-7*ONE_HOUR, "America/Mazatlan",
1066: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1067: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1068: // Rule Mexico 1996 max - Apr Sun>=1 2:00 1:00 D
1069: // Rule Mexico 1996 max - Oct lastSun 2:00 0 S
1070: // America/Mazatlan Mexico(MX) -7:00 Mexico M%sT
1071: //----------------------------------------------------------
1072: new TimeZoneImpl(-7*ONE_HOUR, "America/Denver",
1073: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1074: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1075: // Rule US 1967 max - Oct lastSun 2:00 0 S
1076: // Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
1077: // America/Denver US Mountain time, represented by Denver(US) -7:00 US M%sT
1078: new TimeZoneImpl(-7*ONE_HOUR, "MST",
1079: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1080: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1081: //----------------------------------------------------------
1082: new TimeZoneImpl(-6*ONE_HOUR, "America/Belize"),
1083: // America/Belize Belize(BZ) -6:00 - C%sT
1084: //----------------------------------------------------------
1085: new TimeZoneImpl(-6*ONE_HOUR, "America/Regina"),
1086: // America/Regina Saskatchewan(CA) -6:00 - CST
1087: //----------------------------------------------------------
1088: new TimeZoneImpl(-6*ONE_HOUR, "America/Guatemala"),
1089: // America/Guatemala Guatemala(GT) -6:00 - C%sT
1090: //----------------------------------------------------------
1091: new TimeZoneImpl(-6*ONE_HOUR, "America/Tegucigalpa"),
1092: // America/Tegucigalpa Honduras(HN) -6:00 - C%sT
1093: //----------------------------------------------------------
1094: new TimeZoneImpl(-6*ONE_HOUR, "America/El_Salvador"),
1095: // America/El_Salvador El Salvador(SV) -6:00 - C%sT
1096: //----------------------------------------------------------
1097: new TimeZoneImpl(-6*ONE_HOUR, "America/Costa_Rica"),
1098: // America/Costa_Rica Costa Rica(CR) -6:00 - C%sT
1099: //----------------------------------------------------------
1100: new TimeZoneImpl(-6*ONE_HOUR, "America/Winnipeg",
1101: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1102: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1103: // Rule Winn 1966 max - Oct lastSun 2:00 0 S
1104: // Rule Winn 1987 max - Apr Sun>=1 2:00 1:00 D
1105: // America/Winnipeg Manitoba(CA) -6:00 Winn C%sT
1106: //----------------------------------------------------------
1107: new TimeZoneImpl(-6*ONE_HOUR, "America/Mexico_City",
1108: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1109: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1110: // Rule Mexico 1996 max - Apr Sun>=1 2:00 1:00 D
1111: // Rule Mexico 1996 max - Oct lastSun 2:00 0 S
1112: // America/Mexico_City Mexico(MX) -6:00 Mexico C%sT
1113: //----------------------------------------------------------
1114: new TimeZoneImpl(-6*ONE_HOUR, "America/Chicago",
1115: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1116: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1117: // Rule US 1967 max - Oct lastSun 2:00 0 S
1118: // Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
1119: // America/Chicago US Central time, represented by Chicago(US) -6:00 US C%sT
1120: new TimeZoneImpl(-6*ONE_HOUR, "CST",
1121: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1122: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1123: //----------------------------------------------------------
1124: new TimeZoneImpl(-5*ONE_HOUR, "America/Porto_Acre"),
1125: // America/Porto_Acre Brazil(BR) -5:00 - AST
1126: //----------------------------------------------------------
1127: new TimeZoneImpl(-5*ONE_HOUR, "America/Bogota"),
1128: // America/Bogota Colombia(CO) -5:00 - CO%sT # Colombia Time
1129: //----------------------------------------------------------
1130: new TimeZoneImpl(-5*ONE_HOUR, "America/Guayaquil"),
1131: // America/Guayaquil Ecuador(EC) -5:00 - ECT # Ecuador Time
1132: //----------------------------------------------------------
1133: new TimeZoneImpl(-5*ONE_HOUR, "America/Jamaica"),
1134: // America/Jamaica Jamaica(JM) -5:00 - EST
1135: //----------------------------------------------------------
1136: new TimeZoneImpl(-5*ONE_HOUR, "America/Cayman"),
1137: // America/Cayman Cayman Is(KY) -5:00 - EST
1138: //----------------------------------------------------------
1139: new TimeZoneImpl(-5*ONE_HOUR, "America/Managua"),
1140: // America/Managua Nicaragua(NI) -5:00 - EST
1141: //----------------------------------------------------------
1142: new TimeZoneImpl(-5*ONE_HOUR, "America/Panama"),
1143: // America/Panama Panama(PA) -5:00 - EST
1144: //----------------------------------------------------------
1145: new TimeZoneImpl(-5*ONE_HOUR, "America/Lima"),
1146: // America/Lima Peru(PE) -5:00 - PE%sT # Peru Time
1147: //----------------------------------------------------------
1148: new TimeZoneImpl(-5*ONE_HOUR, "America/Indianapolis"),
1149: // America/Indianapolis Indiana(US) -5:00 - EST
1150: new TimeZoneImpl(-5*ONE_HOUR, "IET"),
1151: //----------------------------------------------------------
1152: new TimeZoneImpl(-5*ONE_HOUR, "America/Nassau",
1153: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1154: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1155: // Rule Bahamas 1964 max - Oct lastSun 2:00 0 S
1156: // Rule Bahamas 1987 max - Apr Sun>=1 2:00 1:00 D
1157: // America/Nassau Bahamas(BS) -5:00 Bahamas E%sT
1158: //----------------------------------------------------------
1159: new TimeZoneImpl(-5*ONE_HOUR, "America/Montreal",
1160: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1161: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1162: // Rule Mont 1957 max - Oct lastSun 2:00 0 S
1163: // Rule Mont 1987 max - Apr Sun>=1 2:00 1:00 D
1164: // America/Montreal Ontario, Quebec(CA) -5:00 Mont E%sT
1165: //----------------------------------------------------------
1166: new TimeZoneImpl(-5*ONE_HOUR, "America/Havana",
1167: Calendar.APRIL, 1, -Calendar.SUNDAY, 0*ONE_HOUR,
1168: Calendar.OCTOBER, 8, -Calendar.SUNDAY, 1*ONE_HOUR, 1*ONE_HOUR),
1169: // Rule Cuba 1990 max - Apr Sun>=1 0:00 1:00 D
1170: // Rule Cuba 1997 max - Oct Sun>=8 0:00s 0 S
1171: // America/Havana Cuba(CU) -5:00 Cuba C%sT
1172: //----------------------------------------------------------
1173: new TimeZoneImpl(-5*ONE_HOUR, "America/Port-au-Prince",
1174: Calendar.APRIL, 1, -Calendar.SUNDAY, 1*ONE_HOUR,
1175: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1176: // Rule Haiti 1988 max - Apr Sun>=1 1:00s 1:00 D
1177: // Rule Haiti 1988 max - Oct lastSun 1:00s 0 S
1178: // America/Port-au-Prince Haiti(HT) -5:00 Haiti E%sT
1179: //----------------------------------------------------------
1180: new TimeZoneImpl(-5*ONE_HOUR, "America/Grand_Turk",
1181: Calendar.APRIL, 1, -Calendar.SUNDAY, 0*ONE_HOUR,
1182: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1183: // Rule TC 1979 max - Oct lastSun 0:00 0 S
1184: // Rule TC 1987 max - Apr Sun>=1 0:00 1:00 D
1185: // America/Grand_Turk Turks and Caicos(TC) -5:00 TC E%sT
1186: //----------------------------------------------------------
1187: new TimeZoneImpl(-5*ONE_HOUR, "America/New_York",
1188: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1189: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1190: // Rule US 1967 max - Oct lastSun 2:00 0 S
1191: // Rule US 1987 max - Apr Sun>=1 2:00 1:00 D
1192: // America/New_York US Eastern time, represented by New York(US) -5:00 US E%sT
1193: new TimeZoneImpl(-5*ONE_HOUR, "EST",
1194: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1195: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1196: //----------------------------------------------------------
1197: new TimeZoneImpl(-4*ONE_HOUR, "America/Antigua"),
1198: // America/Antigua Antigua and Barbuda(AG) -4:00 - AST
1199: //----------------------------------------------------------
1200: new TimeZoneImpl(-4*ONE_HOUR, "America/Anguilla"),
1201: // America/Anguilla Anguilla(AI) -4:00 - AST
1202: //----------------------------------------------------------
1203: new TimeZoneImpl(-4*ONE_HOUR, "America/Curacao"),
1204: // America/Curacao Curacao(AN) -4:00 - AST
1205: //----------------------------------------------------------
1206: new TimeZoneImpl(-4*ONE_HOUR, "America/Aruba"),
1207: // America/Aruba Aruba(AW) -4:00 - AST
1208: //----------------------------------------------------------
1209: new TimeZoneImpl(-4*ONE_HOUR, "America/Barbados"),
1210: // America/Barbados Barbados(BB) -4:00 - A%sT
1211: //----------------------------------------------------------
1212: new TimeZoneImpl(-4*ONE_HOUR, "America/La_Paz"),
1213: // America/La_Paz Bolivia(BO) -4:00 - BOT # Bolivia Time
1214: //----------------------------------------------------------
1215: new TimeZoneImpl(-4*ONE_HOUR, "America/Manaus"),
1216: // America/Manaus Brazil(BR) -4:00 - WST
1217: //----------------------------------------------------------
1218: new TimeZoneImpl(-4*ONE_HOUR, "America/Dominica"),
1219: // America/Dominica Dominica(DM) -4:00 - AST
1220: //----------------------------------------------------------
1221: new TimeZoneImpl(-4*ONE_HOUR, "America/Santo_Domingo"),
1222: // America/Santo_Domingo Dominican Republic(DO) -4:00 - AST
1223: //----------------------------------------------------------
1224: new TimeZoneImpl(-4*ONE_HOUR, "America/Grenada"),
1225: // America/Grenada Grenada(GD) -4:00 - AST
1226: //----------------------------------------------------------
1227: new TimeZoneImpl(-4*ONE_HOUR, "America/Guadeloupe"),
1228: // America/Guadeloupe Guadeloupe(GP) -4:00 - AST
1229: //----------------------------------------------------------
1230: new TimeZoneImpl(-4*ONE_HOUR, "America/Guyana"),
1231: // America/Guyana Guyana(GY) -4:00 - GYT
1232: //----------------------------------------------------------
1233: new TimeZoneImpl(-4*ONE_HOUR, "America/St_Kitts"),
1234: // America/St_Kitts St Kitts-Nevis(KN) -4:00 - AST
1235: //----------------------------------------------------------
1236: new TimeZoneImpl(-4*ONE_HOUR, "America/St_Lucia"),
1237: // America/St_Lucia St Lucia(LC) -4:00 - AST
1238: //----------------------------------------------------------
1239: new TimeZoneImpl(-4*ONE_HOUR, "America/Martinique"),
1240: // America/Martinique Martinique(MQ) -4:00 - AST
1241: //----------------------------------------------------------
1242: new TimeZoneImpl(-4*ONE_HOUR, "America/Montserrat"),
1243: // America/Montserrat Montserrat(MS) -4:00 - AST
1244: //----------------------------------------------------------
1245: new TimeZoneImpl(-4*ONE_HOUR, "America/Puerto_Rico"),
1246: // America/Puerto_Rico Puerto Rico(PR) -4:00 - AST
1247: new TimeZoneImpl(-4*ONE_HOUR, "PRT"),
1248: //----------------------------------------------------------
1249: new TimeZoneImpl(-4*ONE_HOUR, "America/Port_of_Spain"),
1250: // America/Port_of_Spain Trinidad and Tobago(TT) -4:00 - AST
1251: //----------------------------------------------------------
1252: new TimeZoneImpl(-4*ONE_HOUR, "America/St_Vincent"),
1253: // America/St_Vincent St Vincent and the Grenadines(VC) -4:00 - AST
1254: //----------------------------------------------------------
1255: new TimeZoneImpl(-4*ONE_HOUR, "America/Tortola"),
1256: // America/Tortola British Virgin Is(VG) -4:00 - AST
1257: //----------------------------------------------------------
1258: new TimeZoneImpl(-4*ONE_HOUR, "America/St_Thomas"),
1259: // America/St_Thomas Virgin Is(VI) -4:00 - AST
1260: //----------------------------------------------------------
1261: new TimeZoneImpl(-4*ONE_HOUR, "America/Caracas"),
1262: // America/Caracas Venezuela(VE) -4:00 - VET
1263: //----------------------------------------------------------
1264: new TimeZoneImpl(-4*ONE_HOUR, "America/Cuiaba",
1265: Calendar.OCTOBER, 1, -Calendar.SUNDAY, 0*ONE_HOUR,
1266: Calendar.FEBRUARY, 11, -Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1267: // Rule Brazil 1998 max - Oct Sun>=1 0:00 1:00 D
1268: // Rule Brazil 1999 max - Feb Sun>=11 0:00 0 S
1269: // America/Cuiaba Brazil(BR) -4:00 Brazil W%sT
1270: //----------------------------------------------------------
1271: new TimeZoneImpl(-4*ONE_HOUR, "America/Halifax",
1272: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1273: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1274: // Rule Halifax 1962 max - Oct lastSun 2:00 0 S
1275: // Rule Halifax 1987 max - Apr Sun>=1 2:00 1:00 D
1276: // America/Halifax ?(CA) -4:00 Halifax A%sT
1277: //----------------------------------------------------------
1278: new TimeZoneImpl(-4*ONE_HOUR, "America/Thule",
1279: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1280: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1281: // Rule Thule 1993 max - Apr Sun>=1 2:00 1:00 D
1282: // Rule Thule 1993 max - Oct lastSun 2:00 0 S
1283: // America/Thule ?(GL) -4:00 Thule A%sT
1284: //----------------------------------------------------------
1285: new TimeZoneImpl(-4*ONE_HOUR, "America/Asuncion",
1286: Calendar.OCTOBER, 1, 0, 0*ONE_HOUR,
1287: Calendar.MARCH, 1, 0, 0*ONE_HOUR, 1*ONE_HOUR),
1288: // Rule Para 1996 max - Mar 1 0:00 0 -
1289: // Rule Para 1997 max - Oct 1 0:00 1:00 S
1290: // America/Asuncion Paraguay(PY) -4:00 Para PY%sT
1291: //----------------------------------------------------------
1292: new TimeZoneImpl(-4*ONE_HOUR, "America/Santiago",
1293: Calendar.OCTOBER, 9, -Calendar.SUNDAY, 0*ONE_HOUR,
1294: Calendar.MARCH, 9, -Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1295: // Rule Chile 1969 max - Oct Sun>=9 0:00 1:00 S
1296: // Rule Chile 1970 max - Mar Sun>=9 0:00 0 -
1297: // America/Santiago Chile(CL) -4:00 Chile CL%sT
1298: //----------------------------------------------------------
1299: new TimeZoneImpl((int)(-3.5*ONE_HOUR), "America/St_Johns",
1300: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1301: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1302: // Rule StJohns 1960 max - Oct lastSun 2:00 0 S
1303: // Rule StJohns 1989 max - Apr Sun>=1 2:00 1:00 D
1304: // America/St_Johns Canada(CA) -3:30 StJohns N%sT
1305: new TimeZoneImpl((int)(-3.5*ONE_HOUR), "CNT",
1306: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1307: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1308: //----------------------------------------------------------
1309: new TimeZoneImpl(-3*ONE_HOUR, "America/Fortaleza"),
1310: // America/Fortaleza Brazil(BR) -3:00 - EST
1311: //----------------------------------------------------------
1312: new TimeZoneImpl(-3*ONE_HOUR, "America/Cayenne"),
1313: // America/Cayenne French Guiana(GF) -3:00 - GFT
1314: //----------------------------------------------------------
1315: new TimeZoneImpl(-3*ONE_HOUR, "America/Paramaribo"),
1316: // America/Paramaribo Suriname(SR) -3:00 - SRT
1317: //----------------------------------------------------------
1318: new TimeZoneImpl(-3*ONE_HOUR, "America/Montevideo"),
1319: // America/Montevideo Uruguay(UY) -3:00 - UY%sT
1320: //----------------------------------------------------------
1321: new TimeZoneImpl(-3*ONE_HOUR, "America/Buenos_Aires"),
1322: // America/Buenos_Aires Argentina(AR) -3:00 - AR%sT
1323: new TimeZoneImpl(-3*ONE_HOUR, "AGT"),
1324: //----------------------------------------------------------
1325: new TimeZoneImpl(-3*ONE_HOUR, "America/Godthab",
1326: Calendar.MARCH, -1, Calendar.SATURDAY, 22*ONE_HOUR,
1327: Calendar.OCTOBER, -1, Calendar.SATURDAY, 22*ONE_HOUR, 1*ONE_HOUR),
1328: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1329: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1330: // America/Godthab ?(GL) -3:00 EU WG%sT
1331: //----------------------------------------------------------
1332: new TimeZoneImpl(-3*ONE_HOUR, "America/Miquelon",
1333: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1334: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1335: // Rule Mont 1957 max - Oct lastSun 2:00 0 S
1336: // Rule Mont 1987 max - Apr Sun>=1 2:00 1:00 D
1337: // America/Miquelon St Pierre and Miquelon(PM) -3:00 Mont PM%sT # Pierre & Miquelon Time
1338: //----------------------------------------------------------
1339: new TimeZoneImpl(-3*ONE_HOUR, "America/Sao_Paulo",
1340: Calendar.OCTOBER, 1, -Calendar.SUNDAY, 0*ONE_HOUR,
1341: Calendar.FEBRUARY, 11, -Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1342: // Rule Brazil 1998 max - Oct Sun>=1 0:00 1:00 D
1343: // Rule Brazil 1999 max - Feb Sun>=11 0:00 0 S
1344: // America/Sao_Paulo Brazil(BR) -3:00 Brazil E%sT
1345: new TimeZoneImpl(-3*ONE_HOUR, "BET",
1346: Calendar.OCTOBER, 1, -Calendar.SUNDAY, 0*ONE_HOUR,
1347: Calendar.FEBRUARY, 11, -Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1348: //----------------------------------------------------------
1349: new TimeZoneImpl(-2*ONE_HOUR, "America/Noronha"),
1350: // America/Noronha Brazil(BR) -2:00 - FST
1351: //----------------------------------------------------------
1352: new TimeZoneImpl(-1*ONE_HOUR, "America/Scoresbysund",
1353: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
1354: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1355: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1356: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1357: // America/Scoresbysund ?(GL) -1:00 EU EG%sT
1358:
1359: ////////////////////////////////////////////////////////////
1360: // Antarctica
1361: //----------------------------------------------------------
1362: new TimeZoneImpl(-4*ONE_HOUR, "Antarctica/Palmer",
1363: Calendar.OCTOBER, 9, -Calendar.SUNDAY, 0*ONE_HOUR,
1364: Calendar.MARCH, 9, -Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1365: // Rule ChileAQ 1969 max - Oct Sun>=9 0:00 1:00 S
1366: // Rule ChileAQ 1970 max - Mar Sun>=9 0:00 0 -
1367: // Antarctica/Palmer USA - year-round bases(AQ) -4:00 ChileAQ CL%sT
1368: //----------------------------------------------------------
1369: new TimeZoneImpl(6*ONE_HOUR, "Antarctica/Mawson"),
1370: // Antarctica/Mawson Australia - territories(AQ) 6:00 - MAWT # Mawson Time
1371: //----------------------------------------------------------
1372: new TimeZoneImpl(8*ONE_HOUR, "Antarctica/Casey"),
1373: // Antarctica/Casey Australia - territories(AQ) 8:00 - WST # Western (Aus) Standard Time
1374: //----------------------------------------------------------
1375: new TimeZoneImpl(10*ONE_HOUR, "Antarctica/DumontDUrville"),
1376: // Antarctica/DumontDUrville France - year-round bases(AQ) 10:00 - DDUT # Dumont-d'Urville Time
1377: //----------------------------------------------------------
1378: new TimeZoneImpl(12*ONE_HOUR, "Antarctica/McMurdo",
1379: Calendar.OCTOBER, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1380: Calendar.MARCH, 15, -Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1381: // Rule NZAQ 1990 max - Oct Sun>=1 2:00s 1:00 D
1382: // Rule NZAQ 1990 max - Mar Sun>=15 2:00s 0 S
1383: // Antarctica/McMurdo USA - year-round bases(AQ) 12:00 NZAQ NZ%sT
1384:
1385: ////////////////////////////////////////////////////////////
1386: // Australia
1387: //----------------------------------------------------------
1388: new TimeZoneImpl(8*ONE_HOUR, "Australia/Perth"),
1389: // Australia/Perth Australia(AU) 8:00 - WST
1390: //----------------------------------------------------------
1391: new TimeZoneImpl((int)(9.5*ONE_HOUR), "Australia/Darwin"),
1392: // Australia/Darwin Australia(AU) 9:30 - CST
1393: new TimeZoneImpl((int)(9.5*ONE_HOUR), "ACT"),
1394: //----------------------------------------------------------
1395: new TimeZoneImpl((int)(9.5*ONE_HOUR), "Australia/Adelaide",
1396: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1397: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1398: // Rule AS 1987 max - Oct lastSun 2:00s 1:00 -
1399: // Rule AS 1995 max - Mar lastSun 2:00s 0 -
1400: // Australia/Adelaide South Australia(AU) 9:30 AS CST
1401: //----------------------------------------------------------
1402: new TimeZoneImpl(10*ONE_HOUR, "Australia/Brisbane"),
1403: // Australia/Brisbane Australia(AU) 10:00 - EST
1404: //----------------------------------------------------------
1405: new TimeZoneImpl(10*ONE_HOUR, "Australia/Sydney",
1406: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1407: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1408: // Rule AN 1987 max - Oct lastSun 2:00s 1:00 -
1409: // Rule AN 1996 max - Mar lastSun 2:00s 0 -
1410: // Australia/Sydney New South Wales(AU) 10:00 AN EST
1411: new TimeZoneImpl(10*ONE_HOUR, "AET",
1412: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1413: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1414: //----------------------------------------------------------
1415: new TimeZoneImpl((int)(10.5*ONE_HOUR), "Australia/Lord_Howe",
1416: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1417: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR, (int)(0.5*ONE_HOUR)),
1418: // Rule LH 1987 max - Oct lastSun 2:00s 0:30 -
1419: // Rule LH 1996 max - Mar lastSun 2:00s 0 -
1420: // Australia/Lord_Howe Lord Howe Island(AU) 10:30 LH LHST
1421:
1422: ////////////////////////////////////////////////////////////
1423: // Atlantic
1424: //----------------------------------------------------------
1425: new TimeZoneImpl(-4*ONE_HOUR, "Atlantic/Bermuda",
1426: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1427: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1428: // Rule Bahamas 1964 max - Oct lastSun 2:00 0 S
1429: // Rule Bahamas 1987 max - Apr Sun>=1 2:00 1:00 D
1430: // Atlantic/Bermuda Bermuda(BM) -4:00 Bahamas A%sT
1431: //----------------------------------------------------------
1432: new TimeZoneImpl(-4*ONE_HOUR, "Atlantic/Stanley",
1433: Calendar.SEPTEMBER, 8, -Calendar.SUNDAY, 0*ONE_HOUR,
1434: Calendar.APRIL, 16, -Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1435: // Rule Falk 1986 max - Apr Sun>=16 0:00 0 -
1436: // Rule Falk 1996 max - Sep Sun>=8 0:00 1:00 S
1437: // Atlantic/Stanley Falklands(FK) -4:00 Falk FK%sT
1438: //----------------------------------------------------------
1439: new TimeZoneImpl(-2*ONE_HOUR, "Atlantic/South_Georgia"),
1440: // Atlantic/South_Georgia South Georgia(GS) -2:00 - GST # South Georgia Time
1441: //----------------------------------------------------------
1442: new TimeZoneImpl(-1*ONE_HOUR, "Atlantic/Jan_Mayen"),
1443: // Atlantic/Jan_Mayen ?(NO) -1:00 - EGT
1444: //----------------------------------------------------------
1445: new TimeZoneImpl(-1*ONE_HOUR, "Atlantic/Cape_Verde"),
1446: // Atlantic/Cape_Verde Cape Verde(CV) -1:00 - CVT
1447: //----------------------------------------------------------
1448: new TimeZoneImpl(-1*ONE_HOUR, "Atlantic/Azores",
1449: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
1450: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1451: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1452: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1453: // Atlantic/Azores Portugal(PT) -1:00 EU AZO%sT
1454: //----------------------------------------------------------
1455: new TimeZoneImpl(0*ONE_HOUR, "Atlantic/Reykjavik"),
1456: // Atlantic/Reykjavik Iceland(IS) 0:00 - GMT
1457: //----------------------------------------------------------
1458: new TimeZoneImpl(0*ONE_HOUR, "Atlantic/Faeroe",
1459: Calendar.MARCH, -1, Calendar.SUNDAY, 1*ONE_HOUR,
1460: Calendar.OCTOBER, -1, Calendar.SUNDAY, 1*ONE_HOUR, 1*ONE_HOUR),
1461: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1462: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1463: // Atlantic/Faeroe Denmark, Faeroe Islands, and Greenland(DK) 0:00 EU WE%sT
1464: //----------------------------------------------------------
1465: new TimeZoneImpl(0*ONE_HOUR, "Atlantic/Canary",
1466: Calendar.MARCH, -1, Calendar.SUNDAY, 1*ONE_HOUR,
1467: Calendar.OCTOBER, -1, Calendar.SUNDAY, 1*ONE_HOUR, 1*ONE_HOUR),
1468: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1469: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1470: // Atlantic/Canary Spain(ES) 0:00 EU WE%sT
1471:
1472: ////////////////////////////////////////////////////////////
1473: // Africa
1474: //----------------------------------------------------------
1475: new TimeZoneImpl(0*ONE_HOUR, "Africa/Ouagadougou"),
1476: // Africa/Ouagadougou Burkina Faso(BF) 0:00 - GMT
1477: //----------------------------------------------------------
1478: new TimeZoneImpl(0*ONE_HOUR, "Africa/Abidjan"),
1479: // Africa/Abidjan Cote D'Ivoire(CI) 0:00 - GMT
1480: //----------------------------------------------------------
1481: new TimeZoneImpl(0*ONE_HOUR, "Africa/Accra"),
1482: // Africa/Accra Ghana(GH) 0:00 - %s
1483: //----------------------------------------------------------
1484: new TimeZoneImpl(0*ONE_HOUR, "Africa/Banjul"),
1485: // Africa/Banjul Gambia(GM) 0:00 - GMT
1486: //----------------------------------------------------------
1487: new TimeZoneImpl(0*ONE_HOUR, "Africa/Conakry"),
1488: // Africa/Conakry Guinea(GN) 0:00 - GMT
1489: //----------------------------------------------------------
1490: new TimeZoneImpl(0*ONE_HOUR, "Africa/Bissau"),
1491: // Africa/Bissau Guinea-Bissau(GW) 0:00 - GMT
1492: //----------------------------------------------------------
1493: new TimeZoneImpl(0*ONE_HOUR, "Africa/Monrovia"),
1494: // Africa/Monrovia Liberia(LR) 0:00 - GMT
1495: //----------------------------------------------------------
1496: new TimeZoneImpl(0*ONE_HOUR, "Africa/Casablanca"),
1497: // Africa/Casablanca Morocco(MA) 0:00 - WET
1498: //----------------------------------------------------------
1499: new TimeZoneImpl(0*ONE_HOUR, "Africa/Timbuktu"),
1500: // Africa/Timbuktu Mali(ML) 0:00 - GMT
1501: //----------------------------------------------------------
1502: new TimeZoneImpl(0*ONE_HOUR, "Africa/Nouakchott"),
1503: // Africa/Nouakchott Mauritania(MR) 0:00 - GMT
1504: //----------------------------------------------------------
1505: new TimeZoneImpl(0*ONE_HOUR, "Atlantic/St_Helena"),
1506: // Atlantic/St_Helena St Helena(SH) 0:00 - GMT
1507: //----------------------------------------------------------
1508: new TimeZoneImpl(0*ONE_HOUR, "Africa/Freetown"),
1509: // Africa/Freetown Sierra Leone(SL) 0:00 - %s
1510: //----------------------------------------------------------
1511: new TimeZoneImpl(0*ONE_HOUR, "Africa/Dakar"),
1512: // Africa/Dakar Senegal(SN) 0:00 - GMT
1513: //----------------------------------------------------------
1514: new TimeZoneImpl(0*ONE_HOUR, "Africa/Sao_Tome"),
1515: // Africa/Sao_Tome Sao Tome and Principe(ST) 0:00 - GMT
1516: //----------------------------------------------------------
1517: new TimeZoneImpl(0*ONE_HOUR, "Africa/Lome"),
1518: // Africa/Lome Togo(TG) 0:00 - GMT
1519: //----------------------------------------------------------
1520: new TimeZoneImpl(1*ONE_HOUR, "Africa/Luanda"),
1521: // Africa/Luanda Angola(AO) 1:00 - WAT
1522: //----------------------------------------------------------
1523: new TimeZoneImpl(1*ONE_HOUR, "Africa/Porto-Novo"),
1524: // Africa/Porto-Novo Benin(BJ) 1:00 - WAT
1525: //----------------------------------------------------------
1526: new TimeZoneImpl(1*ONE_HOUR, "Africa/Bangui"),
1527: // Africa/Bangui Central African Republic(CF) 1:00 - WAT
1528: //----------------------------------------------------------
1529: new TimeZoneImpl(1*ONE_HOUR, "Africa/Kinshasa"),
1530: // Africa/Kinshasa Democratic Republic of Congo(CG) 1:00 - WAT
1531: //----------------------------------------------------------
1532: new TimeZoneImpl(1*ONE_HOUR, "Africa/Douala"),
1533: // Africa/Douala Cameroon(CM) 1:00 - WAT
1534: //----------------------------------------------------------
1535: new TimeZoneImpl(1*ONE_HOUR, "Africa/Libreville"),
1536: // Africa/Libreville Gabon(GA) 1:00 - WAT
1537: //----------------------------------------------------------
1538: new TimeZoneImpl(1*ONE_HOUR, "Africa/Malabo"),
1539: // Africa/Malabo Equatorial Guinea(GQ) 1:00 - WAT
1540: //----------------------------------------------------------
1541: new TimeZoneImpl(1*ONE_HOUR, "Africa/Niamey"),
1542: // Africa/Niamey Niger(NE) 1:00 - WAT
1543: //----------------------------------------------------------
1544: new TimeZoneImpl(1*ONE_HOUR, "Africa/Lagos"),
1545: // Africa/Lagos Nigeria(NG) 1:00 - WAT
1546: //----------------------------------------------------------
1547: new TimeZoneImpl(1*ONE_HOUR, "Africa/Ndjamena"),
1548: // Africa/Ndjamena Chad(TD) 1:00 - WAT
1549: //----------------------------------------------------------
1550: new TimeZoneImpl(1*ONE_HOUR, "Africa/Tunis"),
1551: // Africa/Tunis Tunisia(TN) 1:00 - CE%sT
1552: //----------------------------------------------------------
1553: new TimeZoneImpl(1*ONE_HOUR, "Africa/Algiers"),
1554: // Africa/Algiers Algeria(DZ) 1:00 - CET
1555: //----------------------------------------------------------
1556: new TimeZoneImpl(1*ONE_HOUR, "Africa/Tripoli",
1557: Calendar.MARCH, -1, Calendar.THURSDAY, 2*ONE_HOUR,
1558: Calendar.OCTOBER, 1, -Calendar.THURSDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1559: // Rule Libya 1997 max - Mar lastThu 2:00s 1:00 S
1560: // Rule Libya 1997 max - Oct Thu>=1 2:00s 0 -
1561: // Africa/Tripoli Libya(LY) 1:00 Libya CE%sT
1562: //----------------------------------------------------------
1563: new TimeZoneImpl(1*ONE_HOUR, "Africa/Windhoek",
1564: Calendar.SEPTEMBER, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
1565: Calendar.APRIL, 1, -Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1566: // Rule Namibia 1994 max - Sep Sun>=1 2:00 1:00 S
1567: // Rule Namibia 1995 max - Apr Sun>=1 2:00 0 -
1568: // Africa/Windhoek Namibia(NA) 1:00 Namibia WA%sT
1569: //----------------------------------------------------------
1570: new TimeZoneImpl(2*ONE_HOUR, "Africa/Bujumbura"),
1571: // Africa/Bujumbura Burundi(BI) 2:00 - CAT
1572: //----------------------------------------------------------
1573: new TimeZoneImpl(2*ONE_HOUR, "Africa/Gaborone"),
1574: // Africa/Gaborone Botswana(BW) 2:00 - CAT
1575: //----------------------------------------------------------
1576: new TimeZoneImpl(2*ONE_HOUR, "Africa/Lubumbashi"),
1577: // Africa/Lubumbashi Democratic Republic of Congo(CG) 2:00 - CAT
1578: //----------------------------------------------------------
1579: new TimeZoneImpl(2*ONE_HOUR, "Africa/Maseru"),
1580: // Africa/Maseru Lesotho(LS) 2:00 - SAST
1581: //----------------------------------------------------------
1582: new TimeZoneImpl(2*ONE_HOUR, "Africa/Blantyre"),
1583: // Africa/Blantyre Malawi(ML) 2:00 - CAT
1584: //----------------------------------------------------------
1585: new TimeZoneImpl(2*ONE_HOUR, "Africa/Maputo"),
1586: // Africa/Maputo Mozambique(MZ) 2:00 - CAT
1587: //----------------------------------------------------------
1588: new TimeZoneImpl(2*ONE_HOUR, "Africa/Kigali"),
1589: // Africa/Kigali Rwanda(RW) 2:00 - CAT
1590: //----------------------------------------------------------
1591: new TimeZoneImpl(2*ONE_HOUR, "Africa/Khartoum"),
1592: // Africa/Khartoum Sudan(SD) 2:00 - CA%sT
1593: //----------------------------------------------------------
1594: new TimeZoneImpl(2*ONE_HOUR, "Africa/Mbabane"),
1595: // Africa/Mbabane Swaziland(SZ) 2:00 - SAST
1596: //----------------------------------------------------------
1597: new TimeZoneImpl(2*ONE_HOUR, "Africa/Lusaka"),
1598: // Africa/Lusaka Zambia(ZM) 2:00 - CAT
1599: //----------------------------------------------------------
1600: new TimeZoneImpl(2*ONE_HOUR, "Africa/Harare"),
1601: // Africa/Harare Zimbabwe(ZW) 2:00 - CAT
1602: new TimeZoneImpl(2*ONE_HOUR, "CAT"),
1603: //----------------------------------------------------------
1604: new TimeZoneImpl(2*ONE_HOUR, "Africa/Johannesburg"),
1605: // Africa/Johannesburg South Africa(ZA) 2:00 - SAST
1606: //----------------------------------------------------------
1607: new TimeZoneImpl(2*ONE_HOUR, "Africa/Cairo",
1608: Calendar.APRIL, -1, Calendar.FRIDAY, 1*ONE_HOUR,
1609: Calendar.SEPTEMBER, -1, Calendar.FRIDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1610: // Rule Egypt 1995 max - Apr lastFri 1:00 1:00 S
1611: // Rule Egypt 1995 max - Sep lastFri 3:00 0 -
1612: // Africa/Cairo Egypt(EG) 2:00 Egypt EE%sT
1613: new TimeZoneImpl(2*ONE_HOUR, "ART",
1614: Calendar.APRIL, -1, Calendar.FRIDAY, 1*ONE_HOUR,
1615: Calendar.SEPTEMBER, -1, Calendar.FRIDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1616: //----------------------------------------------------------
1617: new TimeZoneImpl(3*ONE_HOUR, "Africa/Djibouti"),
1618: // Africa/Djibouti Djibouti(DJ) 3:00 - EAT
1619: //----------------------------------------------------------
1620: new TimeZoneImpl(3*ONE_HOUR, "Africa/Asmera"),
1621: // Africa/Asmera Eritrea(ER) 3:00 - EAT
1622: //----------------------------------------------------------
1623: new TimeZoneImpl(3*ONE_HOUR, "Africa/Addis_Ababa"),
1624: // Africa/Addis_Ababa Ethiopia(ET) 3:00 - EAT
1625: new TimeZoneImpl(3*ONE_HOUR, "EAT"),
1626: //----------------------------------------------------------
1627: new TimeZoneImpl(3*ONE_HOUR, "Africa/Nairobi"),
1628: // Africa/Nairobi Kenya(KE) 3:00 - EAT
1629: //----------------------------------------------------------
1630: new TimeZoneImpl(3*ONE_HOUR, "Africa/Mogadishu"),
1631: // Africa/Mogadishu Somalia(SO) 3:00 - EAT
1632: //----------------------------------------------------------
1633: new TimeZoneImpl(3*ONE_HOUR, "Africa/Dar_es_Salaam"),
1634: // Africa/Dar_es_Salaam Tanzania(TZ) 3:00 - EAT
1635: //----------------------------------------------------------
1636: new TimeZoneImpl(3*ONE_HOUR, "Africa/Kampala"),
1637: // Africa/Kampala Uganda(UG) 3:00 - EAT
1638:
1639: ////////////////////////////////////////////////////////////
1640: // Europe
1641: //----------------------------------------------------------
1642: new TimeZoneImpl(0*ONE_HOUR, "Europe/Dublin",
1643: Calendar.MARCH, -1, Calendar.SUNDAY, 1*ONE_HOUR,
1644: Calendar.OCTOBER, -1, Calendar.SUNDAY, 1*ONE_HOUR, 1*ONE_HOUR),
1645: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1646: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1647: // Europe/Dublin ---(IE) 0:00 EU GMT/IST
1648: //----------------------------------------------------------
1649: new TimeZoneImpl(0*ONE_HOUR, "Europe/Lisbon",
1650: Calendar.MARCH, -1, Calendar.SUNDAY, 1*ONE_HOUR,
1651: Calendar.OCTOBER, -1, Calendar.SUNDAY, 1*ONE_HOUR, 1*ONE_HOUR),
1652: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1653: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1654: // Europe/Lisbon Portugal(PT) 0:00 EU WE%sT
1655: //----------------------------------------------------------
1656: new TimeZoneImpl(0*ONE_HOUR, "Europe/London",
1657: Calendar.MARCH, -1, Calendar.SUNDAY, 1*ONE_HOUR,
1658: Calendar.OCTOBER, -1, Calendar.SUNDAY, 1*ONE_HOUR, 1*ONE_HOUR),
1659: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1660: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1661: // Europe/London ---(GB) 0:00 EU GMT/BST
1662: //----------------------------------------------------------
1663: new TimeZoneImpl(1*ONE_HOUR, "Europe/Andorra",
1664: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1665: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1666: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1667: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1668: // Europe/Andorra Andorra(AD) 1:00 EU CE%sT
1669: //----------------------------------------------------------
1670: new TimeZoneImpl(1*ONE_HOUR, "Europe/Tirane",
1671: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1672: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1673: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1674: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1675: // Europe/Tirane Albania(AL) 1:00 EU CE%sT
1676: //----------------------------------------------------------
1677: new TimeZoneImpl(1*ONE_HOUR, "Europe/Vienna",
1678: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1679: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1680: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1681: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1682: // Europe/Vienna Austria(AT) 1:00 EU CE%sT
1683: //----------------------------------------------------------
1684: new TimeZoneImpl(1*ONE_HOUR, "Europe/Brussels",
1685: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1686: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1687: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1688: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1689: // Europe/Brussels Belgium(BE) 1:00 EU CE%sT
1690: //----------------------------------------------------------
1691: new TimeZoneImpl(1*ONE_HOUR, "Europe/Zurich",
1692: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1693: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1694: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1695: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1696: // Europe/Zurich Switzerland(CH) 1:00 EU CE%sT
1697: //----------------------------------------------------------
1698: new TimeZoneImpl(1*ONE_HOUR, "Europe/Prague",
1699: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1700: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1701: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1702: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1703: // Europe/Prague Czech Republic(CZ) 1:00 EU CE%sT
1704: //----------------------------------------------------------
1705: new TimeZoneImpl(1*ONE_HOUR, "Europe/Berlin",
1706: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1707: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1708: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1709: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1710: // Europe/Berlin Germany(DE) 1:00 EU CE%sT
1711: //----------------------------------------------------------
1712: new TimeZoneImpl(1*ONE_HOUR, "Europe/Copenhagen",
1713: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1714: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1715: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1716: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1717: // Europe/Copenhagen Denmark, Faeroe Islands, and Greenland(DK) 1:00 EU CE%sT
1718: //----------------------------------------------------------
1719: new TimeZoneImpl(1*ONE_HOUR, "Europe/Madrid",
1720: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1721: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1722: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1723: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1724: // Europe/Madrid Spain(ES) 1:00 EU CE%sT
1725: //----------------------------------------------------------
1726: new TimeZoneImpl(1*ONE_HOUR, "Europe/Gibraltar",
1727: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1728: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1729: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1730: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1731: // Europe/Gibraltar Gibraltar(GI) 1:00 EU CE%sT
1732: //----------------------------------------------------------
1733: new TimeZoneImpl(1*ONE_HOUR, "Europe/Budapest",
1734: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1735: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1736: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1737: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1738: // Europe/Budapest Hungary(HU) 1:00 EU CE%sT
1739: //----------------------------------------------------------
1740: new TimeZoneImpl(1*ONE_HOUR, "Europe/Rome",
1741: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1742: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1743: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1744: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1745: // Europe/Rome Italy(IT) 1:00 EU CE%sT
1746: //----------------------------------------------------------
1747: new TimeZoneImpl(1*ONE_HOUR, "Europe/Vaduz",
1748: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1749: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1750: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1751: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1752: // Europe/Vaduz Liechtenstein(LI) 1:00 EU CE%sT
1753: //----------------------------------------------------------
1754: new TimeZoneImpl(1*ONE_HOUR, "Europe/Luxembourg",
1755: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1756: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1757: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1758: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1759: // Europe/Luxembourg Luxembourg(LU) 1:00 EU CE%sT
1760: //----------------------------------------------------------
1761: new TimeZoneImpl(1*ONE_HOUR, "Europe/Monaco",
1762: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1763: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1764: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1765: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1766: // Europe/Monaco Monaco(MC) 1:00 EU CE%sT
1767: //----------------------------------------------------------
1768: new TimeZoneImpl(1*ONE_HOUR, "Europe/Malta",
1769: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1770: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1771: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1772: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1773: // Europe/Malta Malta(MT) 1:00 EU CE%sT
1774: //----------------------------------------------------------
1775: new TimeZoneImpl(1*ONE_HOUR, "Europe/Amsterdam",
1776: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1777: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1778: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1779: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1780: // Europe/Amsterdam Netherlands(NL) 1:00 EU CE%sT
1781: //----------------------------------------------------------
1782: new TimeZoneImpl(1*ONE_HOUR, "Europe/Oslo",
1783: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1784: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1785: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1786: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1787: // Europe/Oslo Norway(NO) 1:00 EU CE%sT
1788: //----------------------------------------------------------
1789: new TimeZoneImpl(1*ONE_HOUR, "Europe/Warsaw",
1790: Calendar.MARCH, -1, Calendar.SUNDAY, 1*ONE_HOUR,
1791: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1792: // Rule W-Eur 1981 max - Mar lastSun 1:00s 1:00 S
1793: // Rule W-Eur 1996 max - Oct lastSun 1:00s 0 -
1794: // Europe/Warsaw Poland(PL) 1:00 W-Eur CE%sT
1795: //----------------------------------------------------------
1796: new TimeZoneImpl(1*ONE_HOUR, "Europe/Stockholm",
1797: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1798: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1799: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1800: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1801: // Europe/Stockholm Sweden(SE) 1:00 EU CE%sT
1802: //----------------------------------------------------------
1803: new TimeZoneImpl(1*ONE_HOUR, "Europe/Belgrade",
1804: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1805: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1806: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1807: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1808: // Europe/Belgrade Yugoslavia(YU) 1:00 EU CE%sT
1809: //----------------------------------------------------------
1810: new TimeZoneImpl(1*ONE_HOUR, "Europe/Paris",
1811: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1812: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1813: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1814: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1815: // Europe/Paris France(FR) 1:00 EU CE%sT
1816: new TimeZoneImpl(1*ONE_HOUR, "ECT",
1817: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1818: Calendar.OCTOBER, -1, Calendar.SUNDAY, 2*ONE_HOUR, 1*ONE_HOUR),
1819: new TimeZoneImpl(2*ONE_HOUR, "Europe/Sofia",
1820: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
1821: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1822: // Rule E-Eur 1981 max - Mar lastSun 0:00 1:00 S
1823: // Rule E-Eur 1996 max - Oct lastSun 0:00 0 -
1824: // Europe/Sofia Bulgaria(BG) 2:00 E-Eur EE%sT
1825: //----------------------------------------------------------
1826: new TimeZoneImpl(2*ONE_HOUR, "Europe/Minsk",
1827: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1828: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1829: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
1830: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
1831: // Europe/Minsk Belarus(BY) 2:00 Russia EE%sT
1832: //----------------------------------------------------------
1833: new TimeZoneImpl(2*ONE_HOUR, "Europe/Tallinn",
1834: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1835: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1836: // Rule C-Eur 1981 max - Mar lastSun 2:00s 1:00 S
1837: // Rule C-Eur 1996 max - Oct lastSun 2:00s 0 -
1838: // Europe/Tallinn Estonia(EE) 2:00 C-Eur EE%sT
1839: //----------------------------------------------------------
1840:
1841: new TimeZoneImpl(2*ONE_HOUR, "Europe/Helsinki",
1842: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR,
1843: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1844: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1845: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1846: // Europe/Helsinki Finland(FI) 2:00 EU EE%sT
1847: //----------------------------------------------------------
1848:
1849: new TimeZoneImpl(2*ONE_HOUR, "Europe/Athens",
1850: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR,
1851: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1852: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1853: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1854: // Europe/Athens Greece(GR) 2:00 EU EE%sT
1855: //----------------------------------------------------------
1856: new TimeZoneImpl(2*ONE_HOUR, "Europe/Vilnius",
1857: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1858: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1859: // Rule C-Eur 1981 max - Mar lastSun 2:00s 1:00 S
1860: // Rule C-Eur 1996 max - Oct lastSun 2:00s 0 -
1861: // Europe/Vilnius Lithuania(LT) 2:00 C-Eur EE%sT
1862: //----------------------------------------------------------
1863: new TimeZoneImpl(2*ONE_HOUR, "Europe/Riga",
1864: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1865: Calendar.SEPTEMBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1866: // Rule Latvia 1992 max - Mar lastSun 2:00s 1:00 S
1867: // Rule Latvia 1992 max - Sep lastSun 2:00s 0 -
1868: // Europe/Riga Latvia(LV) 2:00 Latvia EE%sT
1869: //----------------------------------------------------------
1870: new TimeZoneImpl(2*ONE_HOUR, "Europe/Chisinau",
1871: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
1872: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1873: // Rule E-Eur 1981 max - Mar lastSun 0:00 1:00 S
1874: // Rule E-Eur 1996 max - Oct lastSun 0:00 0 -
1875: // Europe/Chisinau Moldova(MD) 2:00 E-Eur EE%sT
1876: //----------------------------------------------------------
1877: new TimeZoneImpl(2*ONE_HOUR, "Europe/Bucharest",
1878: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
1879: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1880: // Rule E-Eur 1981 max - Mar lastSun 0:00 1:00 S
1881: // Rule E-Eur 1996 max - Oct lastSun 0:00 0 -
1882: // Europe/Bucharest Romania(RO) 2:00 E-Eur EE%sT
1883: //----------------------------------------------------------
1884: new TimeZoneImpl(2*ONE_HOUR, "Europe/Kaliningrad",
1885: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1886: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1887: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
1888: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
1889: // Europe/Kaliningrad Russia(RU) 2:00 Russia EE%sT
1890: //----------------------------------------------------------
1891: new TimeZoneImpl(2*ONE_HOUR, "Europe/Kiev",
1892: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR,
1893: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1894: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1895: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1896: // Europe/Kiev Ukraine(UA) 2:00 EU EE%sT
1897: //----------------------------------------------------------
1898: new TimeZoneImpl(2*ONE_HOUR, "Europe/Istanbul",
1899: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR,
1900: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1901: // Rule EU 1981 max - Mar lastSun 1:00u 1:00 S
1902: // Rule EU 1996 max - Oct lastSun 1:00u 0 -
1903: // Europe/Istanbul Turkey(TR) 2:00 EU EE%sT
1904: new TimeZoneImpl(2*ONE_HOUR, "EET",
1905: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR,
1906: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1907: //----------------------------------------------------------
1908: new TimeZoneImpl(3*ONE_HOUR, "Europe/Simferopol",
1909: Calendar.MARCH, -1, Calendar.SUNDAY, 3*ONE_HOUR,
1910: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1911: // Rule Crimea 1996 max - Mar lastSun 0:00u 1:00 -
1912: // Rule Crimea 1996 max - Oct lastSun 0:00u 0 -
1913: // Europe/Simferopol Ukraine(UA) 3:00 Crimea MSK/MSD
1914: //----------------------------------------------------------
1915: new TimeZoneImpl(3*ONE_HOUR, "Europe/Moscow",
1916: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1917: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1918: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
1919: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
1920: // Europe/Moscow Russia(RU) 3:00 Russia MSK/MSD
1921: //----------------------------------------------------------
1922: new TimeZoneImpl(4*ONE_HOUR, "Europe/Samara",
1923: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
1924: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
1925: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
1926: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
1927: // Europe/Samara Russia(RU) 4:00 Russia SAM%sT
1928:
1929: ////////////////////////////////////////////////////////////
1930: // Asia
1931: //----------------------------------------------------------
1932: new TimeZoneImpl(2*ONE_HOUR, "Asia/Nicosia",
1933: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
1934: Calendar.SEPTEMBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1935: // Rule Cyprus 1979 max - Sep lastSun 0:00 0 -
1936: // Rule Cyprus 1981 max - Mar lastSun 0:00 1:00 S
1937: // Asia/Nicosia Cyprus(CY) 2:00 Cyprus EE%sT
1938: //----------------------------------------------------------
1939: new TimeZoneImpl(2*ONE_HOUR, "Asia/Jerusalem",
1940: Calendar.MARCH, 15, -Calendar.FRIDAY, 0*ONE_HOUR,
1941: Calendar.SEPTEMBER, 1, -Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1942: // Rule Zion 1999 max - Mar Fri>=15 0:00 1:00 D
1943: // Rule Zion 1999 max - Sep Sun>=1 0:00 0 S
1944: // Asia/Jerusalem Israel(IL) 2:00 Zion I%sT
1945: //----------------------------------------------------------
1946: new TimeZoneImpl(2*ONE_HOUR, "Asia/Amman",
1947: Calendar.APRIL, 1, -Calendar.FRIDAY, 0*ONE_HOUR,
1948: Calendar.SEPTEMBER, 15, -Calendar.FRIDAY, 1*ONE_HOUR, 1*ONE_HOUR),
1949: // Rule Jordan 1993 max - Apr Fri>=1 0:00 1:00 S
1950: // Rule Jordan 1995 max - Sep Fri>=15 0:00s 0 -
1951: // Asia/Amman Jordan(JO) 2:00 Jordan EE%sT
1952: //----------------------------------------------------------
1953: new TimeZoneImpl(2*ONE_HOUR, "Asia/Beirut",
1954: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
1955: Calendar.SEPTEMBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
1956: // Rule Lebanon 1993 max - Mar lastSun 0:00 1:00 S
1957: // Rule Lebanon 1993 max - Sep lastSun 0:00 0 -
1958: // Asia/Beirut Lebanon(LB) 2:00 Lebanon EE%sT
1959: //----------------------------------------------------------
1960: new TimeZoneImpl(2*ONE_HOUR, "Asia/Damascus",
1961: Calendar.APRIL, 1, 0, 0*ONE_HOUR,
1962: Calendar.OCTOBER, 1, 0, 0*ONE_HOUR, 1*ONE_HOUR),
1963: // Rule Syria 1994 max - Apr 1 0:00 1:00 S
1964: // Rule Syria 1994 max - Oct 1 0:00 0 -
1965: // Asia/Damascus Syria(SY) 2:00 Syria EE%sT
1966: //----------------------------------------------------------
1967: new TimeZoneImpl(3*ONE_HOUR, "Asia/Bahrain"),
1968: // Asia/Bahrain Bahrain(BH) 3:00 - AST
1969: //----------------------------------------------------------
1970: new TimeZoneImpl(3*ONE_HOUR, "Asia/Kuwait"),
1971: // Asia/Kuwait Kuwait(KW) 3:00 - AST
1972: //----------------------------------------------------------
1973: new TimeZoneImpl(3*ONE_HOUR, "Asia/Qatar"),
1974: // Asia/Qatar Qatar(QA) 3:00 - AST
1975: //----------------------------------------------------------
1976: new TimeZoneImpl(3*ONE_HOUR, "Asia/Aden"),
1977: // Asia/Aden Yemen(YE) 3:00 - AST
1978: //----------------------------------------------------------
1979: new TimeZoneImpl(3*ONE_HOUR, "Asia/Riyadh"),
1980: // Asia/Riyadh Saudi Arabia(SA) 3:00 - AST
1981: //----------------------------------------------------------
1982: new TimeZoneImpl(3*ONE_HOUR, "Asia/Baghdad",
1983: Calendar.APRIL, 1, 0, 3*ONE_HOUR,
1984: Calendar.OCTOBER, 1, 0, 4*ONE_HOUR, 1*ONE_HOUR),
1985: // Rule Iraq 1991 max - Apr 1 3:00s 1:00 D
1986: // Rule Iraq 1991 max - Oct 1 3:00s 0 D
1987: // Asia/Baghdad Iraq(IQ) 3:00 Iraq A%sT
1988: //----------------------------------------------------------
1989: new TimeZoneImpl((int)(3.5*ONE_HOUR), "Asia/Tehran",
1990: Calendar.MARCH, 21, 0, 0*ONE_HOUR,
1991: Calendar.SEPTEMBER, 23, 0, 0*ONE_HOUR, 1*ONE_HOUR),
1992: // Rule Iran 1997 1999 - Mar 21 0:00 1:00 S
1993: // Rule Iran 1997 1999 - Sep 23 0:00 0 -
1994: // Asia/Tehran Iran(IR) 3:30 Iran IR%sT
1995: new TimeZoneImpl((int)(3.5*ONE_HOUR), "MET",
1996: Calendar.MARCH, 21, 0, 0*ONE_HOUR,
1997: Calendar.SEPTEMBER, 23, 0, 0*ONE_HOUR, 1*ONE_HOUR),
1998: //----------------------------------------------------------
1999: new TimeZoneImpl(4*ONE_HOUR, "Asia/Dubai"),
2000: // Asia/Dubai United Arab Emirates(AE) 4:00 - GST
2001: //----------------------------------------------------------
2002: new TimeZoneImpl(4*ONE_HOUR, "Asia/Muscat"),
2003: // Asia/Muscat Oman(OM) 4:00 - GST
2004: //----------------------------------------------------------
2005: new TimeZoneImpl(4*ONE_HOUR, "Asia/Yerevan"),
2006: // Asia/Yerevan Armenia(AM) 4:00 - AM%sT
2007: new TimeZoneImpl(4*ONE_HOUR, "NET"),
2008: //----------------------------------------------------------
2009: new TimeZoneImpl(4*ONE_HOUR, "Asia/Baku",
2010: Calendar.MARCH, -1, Calendar.SUNDAY, 5*ONE_HOUR,
2011: Calendar.OCTOBER, -1, Calendar.SUNDAY, 5*ONE_HOUR, 1*ONE_HOUR),
2012: // Rule EUAsia 1981 max - Mar lastSun 1:00u 1:00 S
2013: // Rule EUAsia 1996 max - Oct lastSun 1:00u 0 -
2014: // Asia/Baku Azerbaijan(AZ) 4:00 EUAsia AZ%sT
2015: //----------------------------------------------------------
2016: new TimeZoneImpl(4*ONE_HOUR, "Asia/Aqtau",
2017: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
2018: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
2019: // Rule E-EurAsia 1981 max - Mar lastSun 0:00 1:00 S
2020: // Rule E-EurAsia 1996 max - Oct lastSun 0:00 0 -
2021: // Asia/Aqtau Kazakhstan(KZ) 4:00 E-EurAsia AQT%sT
2022: //----------------------------------------------------------
2023: new TimeZoneImpl((int)(4.5*ONE_HOUR), "Asia/Kabul"),
2024: // Asia/Kabul Afghanistan(AF) 4:30 - AFT
2025: //----------------------------------------------------------
2026: new TimeZoneImpl(5*ONE_HOUR, "Asia/Tbilisi"),
2027: // Asia/Tbilisi Georgia(GE) 5:00 - GET
2028: //----------------------------------------------------------
2029: new TimeZoneImpl(5*ONE_HOUR, "Asia/Dushanbe"),
2030: // Asia/Dushanbe Tajikistan(TJ) 5:00 - TJT # Tajikistan Time
2031: //----------------------------------------------------------
2032: new TimeZoneImpl(5*ONE_HOUR, "Asia/Ashkhabad"),
2033: // Asia/Ashkhabad Turkmenistan(TM) 5:00 - TMT # Turkmenistan Time
2034: //----------------------------------------------------------
2035: new TimeZoneImpl(5*ONE_HOUR, "Asia/Tashkent"),
2036: // Asia/Tashkent Uzbekistan(UZ) 5:00 - UZT # Uzbekistan Time
2037: //----------------------------------------------------------
2038: new TimeZoneImpl(5*ONE_HOUR, "Asia/Karachi"),
2039: // Asia/Karachi Pakistan(PK) 5:00 - PKT # Pakistan Time
2040: new TimeZoneImpl(5*ONE_HOUR, "PLT"),
2041: //----------------------------------------------------------
2042: new TimeZoneImpl(5*ONE_HOUR, "Asia/Bishkek",
2043: Calendar.APRIL, 7, -Calendar.SUNDAY, 0*ONE_HOUR,
2044: Calendar.SEPTEMBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
2045: // Rule Kirgiz 1992 max - Apr Sun>=7 0:00 1:00 S
2046: // Rule Kirgiz 1991 max - Sep lastSun 0:00 0 -
2047: // Asia/Bishkek Kirgizstan(KG) 5:00 Kirgiz KG%sT # Kirgizstan Time
2048: //----------------------------------------------------------
2049: new TimeZoneImpl(5*ONE_HOUR, "Asia/Aqtobe",
2050: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
2051: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
2052: // Rule E-EurAsia 1981 max - Mar lastSun 0:00 1:00 S
2053: // Rule E-EurAsia 1996 max - Oct lastSun 0:00 0 -
2054: // Asia/Aqtobe Kazakhstan(KZ) 5:00 E-EurAsia AQT%sT
2055: //----------------------------------------------------------
2056: new TimeZoneImpl(5*ONE_HOUR, "Asia/Yekaterinburg",
2057: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2058: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2059: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
2060: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
2061: // Asia/Yekaterinburg Russia(RU) 5:00 Russia YEK%sT # Yekaterinburg Time
2062: //----------------------------------------------------------
2063: new TimeZoneImpl((int)(5.5*ONE_HOUR), "Asia/Calcutta"),
2064: // Asia/Calcutta India(IN) 5:30 - IST
2065: new TimeZoneImpl((int)(5.5*ONE_HOUR), "IST"),
2066: //----------------------------------------------------------
2067: new TimeZoneImpl((int)(5.75*ONE_HOUR), "Asia/Katmandu"),
2068: // Asia/Katmandu Nepal(NP) 5:45 - NPT # Nepal Time
2069: //----------------------------------------------------------
2070: new TimeZoneImpl(6*ONE_HOUR, "Asia/Thimbu"),
2071: // Asia/Thimbu Bhutan(BT) 6:00 - BTT # Bhutan Time
2072: //----------------------------------------------------------
2073: new TimeZoneImpl(6*ONE_HOUR, "Asia/Colombo"),
2074: // Asia/Colombo Sri Lanka(LK) 6:00 - LKT
2075: //----------------------------------------------------------
2076: new TimeZoneImpl(6*ONE_HOUR, "Asia/Dacca"),
2077: // Asia/Dacca Bangladesh(BD) 6:00 - BDT # Bangladesh Time
2078: new TimeZoneImpl(6*ONE_HOUR, "BST"),
2079: //----------------------------------------------------------
2080: new TimeZoneImpl(6*ONE_HOUR, "Asia/Alma-Ata",
2081: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
2082: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
2083: // Rule E-EurAsia 1981 max - Mar lastSun 0:00 1:00 S
2084: // Rule E-EurAsia 1996 max - Oct lastSun 0:00 0 -
2085: // Asia/Alma-Ata Kazakhstan(KZ) 6:00 E-EurAsia ALM%sT
2086: //----------------------------------------------------------
2087: new TimeZoneImpl(6*ONE_HOUR, "Asia/Novosibirsk",
2088: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2089: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2090: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
2091: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
2092: // Asia/Novosibirsk Russia(RU) 6:00 Russia NOV%sT
2093: //----------------------------------------------------------
2094: new TimeZoneImpl((int)(6.5*ONE_HOUR), "Asia/Rangoon"),
2095: // Asia/Rangoon Burma / Myanmar(MM) 6:30 - MMT # Myanmar Time
2096: //----------------------------------------------------------
2097: new TimeZoneImpl(7*ONE_HOUR, "Asia/Jakarta"),
2098: // Asia/Jakarta Indonesia(ID) 7:00 - JAVT
2099: //----------------------------------------------------------
2100: new TimeZoneImpl(7*ONE_HOUR, "Asia/Phnom_Penh"),
2101: // Asia/Phnom_Penh Cambodia(KH) 7:00 - ICT
2102: //----------------------------------------------------------
2103: new TimeZoneImpl(7*ONE_HOUR, "Asia/Vientiane"),
2104: // Asia/Vientiane Laos(LA) 7:00 - ICT
2105: //----------------------------------------------------------
2106: new TimeZoneImpl(7*ONE_HOUR, "Asia/Saigon"),
2107: // Asia/Saigon Vietnam(VN) 7:00 - ICT
2108: new TimeZoneImpl(7*ONE_HOUR, "VST"),
2109: //----------------------------------------------------------
2110: new TimeZoneImpl(7*ONE_HOUR, "Asia/Bangkok"),
2111: // Asia/Bangkok Thailand(TH) 7:00 - ICT
2112: //----------------------------------------------------------
2113: new TimeZoneImpl(7*ONE_HOUR, "Asia/Krasnoyarsk",
2114: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2115: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2116: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
2117: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
2118: // Asia/Krasnoyarsk Russia(RU) 7:00 Russia KRA%sT
2119: //----------------------------------------------------------
2120: new TimeZoneImpl(8*ONE_HOUR, "Asia/Brunei"),
2121: // Asia/Brunei Brunei(BN) 8:00 - BNT
2122: //----------------------------------------------------------
2123: new TimeZoneImpl(8*ONE_HOUR, "Asia/Hong_Kong"),
2124: // Asia/Hong_Kong China(HK) 8:00 - C%sT
2125: //----------------------------------------------------------
2126: new TimeZoneImpl(8*ONE_HOUR, "Asia/Ujung_Pandang"),
2127: // Asia/Ujung_Pandang Indonesia(ID) 8:00 - BORT
2128: //----------------------------------------------------------
2129: new TimeZoneImpl(8*ONE_HOUR, "Asia/Ishigaki"),
2130: // Asia/Ishigaki Japan(JP) 8:00 - CST
2131: //----------------------------------------------------------
2132: new TimeZoneImpl(8*ONE_HOUR, "Asia/Macao"),
2133: // Asia/Macao Macao(MO) 8:00 - C%sT
2134: //----------------------------------------------------------
2135: new TimeZoneImpl(8*ONE_HOUR, "Asia/Kuala_Lumpur"),
2136: // Asia/Kuala_Lumpur Malaysia(MY) 8:00 - MYT # Malaysia Time
2137: //----------------------------------------------------------
2138: new TimeZoneImpl(8*ONE_HOUR, "Asia/Manila"),
2139: // Asia/Manila Philippines(PH) 8:00 - PH%sT
2140: //----------------------------------------------------------
2141: new TimeZoneImpl(8*ONE_HOUR, "Asia/Singapore"),
2142: // Asia/Singapore Singapore(SG) 8:00 - SGT
2143: //----------------------------------------------------------
2144: new TimeZoneImpl(8*ONE_HOUR, "Asia/Taipei"),
2145: // Asia/Taipei Taiwan(TW) 8:00 - C%sT
2146: //----------------------------------------------------------
2147: new TimeZoneImpl(8*ONE_HOUR, "Asia/Shanghai"),
2148: // Asia/Shanghai China(CN) 8:00 - C%sT
2149: new TimeZoneImpl(8*ONE_HOUR, "CTT"),
2150: //----------------------------------------------------------
2151: new TimeZoneImpl(8*ONE_HOUR, "Asia/Ulan_Bator",
2152: Calendar.MARCH, -1, Calendar.SUNDAY, 0*ONE_HOUR,
2153: Calendar.SEPTEMBER, -1, Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
2154: // Rule Mongol 1991 max - Mar lastSun 0:00 1:00 S
2155: // Rule Mongol 1997 max - Sep lastSun 0:00 0 -
2156: // Asia/Ulan_Bator Mongolia(MN) 8:00 Mongol ULA%sT
2157: //----------------------------------------------------------
2158: new TimeZoneImpl(8*ONE_HOUR, "Asia/Irkutsk",
2159: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2160: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2161: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
2162: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
2163: // Asia/Irkutsk Russia(RU) 8:00 Russia IRK%sT
2164: //----------------------------------------------------------
2165: new TimeZoneImpl(9*ONE_HOUR, "Asia/Jayapura"),
2166: // Asia/Jayapura Indonesia(ID) 9:00 - JAYT
2167: //----------------------------------------------------------
2168: new TimeZoneImpl(9*ONE_HOUR, "Asia/Pyongyang"),
2169: // Asia/Pyongyang ?(KP) 9:00 - KST
2170: //----------------------------------------------------------
2171: new TimeZoneImpl(9*ONE_HOUR, "Asia/Seoul"),
2172: // Asia/Seoul ?(KR) 9:00 - K%sT
2173: //----------------------------------------------------------
2174: new TimeZoneImpl(9*ONE_HOUR, "Asia/Tokyo"),
2175: // Asia/Tokyo Japan(JP) 9:00 - JST
2176: new TimeZoneImpl(9*ONE_HOUR, "JST"),
2177: //----------------------------------------------------------
2178: new TimeZoneImpl(9*ONE_HOUR, "Asia/Yakutsk",
2179: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2180: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2181: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
2182: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
2183: // Asia/Yakutsk Russia(RU) 9:00 Russia YAK%sT
2184: //----------------------------------------------------------
2185: new TimeZoneImpl(10*ONE_HOUR, "Asia/Vladivostok",
2186: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2187: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2188: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
2189: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
2190: // Asia/Vladivostok Russia(RU) 10:00 Russia VLA%sT
2191: //----------------------------------------------------------
2192: new TimeZoneImpl(11*ONE_HOUR, "Asia/Magadan",
2193: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2194: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2195: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
2196: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
2197: // Asia/Magadan Russia(RU) 11:00 Russia MAG%sT
2198: //----------------------------------------------------------
2199: new TimeZoneImpl(12*ONE_HOUR, "Asia/Kamchatka",
2200: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2201: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2202: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
2203: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
2204: // Asia/Kamchatka Russia(RU) 12:00 Russia PET%sT
2205: //----------------------------------------------------------
2206: new TimeZoneImpl(13*ONE_HOUR, "Asia/Anadyr",
2207: Calendar.MARCH, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2208: Calendar.OCTOBER, -1, Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2209: // Rule Russia 1993 max - Mar lastSun 2:00s 1:00 S
2210: // Rule Russia 1996 max - Oct lastSun 2:00s 0 -
2211: // Asia/Anadyr Russia(RU) 13:00 Russia ANA%sT
2212:
2213: ////////////////////////////////////////////////////////////
2214: // India
2215: //----------------------------------------------------------
2216: new TimeZoneImpl(3*ONE_HOUR, "Indian/Comoro"),
2217: // Indian/Comoro Comoros(KM) 3:00 - EAT
2218: //----------------------------------------------------------
2219: new TimeZoneImpl(3*ONE_HOUR, "Indian/Antananarivo"),
2220: // Indian/Antananarivo Madagascar(MK) 3:00 - EAT
2221: //----------------------------------------------------------
2222: new TimeZoneImpl(3*ONE_HOUR, "Indian/Mayotte"),
2223: // Indian/Mayotte Mayotte(YT) 3:00 - EAT
2224: //----------------------------------------------------------
2225: new TimeZoneImpl(4*ONE_HOUR, "Indian/Mauritius"),
2226: // Indian/Mauritius Mauritius(MU) 4:00 - MUT # Mauritius Time
2227: //----------------------------------------------------------
2228: new TimeZoneImpl(4*ONE_HOUR, "Indian/Reunion"),
2229: // Indian/Reunion Reunion(RE) 4:00 - RET # Reunion Time
2230: //----------------------------------------------------------
2231: new TimeZoneImpl(4*ONE_HOUR, "Indian/Mahe"),
2232: // Indian/Mahe Seychelles(SC) 4:00 - SCT # Seychelles Time
2233: //----------------------------------------------------------
2234: new TimeZoneImpl(5*ONE_HOUR, "Indian/Kerguelen"),
2235: // Indian/Kerguelen France - year-round bases(FR) 5:00 - TFT # ISO code TF Time
2236: //----------------------------------------------------------
2237: new TimeZoneImpl(5*ONE_HOUR, "Indian/Chagos"),
2238: // Indian/Chagos British Indian Ocean Territory(IO) 5:00 - IOT # BIOT Time
2239: //----------------------------------------------------------
2240: new TimeZoneImpl(5*ONE_HOUR, "Indian/Maldives"),
2241: // Indian/Maldives Maldives(MV) 5:00 - MVT # Maldives Time
2242: //----------------------------------------------------------
2243: new TimeZoneImpl((int)(6.5*ONE_HOUR), "Indian/Cocos"),
2244: // Indian/Cocos Cocos(CC) 6:30 - CCT # Cocos Islands Time
2245: //----------------------------------------------------------
2246: new TimeZoneImpl(7*ONE_HOUR, "Indian/Christmas"),
2247: // Indian/Christmas Australian miscellany(AU) 7:00 - CXT # Christmas Island Time
2248:
2249: ////////////////////////////////////////////////////////////
2250: // Pacific
2251: //----------------------------------------------------------
2252: new TimeZoneImpl(9*ONE_HOUR, "Pacific/Palau"),
2253: // Pacific/Palau Palau(PW) 9:00 - PWT # Palau Time
2254: //----------------------------------------------------------
2255: new TimeZoneImpl(10*ONE_HOUR, "Pacific/Truk"),
2256: // Pacific/Truk Micronesia(FM) 10:00 - TRUT # Truk Time
2257: //----------------------------------------------------------
2258: new TimeZoneImpl(10*ONE_HOUR, "Pacific/Guam"),
2259: // Pacific/Guam Guam(GU) 10:00 - GST
2260: //----------------------------------------------------------
2261: new TimeZoneImpl(10*ONE_HOUR, "Pacific/Saipan"),
2262: // Pacific/Saipan N Mariana Is(MP) 10:00 - MPT
2263: //----------------------------------------------------------
2264: new TimeZoneImpl(10*ONE_HOUR, "Pacific/Port_Moresby"),
2265: // Pacific/Port_Moresby Papua New Guinea(PG) 10:00 - PGT # Papua New Guinea Time
2266: //----------------------------------------------------------
2267: new TimeZoneImpl(11*ONE_HOUR, "Pacific/Ponape"),
2268: // Pacific/Ponape Micronesia(FM) 11:00 - PONT # Ponape Time
2269: //----------------------------------------------------------
2270: new TimeZoneImpl(11*ONE_HOUR, "Pacific/Efate"),
2271: // Pacific/Efate Vanuatu(VU) 11:00 - VU%sT # Vanuatu Time
2272: //----------------------------------------------------------
2273: new TimeZoneImpl(11*ONE_HOUR, "Pacific/Guadalcanal"),
2274: // Pacific/Guadalcanal Solomon Is(SB) 11:00 - SBT # Solomon Is Time
2275: new TimeZoneImpl(11*ONE_HOUR, "SST"),
2276: //----------------------------------------------------------
2277: new TimeZoneImpl(11*ONE_HOUR, "Pacific/Noumea",
2278: Calendar.NOVEMBER, -1, Calendar.SUNDAY, 2*ONE_HOUR,
2279: Calendar.MARCH, 1, -Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2280: // Rule NC 1997 max - Mar Sun>=1 2:00s 0 -
2281: // Rule NC 1997 max - Nov lastSun 2:00s 1:00 S
2282: // Pacific/Noumea New Caledonia(NC) 11:00 NC NC%sT
2283: //----------------------------------------------------------
2284: new TimeZoneImpl(-11*ONE_HOUR, "Pacific/Niue"),
2285: // Pacific/Niue Niue(NU) -11:00 - NUT
2286: //----------------------------------------------------------
2287: new TimeZoneImpl(-11*ONE_HOUR, "Pacific/Apia"),
2288: // Pacific/Apia W Samoa(WS) -11:00 - WST # W Samoa Time
2289: new TimeZoneImpl(-11*ONE_HOUR, "MIT"),
2290: //----------------------------------------------------------
2291: new TimeZoneImpl(-11*ONE_HOUR, "Pacific/Pago_Pago"),
2292: // Pacific/Pago_Pago American Samoa(US) -11:00 - SST # S=Samoa
2293: //----------------------------------------------------------
2294: new TimeZoneImpl(-10*ONE_HOUR, "Pacific/Tahiti"),
2295: // Pacific/Tahiti French Polynesia(PF) -10:00 - TAHT # Tahiti Time
2296: //----------------------------------------------------------
2297: new TimeZoneImpl(-10*ONE_HOUR, "Pacific/Fakaofo"),
2298: // Pacific/Fakaofo Tokelau Is(TK) -10:00 - TKT # Tokelau Time
2299: //----------------------------------------------------------
2300: new TimeZoneImpl(-10*ONE_HOUR, "Pacific/Honolulu"),
2301: // Pacific/Honolulu Hawaii(US) -10:00 - HST
2302: new TimeZoneImpl(-10*ONE_HOUR, "HST"),
2303: //----------------------------------------------------------
2304: new TimeZoneImpl(-10*ONE_HOUR, "Pacific/Rarotonga",
2305: Calendar.OCTOBER, -1, Calendar.SUNDAY, 0*ONE_HOUR,
2306: Calendar.MARCH, 1, -Calendar.SUNDAY, 0*ONE_HOUR, (int)(0.5*ONE_HOUR)),
2307: // Rule Cook 1979 max - Mar Sun>=1 0:00 0 -
2308: // Rule Cook 1979 max - Oct lastSun 0:00 0:30 HS
2309: // Pacific/Rarotonga Cook Is(CK) -10:00 Cook CK%sT
2310: //----------------------------------------------------------
2311: new TimeZoneImpl((int)(-9.5*ONE_HOUR), "Pacific/Marquesas"),
2312: // Pacific/Marquesas French Polynesia(PF) -9:30 - MART # Marquesas Time
2313: //----------------------------------------------------------
2314: new TimeZoneImpl(-9*ONE_HOUR, "Pacific/Gambier"),
2315: // Pacific/Gambier French Polynesia(PF) -9:00 - GAMT # Gambier Time
2316: //----------------------------------------------------------
2317: new TimeZoneImpl((int)(-8.5*ONE_HOUR), "Pacific/Pitcairn"),
2318: // Pacific/Pitcairn Pitcairn(PN) -8:30 - PNT # Pitcairn Time
2319: //----------------------------------------------------------
2320: new TimeZoneImpl(-6*ONE_HOUR, "Pacific/Galapagos"),
2321: // Pacific/Galapagos Ecuador(EC) -6:00 - GALT # Galapagos Time
2322: //----------------------------------------------------------
2323: new TimeZoneImpl(-6*ONE_HOUR, "Pacific/Easter",
2324: Calendar.OCTOBER, 9, -Calendar.SUNDAY, 0*ONE_HOUR,
2325: Calendar.MARCH, 9, -Calendar.SUNDAY, 0*ONE_HOUR, 1*ONE_HOUR),
2326: // Rule Chile 1969 max - Oct Sun>=9 0:00 1:00 S
2327: // Rule Chile 1970 max - Mar Sun>=9 0:00 0 -
2328: // Pacific/Easter Chile(CL) -6:00 Chile EAS%sT
2329: //----------------------------------------------------------
2330: new TimeZoneImpl((int)(11.5*ONE_HOUR), "Pacific/Norfolk"),
2331: // Pacific/Norfolk Norfolk(NF) 11:30 - NFT # Norfolk Time
2332: //----------------------------------------------------------
2333: new TimeZoneImpl(12*ONE_HOUR, "Pacific/Kosrae"),
2334: // Pacific/Kosrae Micronesia(FM) 12:00 - KOST # Kosrae Time
2335: //----------------------------------------------------------
2336: new TimeZoneImpl(12*ONE_HOUR, "Pacific/Tarawa"),
2337: // Pacific/Tarawa Kiribati(KI) 12:00 - GILT # Gilbert Is Time
2338: //----------------------------------------------------------
2339: new TimeZoneImpl(12*ONE_HOUR, "Pacific/Majuro"),
2340: // Pacific/Majuro Marshall Is(MH) 12:00 - MHT
2341: //----------------------------------------------------------
2342: new TimeZoneImpl(12*ONE_HOUR, "Pacific/Nauru"),
2343: // Pacific/Nauru Nauru(NR) 12:00 - NRT
2344: //----------------------------------------------------------
2345: new TimeZoneImpl(12*ONE_HOUR, "Pacific/Funafuti"),
2346: // Pacific/Funafuti Tuvalu(TV) 12:00 - TVT # Tuvalu Time
2347: //----------------------------------------------------------
2348: new TimeZoneImpl(12*ONE_HOUR, "Pacific/Wake"),
2349: // Pacific/Wake Wake(US) 12:00 - WAKT # Wake Time
2350: //----------------------------------------------------------
2351: new TimeZoneImpl(12*ONE_HOUR, "Pacific/Wallis"),
2352: // Pacific/Wallis Wallis and Futuna(WF) 12:00 - WFT # Wallis & Futuna Time
2353: //----------------------------------------------------------
2354: new TimeZoneImpl(12*ONE_HOUR, "Pacific/Fiji"),
2355: // Pacific/Fiji Fiji(FJ) 12:00 - FJT # Fiji Time
2356: //----------------------------------------------------------
2357: new TimeZoneImpl(12*ONE_HOUR, "Pacific/Auckland",
2358: Calendar.OCTOBER, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
2359: Calendar.MARCH, 15, -Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2360: // Rule NZ 1990 max - Oct Sun>=1 2:00s 1:00 D
2361: // Rule NZ 1990 max - Mar Sun>=15 2:00s 0 S
2362: // Pacific/Auckland New Zealand(NZ) 12:00 NZ NZ%sT
2363: new TimeZoneImpl(12*ONE_HOUR, "NST",
2364: Calendar.OCTOBER, 1, -Calendar.SUNDAY, 2*ONE_HOUR,
2365: Calendar.MARCH, 15, -Calendar.SUNDAY, 3*ONE_HOUR, 1*ONE_HOUR),
2366: //----------------------------------------------------------
2367: new TimeZoneImpl((int)(12.75*ONE_HOUR), "Pacific/Chatham",
2368: Calendar.OCTOBER, 1, -Calendar.SUNDAY, (int)(2.75*ONE_HOUR),
2369: Calendar.MARCH, 15, -Calendar.SUNDAY, (int)(3.75*ONE_HOUR), 1*ONE_HOUR),
2370: // Rule Chatham 1990 max - Oct Sun>=1 2:45s 1:00 D
2371: // Rule Chatham 1991 max - Mar Sun>=15 2:45s 0 S
2372: // Pacific/Chatham New Zealand(NZ) 12:45 Chatham CHA%sT
2373: //----------------------------------------------------------
2374: new TimeZoneImpl(13*ONE_HOUR, "Pacific/Enderbury"),
2375: // Pacific/Enderbury Kiribati(KI) 13:00 - PHOT
2376: //----------------------------------------------------------
2377: new TimeZoneImpl(13*ONE_HOUR, "Pacific/Tongatapu"),
2378: // Pacific/Tongatapu Tonga(TO) 13:00 - TOT
2379: //----------------------------------------------------------
2380: new TimeZoneImpl(14*ONE_HOUR, "Pacific/Kiritimati"),
2381: // Pacific/Kiritimati Kiribati(KI) 14:00 - LINT
2382: ************/
2383: };
2384:
2385: private static final void appendTwoDigits(StringBuffer sb,
2386: int number) {
2387: if (number < 10) {
2388: sb.append('0');
2389: }
2390: sb.append(number);
2391: }
2392:
2393: }
|