Source for java.util.GregorianCalendar

   1: /* java.util.GregorianCalendar
   2:    Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004, 2007
   3:    Free Software Foundation, Inc.
   4: 
   5: This file is part of GNU Classpath.
   6: 
   7: GNU Classpath is free software; you can redistribute it and/or modify
   8: it under the terms of the GNU General Public License as published by
   9: the Free Software Foundation; either version 2, or (at your option)
  10: any later version.
  11: 
  12: GNU Classpath is distributed in the hope that it will be useful, but
  13: WITHOUT ANY WARRANTY; without even the implied warranty of
  14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15: General Public License for more details.
  16: 
  17: You should have received a copy of the GNU General Public License
  18: along with GNU Classpath; see the file COPYING.  If not, write to the
  19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20: 02110-1301 USA.
  21: 
  22: Linking this library statically or dynamically with other modules is
  23: making a combined work based on this library.  Thus, the terms and
  24: conditions of the GNU General Public License cover the whole
  25: combination.
  26: 
  27: As a special exception, the copyright holders of this library give you
  28: permission to link this library with independent modules to produce an
  29: executable, regardless of the license terms of these independent
  30: modules, and to copy and distribute the resulting executable under
  31: terms of your choice, provided that you also meet, for each linked
  32: independent module, the terms and conditions of the license of that
  33: module.  An independent module is a module which is not derived from
  34: or based on this library.  If you modify this library, you may extend
  35: this exception to your version of the library, but you are not
  36: obligated to do so.  If you do not wish to do so, delete this
  37: exception statement from your version. */
  38: 
  39: 
  40: package java.util;
  41: 
  42: 
  43: /**
  44:  * <p>
  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
  50:  * by 400).
  51:  * </p>
  52:  * <p>
  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.
  58:  * </p>
  59:  * <p>
  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.
  64:  * </p>
  65:  * <p>
  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.
  72:  * </p>
  73:  * <p>
  74:  * There are two eras available for the Gregorian calendar, namely BC and AD.
  75:  * </p>
  76:  * <p>
  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.
  80:  * </p>
  81:  * <p>
  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
  86:  * from 2 onwards.
  87:  * </p>
  88:  * <p>
  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.
  98:  * </p>
  99:  * <p>
 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.
 110:  * </p>
 111:  * <p>
 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.
 121:  * </p>
 122:  * <p>
 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.
 127:  * </p>
 128:  *
 129:  * @see Calendar
 130:  * @see TimeZone
 131:  * @see Calendar#getFirstDayOfWeek()
 132:  * @see Calendar#getMinimalDaysInFirstWeek()
 133:  */
 134: public class GregorianCalendar extends Calendar
 135: {
 136:   /**
 137:    * Constant representing the era BC (Before Christ).
 138:    */
 139:   public static final int BC = 0;
 140: 
 141:   /**
 142:    * Constant representing the era AD (Anno Domini).
 143:    */
 144:   public static final int AD = 1;
 145: 
 146:   /**
 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).
 151:    *
 152:    * @serial the changeover point from the Julian calendar
 153:    *         system to the Gregorian.
 154:    */
 155:   private long gregorianCutover = (new Date((24 * 60 * 60 * 1000L) * (((1582 * (365 * 4
 156:                                             + 1)) / 4
 157:                                             + (java.util.Calendar.OCTOBER * (31
 158:                                             + 30 + 31 + 30 + 31) - 9) / 5 + 5)
 159:                                             - ((1970 * (365 * 4 + 1)) / 4 + 1
 160:                                             - 13)))).getTime();
 161: 
 162:   /**
 163:    * For compatability with Sun's JDK.
 164:    */
 165:   static final long serialVersionUID = -8125100834729963327L;
 166: 
 167:   /**
 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)
 172:    *
 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.
 176:    *
 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.
 181:    */
 182:   private static final int EPOCH_DAYS = 719162;
 183: 
 184:   /**
 185:    * Constructs a new GregorianCalender representing the current
 186:    * time, using the default time zone and the default locale.
 187:    */
 188:   public GregorianCalendar()
 189:   {
 190:     this(TimeZone.getDefault(), Locale.getDefault());
 191:   }
 192: 
 193:   /**
 194:    * Constructs a new GregorianCalender representing the current
 195:    * time, using the specified time zone and the default locale.
 196:    *
 197:    * @param zone a time zone.
 198:    */
 199:   public GregorianCalendar(TimeZone zone)
 200:   {
 201:     this(zone, Locale.getDefault());
 202:   }
 203: 
 204:   /**
 205:    * Constructs a new GregorianCalender representing the current
 206:    * time, using the default time zone and the specified locale.
 207:    *
 208:    * @param locale a locale.
 209:    */
 210:   public GregorianCalendar(Locale locale)
 211:   {
 212:     this(TimeZone.getDefault(), locale);
 213:   }
 214: 
 215:   /**
 216:    * Constructs a new GregorianCalender representing the current
 217:    * time with the given time zone and the given locale.
 218:    *
 219:    * @param zone a time zone.
 220:    * @param locale a locale.
 221:    */
 222:   public GregorianCalendar(TimeZone zone, Locale locale)
 223:   {
 224:     this(zone, locale, false);
 225:     setTimeInMillis(System.currentTimeMillis());
 226:   }
 227: 
 228:   /**
 229:    * Common constructor that all constructors should call.
 230:    * @param zone a time zone.
 231:    * @param locale a locale.
 232:    * @param unused unused parameter to make the signature differ from
 233:    * the public constructor (TimeZone, Locale).
 234:    */
 235:   private GregorianCalendar(TimeZone zone, Locale locale, boolean unused)
 236:   {
 237:     super(zone, locale);
 238:   }
 239: 
 240:   /**
 241:    * Constructs a new GregorianCalendar representing midnight on the
 242:    * given date with the default time zone and locale.
 243:    *
 244:    * @param year corresponds to the YEAR time field.
 245:    * @param month corresponds to the MONTH time field.
 246:    * @param day corresponds to the DAY time field.
 247:    */
 248:   public GregorianCalendar(int year, int month, int day)
 249:   {
 250:     this(TimeZone.getDefault(), Locale.getDefault(), false);
 251:     set(year, month, day);
 252:   }
 253: 
 254:   /**
 255:    * Constructs a new GregorianCalendar representing midnight on the
 256:    * given date with the default time zone and locale.
 257:    *
 258:    * @param year corresponds to the YEAR time field.
 259:    * @param month corresponds to the MONTH time field.
 260:    * @param day corresponds to the DAY time field.
 261:    * @param hour corresponds to the HOUR_OF_DAY time field.
 262:    * @param minute corresponds to the MINUTE time field.
 263:    */
 264:   public GregorianCalendar(int year, int month, int day, int hour, int minute)
 265:   {
 266:     this(TimeZone.getDefault(), Locale.getDefault(), false);
 267:     set(year, month, day, hour, minute);
 268:   }
 269: 
 270:   /**
 271:    * Constructs a new GregorianCalendar representing midnight on the
 272:    * given date with the default time zone and locale.
 273:    *
 274:    * @param year corresponds to the YEAR time field.
 275:    * @param month corresponds to the MONTH time field.
 276:    * @param day corresponds to the DAY time field.
 277:    * @param hour corresponds to the HOUR_OF_DAY time field.
 278:    * @param minute corresponds to the MINUTE time field.
 279:    * @param second corresponds to the SECOND time field.
 280:    */
 281:   public GregorianCalendar(int year, int month, int day, int hour, int minute,
 282:                            int second)
 283:   {
 284:     this(TimeZone.getDefault(), Locale.getDefault(), false);
 285:     set(year, month, day, hour, minute, second);
 286:   }
 287: 
 288:   /**
 289:    * Sets the date of the switch from Julian dates to Gregorian dates.
 290:    * You can use <code>new Date(Long.MAX_VALUE)</code> to use a pure
 291:    * Julian calendar, or <code>Long.MIN_VALUE</code> for a pure Gregorian
 292:    * calendar.
 293:    *
 294:    * @param date the date of the change.
 295:    */
 296:   public void setGregorianChange(Date date)
 297:   {
 298:     gregorianCutover = date.getTime();
 299:   }
 300: 
 301:   /**
 302:    * Gets the date of the switch from Julian dates to Gregorian dates.
 303:    *
 304:    * @return the date of the change.
 305:    */
 306:   public final Date getGregorianChange()
 307:   {
 308:     return new Date(gregorianCutover);
 309:   }
 310: 
 311:   /**
 312:    * <p>
 313:    * Determines if the given year is a leap year.  The result is
 314:    * undefined if the Gregorian change took place in 1800, so that
 315:    * the end of February is skipped, and that year is specified.
 316:    * (well...).
 317:    * </p>
 318:    * <p>
 319:    * To specify a year in the BC era, use a negative value calculated
 320:    * as 1 - y, where y is the required year in BC.  So, 1 BC is 0,
 321:    * 2 BC is -1, 3 BC is -2, etc.
 322:    * </p>
 323:    *
 324:    * @param year a year (use a negative value for BC).
 325:    * @return true, if the given year is a leap year, false otherwise.
 326:    */
 327:   public boolean isLeapYear(int year)
 328:   {
 329:     // Only years divisible by 4 can be leap years
 330:     if ((year & 3) != 0)
 331:       return false;
 332: 
 333:     // Is the leap-day a Julian date? Then it's a leap year
 334:     if (! isGregorian(year, 31 + 29 - 1))
 335:       return true;
 336: 
 337:     // Apply gregorian rules otherwise
 338:     return ((year % 100) != 0 || (year % 400) == 0);
 339:   }
 340: 
 341:   /**
 342:    * Retrieves the day of the week corresponding to the specified
 343:    * day of the specified year.
 344:    *
 345:    * @param year the year in which the dayOfYear occurs.
 346:    * @param dayOfYear the day of the year (an integer between 0 and
 347:    *        and 366)
 348:    */
 349:   private int getWeekDay(int year, int dayOfYear)
 350:   {
 351:     boolean greg = isGregorian(year, dayOfYear);
 352:     int day = (int) getLinearDay(year, dayOfYear, greg);
 353: 
 354:     // The epoch was a thursday.
 355:     int weekday = (day + THURSDAY) % 7;
 356:     if (weekday <= 0)
 357:       weekday += 7;
 358:     return weekday;
 359:   }
 360: 
 361:   /**
 362:    * Returns the day of the week for the first day of a given month (0..11)
 363:    */
 364:   private int getFirstDayOfMonth(int year, int month)
 365:   {
 366:     int[] dayCount = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
 367: 
 368:     if (month > 11)
 369:       {
 370:         year += (month / 12);
 371:         month = month % 12;
 372:       }
 373: 
 374:     if (month < 0)
 375:       {
 376:         year += (int) month / 12;
 377:         month = month % 12;
 378:         if (month < 0)
 379:           {
 380:             month += 12;
 381:             year--;
 382:           }
 383:       }
 384: 
 385:     int dayOfYear = dayCount[month] + 1;
 386:     if (month > 1)
 387:       if (isLeapYear(year))
 388:         dayOfYear++;
 389: 
 390:     boolean greg = isGregorian(year, dayOfYear);
 391:     int day = (int) getLinearDay(year, dayOfYear, greg);
 392: 
 393:     // The epoch was a thursday.
 394:     int weekday = (day + THURSDAY) % 7;
 395:     if (weekday <= 0)
 396:       weekday += 7;
 397:     return weekday;
 398:   }
 399: 
 400:   /**
 401:    * Takes a year, and a (zero based) day of year and determines
 402:    * if it is gregorian or not.
 403:    */
 404:   private boolean isGregorian(int year, int dayOfYear)
 405:   {
 406:     int relativeDay = (year - 1) * 365 + ((year - 1) >> 2) + dayOfYear
 407:                       - EPOCH_DAYS; // gregorian days from 1 to epoch.
 408:     int gregFactor = (int) Math.floor((double) (year - 1) / 400.)
 409:                      - (int) Math.floor((double) (year - 1) / 100.);
 410: 
 411:     return ((relativeDay + gregFactor) * 60L * 60L * 24L * 1000L >= gregorianCutover);
 412:   }
 413: 
 414:   /**
 415:    * Check set fields for validity, without leniency.
 416:    *
 417:    * @throws IllegalArgumentException if a field is invalid
 418:    */
 419:   private void nonLeniencyCheck() throws IllegalArgumentException
 420:   {
 421:     int[] month_days = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 422:     int year = fields[YEAR];
 423:     int month = fields[MONTH];
 424:     int leap = isLeapYear(year) ? 1 : 0;
 425: 
 426:     if (isSet[ERA] && fields[ERA] != AD && fields[ERA] != BC)
 427:       throw new IllegalArgumentException("Illegal ERA.");
 428:     if (isSet[YEAR] && fields[YEAR] < 1)
 429:       throw new IllegalArgumentException("Illegal YEAR.");
 430:     if (isSet[MONTH] && (month < 0 || month > 11))
 431:       throw new IllegalArgumentException("Illegal MONTH.");
 432:     if (isSet[WEEK_OF_YEAR])
 433:       {
 434:         int daysInYear = 365 + leap;
 435:         daysInYear += (getFirstDayOfMonth(year, 0) - 1); // pad first week
 436:         int last = getFirstDayOfMonth(year, 11) + 4;
 437:         if (last > 7)
 438:           last -= 7;
 439:         daysInYear += 7 - last;
 440:         int weeks = daysInYear / 7;
 441:         if (fields[WEEK_OF_YEAR] < 1 || fields[WEEK_OF_YEAR] > weeks)
 442:           throw new IllegalArgumentException("Illegal WEEK_OF_YEAR.");
 443:       }
 444: 
 445:     if (isSet[WEEK_OF_MONTH])
 446:       {
 447:         int weeks = (month == 1 && leap == 0) ? 5 : 6;
 448:         if (fields[WEEK_OF_MONTH] < 1 || fields[WEEK_OF_MONTH] > weeks)
 449:           throw new IllegalArgumentException("Illegal WEEK_OF_MONTH.");
 450:       }
 451: 
 452:     if (isSet[DAY_OF_MONTH])
 453:       if (fields[DAY_OF_MONTH] < 1
 454:           || fields[DAY_OF_MONTH] > month_days[month]
 455:           + ((month == 1) ? leap : 0))
 456:         throw new IllegalArgumentException("Illegal DAY_OF_MONTH.");
 457: 
 458:     if (isSet[DAY_OF_YEAR]
 459:         && (fields[DAY_OF_YEAR] < 1 || fields[DAY_OF_YEAR] > 365 + leap))
 460:       throw new IllegalArgumentException("Illegal DAY_OF_YEAR.");
 461: 
 462:     if (isSet[DAY_OF_WEEK]
 463:         && (fields[DAY_OF_WEEK] < 1 || fields[DAY_OF_WEEK] > 7))
 464:       throw new IllegalArgumentException("Illegal DAY_OF_WEEK.");
 465: 
 466:     if (isSet[DAY_OF_WEEK_IN_MONTH])
 467:       {
 468:         int weeks = (month == 1 && leap == 0) ? 4 : 5;
 469:         if (fields[DAY_OF_WEEK_IN_MONTH] < -weeks
 470:             || fields[DAY_OF_WEEK_IN_MONTH] > weeks)
 471:           throw new IllegalArgumentException("Illegal DAY_OF_WEEK_IN_MONTH.");
 472:       }
 473: 
 474:     if (isSet[AM_PM] && fields[AM_PM] != AM && fields[AM_PM] != PM)
 475:       throw new IllegalArgumentException("Illegal AM_PM.");
 476:     if (isSet[HOUR] && (fields[HOUR] < 0 || fields[HOUR] > 11))
 477:       throw new IllegalArgumentException("Illegal HOUR.");
 478:     if (isSet[HOUR_OF_DAY]
 479:         && (fields[HOUR_OF_DAY] < 0 || fields[HOUR_OF_DAY] > 23))
 480:       throw new IllegalArgumentException("Illegal HOUR_OF_DAY.");
 481:     if (isSet[MINUTE] && (fields[MINUTE] < 0 || fields[MINUTE] > 59))
 482:       throw new IllegalArgumentException("Illegal MINUTE.");
 483:     if (isSet[SECOND] && (fields[SECOND] < 0 || fields[SECOND] > 59))
 484:       throw new IllegalArgumentException("Illegal SECOND.");
 485:     if (isSet[MILLISECOND]
 486:         && (fields[MILLISECOND] < 0 || fields[MILLISECOND] > 999))
 487:       throw new IllegalArgumentException("Illegal MILLISECOND.");
 488:     if (isSet[ZONE_OFFSET]
 489:         && (fields[ZONE_OFFSET] < -12 * 60 * 60 * 1000L
 490:         || fields[ZONE_OFFSET] > 12 * 60 * 60 * 1000L))
 491:       throw new IllegalArgumentException("Illegal ZONE_OFFSET.");
 492:     if (isSet[DST_OFFSET]
 493:         && (fields[DST_OFFSET] < -12 * 60 * 60 * 1000L
 494:         || fields[DST_OFFSET] > 12 * 60 * 60 * 1000L))
 495:       throw new IllegalArgumentException("Illegal DST_OFFSET.");
 496:   }
 497: 
 498:   /**
 499:    * Converts the time field values (<code>fields</code>) to
 500:    * milliseconds since the epoch UTC (<code>time</code>).
 501:    *
 502:    * @throws IllegalArgumentException if any calendar fields
 503:    *         are invalid.
 504:    */
 505:   protected synchronized void computeTime()
 506:   {
 507:     int millisInDay = 0;
 508:     int era = fields[ERA];
 509:     int year = fields[YEAR];
 510:     int month = fields[MONTH];
 511:     int day = fields[DAY_OF_MONTH];
 512: 
 513:     int minute = fields[MINUTE];
 514:     int second = fields[SECOND];
 515:     int millis = fields[MILLISECOND];
 516:     int[] month_days = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 517:     int[] dayCount = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
 518:     int hour = 0;
 519: 
 520:     if (! isLenient())
 521:       nonLeniencyCheck();
 522: 
 523:     if (! isSet[MONTH] && (! isSet[DAY_OF_WEEK] || isSet[WEEK_OF_YEAR]))
 524:       {
 525:         // 5: YEAR + DAY_OF_WEEK + WEEK_OF_YEAR
 526:         if (isSet[WEEK_OF_YEAR])
 527:           {
 528:             int first = getFirstDayOfMonth(year, 0);
 529:             int offs = 1;
 530:             int daysInFirstWeek = getFirstDayOfWeek() - first;
 531:             if (daysInFirstWeek <= 0)
 532:               daysInFirstWeek += 7;
 533: 
 534:             if (daysInFirstWeek < getMinimalDaysInFirstWeek())
 535:               offs += daysInFirstWeek;
 536:             else
 537:               offs -= 7 - daysInFirstWeek;
 538:             month = 0;
 539:             day = offs + 7 * (fields[WEEK_OF_YEAR] - 1);
 540:             offs = fields[DAY_OF_WEEK] - getFirstDayOfWeek();
 541: 
 542:             if (offs < 0)
 543:               offs += 7;
 544:             day += offs;
 545:           }
 546:         else
 547:           {
 548:             // 4:  YEAR + DAY_OF_YEAR
 549:             month = 0;
 550:             day = fields[DAY_OF_YEAR];
 551:           }
 552:       }
 553:     else
 554:       {
 555:         if (isSet[DAY_OF_WEEK])
 556:           {
 557:             int first = getFirstDayOfMonth(year, month);
 558: 
 559:             // 3: YEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK
 560:             if (isSet[DAY_OF_WEEK_IN_MONTH])
 561:               {
 562:                 if (fields[DAY_OF_WEEK_IN_MONTH] < 0)
 563:                   {
 564:                     month++;
 565:                     first = getFirstDayOfMonth(year, month);
 566:                     day = 1 + 7 * (fields[DAY_OF_WEEK_IN_MONTH]);
 567:                   }
 568:                 else
 569:                   day = 1 + 7 * (fields[DAY_OF_WEEK_IN_MONTH] - 1);
 570: 
 571:                 int offs = fields[DAY_OF_WEEK] - first;
 572:                 if (offs < 0)
 573:                   offs += 7;
 574:                 day += offs;
 575:               }
 576:             else
 577:               { // 2: YEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEK
 578:                 int offs = 1;
 579:                 int daysInFirstWeek = getFirstDayOfWeek() - first;
 580:                 if (daysInFirstWeek <= 0)
 581:                   daysInFirstWeek += 7;
 582: 
 583:                 if (daysInFirstWeek < getMinimalDaysInFirstWeek())
 584:                   offs += daysInFirstWeek;
 585:                 else
 586:                   offs -= 7 - daysInFirstWeek;
 587: 
 588:                 day = offs + 7 * (fields[WEEK_OF_MONTH] - 1);
 589:                 offs = fields[DAY_OF_WEEK] - getFirstDayOfWeek();
 590:                 if (offs < 0)
 591:                   offs += 7;
 592:                 day += offs;
 593:               }
 594:           }
 595: 
 596:         // 1:  YEAR + MONTH + DAY_OF_MONTH
 597:       }
 598:     if (era == BC && year > 0)
 599:       year = 1 - year;
 600: 
 601:     // rest of code assumes day/month/year set
 602:     // should negative BC years be AD?
 603:     // get the hour (but no check for validity)
 604:     if (isSet[HOUR])
 605:       {
 606:         hour = fields[HOUR];
 607:         if (fields[AM_PM] == PM)
 608:           hour += 12;
 609:       }
 610:     else
 611:       hour = fields[HOUR_OF_DAY];
 612: 
 613:     // Read the era,year,month,day fields and convert as appropriate.
 614:     // Calculate number of milliseconds into the day
 615:     // This takes care of both h, m, s, ms over/underflows.
 616:     long allMillis = (((hour * 60L) + minute) * 60L + second) * 1000L + millis;
 617:     day += allMillis / (24 * 60 * 60 * 1000L);
 618:     millisInDay = (int) (allMillis % (24 * 60 * 60 * 1000L));
 619: 
 620:     if (month < 0)
 621:       {
 622:         year += (int) month / 12;
 623:         month = month % 12;
 624:         if (month < 0)
 625:           {
 626:             month += 12;
 627:             year--;
 628:           }
 629:       }
 630:     if (month > 11)
 631:       {
 632:         year += (month / 12);
 633:         month = month % 12;
 634:       }
 635: 
 636:     month_days[1] = isLeapYear(year) ? 29 : 28;
 637: 
 638:     while (day <= 0)
 639:       {
 640:         if (month == 0)
 641:           {
 642:             year--;
 643:             month_days[1] = isLeapYear(year) ? 29 : 28;
 644:           }
 645:         month = (month + 11) % 12;
 646:         day += month_days[month];
 647:       }
 648:     while (day > month_days[month])
 649:       {
 650:         day -= (month_days[month]);
 651:         month = (month + 1) % 12;
 652:         if (month == 0)
 653:           {
 654:             year++;
 655:             month_days[1] = isLeapYear(year) ? 29 : 28;
 656:           }
 657:       }
 658: 
 659:     // ok, by here we have valid day,month,year,era and millisinday
 660:     int dayOfYear = dayCount[month] + day - 1; // (day starts on 1)
 661:     if (isLeapYear(year) && month > 1)
 662:       dayOfYear++;
 663: 
 664:     int relativeDay = (year - 1) * 365 + ((year - 1) >> 2) + dayOfYear
 665:                       - EPOCH_DAYS; // gregorian days from 1 to epoch.
 666:     int gregFactor = (int) Math.floor((double) (year - 1) / 400.)
 667:                      - (int) Math.floor((double) (year - 1) / 100.);
 668: 
 669:     if ((relativeDay + gregFactor) * 60L * 60L * 24L * 1000L >= gregorianCutover)
 670:       relativeDay += gregFactor;
 671:     else
 672:       relativeDay -= 2;
 673: 
 674:     time = relativeDay * (24 * 60 * 60 * 1000L) + millisInDay;
 675: 
 676:     // the epoch was a Thursday.
 677:     int weekday = (int) (relativeDay + THURSDAY) % 7;
 678:     if (weekday <= 0)
 679:       weekday += 7;
 680:     fields[DAY_OF_WEEK] = weekday;
 681: 
 682:     // Time zone corrections.
 683:     TimeZone zone = getTimeZone();
 684:     int rawOffset = isSet[ZONE_OFFSET] ? fields[ZONE_OFFSET]
 685:                                        : zone.getRawOffset();
 686: 
 687:     int dstOffset = isSet[DST_OFFSET] ? fields[DST_OFFSET]
 688:                                       : (zone.getOffset((year < 0) ? BC : AD,
 689:                                                         (year < 0) ? 1 - year
 690:                                                                    : year,
 691:                                                         month, day, weekday,
 692:                                                         millisInDay)
 693:                                       - zone.getRawOffset());
 694: 
 695:     time -= rawOffset + dstOffset;
 696: 
 697:     isTimeSet = true;
 698:   }
 699: 
 700:   /**
 701:    * Get the linear day in days since the epoch, using the
 702:    * Julian or Gregorian calendar as specified.  If you specify a
 703:    * nonpositive year it is interpreted as BC as following: 0 is 1
 704:    * BC, -1 is 2 BC and so on.
 705:    *
 706:    * @param year the year of the date.
 707:    * @param dayOfYear the day of year of the date; 1 based.
 708:    * @param gregorian <code>true</code>, if we should use the Gregorian rules.
 709:    * @return the days since the epoch, may be negative.
 710:    */
 711:   private long getLinearDay(int year, int dayOfYear, boolean gregorian)
 712:   {
 713:     // The 13 is the number of days, that were omitted in the Gregorian
 714:     // Calender until the epoch.
 715:     // We shift right by 2 instead of dividing by 4, to get correct
 716:     // results for negative years (and this is even more efficient).
 717:     long julianDay = (year - 1) * 365L + ((year - 1) >> 2) + (dayOfYear - 1)
 718:                      - EPOCH_DAYS; // gregorian days from 1 to epoch.
 719: 
 720:     if (gregorian)
 721:       {
 722:         // subtract the days that are missing in gregorian calendar
 723:         // with respect to julian calendar.
 724:         //
 725:         // Okay, here we rely on the fact that the gregorian
 726:         // calendar was introduced in the AD era.  This doesn't work
 727:         // with negative years.
 728:         //
 729:         // The additional leap year factor accounts for the fact that
 730:         // a leap day is not seen on Jan 1 of the leap year.
 731:         int gregOffset = (int) Math.floor((double) (year - 1) / 400.)
 732:                          - (int) Math.floor((double) (year - 1) / 100.);
 733: 
 734:         return julianDay + gregOffset;
 735:       }
 736:     else
 737:       julianDay -= 2;
 738:     return julianDay;
 739:   }
 740: 
 741:   /**
 742:    * Converts the given linear day into era, year, month,
 743:    * day_of_year, day_of_month, day_of_week, and writes the result
 744:    * into the fields array.
 745:    *
 746:    * @param day the linear day.
 747:    * @param gregorian true, if we should use Gregorian rules.
 748:    */
 749:   private void calculateDay(int[] fields, long day, boolean gregorian)
 750:   {
 751:     // the epoch was a Thursday.
 752:     int weekday = (int) (day + THURSDAY) % 7;
 753:     if (weekday <= 0)
 754:       weekday += 7;
 755:     fields[DAY_OF_WEEK] = weekday;
 756: 
 757:     // get a first approximation of the year.  This may be one
 758:     // year too big.
 759:     int year = 1970
 760:                + (int) (gregorian
 761:                         ? ((day - 100L) * 400L) / (365L * 400L + 100L - 4L
 762:                         + 1L) : ((day - 100L) * 4L) / (365L * 4L + 1L));
 763:     if (day >= 0)
 764:       year++;
 765: 
 766:     long firstDayOfYear = getLinearDay(year, 1, gregorian);
 767: 
 768:     // Now look in which year day really lies.
 769:     if (day < firstDayOfYear)
 770:       {
 771:         year--;
 772:         firstDayOfYear = getLinearDay(year, 1, gregorian);
 773:       }
 774: 
 775:     day -= firstDayOfYear - 1; // day of year,  one based.
 776: 
 777:     fields[DAY_OF_YEAR] = (int) day;
 778:     if (year <= 0)
 779:       {
 780:         fields[ERA] = BC;
 781:         fields[YEAR] = 1 - year;
 782:       }
 783:     else
 784:       {
 785:         fields[ERA] = AD;
 786:         fields[YEAR] = year;
 787:       }
 788: 
 789:     int leapday = isLeapYear(year) ? 1 : 0;
 790:     if (day <= 31 + 28 + leapday)
 791:       {
 792:         fields[MONTH] = (int) day / 32; // 31->JANUARY, 32->FEBRUARY
 793:         fields[DAY_OF_MONTH] = (int) day - 31 * fields[MONTH];
 794:       }
 795:     else
 796:       {
 797:         // A few more magic formulas
 798:         int scaledDay = ((int) day - leapday) * 5 + 8;
 799:         fields[MONTH] = scaledDay / (31 + 30 + 31 + 30 + 31);
 800:         fields[DAY_OF_MONTH] = (scaledDay % (31 + 30 + 31 + 30 + 31)) / 5 + 1;
 801:       }
 802:   }
 803: 
 804:   /**
 805:    * Converts the milliseconds since the epoch UTC
 806:    * (<code>time</code>) to time fields
 807:    * (<code>fields</code>).
 808:    */
 809:   protected synchronized void computeFields()
 810:   {
 811:     boolean gregorian = (time >= gregorianCutover);
 812: 
 813:     TimeZone zone = getTimeZone();
 814:     fields[ZONE_OFFSET] = zone.getRawOffset();
 815:     long localTime = time + fields[ZONE_OFFSET];
 816: 
 817:     long day = localTime / (24 * 60 * 60 * 1000L);
 818:     int millisInDay = (int) (localTime % (24 * 60 * 60 * 1000L));
 819: 
 820:     if (millisInDay < 0)
 821:       {
 822:         millisInDay += (24 * 60 * 60 * 1000);
 823:         day--;
 824:       }
 825: 
 826:     calculateDay(fields, day, gregorian);
 827:     fields[DST_OFFSET] = zone.getOffset(fields[ERA], fields[YEAR],
 828:                                         fields[MONTH], fields[DAY_OF_MONTH],
 829:                                         fields[DAY_OF_WEEK], millisInDay)
 830:                          - fields[ZONE_OFFSET];
 831: 
 832:     millisInDay += fields[DST_OFFSET];
 833:     if (millisInDay >= 24 * 60 * 60 * 1000)
 834:       {
 835:         millisInDay -= 24 * 60 * 60 * 1000;
 836:         calculateDay(fields, ++day, gregorian);
 837:       }
 838: 
 839:     fields[DAY_OF_WEEK_IN_MONTH] = (fields[DAY_OF_MONTH] + 6) / 7;
 840: 
 841:     // which day of the week are we (0..6), relative to getFirstDayOfWeek
 842:     int relativeWeekday = (7 + fields[DAY_OF_WEEK] - getFirstDayOfWeek()) % 7;
 843: 
 844:     // which day of the week is the first of this month?
 845:     // nb 35 is the smallest multiple of 7 that ensures that
 846:     // the left hand side of the modulo operator is positive.
 847:     int relativeWeekdayOfFirst = (relativeWeekday - fields[DAY_OF_MONTH]
 848:                                   + 1 + 35) % 7;
 849: 
 850:     // which week of the month is the first of this month in?
 851:     int minDays = getMinimalDaysInFirstWeek();
 852:     int weekOfFirst = ((7 - relativeWeekdayOfFirst) >= minDays) ? 1 : 0;
 853: 
 854:     // which week of the month is this day in?
 855:     fields[WEEK_OF_MONTH] = (fields[DAY_OF_MONTH]
 856:                              + relativeWeekdayOfFirst - 1) / 7 + weekOfFirst;
 857: 
 858:     int weekOfYear = (fields[DAY_OF_YEAR] - relativeWeekday + 6) / 7;
 859: 
 860:     // Do the Correction: getMinimalDaysInFirstWeek() is always in the
 861:     // first week.
 862:     int firstWeekday = (7 + getWeekDay(fields[YEAR], minDays)
 863:                        - getFirstDayOfWeek()) % 7;
 864:     if (minDays - firstWeekday < 1)
 865:       weekOfYear++;
 866:     fields[WEEK_OF_YEAR] = weekOfYear;
 867: 
 868:     int hourOfDay = millisInDay / (60 * 60 * 1000);
 869:     fields[AM_PM] = (hourOfDay < 12) ? AM : PM;
 870:     int hour = hourOfDay % 12;
 871:     fields[HOUR] = hour;
 872:     fields[HOUR_OF_DAY] = hourOfDay;
 873:     millisInDay %= (60 * 60 * 1000);
 874:     fields[MINUTE] = millisInDay / (60 * 1000);
 875:     millisInDay %= (60 * 1000);
 876:     fields[SECOND] = millisInDay / (1000);
 877:     fields[MILLISECOND] = millisInDay % 1000;
 878: 
 879:     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;
 880:   }
 881: 
 882:   /**
 883:    * Return a hash code for this object, following the general contract
 884:    * specified by {@link Object#hashCode()}.
 885:    * @return the hash code
 886:    */
 887:   public int hashCode()
 888:   {
 889:     int val = (int) ((gregorianCutover >>> 32) ^ (gregorianCutover & 0xffffffff));
 890:     return super.hashCode() ^ val;
 891:   }
 892: 
 893:   /**
 894:    * Compares the given calendar with this.  An object, o, is
 895:    * equivalent to this if it is also a <code>GregorianCalendar</code>
 896:    * with the same time since the epoch under the same conditions
 897:    * (same change date and same time zone).
 898:    *
 899:    * @param o the object to that we should compare.
 900:    * @return true, if the given object is a calendar, that represents
 901:    * the same time (but doesn't necessarily have the same fields).
 902:    * @throws IllegalArgumentException if one of the fields
 903:    *         <code>ZONE_OFFSET</code> or <code>DST_OFFSET</code> is
 904:    *         specified, if an unknown field is specified or if one
 905:    *         of the calendar fields receives an illegal value when
 906:    *         leniancy is not enabled.
 907:    */
 908:   public boolean equals(Object o)
 909:   {
 910:     if (! (o instanceof GregorianCalendar))
 911:       return false;
 912: 
 913:     GregorianCalendar cal = (GregorianCalendar) o;
 914:     return (cal.gregorianCutover == gregorianCutover
 915:             && super.equals(o));
 916:   }
 917: 
 918:   /**
 919:    * Adds the specified amount of time to the given time field.  The
 920:    * amount may be negative to subtract the time.  If the field overflows
 921:    * it does what you expect: Jan, 25 + 10 Days is Feb, 4.
 922:    * @param field one of the time field constants.
 923:    * @param amount the amount of time to add.
 924:    * @exception IllegalArgumentException if <code>field</code> is
 925:    *   <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or invalid; or
 926:    *   if <code>amount</code> contains an out-of-range value and the calendar
 927:    *   is not in lenient mode.
 928:    */
 929:   public void add(int field, int amount)
 930:   {
 931:     switch (field)
 932:       {
 933:       case YEAR:
 934:         complete();
 935:         fields[YEAR] += amount;
 936:         isTimeSet = false;
 937:         break;
 938:       case MONTH:
 939:         complete();
 940:         int months = fields[MONTH] + amount;
 941:         fields[YEAR] += months / 12;
 942:         fields[MONTH] = months % 12;
 943:         if (fields[MONTH] < 0)
 944:           {
 945:             fields[MONTH] += 12;
 946:             fields[YEAR]--;
 947:           }
 948:         int maxDay = getActualMaximum(DAY_OF_MONTH);
 949:         if (fields[DAY_OF_MONTH] > maxDay)
 950:           fields[DAY_OF_MONTH] = maxDay;
 951:         set(YEAR, fields[YEAR]);
 952:         set(MONTH, fields[MONTH]);
 953:         break;
 954:       case DAY_OF_MONTH:
 955:       case DAY_OF_YEAR:
 956:       case DAY_OF_WEEK:
 957:         if (! isTimeSet)
 958:           computeTime();
 959:         time += amount * (24 * 60 * 60 * 1000L);
 960:         areFieldsSet = false;
 961:         break;
 962:       case WEEK_OF_YEAR:
 963:       case WEEK_OF_MONTH:
 964:       case DAY_OF_WEEK_IN_MONTH:
 965:         if (! isTimeSet)
 966:           computeTime();
 967:         time += amount * (7 * 24 * 60 * 60 * 1000L);
 968:         areFieldsSet = false;
 969:         break;
 970:       case AM_PM:
 971:         if (! isTimeSet)
 972:           computeTime();
 973:         time += amount * (12 * 60 * 60 * 1000L);
 974:         areFieldsSet = false;
 975:         break;
 976:       case HOUR:
 977:       case HOUR_OF_DAY:
 978:         if (! isTimeSet)
 979:           computeTime();
 980:         time += amount * (60 * 60 * 1000L);
 981:         areFieldsSet = false;
 982:         break;
 983:       case MINUTE:
 984:         if (! isTimeSet)
 985:           computeTime();
 986:         time += amount * (60 * 1000L);
 987:         areFieldsSet = false;
 988:         break;
 989:       case SECOND:
 990:         if (! isTimeSet)
 991:           computeTime();
 992:         time += amount * (1000L);
 993:         areFieldsSet = false;
 994:         break;
 995:       case MILLISECOND:
 996:         if (! isTimeSet)
 997:           computeTime();
 998:         time += amount;
 999:         areFieldsSet = false;
1000:         break;
1001:       case ZONE_OFFSET:
1002:       case DST_OFFSET:default:
1003:         throw new IllegalArgumentException("Invalid or unknown field");
1004:       }
1005:   }
1006: 
1007:   /**
1008:    * Rolls the specified time field up or down.  This means add one
1009:    * to the specified field, but don't change the other fields.  If
1010:    * the maximum for this field is reached, start over with the
1011:    * minimum value.
1012:    *
1013:    * <strong>Note:</strong> There may be situation, where the other
1014:    * fields must be changed, e.g rolling the month on May, 31.
1015:    * The date June, 31 is automatically converted to July, 1.
1016:    * This requires lenient settings.
1017:    *
1018:    * @param field the time field. One of the time field constants.
1019:    * @param up the direction, true for up, false for down.
1020:    * @throws IllegalArgumentException if one of the fields
1021:    *         <code>ZONE_OFFSET</code> or <code>DST_OFFSET</code> is
1022:    *         specified, if an unknown field is specified or if one
1023:    *         of the calendar fields receives an illegal value when
1024:    *         leniancy is not enabled.
1025:    */
1026:   public void roll(int field, boolean up)
1027:   {
1028:     roll(field, up ? 1 : -1);
1029:   }
1030: 
1031:   /**
1032:    * Checks that the fields are still within their legal bounds,
1033:    * following use of the <code>roll()</code> method.
1034:    *
1035:    * @param field the field to check.
1036:    * @param delta multipler for alterations to the <code>time</code>.
1037:    * @see #roll(int, boolean)
1038:    * @see #roll(int, int)
1039:    */
1040:   private void cleanUpAfterRoll(int field, int delta)
1041:   {
1042:     switch (field)
1043:       {
1044:       case ERA:
1045:       case YEAR:
1046:       case MONTH:
1047:         // check that day of month is still in correct range
1048:         if (fields[DAY_OF_MONTH] > getActualMaximum(DAY_OF_MONTH))
1049:           fields[DAY_OF_MONTH] = getActualMaximum(DAY_OF_MONTH);
1050:         isTimeSet = false;
1051:         isSet[WEEK_OF_MONTH] = false;
1052:         isSet[DAY_OF_WEEK] = false;
1053:         isSet[DAY_OF_WEEK_IN_MONTH] = false;
1054:         isSet[DAY_OF_YEAR] = false;
1055:         isSet[WEEK_OF_YEAR] = false;
1056:         break;
1057:       case DAY_OF_MONTH:
1058:         isSet[WEEK_OF_MONTH] = false;
1059:         isSet[DAY_OF_WEEK] = false;
1060:         isSet[DAY_OF_WEEK_IN_MONTH] = false;
1061:         isSet[DAY_OF_YEAR] = false;
1062:         isSet[WEEK_OF_YEAR] = false;
1063:         time += delta * (24 * 60 * 60 * 1000L);
1064:         break;
1065:       case WEEK_OF_MONTH:
1066:         isSet[DAY_OF_MONTH] = false;
1067:         isSet[DAY_OF_WEEK_IN_MONTH] = false;
1068:         isSet[DAY_OF_YEAR] = false;
1069:         isSet[WEEK_OF_YEAR] = false;
1070:         time += delta * (7 * 24 * 60 * 60 * 1000L);
1071:         break;
1072:       case DAY_OF_WEEK_IN_MONTH:
1073:         isSet[DAY_OF_MONTH] = false;
1074:         isSet[WEEK_OF_MONTH] = false;
1075:         isSet[DAY_OF_YEAR] = false;
1076:         isSet[WEEK_OF_YEAR] = false;
1077:         time += delta * (7 * 24 * 60 * 60 * 1000L);
1078:         break;
1079:       case DAY_OF_YEAR:
1080:         isSet[MONTH] = false;
1081:         isSet[DAY_OF_MONTH] = false;
1082:         isSet[WEEK_OF_MONTH] = false;
1083:         isSet[DAY_OF_WEEK_IN_MONTH] = false;
1084:         isSet[DAY_OF_WEEK] = false;
1085:         isSet[WEEK_OF_YEAR] = false;
1086:         time += delta * (24 * 60 * 60 * 1000L);
1087:         break;
1088:       case WEEK_OF_YEAR:
1089:         isSet[MONTH] = false;
1090:         isSet[DAY_OF_MONTH] = false;
1091:         isSet[WEEK_OF_MONTH] = false;
1092:         isSet[DAY_OF_WEEK_IN_MONTH] = false;
1093:         isSet[DAY_OF_YEAR] = false;
1094:         time += delta * (7 * 24 * 60 * 60 * 1000L);
1095:         break;
1096:       case AM_PM:
1097:         isSet[HOUR_OF_DAY] = false;
1098:         time += delta * (12 * 60 * 60 * 1000L);
1099:         break;
1100:       case HOUR:
1101:         isSet[HOUR_OF_DAY] = false;
1102:         time += delta * (60 * 60 * 1000L);
1103:         break;
1104:       case HOUR_OF_DAY:
1105:         isSet[HOUR] = false;
1106:         isSet[AM_PM] = false;
1107:         time += delta * (60 * 60 * 1000L);
1108:         break;
1109:       case MINUTE:
1110:         time += delta * (60 * 1000L);
1111:         break;
1112:       case SECOND:
1113:         time += delta * (1000L);
1114:         break;
1115:       case MILLISECOND:
1116:         time += delta;
1117:         break;
1118:       }
1119:   }
1120: 
1121:   /**
1122:    * Rolls the specified time field by the given amount.  This means
1123:    * add amount to the specified field, but don't change the other
1124:    * fields.  If the maximum for this field is reached, start over
1125:    * with the minimum value and vice versa for negative amounts.
1126:    *
1127:    * <strong>Note:</strong> There may be situation, where the other
1128:    * fields must be changed, e.g rolling the month on May, 31.
1129:    * The date June, 31 is automatically corrected to June, 30.
1130:    *
1131:    * @param field the time field. One of the time field constants.
1132:    * @param amount the amount by which we should roll.
1133:    * @throws IllegalArgumentException if one of the fields
1134:    *         <code>ZONE_OFFSET</code> or <code>DST_OFFSET</code> is
1135:    *         specified, if an unknown field is specified or if one
1136:    *         of the calendar fields receives an illegal value when
1137:    *         leniancy is not enabled.
1138:    */
1139:   public void roll(int field, int amount)
1140:   {
1141:     switch (field)
1142:       {
1143:       case DAY_OF_WEEK:
1144:         // day of week is special: it rolls automatically
1145:         add(field, amount);
1146:         return;
1147:       case ZONE_OFFSET:
1148:       case DST_OFFSET:
1149:         throw new IllegalArgumentException("Can't roll time zone");
1150:       }
1151:     complete();
1152:     int min = getActualMinimum(field);
1153:     int range = getActualMaximum(field) - min + 1;
1154:     int oldval = fields[field];
1155:     int newval = (oldval - min + range + amount) % range + min;
1156:     if (newval < min)
1157:       newval += range;
1158:     fields[field] = newval;
1159:     cleanUpAfterRoll(field, newval - oldval);
1160:   }
1161: 
1162:   /**
1163:    * The minimum values for the calendar fields.
1164:    */
1165:   private static final int[] minimums =
1166:                                         {
1167:                                           BC, 1, 0, 0, 1, 1, 1, SUNDAY, 1, AM,
1168:                                           1, 0, 0, 0, 0, -(12 * 60 * 60 * 1000),
1169:                                           0
1170:                                         };
1171: 
1172:   /**
1173:    * The maximum values for the calendar fields.
1174:    */
1175:   private static final int[] maximums =
1176:                                         {
1177:                                           AD, 5000000, 11, 53, 6, 31, 366,
1178:                                           SATURDAY, 5, PM, 12, 23, 59, 59, 999,
1179:                                           +(12 * 60 * 60 * 1000),
1180:                                           (12 * 60 * 60 * 1000)
1181:                                         };
1182: 
1183:   /**
1184:    * Gets the smallest value that is allowed for the specified field.
1185:    *
1186:    * @param field one of the time field constants.
1187:    * @return the smallest value for the specified field.
1188:    */
1189:   public int getMinimum(int field)
1190:   {
1191:     return minimums[field];
1192:   }
1193: 
1194:   /**
1195:    * Gets the biggest value that is allowed for the specified field.
1196:    *
1197:    * @param field one of the time field constants.
1198:    * @return the biggest value.
1199:    */
1200:   public int getMaximum(int field)
1201:   {
1202:     return maximums[field];
1203:   }
1204: 
1205:   /**
1206:    * Gets the greatest minimum value that is allowed for the specified field.
1207:    * This is the largest value returned by the <code>getActualMinimum(int)</code>
1208:    * method.
1209:    *
1210:    * @param field the time field. One of the time field constants.
1211:    * @return the greatest minimum value.
1212:    * @see #getActualMinimum(int)
1213:    */
1214:   public int getGreatestMinimum(int field)
1215:   {
1216:     if (field == WEEK_OF_YEAR)
1217:       return 1;
1218:     return minimums[field];
1219:   }
1220: 
1221:   /**
1222:    * Gets the smallest maximum value that is allowed for the
1223:    * specified field.  This is the smallest value returned
1224:    * by the <code>getActualMaximum(int)</code>.  For example,
1225:    * this is 28 for DAY_OF_MONTH (as all months have at least
1226:    * 28 days).
1227:    *
1228:    * @param field the time field. One of the time field constants.
1229:    * @return the least maximum value.
1230:    * @see #getActualMaximum(int)
1231:    * @since 1.2
1232:    */
1233:   public int getLeastMaximum(int field)
1234:   {
1235:     switch (field)
1236:       {
1237:       case WEEK_OF_YEAR:
1238:         return 52;
1239:       case DAY_OF_MONTH:
1240:         return 28;
1241:       case DAY_OF_YEAR:
1242:         return 365;
1243:       case DAY_OF_WEEK_IN_MONTH:
1244:       case WEEK_OF_MONTH:
1245:         return 4;
1246:       default:
1247:         return maximums[field];
1248:       }
1249:   }
1250: 
1251:   /**
1252:    * Gets the actual minimum value that is allowed for the specified field.
1253:    * This value is dependent on the values of the other fields.  Note that
1254:    * this calls <code>complete()</code> if not enough fields are set.  This
1255:    * can have ugly side effects.  The value given depends on the current
1256:    * time used by this instance.
1257:    *
1258:    * @param field the time field. One of the time field constants.
1259:    * @return the actual minimum value.
1260:    * @since 1.2
1261:    */
1262:   public int getActualMinimum(int field)
1263:   {
1264:     if (field == WEEK_OF_YEAR)
1265:       {
1266:         int min = getMinimalDaysInFirstWeek();
1267:         if (min == 0)
1268:           return 1;
1269:         if (! areFieldsSet || ! isSet[ERA] || ! isSet[YEAR])
1270:           complete();
1271: 
1272:         int year = fields[ERA] == AD ? fields[YEAR] : 1 - fields[YEAR];
1273:         int weekday = getWeekDay(year, min);
1274:         if ((7 + weekday - getFirstDayOfWeek()) % 7 >= min - 1)
1275:           return 1;
1276:         return 0;
1277:       }
1278:     return minimums[field];
1279:   }
1280: 
1281:   /**
1282:    * Gets the actual maximum value that is allowed for the specified field.
1283:    * This value is dependent on the values of the other fields.  Note that
1284:    * this calls <code>complete()</code> if not enough fields are set.  This
1285:    * can have ugly side effects.  The value given depends on the current time
1286:    * used by this instance; thus, leap years have a maximum day of month value of
1287:    * 29, rather than 28.
1288:    *
1289:    * @param field the time field. One of the time field constants.
1290:    * @return the actual maximum value.
1291:    */
1292:   public int getActualMaximum(int field)
1293:   {
1294:     switch (field)
1295:       {
1296:       case WEEK_OF_YEAR:
1297:         {
1298:           if (! areFieldsSet || ! isSet[ERA] || ! isSet[YEAR])
1299:             complete();
1300: 
1301:           // This is wrong for the year that contains the gregorian change.
1302:           // I.e it gives the weeks in the julian year or in the gregorian
1303:           // year in that case.
1304:           int year = fields[ERA] == AD ? fields[YEAR] : 1 - fields[YEAR];
1305:           int lastDay = isLeapYear(year) ? 366 : 365;
1306:           int weekday = getWeekDay(year, lastDay);
1307:           int week = (lastDay + 6 - (7 + weekday - getFirstDayOfWeek()) % 7) / 7;
1308: 
1309:           int minimalDays = getMinimalDaysInFirstWeek();
1310:           int firstWeekday = getWeekDay(year, minimalDays);
1311:           /*
1312:            * Is there a set of days at the beginning of the year, before the
1313:            * first day of the week, equal to or greater than the minimum number
1314:            * of days required in the first week?
1315:            */
1316:           if (minimalDays - (7 + firstWeekday - getFirstDayOfWeek()) % 7 < 1)
1317:             return week + 1; /* Add week 1: firstWeekday through to firstDayOfWeek */
1318:         }
1319:       case DAY_OF_MONTH:
1320:         {
1321:           if (! areFieldsSet || ! isSet[MONTH])
1322:             complete();
1323:           int month = fields[MONTH];
1324: 
1325:           // If you change this, you should also change
1326:           // SimpleTimeZone.getDaysInMonth();
1327:           if (month == FEBRUARY)
1328:             {
1329:               if (! isSet[YEAR] || ! isSet[ERA])
1330:                 complete();
1331:               int year = fields[ERA] == AD ? fields[YEAR] : 1 - fields[YEAR];
1332:               return isLeapYear(year) ? 29 : 28;
1333:             }
1334:           else if (month < AUGUST)
1335:             return 31 - (month & 1);
1336:           else
1337:             return 30 + (month & 1);
1338:         }
1339:       case DAY_OF_YEAR:
1340:         {
1341:           if (! areFieldsSet || ! isSet[ERA] || ! isSet[YEAR])
1342:             complete();
1343:           int year = fields[ERA] == AD ? fields[YEAR] : 1 - fields[YEAR];
1344:           return isLeapYear(year) ? 366 : 365;
1345:         }
1346:       case DAY_OF_WEEK_IN_MONTH:
1347:         {
1348:           // This is wrong for the month that contains the gregorian change.
1349:           int daysInMonth = getActualMaximum(DAY_OF_MONTH);
1350: 
1351:           // That's black magic, I know
1352:           return (daysInMonth - (fields[DAY_OF_MONTH] - 1) % 7 + 6) / 7;
1353:         }
1354:       case WEEK_OF_MONTH:
1355:         {
1356:           int daysInMonth = getActualMaximum(DAY_OF_MONTH);
1357:           int weekday = (daysInMonth - fields[DAY_OF_MONTH]
1358:                         + fields[DAY_OF_WEEK] - SUNDAY) % 7 + SUNDAY;
1359:           return (daysInMonth + 6 - (7 + weekday - getFirstDayOfWeek()) % 7) / 7;
1360:         }
1361:       default:
1362:         return maximums[field];
1363:       }
1364:   }
1365: }