1 /* java.util.GregorianCalendar
2 Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
5 This file is part of GNU Classpath.
7 GNU Classpath is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Classpath is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Classpath; see the file COPYING. If not, write to the
19 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 Linking this library statically or dynamically with other modules is
23 making a combined work based on this library. Thus, the terms and
24 conditions of the GNU General Public License cover the whole
27 As a special exception, the copyright holders of this library give you
28 permission to link this library with independent modules to produce an
29 executable, regardless of the license terms of these independent
30 modules, and to copy and distribute the resulting executable under
31 terms of your choice, provided that you also meet, for each linked
32 independent module, the terms and conditions of the license of that
33 module. An independent module is a module which is not derived from
34 or based on this library. If you modify this library, you may extend
35 this exception to your version of the library, but you are not
36 obligated to do so. If you do not wish to do so, delete this
37 exception statement from your version. */
45 * This class represents the Gregorian calendar, that is used in most
46 * countries all over the world. It does also handle the Julian calendar
47 * for dates smaller than the date of the change to the Gregorian calendar.
48 * The Gregorian calendar differs from the Julian calendar by a different
49 * leap year rule (no leap year every 100 years, except if year is divisible
53 * This change date is different from country to country, and can be changed with
54 * <code>setGregorianChange</code>. The first countries to adopt the Gregorian
55 * calendar did so on the 15th of October, 1582. This date followed October
56 * the 4th, 1582 in the Julian calendar system. The non-existant days that were
57 * omitted when the change took place are interpreted as Gregorian dates.
60 * Prior to the changeover date, New Year's Day occurred on the 25th of March.
61 * However, this class always takes New Year's Day as being the 1st of January.
62 * Client code should manually adapt the year value, if required, for dates
63 * between January the 1st and March the 24th in years prior to the changeover.
66 * Any date infinitely forwards or backwards in time can be represented by
67 * this class. A <em>proleptic</em> calendar system is used, which allows
68 * future dates to be created via the existing rules. This allows meaningful
69 * and consistent dates to be produced for all years. However, dates are only
70 * historically accurate following March the 1st, 4AD when the Julian calendar
71 * system was adopted. Prior to this, leap year rules were applied erraticly.
74 * There are two eras available for the Gregorian calendar, namely BC and AD.
77 * Weeks are defined as a period of seven days, beginning on the first day
78 * of the week, as returned by <code>getFirstDayOfWeek()</code>, and ending
79 * on the day prior to this.
82 * The weeks of the year are numbered from 1 to a possible 53. The first week
83 * of the year is defined as the first week that contains at least the minimum
84 * number of days of the first week in the new year (retrieved via
85 * <code>getMinimalDaysInFirstWeek()</code>). All weeks after this are numbered
89 * For example, take the year 2004. It began on a Thursday. The first week
90 * of 2004 depends both on where a week begins and how long it must minimally
91 * last. Let's say that the week begins on a Monday and must have a minimum
92 * of 5 days. In this case, the first week begins on Monday, the 5th of January.
93 * The first 4 days (Thursday to Sunday) are not eligible, as they are too few
94 * to make up the minimum number of days of the first week which must be in
95 * the new year. If the minimum was lowered to 4 days, then the first week
96 * would instead begin on Monday, the 29th of December, 2003. This first week
97 * has 4 of its days in the new year, and is now eligible.
100 * The weeks of the month are numbered from 0 to a possible 6. The first week
101 * of the month (numbered 1) is a set of days, prior to the first day of the week,
102 * which number at least the minimum number of days in a week. Unlike the first
103 * week of the year, the first week of the month only uses days from that particular
104 * month. As a consequence, it may have a variable number of days (from the minimum
105 * number required up to a full week of 7) and it need not start on the first day of
106 * the week. It must, however, be following by the first day of the week, as this
107 * marks the beginning of week 2. Any days of the month which occur prior to the
108 * first week (because the first day of the week occurs before the minimum number
109 * of days is met) are seen as week 0.
112 * Again, we will take the example of the year 2004 to demonstrate this. September
113 * 2004 begins on a Wednesday. Taking our first day of the week as Monday, and the
114 * minimum length of the first week as 6, we find that week 1 runs from Monday,
115 * the 6th of September to Sunday the 12th. Prior to the 6th, there are only
116 * 5 days (Wednesday through to Sunday). This is too small a number to meet the
117 * minimum, so these are classed as being days in week 0. Week 2 begins on the
118 * 13th, and so on. This changes if we reduce the minimum to 5. In this case,
119 * week 1 is a truncated week from Wednesday the 1st to Sunday the 5th, and week
120 * 0 doesn't exist. The first seven day week is week 2, starting on the 6th.
123 * On using the <code>clear()</code> method, the Gregorian calendar returns
124 * to its default value of the 1st of January, 1970 AD 00:00:00 (the epoch).
125 * The day of the week is set to the correct day for that particular time.
126 * The day is also the first of the month, and the date is in week 0.
131 * @see Calendar#getFirstDayOfWeek()
132 * @see Calendar#getMinimalDaysInFirstWeek()
134 public class GregorianCalendar
extends Calendar
137 * Constant representing the era BC (Before Christ).
139 public static final int BC
= 0;
142 * Constant representing the era AD (Anno Domini).
144 public static final int AD
= 1;
147 * The point at which the Gregorian calendar rules were used.
148 * This may be changed by using setGregorianChange;
149 * The default is midnight (UTC) on October 5, 1582 (Julian),
150 * or October 15, 1582 (Gregorian).
152 * @serial the changeover point from the Julian calendar
153 * system to the Gregorian.
155 private long gregorianCutover
= (new Date((24 * 60 * 60 * 1000L) * (((1582 * (365 * 4
157 + (java
.util
.Calendar
.OCTOBER
* (31
158 + 30 + 31 + 30 + 31) - 9) / 5 + 5)
159 - ((1970 * (365 * 4 + 1)) / 4 + 1
163 * For compatability with Sun's JDK.
165 static final long serialVersionUID
= -8125100834729963327L;
168 * Days in the epoch. Relative Jan 1, year '0' which is not a leap year.
169 * (although there is no year zero, this does not matter.)
170 * This is consistent with the formula:
171 * = (year-1)*365L + ((year-1) >> 2)
173 * Plus the gregorian correction:
174 * Math.floor((year-1) / 400.) - Math.floor((year-1) / 100.);
175 * For a correct julian date, the correction is -2 instead.
177 * The gregorian cutover in 1582 was 10 days, so by calculating the
178 * correction from year zero, we have 15 non-leap days (even centuries)
179 * minus 3 leap days (year 400,800,1200) = 12. Subtracting two corrects
180 * this to the correct number 10.
182 private static final int EPOCH_DAYS
= 719162;
185 * Constructs a new GregorianCalender representing the current
186 * time, using the default time zone and the default locale.
188 public GregorianCalendar()
190 this(TimeZone
.getDefault(), Locale
.getDefault());
194 * Constructs a new GregorianCalender representing the current
195 * time, using the specified time zone and the default locale.
197 * @param zone a time zone.
199 public GregorianCalendar(TimeZone zone
)
201 this(zone
, Locale
.getDefault());
205 * Constructs a new GregorianCalender representing the current
206 * time, using the default time zone and the specified locale.
208 * @param locale a locale.
210 public GregorianCalendar(Locale locale
)
212 this(TimeZone
.getDefault(), locale
);
216 * Constructs a new GregorianCalender representing the current
217 * time with the given time zone and the given locale.
219 * @param zone a time zone.
220 * @param locale a locale.
222 public GregorianCalendar(TimeZone zone
, Locale locale
)
224 this(zone
, locale
, false);
225 setTimeInMillis(System
.currentTimeMillis());
230 * Common constructor that all constructors should call.
231 * @param zone a time zone.
232 * @param locale a locale.
233 * @param unused unused parameter to make the signature differ from
234 * the public constructor (TimeZone, Locale).
236 private GregorianCalendar(TimeZone zone
, Locale locale
, boolean unused
)
242 * Constructs a new GregorianCalendar representing midnight on the
243 * given date with the default time zone and locale.
245 * @param year corresponds to the YEAR time field.
246 * @param month corresponds to the MONTH time field.
247 * @param day corresponds to the DAY time field.
249 public GregorianCalendar(int year
, int month
, int day
)
251 this(TimeZone
.getDefault(), Locale
.getDefault(), false);
252 set(year
, month
, day
);
256 * Constructs a new GregorianCalendar representing midnight on the
257 * given date with the default time zone and locale.
259 * @param year corresponds to the YEAR time field.
260 * @param month corresponds to the MONTH time field.
261 * @param day corresponds to the DAY time field.
262 * @param hour corresponds to the HOUR_OF_DAY time field.
263 * @param minute corresponds to the MINUTE time field.
265 public GregorianCalendar(int year
, int month
, int day
, int hour
, int minute
)
267 this(TimeZone
.getDefault(), Locale
.getDefault(), false);
268 set(year
, month
, day
, hour
, minute
);
272 * Constructs a new GregorianCalendar representing midnight on the
273 * given date with the default time zone and locale.
275 * @param year corresponds to the YEAR time field.
276 * @param month corresponds to the MONTH time field.
277 * @param day corresponds to the DAY time field.
278 * @param hour corresponds to the HOUR_OF_DAY time field.
279 * @param minute corresponds to the MINUTE time field.
280 * @param second corresponds to the SECOND time field.
282 public GregorianCalendar(int year
, int month
, int day
, int hour
, int minute
,
285 this(TimeZone
.getDefault(), Locale
.getDefault(), false);
286 set(year
, month
, day
, hour
, minute
, second
);
290 * Sets the date of the switch from Julian dates to Gregorian dates.
291 * You can use <code>new Date(Long.MAX_VALUE)</code> to use a pure
292 * Julian calendar, or <code>Long.MIN_VALUE</code> for a pure Gregorian
295 * @param date the date of the change.
297 public void setGregorianChange(Date date
)
299 gregorianCutover
= date
.getTime();
303 * Gets the date of the switch from Julian dates to Gregorian dates.
305 * @return the date of the change.
307 public final Date
getGregorianChange()
309 return new Date(gregorianCutover
);
314 * Determines if the given year is a leap year. The result is
315 * undefined if the Gregorian change took place in 1800, so that
316 * the end of February is skipped, and that year is specified.
320 * To specify a year in the BC era, use a negative value calculated
321 * as 1 - y, where y is the required year in BC. So, 1 BC is 0,
322 * 2 BC is -1, 3 BC is -2, etc.
325 * @param year a year (use a negative value for BC).
326 * @return true, if the given year is a leap year, false otherwise.
328 public boolean isLeapYear(int year
)
330 // Only years divisible by 4 can be leap years
334 // Is the leap-day a Julian date? Then it's a leap year
335 if (! isGregorian(year
, 31 + 29 - 1))
338 // Apply gregorian rules otherwise
339 return ((year
% 100) != 0 || (year
% 400) == 0);
343 * Retrieves the day of the week corresponding to the specified
344 * day of the specified year.
346 * @param year the year in which the dayOfYear occurs.
347 * @param dayOfYear the day of the year (an integer between 0 and
350 private int getWeekDay(int year
, int dayOfYear
)
352 boolean greg
= isGregorian(year
, dayOfYear
);
353 int day
= (int) getLinearDay(year
, dayOfYear
, greg
);
355 // The epoch was a thursday.
356 int weekday
= (day
+ THURSDAY
) % 7;
363 * Returns the day of the week for the first day of a given month (0..11)
365 private int getFirstDayOfMonth(int year
, int month
)
367 int[] dayCount
= { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
371 year
+= (month
/ 12);
377 year
+= (int) month
/ 12;
386 int dayOfYear
= dayCount
[month
] + 1;
388 if (isLeapYear(year
))
391 boolean greg
= isGregorian(year
, dayOfYear
);
392 int day
= (int) getLinearDay(year
, dayOfYear
, greg
);
394 // The epoch was a thursday.
395 int weekday
= (day
+ THURSDAY
) % 7;
402 * Takes a year, and a (zero based) day of year and determines
403 * if it is gregorian or not.
405 private boolean isGregorian(int year
, int dayOfYear
)
407 int relativeDay
= (year
- 1) * 365 + ((year
- 1) >> 2) + dayOfYear
408 - EPOCH_DAYS
; // gregorian days from 1 to epoch.
409 int gregFactor
= (int) Math
.floor((double) (year
- 1) / 400.)
410 - (int) Math
.floor((double) (year
- 1) / 100.);
412 return ((relativeDay
+ gregFactor
) * 60L * 60L * 24L * 1000L >= gregorianCutover
);
416 * Check set fields for validity, without leniency.
418 * @throws IllegalArgumentException if a field is invalid
420 private void nonLeniencyCheck() throws IllegalArgumentException
422 int[] month_days
= { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
423 int year
= fields
[YEAR
];
424 int month
= fields
[MONTH
];
425 int leap
= isLeapYear(year
) ?
1 : 0;
427 if (isSet
[ERA
] && fields
[ERA
] != AD
&& fields
[ERA
] != BC
)
428 throw new IllegalArgumentException("Illegal ERA.");
429 if (isSet
[YEAR
] && fields
[YEAR
] < 1)
430 throw new IllegalArgumentException("Illegal YEAR.");
431 if (isSet
[MONTH
] && (month
< 0 || month
> 11))
432 throw new IllegalArgumentException("Illegal MONTH.");
433 if (isSet
[WEEK_OF_YEAR
])
435 int daysInYear
= 365 + leap
;
436 daysInYear
+= (getFirstDayOfMonth(year
, 0) - 1); // pad first week
437 int last
= getFirstDayOfMonth(year
, 11) + 4;
440 daysInYear
+= 7 - last
;
441 int weeks
= daysInYear
/ 7;
442 if (fields
[WEEK_OF_YEAR
] < 1 || fields
[WEEK_OF_YEAR
] > weeks
)
443 throw new IllegalArgumentException("Illegal WEEK_OF_YEAR.");
446 if (isSet
[WEEK_OF_MONTH
])
448 int weeks
= (month
== 1 && leap
== 0) ?
4 : 5;
449 if (fields
[WEEK_OF_MONTH
] < 1 || fields
[WEEK_OF_MONTH
] > weeks
)
450 throw new IllegalArgumentException("Illegal WEEK_OF_MONTH.");
453 if (isSet
[DAY_OF_MONTH
])
454 if (fields
[DAY_OF_MONTH
] < 1
455 || fields
[DAY_OF_MONTH
] > month_days
[month
]
456 + ((month
== 1) ? leap
: 0))
457 throw new IllegalArgumentException("Illegal DAY_OF_MONTH.");
459 if (isSet
[DAY_OF_YEAR
]
460 && (fields
[DAY_OF_YEAR
] < 1 || fields
[DAY_OF_YEAR
] > 365 + leap
))
461 throw new IllegalArgumentException("Illegal DAY_OF_YEAR.");
463 if (isSet
[DAY_OF_WEEK
]
464 && (fields
[DAY_OF_WEEK
] < 1 || fields
[DAY_OF_WEEK
] > 7))
465 throw new IllegalArgumentException("Illegal DAY_OF_WEEK.");
467 if (isSet
[DAY_OF_WEEK_IN_MONTH
])
469 int weeks
= (month
== 1 && leap
== 0) ?
4 : 5;
470 if (fields
[DAY_OF_WEEK_IN_MONTH
] < -weeks
471 || fields
[DAY_OF_WEEK_IN_MONTH
] > weeks
)
472 throw new IllegalArgumentException("Illegal DAY_OF_WEEK_IN_MONTH.");
475 if (isSet
[AM_PM
] && fields
[AM_PM
] != AM
&& fields
[AM_PM
] != PM
)
476 throw new IllegalArgumentException("Illegal AM_PM.");
477 if (isSet
[HOUR
] && (fields
[HOUR
] < 0 || fields
[HOUR
] > 11))
478 throw new IllegalArgumentException("Illegal HOUR.");
479 if (isSet
[HOUR_OF_DAY
]
480 && (fields
[HOUR_OF_DAY
] < 0 || fields
[HOUR_OF_DAY
] > 23))
481 throw new IllegalArgumentException("Illegal HOUR_OF_DAY.");
482 if (isSet
[MINUTE
] && (fields
[MINUTE
] < 0 || fields
[MINUTE
] > 59))
483 throw new IllegalArgumentException("Illegal MINUTE.");
484 if (isSet
[SECOND
] && (fields
[SECOND
] < 0 || fields
[SECOND
] > 59))
485 throw new IllegalArgumentException("Illegal SECOND.");
486 if (isSet
[MILLISECOND
]
487 && (fields
[MILLISECOND
] < 0 || fields
[MILLISECOND
] > 999))
488 throw new IllegalArgumentException("Illegal MILLISECOND.");
489 if (isSet
[ZONE_OFFSET
]
490 && (fields
[ZONE_OFFSET
] < -12 * 60 * 60 * 1000L
491 || fields
[ZONE_OFFSET
] > 12 * 60 * 60 * 1000L))
492 throw new IllegalArgumentException("Illegal ZONE_OFFSET.");
493 if (isSet
[DST_OFFSET
]
494 && (fields
[DST_OFFSET
] < -12 * 60 * 60 * 1000L
495 || fields
[DST_OFFSET
] > 12 * 60 * 60 * 1000L))
496 throw new IllegalArgumentException("Illegal DST_OFFSET.");
500 * Converts the time field values (<code>fields</code>) to
501 * milliseconds since the epoch UTC (<code>time</code>).
503 * @throws IllegalArgumentException if any calendar fields
506 protected synchronized void computeTime()
509 int era
= fields
[ERA
];
510 int year
= fields
[YEAR
];
511 int month
= fields
[MONTH
];
512 int day
= fields
[DAY_OF_MONTH
];
514 int minute
= fields
[MINUTE
];
515 int second
= fields
[SECOND
];
516 int millis
= fields
[MILLISECOND
];
517 int[] month_days
= { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
518 int[] dayCount
= { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
524 if (! isSet
[MONTH
] && (! isSet
[DAY_OF_WEEK
] || isSet
[WEEK_OF_YEAR
]))
526 // 5: YEAR + DAY_OF_WEEK + WEEK_OF_YEAR
527 if (isSet
[WEEK_OF_YEAR
])
529 int first
= getFirstDayOfMonth(year
, 0);
531 int daysInFirstWeek
= getFirstDayOfWeek() - first
;
532 if (daysInFirstWeek
<= 0)
533 daysInFirstWeek
+= 7;
535 if (daysInFirstWeek
< getMinimalDaysInFirstWeek())
536 offs
+= daysInFirstWeek
;
538 offs
-= 7 - daysInFirstWeek
;
540 day
= offs
+ 7 * (fields
[WEEK_OF_YEAR
] - 1);
541 offs
= fields
[DAY_OF_WEEK
] - getFirstDayOfWeek();
549 // 4: YEAR + DAY_OF_YEAR
551 day
= fields
[DAY_OF_YEAR
];
556 if (isSet
[DAY_OF_WEEK
])
558 int first
= getFirstDayOfMonth(year
, month
);
560 // 3: YEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK
561 if (isSet
[DAY_OF_WEEK_IN_MONTH
])
563 if (fields
[DAY_OF_WEEK_IN_MONTH
] < 0)
566 first
= getFirstDayOfMonth(year
, month
);
567 day
= 1 + 7 * (fields
[DAY_OF_WEEK_IN_MONTH
]);
570 day
= 1 + 7 * (fields
[DAY_OF_WEEK_IN_MONTH
] - 1);
572 int offs
= fields
[DAY_OF_WEEK
] - first
;
578 { // 2: YEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEK
580 int daysInFirstWeek
= getFirstDayOfWeek() - first
;
581 if (daysInFirstWeek
<= 0)
582 daysInFirstWeek
+= 7;
584 if (daysInFirstWeek
< getMinimalDaysInFirstWeek())
585 offs
+= daysInFirstWeek
;
587 offs
-= 7 - daysInFirstWeek
;
589 day
= offs
+ 7 * (fields
[WEEK_OF_MONTH
] - 1);
590 offs
= fields
[DAY_OF_WEEK
] - getFirstDayOfWeek();
597 // 1: YEAR + MONTH + DAY_OF_MONTH
599 if (era
== BC
&& year
> 0)
602 // rest of code assumes day/month/year set
603 // should negative BC years be AD?
604 // get the hour (but no check for validity)
608 if (fields
[AM_PM
] == PM
)
612 hour
= fields
[HOUR_OF_DAY
];
614 // Read the era,year,month,day fields and convert as appropriate.
615 // Calculate number of milliseconds into the day
616 // This takes care of both h, m, s, ms over/underflows.
617 long allMillis
= (((hour
* 60L) + minute
) * 60L + second
) * 1000L + millis
;
618 day
+= allMillis
/ (24 * 60 * 60 * 1000L);
619 millisInDay
= (int) (allMillis
% (24 * 60 * 60 * 1000L));
623 year
+= (int) month
/ 12;
633 year
+= (month
/ 12);
637 month_days
[1] = isLeapYear(year
) ?
29 : 28;
644 month_days
[1] = isLeapYear(year
) ?
29 : 28;
646 month
= (month
+ 11) % 12;
647 day
+= month_days
[month
];
649 while (day
> month_days
[month
])
651 day
-= (month_days
[month
]);
652 month
= (month
+ 1) % 12;
656 month_days
[1] = isLeapYear(year
) ?
29 : 28;
660 // ok, by here we have valid day,month,year,era and millisinday
661 int dayOfYear
= dayCount
[month
] + day
- 1; // (day starts on 1)
662 if (isLeapYear(year
) && month
> 1)
665 int relativeDay
= (year
- 1) * 365 + ((year
- 1) >> 2) + dayOfYear
666 - EPOCH_DAYS
; // gregorian days from 1 to epoch.
667 int gregFactor
= (int) Math
.floor((double) (year
- 1) / 400.)
668 - (int) Math
.floor((double) (year
- 1) / 100.);
670 if ((relativeDay
+ gregFactor
) * 60L * 60L * 24L * 1000L >= gregorianCutover
)
671 relativeDay
+= gregFactor
;
675 time
= relativeDay
* (24 * 60 * 60 * 1000L) + millisInDay
;
677 // the epoch was a Thursday.
678 int weekday
= (int) (relativeDay
+ THURSDAY
) % 7;
681 fields
[DAY_OF_WEEK
] = weekday
;
683 // Time zone corrections.
684 TimeZone zone
= getTimeZone();
685 int rawOffset
= isSet
[ZONE_OFFSET
] ? fields
[ZONE_OFFSET
]
686 : zone
.getRawOffset();
688 int dstOffset
= isSet
[DST_OFFSET
] ? fields
[DST_OFFSET
]
689 : (zone
.getOffset((year
< 0) ? BC
: AD
,
690 (year
< 0) ?
1 - year
694 - zone
.getRawOffset());
696 time
-= rawOffset
+ dstOffset
;
702 * Get the linear day in days since the epoch, using the
703 * Julian or Gregorian calendar as specified. If you specify a
704 * nonpositive year it is interpreted as BC as following: 0 is 1
705 * BC, -1 is 2 BC and so on.
707 * @param year the year of the date.
708 * @param dayOfYear the day of year of the date; 1 based.
709 * @param gregorian <code>true</code>, if we should use the Gregorian rules.
710 * @return the days since the epoch, may be negative.
712 private long getLinearDay(int year
, int dayOfYear
, boolean gregorian
)
714 // The 13 is the number of days, that were omitted in the Gregorian
715 // Calender until the epoch.
716 // We shift right by 2 instead of dividing by 4, to get correct
717 // results for negative years (and this is even more efficient).
718 long julianDay
= (year
- 1) * 365L + ((year
- 1) >> 2) + (dayOfYear
- 1)
719 - EPOCH_DAYS
; // gregorian days from 1 to epoch.
723 // subtract the days that are missing in gregorian calendar
724 // with respect to julian calendar.
726 // Okay, here we rely on the fact that the gregorian
727 // calendar was introduced in the AD era. This doesn't work
728 // with negative years.
730 // The additional leap year factor accounts for the fact that
731 // a leap day is not seen on Jan 1 of the leap year.
732 int gregOffset
= (int) Math
.floor((double) (year
- 1) / 400.)
733 - (int) Math
.floor((double) (year
- 1) / 100.);
735 return julianDay
+ gregOffset
;
743 * Converts the given linear day into era, year, month,
744 * day_of_year, day_of_month, day_of_week, and writes the result
745 * into the fields array.
747 * @param day the linear day.
748 * @param gregorian true, if we should use Gregorian rules.
750 private void calculateDay(int[] fields
, long day
, boolean gregorian
)
752 // the epoch was a Thursday.
753 int weekday
= (int) (day
+ THURSDAY
) % 7;
756 fields
[DAY_OF_WEEK
] = weekday
;
758 // get a first approximation of the year. This may be one
762 ?
((day
- 100L) * 400L) / (365L * 400L + 100L - 4L
763 + 1L) : ((day
- 100L) * 4L) / (365L * 4L + 1L));
767 long firstDayOfYear
= getLinearDay(year
, 1, gregorian
);
769 // Now look in which year day really lies.
770 if (day
< firstDayOfYear
)
773 firstDayOfYear
= getLinearDay(year
, 1, gregorian
);
776 day
-= firstDayOfYear
- 1; // day of year, one based.
778 fields
[DAY_OF_YEAR
] = (int) day
;
782 fields
[YEAR
] = 1 - year
;
790 int leapday
= isLeapYear(year
) ?
1 : 0;
791 if (day
<= 31 + 28 + leapday
)
793 fields
[MONTH
] = (int) day
/ 32; // 31->JANUARY, 32->FEBRUARY
794 fields
[DAY_OF_MONTH
] = (int) day
- 31 * fields
[MONTH
];
798 // A few more magic formulas
799 int scaledDay
= ((int) day
- leapday
) * 5 + 8;
800 fields
[MONTH
] = scaledDay
/ (31 + 30 + 31 + 30 + 31);
801 fields
[DAY_OF_MONTH
] = (scaledDay
% (31 + 30 + 31 + 30 + 31)) / 5 + 1;
806 * Converts the milliseconds since the epoch UTC
807 * (<code>time</code>) to time fields
808 * (<code>fields</code>).
810 protected synchronized void computeFields()
812 boolean gregorian
= (time
>= gregorianCutover
);
814 TimeZone zone
= getTimeZone();
815 fields
[ZONE_OFFSET
] = zone
.getRawOffset();
816 long localTime
= time
+ fields
[ZONE_OFFSET
];
818 long day
= localTime
/ (24 * 60 * 60 * 1000L);
819 int millisInDay
= (int) (localTime
% (24 * 60 * 60 * 1000L));
823 millisInDay
+= (24 * 60 * 60 * 1000);
827 calculateDay(fields
, day
, gregorian
);
828 fields
[DST_OFFSET
] = zone
.getOffset(fields
[ERA
], fields
[YEAR
],
829 fields
[MONTH
], fields
[DAY_OF_MONTH
],
830 fields
[DAY_OF_WEEK
], millisInDay
)
831 - fields
[ZONE_OFFSET
];
833 millisInDay
+= fields
[DST_OFFSET
];
834 if (millisInDay
>= 24 * 60 * 60 * 1000)
836 millisInDay
-= 24 * 60 * 60 * 1000;
837 calculateDay(fields
, ++day
, gregorian
);
840 fields
[DAY_OF_WEEK_IN_MONTH
] = (fields
[DAY_OF_MONTH
] + 6) / 7;
842 // which day of the week are we (0..6), relative to getFirstDayOfWeek
843 int relativeWeekday
= (7 + fields
[DAY_OF_WEEK
] - getFirstDayOfWeek()) % 7;
845 fields
[WEEK_OF_MONTH
] = (fields
[DAY_OF_MONTH
] - relativeWeekday
+ 12) / 7;
847 int weekOfYear
= (fields
[DAY_OF_YEAR
] - relativeWeekday
+ 6) / 7;
849 // Do the Correction: getMinimalDaysInFirstWeek() is always in the
851 int minDays
= getMinimalDaysInFirstWeek();
852 int firstWeekday
= (7 + getWeekDay(fields
[YEAR
], minDays
)
853 - getFirstDayOfWeek()) % 7;
854 if (minDays
- firstWeekday
< 1)
856 fields
[WEEK_OF_YEAR
] = weekOfYear
;
858 int hourOfDay
= millisInDay
/ (60 * 60 * 1000);
859 fields
[AM_PM
] = (hourOfDay
< 12) ? AM
: PM
;
860 int hour
= hourOfDay
% 12;
862 fields
[HOUR_OF_DAY
] = hourOfDay
;
863 millisInDay
%= (60 * 60 * 1000);
864 fields
[MINUTE
] = millisInDay
/ (60 * 1000);
865 millisInDay
%= (60 * 1000);
866 fields
[SECOND
] = millisInDay
/ (1000);
867 fields
[MILLISECOND
] = millisInDay
% 1000;
869 areFieldsSet
= isSet
[ERA
] = isSet
[YEAR
] = isSet
[MONTH
] = isSet
[WEEK_OF_YEAR
] = isSet
[WEEK_OF_MONTH
] = isSet
[DAY_OF_MONTH
] = isSet
[DAY_OF_YEAR
] = isSet
[DAY_OF_WEEK
] = isSet
[DAY_OF_WEEK_IN_MONTH
] = isSet
[AM_PM
] = isSet
[HOUR
] = isSet
[HOUR_OF_DAY
] = isSet
[MINUTE
] = isSet
[SECOND
] = isSet
[MILLISECOND
] = isSet
[ZONE_OFFSET
] = isSet
[DST_OFFSET
] = true;
873 * Return a hash code for this object, following the general contract
874 * specified by {@link Object#hashCode()}.
875 * @return the hash code
877 public int hashCode()
879 int val
= (int) ((gregorianCutover
>>> 32) ^
(gregorianCutover
& 0xffffffff));
880 return super.hashCode() ^ val
;
884 * Compares the given calendar with this. An object, o, is
885 * equivalent to this if it is also a <code>GregorianCalendar</code>
886 * with the same time since the epoch under the same conditions
887 * (same change date and same time zone).
889 * @param o the object to that we should compare.
890 * @return true, if the given object is a calendar, that represents
891 * the same time (but doesn't necessarily have the same fields).
892 * @throws IllegalArgumentException if one of the fields
893 * <code>ZONE_OFFSET</code> or <code>DST_OFFSET</code> is
894 * specified, if an unknown field is specified or if one
895 * of the calendar fields receives an illegal value when
896 * leniancy is not enabled.
898 public boolean equals(Object o
)
900 if (! (o
instanceof GregorianCalendar
))
903 GregorianCalendar cal
= (GregorianCalendar
) o
;
904 return (cal
.gregorianCutover
== gregorianCutover
909 * Adds the specified amount of time to the given time field. The
910 * amount may be negative to subtract the time. If the field overflows
911 * it does what you expect: Jan, 25 + 10 Days is Feb, 4.
912 * @param field one of the time field constants.
913 * @param amount the amount of time to add.
914 * @exception IllegalArgumentException if <code>field</code> is
915 * <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or invalid; or
916 * if <code>amount</code> contains an out-of-range value and the calendar
917 * is not in lenient mode.
919 public void add(int field
, int amount
)
925 fields
[YEAR
] += amount
;
930 int months
= fields
[MONTH
] + amount
;
931 fields
[YEAR
] += months
/ 12;
932 fields
[MONTH
] = months
% 12;
933 if (fields
[MONTH
] < 0)
938 int maxDay
= getActualMaximum(DAY_OF_MONTH
);
939 if (fields
[DAY_OF_MONTH
] > maxDay
)
940 fields
[DAY_OF_MONTH
] = maxDay
;
941 set(YEAR
, fields
[YEAR
]);
942 set(MONTH
, fields
[MONTH
]);
949 time
+= amount
* (24 * 60 * 60 * 1000L);
950 areFieldsSet
= false;
954 case DAY_OF_WEEK_IN_MONTH
:
957 time
+= amount
* (7 * 24 * 60 * 60 * 1000L);
958 areFieldsSet
= false;
963 time
+= amount
* (12 * 60 * 60 * 1000L);
964 areFieldsSet
= false;
970 time
+= amount
* (60 * 60 * 1000L);
971 areFieldsSet
= false;
976 time
+= amount
* (60 * 1000L);
977 areFieldsSet
= false;
982 time
+= amount
* (1000L);
983 areFieldsSet
= false;
989 areFieldsSet
= false;
992 case DST_OFFSET
:default:
993 throw new IllegalArgumentException("Invalid or unknown field");
998 * Rolls the specified time field up or down. This means add one
999 * to the specified field, but don't change the other fields. If
1000 * the maximum for this field is reached, start over with the
1003 * <strong>Note:</strong> There may be situation, where the other
1004 * fields must be changed, e.g rolling the month on May, 31.
1005 * The date June, 31 is automatically converted to July, 1.
1006 * This requires lenient settings.
1008 * @param field the time field. One of the time field constants.
1009 * @param up the direction, true for up, false for down.
1010 * @throws IllegalArgumentException if one of the fields
1011 * <code>ZONE_OFFSET</code> or <code>DST_OFFSET</code> is
1012 * specified, if an unknown field is specified or if one
1013 * of the calendar fields receives an illegal value when
1014 * leniancy is not enabled.
1016 public void roll(int field
, boolean up
)
1018 roll(field
, up ?
1 : -1);
1022 * Checks that the fields are still within their legal bounds,
1023 * following use of the <code>roll()</code> method.
1025 * @param field the field to check.
1026 * @param delta multipler for alterations to the <code>time</code>.
1027 * @see #roll(int, boolean)
1028 * @see #roll(int, int)
1030 private void cleanUpAfterRoll(int field
, int delta
)
1037 // check that day of month is still in correct range
1038 if (fields
[DAY_OF_MONTH
] > getActualMaximum(DAY_OF_MONTH
))
1039 fields
[DAY_OF_MONTH
] = getActualMaximum(DAY_OF_MONTH
);
1041 isSet
[WEEK_OF_MONTH
] = false;
1042 isSet
[DAY_OF_WEEK
] = false;
1043 isSet
[DAY_OF_WEEK_IN_MONTH
] = false;
1044 isSet
[DAY_OF_YEAR
] = false;
1045 isSet
[WEEK_OF_YEAR
] = false;
1048 isSet
[WEEK_OF_MONTH
] = false;
1049 isSet
[DAY_OF_WEEK
] = false;
1050 isSet
[DAY_OF_WEEK_IN_MONTH
] = false;
1051 isSet
[DAY_OF_YEAR
] = false;
1052 isSet
[WEEK_OF_YEAR
] = false;
1053 time
+= delta
* (24 * 60 * 60 * 1000L);
1056 isSet
[DAY_OF_MONTH
] = false;
1057 isSet
[DAY_OF_WEEK_IN_MONTH
] = false;
1058 isSet
[DAY_OF_YEAR
] = false;
1059 isSet
[WEEK_OF_YEAR
] = false;
1060 time
+= delta
* (7 * 24 * 60 * 60 * 1000L);
1062 case DAY_OF_WEEK_IN_MONTH
:
1063 isSet
[DAY_OF_MONTH
] = false;
1064 isSet
[WEEK_OF_MONTH
] = false;
1065 isSet
[DAY_OF_YEAR
] = false;
1066 isSet
[WEEK_OF_YEAR
] = false;
1067 time
+= delta
* (7 * 24 * 60 * 60 * 1000L);
1070 isSet
[MONTH
] = false;
1071 isSet
[DAY_OF_MONTH
] = false;
1072 isSet
[WEEK_OF_MONTH
] = false;
1073 isSet
[DAY_OF_WEEK_IN_MONTH
] = false;
1074 isSet
[DAY_OF_WEEK
] = false;
1075 isSet
[WEEK_OF_YEAR
] = false;
1076 time
+= delta
* (24 * 60 * 60 * 1000L);
1079 isSet
[MONTH
] = false;
1080 isSet
[DAY_OF_MONTH
] = false;
1081 isSet
[WEEK_OF_MONTH
] = false;
1082 isSet
[DAY_OF_WEEK_IN_MONTH
] = false;
1083 isSet
[DAY_OF_YEAR
] = false;
1084 time
+= delta
* (7 * 24 * 60 * 60 * 1000L);
1087 isSet
[HOUR_OF_DAY
] = false;
1088 time
+= delta
* (12 * 60 * 60 * 1000L);
1091 isSet
[HOUR_OF_DAY
] = false;
1092 time
+= delta
* (60 * 60 * 1000L);
1095 isSet
[HOUR
] = false;
1096 isSet
[AM_PM
] = false;
1097 time
+= delta
* (60 * 60 * 1000L);
1100 time
+= delta
* (60 * 1000L);
1103 time
+= delta
* (1000L);
1112 * Rolls the specified time field by the given amount. This means
1113 * add amount to the specified field, but don't change the other
1114 * fields. If the maximum for this field is reached, start over
1115 * with the minimum value and vice versa for negative amounts.
1117 * <strong>Note:</strong> There may be situation, where the other
1118 * fields must be changed, e.g rolling the month on May, 31.
1119 * The date June, 31 is automatically corrected to June, 30.
1121 * @param field the time field. One of the time field constants.
1122 * @param amount the amount by which we should roll.
1123 * @throws IllegalArgumentException if one of the fields
1124 * <code>ZONE_OFFSET</code> or <code>DST_OFFSET</code> is
1125 * specified, if an unknown field is specified or if one
1126 * of the calendar fields receives an illegal value when
1127 * leniancy is not enabled.
1129 public void roll(int field
, int amount
)
1134 // day of week is special: it rolls automatically
1139 throw new IllegalArgumentException("Can't roll time zone");
1142 int min
= getActualMinimum(field
);
1143 int range
= getActualMaximum(field
) - min
+ 1;
1144 int oldval
= fields
[field
];
1145 int newval
= (oldval
- min
+ range
+ amount
) % range
+ min
;
1148 fields
[field
] = newval
;
1149 cleanUpAfterRoll(field
, newval
- oldval
);
1153 * The minimum values for the calendar fields.
1155 private static final int[] minimums
=
1157 BC
, 1, 0, 0, 1, 1, 1, SUNDAY
, 1, AM
,
1158 1, 0, 0, 0, 0, -(12 * 60 * 60 * 1000),
1163 * The maximum values for the calendar fields.
1165 private static final int[] maximums
=
1167 AD
, 5000000, 11, 53, 5, 31, 366,
1168 SATURDAY
, 5, PM
, 12, 23, 59, 59, 999,
1169 +(12 * 60 * 60 * 1000),
1170 (12 * 60 * 60 * 1000)
1174 * Gets the smallest value that is allowed for the specified field.
1176 * @param field one of the time field constants.
1177 * @return the smallest value for the specified field.
1179 public int getMinimum(int field
)
1181 return minimums
[field
];
1185 * Gets the biggest value that is allowed for the specified field.
1187 * @param field one of the time field constants.
1188 * @return the biggest value.
1190 public int getMaximum(int field
)
1192 return maximums
[field
];
1196 * Gets the greatest minimum value that is allowed for the specified field.
1197 * This is the largest value returned by the <code>getActualMinimum(int)</code>
1200 * @param field the time field. One of the time field constants.
1201 * @return the greatest minimum value.
1202 * @see #getActualMinimum(int)
1204 public int getGreatestMinimum(int field
)
1206 if (field
== WEEK_OF_YEAR
)
1208 return minimums
[field
];
1212 * Gets the smallest maximum value that is allowed for the
1213 * specified field. This is the smallest value returned
1214 * by the <code>getActualMaximum(int)</code>. For example,
1215 * this is 28 for DAY_OF_MONTH (as all months have at least
1218 * @param field the time field. One of the time field constants.
1219 * @return the least maximum value.
1220 * @see #getActualMaximum(int)
1223 public int getLeastMaximum(int field
)
1233 case DAY_OF_WEEK_IN_MONTH
:
1237 return maximums
[field
];
1242 * Gets the actual minimum value that is allowed for the specified field.
1243 * This value is dependent on the values of the other fields. Note that
1244 * this calls <code>complete()</code> if not enough fields are set. This
1245 * can have ugly side effects. The value given depends on the current
1246 * time used by this instance.
1248 * @param field the time field. One of the time field constants.
1249 * @return the actual minimum value.
1252 public int getActualMinimum(int field
)
1254 if (field
== WEEK_OF_YEAR
)
1256 int min
= getMinimalDaysInFirstWeek();
1259 if (! areFieldsSet
|| ! isSet
[ERA
] || ! isSet
[YEAR
])
1262 int year
= fields
[ERA
] == AD ? fields
[YEAR
] : 1 - fields
[YEAR
];
1263 int weekday
= getWeekDay(year
, min
);
1264 if ((7 + weekday
- getFirstDayOfWeek()) % 7 >= min
- 1)
1268 return minimums
[field
];
1272 * Gets the actual maximum value that is allowed for the specified field.
1273 * This value is dependent on the values of the other fields. Note that
1274 * this calls <code>complete()</code> if not enough fields are set. This
1275 * can have ugly side effects. The value given depends on the current time
1276 * used by this instance; thus, leap years have a maximum day of month value of
1277 * 29, rather than 28.
1279 * @param field the time field. One of the time field constants.
1280 * @return the actual maximum value.
1282 public int getActualMaximum(int field
)
1288 if (! areFieldsSet
|| ! isSet
[ERA
] || ! isSet
[YEAR
])
1291 // This is wrong for the year that contains the gregorian change.
1292 // I.e it gives the weeks in the julian year or in the gregorian
1293 // year in that case.
1294 int year
= fields
[ERA
] == AD ? fields
[YEAR
] : 1 - fields
[YEAR
];
1295 int lastDay
= isLeapYear(year
) ?
366 : 365;
1296 int weekday
= getWeekDay(year
, lastDay
);
1297 int week
= (lastDay
+ 6 - (7 + weekday
- getFirstDayOfWeek()) % 7) / 7;
1299 int minimalDays
= getMinimalDaysInFirstWeek();
1300 int firstWeekday
= getWeekDay(year
, minimalDays
);
1302 * Is there a set of days at the beginning of the year, before the
1303 * first day of the week, equal to or greater than the minimum number
1304 * of days required in the first week?
1306 if (minimalDays
- (7 + firstWeekday
- getFirstDayOfWeek()) % 7 < 1)
1307 return week
+ 1; /* Add week 1: firstWeekday through to firstDayOfWeek */
1311 if (! areFieldsSet
|| ! isSet
[MONTH
])
1313 int month
= fields
[MONTH
];
1315 // If you change this, you should also change
1316 // SimpleTimeZone.getDaysInMonth();
1317 if (month
== FEBRUARY
)
1319 if (! isSet
[YEAR
] || ! isSet
[ERA
])
1321 int year
= fields
[ERA
] == AD ? fields
[YEAR
] : 1 - fields
[YEAR
];
1322 return isLeapYear(year
) ?
29 : 28;
1324 else if (month
< AUGUST
)
1325 return 31 - (month
& 1);
1327 return 30 + (month
& 1);
1331 if (! areFieldsSet
|| ! isSet
[ERA
] || ! isSet
[YEAR
])
1333 int year
= fields
[ERA
] == AD ? fields
[YEAR
] : 1 - fields
[YEAR
];
1334 return isLeapYear(year
) ?
366 : 365;
1336 case DAY_OF_WEEK_IN_MONTH
:
1338 // This is wrong for the month that contains the gregorian change.
1339 int daysInMonth
= getActualMaximum(DAY_OF_MONTH
);
1341 // That's black magic, I know
1342 return (daysInMonth
- (fields
[DAY_OF_MONTH
] - 1) % 7 + 6) / 7;
1346 int daysInMonth
= getActualMaximum(DAY_OF_MONTH
);
1347 int weekday
= (daysInMonth
- fields
[DAY_OF_MONTH
]
1348 + fields
[DAY_OF_WEEK
] - SUNDAY
) % 7 + SUNDAY
;
1349 return (daysInMonth
+ 6 - (7 + weekday
- getFirstDayOfWeek()) % 7) / 7;
1352 return maximums
[field
];