libjava/classpath/java/util/SimpleTimeZone.java

   1 /* java.util.SimpleTimeZone
   2    Copyright (C) 1998, 1999, 2000, 2003, 2004, 2005, 2007
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GNU Classpath.
   6
   7 GNU Classpath is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Classpath is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Classpath; see the file COPYING.  If not, write to the
  19 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301 USA.
  21
  22 Linking this library statically or dynamically with other modules is
  23 making a combined work based on this library.  Thus, the terms and
  24 conditions of the GNU General Public License cover the whole
  25 combination.
  26
  27 As a special exception, the copyright holders of this library give you
  28 permission to link this library with independent modules to produce an
  29 executable, regardless of the license terms of these independent
  30 modules, and to copy and distribute the resulting executable under
  31 terms of your choice, provided that you also meet, for each linked
  32 independent module, the terms and conditions of the license of that
  33 module.  An independent module is a module which is not derived from
  34 or based on this library.  If you modify this library, you may extend
  35 this exception to your version of the library, but you are not
  36 obligated to do so.  If you do not wish to do so, delete this
  37 exception statement from your version. */
  38
  39
  40 package java.util;
  41
  42
  43 /**
  44  * This class represents a simple time zone offset and handles
  45  * daylight savings.  It can only handle one daylight savings rule, so
  46  * it can't represent historical changes.
  47  *
  48  * This object is tightly bound to the Gregorian calendar.  It assumes
  49  * a regular seven days week, and the month lengths are that of the
  50  * Gregorian Calendar.  It can only handle daylight savings for years
  51  * lying in the AD era.
  52  *
  53  * @see Calendar
  54  * @see GregorianCalendar
  55  * @author Jochen Hoenicke
  56  */
  57 public class SimpleTimeZone extends TimeZone
  58 {
  59   /**
  60    * The raw time zone offset in milliseconds to GMT, ignoring
  61    * daylight savings.
  62    * @serial
  63    */
  64   private int rawOffset;
  65
  66   /**
  67    * True, if this timezone uses daylight savings, false otherwise.
  68    * @serial
  69    */
  70   private boolean useDaylight;
  71
  72   /**
  73    * The daylight savings offset.  This is a positive offset in
  74    * milliseconds with respect to standard time.  Typically this
  75    * is one hour, but for some time zones this may be half an hour.
  76    * @serial
  77    * @since JDK1.1.4
  78    */
  79   private int dstSavings = 60 * 60 * 1000;
  80
  81   /**
  82    * The first year, in which daylight savings rules applies.
  83    * @serial
  84    */
  85   private int startYear;
  86   private static final int DOM_MODE = 1;
  87   private static final int DOW_IN_MONTH_MODE = 2;
  88   private static final int DOW_GE_DOM_MODE = 3;
  89   private static final int DOW_LE_DOM_MODE = 4;
  90
  91   /**
  92    * The mode of the start rule. This takes one of the following values:
  93    * <dl>
  94    * <dt>DOM_MODE (1)</dt>
  95    * <dd> startDay contains the day in month of the start date,
  96    * startDayOfWeek is unused. </dd>
  97    * <dt>DOW_IN_MONTH_MODE (2)</dt>
  98    * <dd> The startDay gives the day of week in month, and
  99    * startDayOfWeek the day of week.  For example startDay=2 and
 100    * startDayOfWeek=Calender.SUNDAY specifies that the change is on
 101    * the second sunday in that month.  You must make sure, that this
 102    * day always exists (ie. don't specify the 5th sunday).
 103    * </dd>
 104    * <dt>DOW_GE_DOM_MODE (3)</dt>
 105    * <dd> The start is on the first startDayOfWeek on or after
 106    * startDay.  For example startDay=13 and
 107    * startDayOfWeek=Calendar.FRIDAY specifies that the daylight
 108    * savings start on the first FRIDAY on or after the 13th of that
 109    * Month. Make sure that the change is always in the given month, or
 110    * the result is undefined.
 111    * </dd>
 112    * <dt>DOW_LE_DOM_MONTH (4)</dt>
 113    * <dd> The start is on the first startDayOfWeek on or before the
 114    * startDay.  Make sure that the change is always in the given
 115    * month, or the result is undefined.
 116    </dd>
 117    * </dl>
 118    * @serial */
 119   private int startMode;
 120
 121   /**
 122    * The month in which daylight savings start.  This is one of the
 123    * constants Calendar.JANUARY, ..., Calendar.DECEMBER.
 124    * @serial
 125    */
 126   private int startMonth;
 127
 128   /**
 129    * This variable can have different meanings.  See startMode for details
 130    * @see #startMode
 131    * @serial
 132    */
 133   private int startDay;
 134
 135   /**
 136    * This variable specifies the day of week the change takes place.  If
 137    * startMode == DOM_MODE, this is undefined.
 138    * @serial
 139    * @see #startMode
 140    */
 141   private int startDayOfWeek;
 142
 143   /**
 144    * This variable specifies the time of change to daylight savings.
 145    * This time is given in milliseconds after midnight in startTimeMode
 146    * chosen time mode.
 147    * @serial
 148    */
 149   private int startTime;
 150
 151   /**
 152    * This variable specifies the mode that startTime is specified in.  By
 153    * default it is WALL_TIME, but can also be STANDARD_TIME or UTC_TIME.  For
 154    * startTime, STANDARD_TIME and WALL_TIME are equivalent.
 155    * @serial
 156    */
 157   private int startTimeMode = WALL_TIME;
 158
 159   /**
 160    * The month in which daylight savings ends.  This is one of the
 161    * constants Calendar.JANUARY, ..., Calendar.DECEMBER.
 162    * @serial
 163    */
 164   private int endMonth;
 165
 166   /**
 167    * This variable gives the mode for the end of daylight savings rule.
 168    * It can take the same values as startMode.
 169    * @serial
 170    * @see #startMode
 171    */
 172   private int endMode;
 173
 174   /**
 175    * This variable can have different meanings.  See startMode for details
 176    * @serial
 177    * @see #startMode
 178    */
 179   private int endDay;
 180
 181   /**
 182    * This variable specifies the day of week the change takes place.  If
 183    * endMode == DOM_MODE, this is undefined.
 184    * @serial
 185    * @see #startMode
 186    */
 187   private int endDayOfWeek;
 188
 189   /**
 190    * This variable specifies the time of change back to standard time.
 191    * This time is given in milliseconds after midnight in endTimeMode
 192    * chosen time mode.
 193    * @serial
 194    */
 195   private int endTime;
 196
 197   /**
 198    * This variable specifies the mode that endTime is specified in.  By
 199    * default it is WALL_TIME, but can also be STANDARD_TIME or UTC_TIME.
 200    * @serial
 201    */
 202   private int endTimeMode = WALL_TIME;
 203
 204   /**
 205    * This variable points to a deprecated array from JDK 1.1.  It is
 206    * ignored in JDK 1.2 but streamed out for compatibility with JDK 1.1.
 207    * The array contains the lengths of the months in the year and is
 208    * assigned from a private static final field to avoid allocating
 209    * the array for every instance of the object.
 210    * Note that static final fields are not serialized.
 211    * @serial
 212    */
 213   private byte[] monthLength = monthArr;
 214   private static final byte[] monthArr =
 215                                          {
 216                                            31, 28, 31, 30, 31, 30, 31, 31, 30,
 217                                            31, 30, 31
 218                                          };
 219
 220   /**
 221    * The version of the serialized data on the stream.
 222    * <dl>
 223    * <dt>0 or not present on stream</dt>
 224    * <dd> JDK 1.1.3 or earlier, only provides this fields:
 225    * rawOffset, startDay, startDayOfWeek, startMonth, startTime,
 226    * startYear, endDay, endDayOfWeek, endMonth, endTime
 227    * </dd>
 228    * <dd> JDK 1.1.4 or later. This includes three new fields, namely
 229    * startMode, endMode and dstSavings.  And there is a optional section
 230    * as described in writeObject.
 231    * </dd>
 232    * </dl>
 233    *
 234    * XXX - JDK 1.2 Beta 4 docu states 1.1.4, but my 1.1.5 has the old
 235    * version.
 236    *
 237    * When streaming out this class it is always written in the latest
 238    * version.
 239    * @serial
 240    * @since JDK1.1.4
 241    */
 242   private int serialVersionOnStream = 2;
 243   private static final long serialVersionUID = -403250971215465050L;
 244
 245   /**
 246    * Constant to indicate that start and end times are specified in standard
 247    * time, without adjusting for daylight savings.
 248    */
 249   public static final int STANDARD_TIME = 1;
 250
 251   /**
 252    * Constant to indicate that start and end times are specified in wall
 253    * time, adjusting for daylight savings.  This is the default.
 254    */
 255   public static final int WALL_TIME = 0;
 256
 257   /**
 258    * Constant to indicate that start and end times are specified in UTC.
 259    */
 260   public static final int UTC_TIME = 2;
 261
 262   /**
 263    * Create a <code>SimpleTimeZone</code> with the given time offset
 264    * from GMT and without daylight savings.
 265    * @param rawOffset the time offset from GMT in milliseconds.
 266    * @param id The identifier of this time zone.
 267    */
 268   public SimpleTimeZone(int rawOffset, String id)
 269   {
 270     this.rawOffset = rawOffset;
 271     setID(id);
 272     useDaylight = false;
 273     startYear = 0;
 274   }
 275
 276   /**
 277    * Create a <code>SimpleTimeZone</code> with the given time offset
 278    * from GMT and with daylight savings.  The start/end parameters
 279    * can have different meaning (replace WEEKDAY with a real day of
 280    * week). Only the first two meanings were supported by earlier
 281    * versions of jdk.
 282    *
 283    * <dl>
 284    * <dt><code>day &gt; 0, dayOfWeek = Calendar.WEEKDAY</code></dt>
 285    * <dd>The start/end of daylight savings is on the <code>day</code>-th
 286    * <code>WEEKDAY</code> in the given month. </dd>
 287    * <dt><code>day &lt; 0, dayOfWeek = Calendar.WEEKDAY</code></dt>
 288    * <dd>The start/end of daylight savings is on the <code>-day</code>-th
 289    * <code>WEEKDAY</code> counted from the <i>end</i> of the month. </dd>
 290    * <dt><code>day &gt; 0, dayOfWeek = 0</code></dt>
 291    * <dd>The start/end of daylight is on the <code>day</code>-th day of
 292    * the month. </dd>
 293    * <dt><code>day &gt; 0, dayOfWeek = -Calendar.WEEKDAY</code></dt>
 294    * <dd>The start/end of daylight is on the first WEEKDAY on or after
 295    * the <code>day</code>-th day of the month.  You must make sure that
 296    * this day lies in the same month. </dd>
 297    * <dt><code>day &lt; 0, dayOfWeek = -Calendar.WEEKDAY</code></dt>
 298    * <dd>The start/end of daylight is on the first WEEKDAY on or
 299    * <i>before</i> the <code>-day</code>-th day of the month.  You
 300    * must make sure that this day lies in the same month. </dd>
 301    * </dl>
 302    *
 303    * If you give a non existing month, a day that is zero, or too big,
 304    * or a dayOfWeek that is too big,  the result is undefined.
 305    *
 306    * The start rule must have a different month than the end rule.
 307    * This restriction shouldn't hurt for all possible time zones.
 308    *
 309    * @param rawOffset The time offset from GMT in milliseconds.
 310    * @param id  The identifier of this time zone.
 311    * @param startMonth The start month of daylight savings; use the
 312    * constants in Calendar.
 313    * @param startDayOfWeekInMonth A day in month or a day of week number, as
 314    * described above.
 315    * @param startDayOfWeek The start rule day of week; see above.
 316    * @param startTime A time in millis in standard time.
 317    * @param endMonth The end month of daylight savings; use the
 318    * constants in Calendar.
 319    * @param endDayOfWeekInMonth A day in month or a day of week number, as
 320    * described above.
 321    * @param endDayOfWeek The end rule day of week; see above.
 322    * @param endTime A time in millis in standard time.
 323    * @throws IllegalArgumentException if parameters are invalid or out of
 324    * range.
 325    */
 326   public SimpleTimeZone(int rawOffset, String id, int startMonth,
 327                         int startDayOfWeekInMonth, int startDayOfWeek,
 328                         int startTime, int endMonth, int endDayOfWeekInMonth,
 329                         int endDayOfWeek, int endTime)
 330   {
 331     this.rawOffset = rawOffset;
 332     setID(id);
 333     useDaylight = true;
 334
 335     setStartRule(startMonth, startDayOfWeekInMonth, startDayOfWeek, startTime);
 336     setEndRule(endMonth, endDayOfWeekInMonth, endDayOfWeek, endTime);
 337     if (startMonth == endMonth)
 338       throw new IllegalArgumentException("startMonth and endMonth must be different");
 339     this.startYear = 0;
 340   }
 341
 342   /**
 343    * This constructs a new SimpleTimeZone that supports a daylight savings
 344    * rule.  The parameter are the same as for the constructor above, except
 345    * there is the additional dstSavaings parameter.
 346    *
 347    * @param dstSavings the amount of savings for daylight savings
 348    * time in milliseconds.  This must be positive.
 349    * @since 1.2
 350    */
 351   public SimpleTimeZone(int rawOffset, String id, int startMonth,
 352                         int startDayOfWeekInMonth, int startDayOfWeek,
 353                         int startTime, int endMonth, int endDayOfWeekInMonth,
 354                         int endDayOfWeek, int endTime, int dstSavings)
 355   {
 356     this(rawOffset, id, startMonth, startDayOfWeekInMonth, startDayOfWeek,
 357          startTime, endMonth, endDayOfWeekInMonth, endDayOfWeek, endTime);
 358
 359     this.dstSavings = dstSavings;
 360   }
 361
 362   /**
 363    * This constructs a new SimpleTimeZone that supports a daylight savings
 364    * rule.  The parameter are the same as for the constructor above, except
 365    * there are the additional startTimeMode, endTimeMode, and dstSavings
 366    * parameters.
 367    *
 368    * @param startTimeMode the mode that start times are specified in.  One of
 369    * WALL_TIME, STANDARD_TIME, or UTC_TIME.
 370    * @param endTimeMode the mode that end times are specified in.  One of
 371    * WALL_TIME, STANDARD_TIME, or UTC_TIME.
 372    * @param dstSavings the amount of savings for daylight savings
 373    * time in milliseconds.  This must be positive.
 374    * @throws IllegalArgumentException if parameters are invalid or out of
 375    * range.
 376    * @since 1.4
 377    */
 378   public SimpleTimeZone(int rawOffset, String id, int startMonth,
 379                         int startDayOfWeekInMonth, int startDayOfWeek,
 380                         int startTime, int startTimeMode, int endMonth,
 381                         int endDayOfWeekInMonth, int endDayOfWeek,
 382                         int endTime, int endTimeMode, int dstSavings)
 383   {
 384     this(rawOffset, id, startMonth, startDayOfWeekInMonth, startDayOfWeek,
 385          startTime, endMonth, endDayOfWeekInMonth, endDayOfWeek, endTime);
 386
 387     if (startTimeMode < WALL_TIME || startTimeMode > UTC_TIME)
 388       throw new IllegalArgumentException("startTimeMode must be one of WALL_TIME, STANDARD_TIME, or UTC_TIME");
 389     if (endTimeMode < WALL_TIME || endTimeMode > UTC_TIME)
 390       throw new IllegalArgumentException("endTimeMode must be one of WALL_TIME, STANDARD_TIME, or UTC_TIME");
 391
 392     this.dstSavings = dstSavings;
 393     this.startTimeMode = startTimeMode;
 394     this.endTimeMode = endTimeMode;
 395   }
 396
 397   /**
 398    * Sets the first year, where daylight savings applies.  The daylight
 399    * savings rule never apply for years in the BC era.  Note that this
 400    * is gregorian calendar specific.
 401    * @param year the start year.
 402    */
 403   public void setStartYear(int year)
 404   {
 405     startYear = year;
 406     useDaylight = true;
 407   }
 408
 409   /**
 410    * Checks if the month, day, dayOfWeek arguments are in range and
 411    * returns the mode of the rule.
 412    * @param month the month parameter as in the constructor
 413    * @param day the day parameter as in the constructor
 414    * @param dayOfWeek the day of week parameter as in the constructor
 415    * @return the mode of this rule see startMode.
 416    * @exception IllegalArgumentException if parameters are out of range.
 417    * @see #SimpleTimeZone(int, String, int, int, int, int, int, int, int, int)
 418    * @see #startMode
 419    */
 420   private int checkRule(int month, int day, int dayOfWeek)
 421   {
 422     if (month < 0 || month > 11)
 423       throw new IllegalArgumentException("month out of range");
 424
 425     int daysInMonth = getDaysInMonth(month, 1);
 426     if (dayOfWeek == 0)
 427       {
 428         if (day <= 0 || day > daysInMonth)
 429           throw new IllegalArgumentException("day out of range");
 430         return DOM_MODE;
 431       }
 432     else if (dayOfWeek > 0)
 433       {
 434         if (Math.abs(day) > (daysInMonth + 6) / 7)
 435           throw new IllegalArgumentException("dayOfWeekInMonth out of range");
 436         if (dayOfWeek > Calendar.SATURDAY)
 437           throw new IllegalArgumentException("dayOfWeek out of range");
 438         return DOW_IN_MONTH_MODE;
 439       }
 440     else
 441       {
 442         if (day == 0 || Math.abs(day) > daysInMonth)
 443           throw new IllegalArgumentException("day out of range");
 444         if (dayOfWeek < -Calendar.SATURDAY)
 445           throw new IllegalArgumentException("dayOfWeek out of range");
 446         if (day < 0)
 447           return DOW_LE_DOM_MODE;
 448         else
 449           return DOW_GE_DOM_MODE;
 450       }
 451   }
 452
 453   /**
 454    * Sets the daylight savings start rule.  You must also set the
 455    * end rule with <code>setEndRule</code> or the result of
 456    * getOffset is undefined.  For the parameters see the ten-argument
 457    * constructor above.
 458    *
 459    * @param month The month where daylight savings start, zero
 460    * based.  You should use the constants in Calendar.
 461    * @param day A day of month or day of week in month.
 462    * @param dayOfWeek The day of week where daylight savings start.
 463    * @param time The time in milliseconds standard time where daylight
 464    * savings start.
 465    * @exception IllegalArgumentException if parameters are out of range.
 466    * @see SimpleTimeZone
 467    */
 468   public void setStartRule(int month, int day, int dayOfWeek, int time)
 469   {
 470     this.startMode = checkRule(month, day, dayOfWeek);
 471     this.startMonth = month;
 472     this.startDay = day;
 473     this.startDayOfWeek = Math.abs(dayOfWeek);
 474     this.startTime = time;
 475     this.startTimeMode = WALL_TIME;
 476   }
 477
 478   /**
 479    * Sets the daylight savings start rule.  You must also set the
 480    * end rule with <code>setEndRule</code> or the result of
 481    * getOffset is undefined.  For the parameters see the ten-argument
 482    * constructor above.
 483    *
 484    * Note that this API isn't incredibly well specified.  It appears that the
 485    * after flag must override the parameters, since normally, the day and
 486    * dayofweek can select this.  I.e., if day < 0 and dayOfWeek < 0, on or
 487    * before mode is chosen.  But if after == true, this implementation
 488    * overrides the signs of the other arguments.  And if dayOfWeek == 0, it
 489    * falls back to the behavior in the other APIs.  I guess this should be
 490    * checked against Sun's implementation.
 491    *
 492    * @param month The month where daylight savings start, zero
 493    * based.  You should use the constants in Calendar.
 494    * @param day A day of month or day of week in month.
 495    * @param dayOfWeek The day of week where daylight savings start.
 496    * @param time The time in milliseconds standard time where daylight
 497    * savings start.
 498    * @param after If true, day and dayOfWeek specify first day of week on or
 499    * after day, else first day of week on or before.
 500    * @since 1.2
 501    * @see SimpleTimeZone
 502    */
 503   public void setStartRule(int month, int day, int dayOfWeek, int time,
 504                            boolean after)
 505   {
 506     if (after)
 507       setStartRule(month, day, -dayOfWeek, time);
 508     else
 509       setStartRule(month, -day, -dayOfWeek, time);
 510   }
 511
 512   /**
 513    * Sets the daylight savings start rule.  You must also set the
 514    * end rule with <code>setEndRule</code> or the result of
 515    * getOffset is undefined.  For the parameters see the ten-argument
 516    * constructor above.
 517    *
 518    * @param month The month where daylight savings start, zero
 519    * based.  You should use the constants in Calendar.
 520    * @param day A day of month or day of week in month.
 521    * @param time The time in milliseconds standard time where daylight
 522    * savings start.
 523    * @see SimpleTimeZone
 524    * @since 1.2
 525    */
 526   public void setStartRule(int month, int day, int time)
 527   {
 528     setStartRule(month, day, 0, time);
 529   }
 530
 531   /**
 532    * Sets the daylight savings end rule.  You must also set the
 533    * start rule with <code>setStartRule</code> or the result of
 534    * getOffset is undefined. For the parameters see the ten-argument
 535    * constructor above.
 536    *
 537    * @param month The end month of daylight savings.
 538    * @param day A day in month, or a day of week in month.
 539    * @param dayOfWeek A day of week, when daylight savings ends.
 540    * @param time A time in millis in standard time.
 541    * @see #setStartRule(int, int, int, int)
 542    */
 543   public void setEndRule(int month, int day, int dayOfWeek, int time)
 544   {
 545     this.endMode = checkRule(month, day, dayOfWeek);
 546     this.endMonth = month;
 547     this.endDay = day;
 548     this.endDayOfWeek = Math.abs(dayOfWeek);
 549     this.endTime = time;
 550     this.endTimeMode = WALL_TIME;
 551     useDaylight = true;
 552   }
 553
 554   /**
 555    * Sets the daylight savings end rule.  You must also set the
 556    * start rule with <code>setStartRule</code> or the result of
 557    * getOffset is undefined. For the parameters see the ten-argument
 558    * constructor above.
 559    *
 560    * Note that this API isn't incredibly well specified.  It appears that the
 561    * after flag must override the parameters, since normally, the day and
 562    * dayofweek can select this.  I.e., if day < 0 and dayOfWeek < 0, on or
 563    * before mode is chosen.  But if after == true, this implementation
 564    * overrides the signs of the other arguments.  And if dayOfWeek == 0, it
 565    * falls back to the behavior in the other APIs.  I guess this should be
 566    * checked against Sun's implementation.
 567    *
 568    * @param month The end month of daylight savings.
 569    * @param day A day in month, or a day of week in month.
 570    * @param dayOfWeek A day of week, when daylight savings ends.
 571    * @param time A time in millis in standard time.
 572    * @param after If true, day and dayOfWeek specify first day of week on or
 573    * after day, else first day of week on or before.
 574    * @since 1.2
 575    * @see #setStartRule(int, int, int, int, boolean)
 576    */
 577   public void setEndRule(int month, int day, int dayOfWeek, int time,
 578                          boolean after)
 579   {
 580     if (after)
 581       setEndRule(month, day, -dayOfWeek, time);
 582     else
 583       setEndRule(month, -day, -dayOfWeek, time);
 584   }
 585
 586   /**
 587    * Sets the daylight savings end rule.  You must also set the
 588    * start rule with <code>setStartRule</code> or the result of
 589    * getOffset is undefined. For the parameters see the ten-argument
 590    * constructor above.
 591    *
 592    * @param month The end month of daylight savings.
 593    * @param day A day in month, or a day of week in month.
 594    * @param time A time in millis in standard time.
 595    * @see #setStartRule(int, int, int)
 596    */
 597   public void setEndRule(int month, int day, int time)
 598   {
 599     setEndRule(month, day, 0, time);
 600   }
 601
 602   /**
 603    * Gets the time zone offset, for current date, modified in case of
 604    * daylight savings.  This is the offset to add to UTC to get the local
 605    * time.
 606    *
 607    * In the standard JDK the results given by this method may result in
 608    * inaccurate results at the end of February or the beginning of March.
 609    * To avoid this, you should use Calendar instead:
 610    * <code>offset = cal.get(Calendar.ZONE_OFFSET)
 611    * + cal.get(Calendar.DST_OFFSET);</code>
 612    *
 613    * This version doesn't suffer this inaccuracy.
 614    *
 615    * The arguments don't follow the approach for setting start and end rules.
 616    * The day must be a positive number and dayOfWeek must be a positive value
 617    * from Calendar.  dayOfWeek is redundant, but must match the other values
 618    * or an inaccurate result may be returned.
 619    *
 620    * @param era the era of the given date
 621    * @param year the year of the given date
 622    * @param month the month of the given date, 0 for January.
 623    * @param day the day of month
 624    * @param dayOfWeek the day of week; this must match the other fields.
 625    * @param millis the millis in the day (in local standard time)
 626    * @return the time zone offset in milliseconds.
 627    * @throws IllegalArgumentException if arguments are incorrect.
 628    */
 629   public int getOffset(int era, int year, int month, int day, int dayOfWeek,
 630                        int millis)
 631   {
 632     int daysInMonth = getDaysInMonth(month, year);
 633     if (day < 1 || day > daysInMonth)
 634       throw new IllegalArgumentException("day out of range");
 635     if (dayOfWeek < Calendar.SUNDAY || dayOfWeek > Calendar.SATURDAY)
 636       throw new IllegalArgumentException("dayOfWeek out of range");
 637     if (month < Calendar.JANUARY || month > Calendar.DECEMBER)
 638       throw new IllegalArgumentException("month out of range:" + month);
 639
 640     // This method is called by Calendar, so we mustn't use that class.
 641     int daylightSavings = 0;
 642     if (useDaylight && era == GregorianCalendar.AD && year >= startYear)
 643       {
 644         int orig_year = year;
 645         int time = startTime + (startTimeMode == UTC_TIME ? rawOffset : 0);
 646         // This does only work for Gregorian calendars :-(
 647         // This is mainly because setStartYear doesn't take an era.
 648         boolean afterStart = ! isBefore(year, month, day, dayOfWeek, millis,
 649                                         startMode, startMonth, startDay,
 650                                         startDayOfWeek, time);
 651         millis += dstSavings;
 652         if (millis >= 24 * 60 * 60 * 1000)
 653           {
 654             millis -= 24 * 60 * 60 * 1000;
 655             dayOfWeek = (dayOfWeek % 7) + 1;
 656             if (++day > daysInMonth)
 657               {
 658                 day = 1;
 659                 if (month++ == Calendar.DECEMBER)
 660                   {
 661                     month = Calendar.JANUARY;
 662                     year++;
 663                   }
 664               }
 665           }
 666         time = endTime + (endTimeMode == UTC_TIME ? rawOffset : 0);
 667         if (endTimeMode != WALL_TIME)
 668           time += dstSavings;
 669         boolean beforeEnd = isBefore(year, month, day, dayOfWeek, millis,
 670                                      endMode, endMonth, endDay, endDayOfWeek,
 671                                      time);
 672
 673         if (year != orig_year)
 674           afterStart = false;
 675         if (startMonth < endMonth)
 676           // use daylight savings, if the date is after the start of
 677           // savings, and before the end of savings.
 678           daylightSavings = afterStart && beforeEnd ? dstSavings : 0;
 679         else
 680           // use daylight savings, if the date is before the end of
 681           // savings, or after the start of savings.
 682           daylightSavings = beforeEnd || afterStart ? dstSavings : 0;
 683       }
 684     return rawOffset + daylightSavings;
 685   }
 686
 687   /**
 688    * Returns the time zone offset to GMT in milliseconds, ignoring
 689    * day light savings.
 690    * @return the time zone offset.
 691    */
 692   public int getRawOffset()
 693   {
 694     return rawOffset;
 695   }
 696
 697   /**
 698    * Sets the standard time zone offset to GMT.
 699    * @param rawOffset The time offset from GMT in milliseconds.
 700    */
 701   public void setRawOffset(int rawOffset)
 702   {
 703     this.rawOffset = rawOffset;
 704   }
 705
 706   /**
 707    * Gets the daylight savings offset.  This is a positive offset in
 708    * milliseconds with respect to standard time.  Typically this
 709    * is one hour, but for some time zones this may be half an our.
 710    * @return the daylight savings offset in milliseconds.
 711    *
 712    * @since 1.2
 713    */
 714   public int getDSTSavings()
 715   {
 716     return dstSavings;
 717   }
 718
 719   /**
 720    * Sets the daylight savings offset.  This is a positive offset in
 721    * milliseconds with respect to standard time.
 722    *
 723    * @param dstSavings the daylight savings offset in milliseconds.
 724    *
 725    * @since 1.2
 726    */
 727   public void setDSTSavings(int dstSavings)
 728   {
 729     if (dstSavings <= 0)
 730       throw new IllegalArgumentException("illegal value for dstSavings");
 731
 732     this.dstSavings = dstSavings;
 733   }
 734
 735   /**
 736    * Returns if this time zone uses daylight savings time.
 737    * @return true, if we use daylight savings time, false otherwise.
 738    */
 739   public boolean useDaylightTime()
 740   {
 741     return useDaylight;
 742   }
 743
 744   /**
 745    * Returns the number of days in the given month.
 746    * Uses gregorian rules prior to 1582 (The default and earliest cutover)
 747    * @param month The month, zero based; use one of the Calendar constants.
 748    * @param year  The year.
 749    */
 750   private int getDaysInMonth(int month, int year)
 751   {
 752     if (month == Calendar.FEBRUARY)
 753       {
 754         if ((year & 3) != 0)
 755           return 28;
 756
 757         // Assume default Gregorian cutover,
 758         // all years prior to this must be Julian
 759         if (year < 1582)
 760           return 29;
 761
 762         // Gregorian rules
 763         return ((year % 100) != 0 || (year % 400) == 0) ? 29 : 28;
 764       }
 765     else
 766       return monthArr[month];
 767   }
 768
 769   /**
 770    * Checks if the date given in calXXXX, is before the change between
 771    * dst and standard time.
 772    * @param calYear the year of the date to check (for leap day checking).
 773    * @param calMonth the month of the date to check.
 774    * @param calDayOfMonth the day of month of the date to check.
 775    * @param calDayOfWeek the day of week of the date to check.
 776    * @param calMillis the millis of day of the date to check (standard time).
 777    * @param mode  the change mode; same semantic as startMode.
 778    * @param month the change month; same semantic as startMonth.
 779    * @param day   the change day; same semantic as startDay.
 780    * @param dayOfWeek the change day of week;
 781    * @param millis the change time in millis since midnight standard time.
 782    * same semantic as startDayOfWeek.
 783    * @return true, if cal is before the change, false if cal is on
 784    * or after the change.
 785    */
 786   private boolean isBefore(int calYear, int calMonth, int calDayOfMonth,
 787                            int calDayOfWeek, int calMillis, int mode,
 788                            int month, int day, int dayOfWeek, int millis)
 789   {
 790     // This method is called by Calendar, so we mustn't use that class.
 791     // We have to do all calculations by hand.
 792     // check the months:
 793     // XXX - this is not correct:
 794     // for the DOW_GE_DOM and DOW_LE_DOM modes the change date may
 795     // be in a different month.
 796     if (calMonth != month)
 797       return calMonth < month;
 798
 799     // check the day:
 800     switch (mode)
 801       {
 802       case DOM_MODE:
 803         if (calDayOfMonth != day)
 804           return calDayOfMonth < day;
 805         break;
 806       case DOW_IN_MONTH_MODE:
 807         {
 808           // This computes the day of month of the day of type
 809           // "dayOfWeek" that lies in the same (sunday based) week as cal.
 810           calDayOfMonth += (dayOfWeek - calDayOfWeek);
 811
 812           // Now we convert it to 7 based number (to get a one based offset
 813           // after dividing by 7).  If we count from the end of the
 814           // month, we get want a -7 based number counting the days from
 815           // the end:
 816           if (day < 0)
 817             calDayOfMonth -= getDaysInMonth(calMonth, calYear) + 7;
 818           else
 819             calDayOfMonth += 6;
 820
 821           //  day > 0                    day < 0
 822           //  S  M  T  W  T  F  S        S  M  T  W  T  F  S
 823           //     7  8  9 10 11 12         -36-35-34-33-32-31
 824           // 13 14 15 16 17 18 19      -30-29-28-27-26-25-24
 825           // 20 21 22 23 24 25 26      -23-22-21-20-19-18-17
 826           // 27 28 29 30 31 32 33      -16-15-14-13-12-11-10
 827           // 34 35 36                   -9 -8 -7
 828           // Now we calculate the day of week in month:
 829           int week = calDayOfMonth / 7;
 830
 831           //  day > 0                    day < 0
 832           //  S  M  T  W  T  F  S        S  M  T  W  T  F  S
 833           //     1  1  1  1  1  1          -5 -5 -4 -4 -4 -4
 834           //  1  2  2  2  2  2  2       -4 -4 -4 -3 -3 -3 -3
 835           //  2  3  3  3  3  3  3       -3 -3 -3 -2 -2 -2 -2
 836           //  3  4  4  4  4  4  4       -2 -2 -2 -1 -1 -1 -1
 837           //  4  5  5                   -1 -1 -1
 838           if (week != day)
 839             return week < day;
 840
 841           if (calDayOfWeek != dayOfWeek)
 842             return calDayOfWeek < dayOfWeek;
 843
 844           // daylight savings starts/ends  on the given day.
 845           break;
 846         }
 847       case DOW_LE_DOM_MODE:
 848         // The greatest sunday before or equal December, 12
 849         // is the same as smallest sunday after or equal December, 6.
 850         day = Math.abs(day) - 6;
 851       case DOW_GE_DOM_MODE:
 852         // Calculate the day of month of the day of type
 853         // "dayOfWeek" that lies before (or on) the given date.
 854         calDayOfMonth -= (calDayOfWeek < dayOfWeek ? 7 : 0) + calDayOfWeek
 855         - dayOfWeek;
 856         if (calDayOfMonth < day)
 857           return true;
 858         if (calDayOfWeek != dayOfWeek || calDayOfMonth >= day + 7)
 859           return false;
 860
 861         // now we have the same day
 862         break;
 863       }
 864
 865     // the millis decides:
 866     return (calMillis < millis);
 867   }
 868
 869   /**
 870    * Determines if the given date is in daylight savings time.
 871    * @return true, if it is in daylight savings time, false otherwise.
 872    */
 873   public boolean inDaylightTime(Date date)
 874   {
 875     Calendar cal = Calendar.getInstance(this);
 876     cal.setTime(date);
 877     return (cal.get(Calendar.DST_OFFSET) != 0);
 878   }
 879
 880   /**
 881    * Generates the hashCode for the SimpleDateFormat object.  It is
 882    * the rawOffset, possibly, if useDaylightSavings is true, xored
 883    * with startYear, startMonth, startDayOfWeekInMonth, ..., endTime.
 884    */
 885   public synchronized int hashCode()
 886   {
 887     return rawOffset
 888            ^ (useDaylight
 889               ? startMonth ^ startDay ^ startDayOfWeek ^ startTime ^ endMonth
 890               ^ endDay ^ endDayOfWeek ^ endTime : 0);
 891   }
 892
 893   public synchronized boolean equals(Object o)
 894   {
 895     if (this == o)
 896       return true;
 897     if (! (o instanceof SimpleTimeZone))
 898       return false;
 899     SimpleTimeZone zone = (SimpleTimeZone) o;
 900     if (zone.hashCode() != hashCode() || ! getID().equals(zone.getID())
 901         || rawOffset != zone.rawOffset || useDaylight != zone.useDaylight)
 902       return false;
 903     if (! useDaylight)
 904       return true;
 905     return (startYear == zone.startYear && startMonth == zone.startMonth
 906            && startDay == zone.startDay
 907            && startDayOfWeek == zone.startDayOfWeek
 908            && startTime == zone.startTime
 909            && startTimeMode == zone.startTimeMode && endMonth == zone.endMonth
 910            && endDay == zone.endDay && endDayOfWeek == zone.endDayOfWeek
 911            && endTime == zone.endTime && endTimeMode == zone.endTimeMode);
 912   }
 913
 914   /**
 915    * Test if the other time zone uses the same rule and only
 916    * possibly differs in ID.  This implementation for this particular
 917    * class will return true if the other object is a SimpleTimeZone,
 918    * the raw offsets and useDaylight are identical and if useDaylight
 919    * is true, also the start and end datas are identical.
 920    * @return true if this zone uses the same rule.
 921    */
 922   public boolean hasSameRules(TimeZone other)
 923   {
 924     if (this == other)
 925       return true;
 926     if (! (other instanceof SimpleTimeZone))
 927       return false;
 928     SimpleTimeZone zone = (SimpleTimeZone) other;
 929     if (zone.hashCode() != hashCode() || rawOffset != zone.rawOffset
 930         || useDaylight != zone.useDaylight)
 931       return false;
 932     if (! useDaylight)
 933       return true;
 934     return (startYear == zone.startYear && startMonth == zone.startMonth
 935            && startDay == zone.startDay
 936            && startDayOfWeek == zone.startDayOfWeek
 937            && startTime == zone.startTime
 938            && startTimeMode == zone.startTimeMode && endMonth == zone.endMonth
 939            && endDay == zone.endDay && endDayOfWeek == zone.endDayOfWeek
 940            && endTime == zone.endTime && endTimeMode == zone.endTimeMode);
 941   }
 942
 943   /**
 944    * Returns a string representation of this SimpleTimeZone object.
 945    * @return a string representation of this SimpleTimeZone object.
 946    */
 947   public String toString()
 948   {
 949     // the test for useDaylight is an incompatibility to jdk1.2, but
 950     // I think this shouldn't hurt.
 951     return getClass().getName() + "[" + "id=" + getID() + ",offset="
 952            + rawOffset + ",dstSavings=" + dstSavings + ",useDaylight="
 953            + useDaylight
 954            + (useDaylight
 955               ? ",startYear=" + startYear + ",startMode=" + startMode
 956               + ",startMonth=" + startMonth + ",startDay=" + startDay
 957               + ",startDayOfWeek=" + startDayOfWeek + ",startTime="
 958               + startTime + ",startTimeMode=" + startTimeMode + ",endMode="
 959               + endMode + ",endMonth=" + endMonth + ",endDay=" + endDay
 960               + ",endDayOfWeek=" + endDayOfWeek + ",endTime=" + endTime
 961               + ",endTimeMode=" + endTimeMode : "") + "]";
 962   }
 963
 964   /**
 965    * Reads a serialized simple time zone from stream.
 966    * @see #writeObject
 967    */
 968   private void readObject(java.io.ObjectInputStream input)
 969     throws java.io.IOException, ClassNotFoundException
 970   {
 971     input.defaultReadObject();
 972     if (serialVersionOnStream == 0)
 973       {
 974         // initialize the new fields to default values.
 975         dstSavings = 60 * 60 * 1000;
 976         endMode = DOW_IN_MONTH_MODE;
 977         startMode = DOW_IN_MONTH_MODE;
 978         startTimeMode = WALL_TIME;
 979         endTimeMode = WALL_TIME;
 980         serialVersionOnStream = 2;
 981       }
 982     else
 983       {
 984         int length = input.readInt();
 985         byte[] byteArray = new byte[length];
 986         input.read(byteArray, 0, length);
 987         if (length >= 4)
 988           {
 989             // Lets hope that Sun does extensions to the serialized
 990             // form in a sane manner.
 991             startDay = byteArray[0];
 992             startDayOfWeek = byteArray[1];
 993             endDay = byteArray[2];
 994             endDayOfWeek = byteArray[3];
 995           }
 996       }
 997   }
 998
 999   /**
1000    * Serializes this object to a stream.  @serialdata The object is
1001    * first written in the old JDK 1.1 format, so that it can be read
1002    * by by the old classes.  This means, that the
1003    * <code>start/endDay(OfWeek)</code>-Fields are written in the
1004    * DOW_IN_MONTH_MODE rule, since this was the only supported rule
1005    * in 1.1.
1006    *
1007    * In the optional section, we write first the length of an byte
1008    * array as int and afterwards the byte array itself.  The byte
1009    * array contains in this release four elements, namely the real
1010    * startDay, startDayOfWeek endDay, endDayOfWeek in that Order.
1011    * These fields are needed, because for compatibility reasons only
1012    * approximative values are written to the required section, as
1013    * described above.
1014    */
1015   private void writeObject(java.io.ObjectOutputStream output)
1016     throws java.io.IOException
1017   {
1018     byte[] byteArray = new byte[]
1019                        {
1020                          (byte) startDay, (byte) startDayOfWeek, (byte) endDay,
1021                          (byte) endDayOfWeek
1022                        };
1023
1024     /* calculate the approximation for JDK 1.1 */
1025     switch (startMode)
1026       {
1027       case DOM_MODE:
1028         startDayOfWeek = Calendar.SUNDAY; // random day of week
1029
1030       // fall through
1031       case DOW_GE_DOM_MODE:
1032       case DOW_LE_DOM_MODE:
1033         startDay = (startDay + 6) / 7;
1034       }
1035     switch (endMode)
1036       {
1037       case DOM_MODE:
1038         endDayOfWeek = Calendar.SUNDAY;
1039
1040       // fall through
1041       case DOW_GE_DOM_MODE:
1042       case DOW_LE_DOM_MODE:
1043         endDay = (endDay + 6) / 7;
1044       }
1045
1046     // the required part:
1047     output.defaultWriteObject();
1048     // the optional part:
1049     output.writeInt(byteArray.length);
1050     output.write(byteArray, 0, byteArray.length);
1051   }
1052 }