Robust/src/ClassLibrary/MGC/gnu/GregorianCalendar.java

   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 }