001/* java.util.SimpleTimeZone
002   Copyright (C) 1998, 1999, 2000, 2003, 2004, 2005, 2007
003   Free Software Foundation, Inc.
004
005This file is part of GNU Classpath.
006
007GNU Classpath is free software; you can redistribute it and/or modify
008it under the terms of the GNU General Public License as published by
009the Free Software Foundation; either version 2, or (at your option)
010any later version.
011
012GNU Classpath is distributed in the hope that it will be useful, but
013WITHOUT ANY WARRANTY; without even the implied warranty of
014MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
015General Public License for more details.
016
017You should have received a copy of the GNU General Public License
018along with GNU Classpath; see the file COPYING.  If not, write to the
019Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02002110-1301 USA.
021
022Linking this library statically or dynamically with other modules is
023making a combined work based on this library.  Thus, the terms and
024conditions of the GNU General Public License cover the whole
025combination.
026
027As a special exception, the copyright holders of this library give you
028permission to link this library with independent modules to produce an
029executable, regardless of the license terms of these independent
030modules, and to copy and distribute the resulting executable under
031terms of your choice, provided that you also meet, for each linked
032independent module, the terms and conditions of the license of that
033module.  An independent module is a module which is not derived from
034or based on this library.  If you modify this library, you may extend
035this exception to your version of the library, but you are not
036obligated to do so.  If you do not wish to do so, delete this
037exception statement from your version. */
038
039
040package java.util;
041
042
043/**
044 * This class represents a simple time zone offset and handles
045 * daylight savings.  It can only handle one daylight savings rule, so
046 * it can't represent historical changes.
047 *
048 * This object is tightly bound to the Gregorian calendar.  It assumes
049 * a regular seven days week, and the month lengths are that of the
050 * Gregorian Calendar.  It can only handle daylight savings for years
051 * lying in the AD era.
052 *
053 * @see Calendar
054 * @see GregorianCalendar
055 * @author Jochen Hoenicke
056 */
057public class SimpleTimeZone extends TimeZone
058{
059  /**
060   * The raw time zone offset in milliseconds to GMT, ignoring
061   * daylight savings.
062   * @serial
063   */
064  private int rawOffset;
065
066  /**
067   * True, if this timezone uses daylight savings, false otherwise.
068   * @serial
069   */
070  private boolean useDaylight;
071
072  /**
073   * The daylight savings offset.  This is a positive offset in
074   * milliseconds with respect to standard time.  Typically this
075   * is one hour, but for some time zones this may be half an hour.
076   * @serial
077   * @since JDK1.1.4
078   */
079  private int dstSavings = 60 * 60 * 1000;
080
081  /**
082   * The first year, in which daylight savings rules applies.
083   * @serial
084   */
085  private int startYear;
086  private static final int DOM_MODE = 1;
087  private static final int DOW_IN_MONTH_MODE = 2;
088  private static final int DOW_GE_DOM_MODE = 3;
089  private static final int DOW_LE_DOM_MODE = 4;
090
091  /**
092   * The mode of the start rule. This takes one of the following values:
093   * <dl>
094   * <dt>DOM_MODE (1)</dt>
095   * <dd> startDay contains the day in month of the start date,
096   * startDayOfWeek is unused. </dd>
097   * <dt>DOW_IN_MONTH_MODE (2)</dt>
098   * <dd> The startDay gives the day of week in month, and
099   * 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 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}