001    /* java.util.SimpleTimeZone
002       Copyright (C) 1998, 1999, 2000, 2003, 2004, 2005, 2007
003       Free Software Foundation, Inc.
004    
005    This file is part of GNU Classpath.
006    
007    GNU Classpath is free software; you can redistribute it and/or modify
008    it under the terms of the GNU General Public License as published by
009    the Free Software Foundation; either version 2, or (at your option)
010    any later version.
011    
012    GNU Classpath is distributed in the hope that it will be useful, but
013    WITHOUT ANY WARRANTY; without even the implied warranty of
014    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
015    General Public License for more details.
016    
017    You should have received a copy of the GNU General Public License
018    along with GNU Classpath; see the file COPYING.  If not, write to the
019    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
020    02110-1301 USA.
021    
022    Linking this library statically or dynamically with other modules is
023    making a combined work based on this library.  Thus, the terms and
024    conditions of the GNU General Public License cover the whole
025    combination.
026    
027    As a special exception, the copyright holders of this library give you
028    permission to link this library with independent modules to produce an
029    executable, regardless of the license terms of these independent
030    modules, and to copy and distribute the resulting executable under
031    terms of your choice, provided that you also meet, for each linked
032    independent module, the terms and conditions of the license of that
033    module.  An independent module is a module which is not derived from
034    or based on this library.  If you modify this library, you may extend
035    this exception to your version of the library, but you are not
036    obligated to do so.  If you do not wish to do so, delete this
037    exception statement from your version. */
038    
039    
040    package 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     */
057    public 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    }