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 > 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 < 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 > 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 > 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 < 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 }