--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.base/share/classes/java/util/GregorianCalendar.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,3298 @@
+/*
+ * Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * (C) Copyright Taligent, Inc. 1996-1998 - All Rights Reserved
+ * (C) Copyright IBM Corp. 1996-1998 - All Rights Reserved
+ *
+ * The original version of this source code and documentation is copyrighted
+ * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
+ * materials are provided under terms of a License Agreement between Taligent
+ * and Sun. This technology is protected by multiple US and International
+ * patents. This notice and attribution to Taligent may not be removed.
+ * Taligent is a registered trademark of Taligent, Inc.
+ *
+ */
+
+package java.util;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.time.Instant;
+import java.time.ZonedDateTime;
+import java.time.temporal.ChronoField;
+import sun.util.calendar.BaseCalendar;
+import sun.util.calendar.CalendarDate;
+import sun.util.calendar.CalendarSystem;
+import sun.util.calendar.CalendarUtils;
+import sun.util.calendar.Era;
+import sun.util.calendar.Gregorian;
+import sun.util.calendar.JulianCalendar;
+import sun.util.calendar.ZoneInfo;
+
+/**
+ * <code>GregorianCalendar</code> is a concrete subclass of
+ * <code>Calendar</code> and provides the standard calendar system
+ * used by most of the world.
+ *
+ * <p> <code>GregorianCalendar</code> is a hybrid calendar that
+ * supports both the Julian and Gregorian calendar systems with the
+ * support of a single discontinuity, which corresponds by default to
+ * the Gregorian date when the Gregorian calendar was instituted
+ * (October 15, 1582 in some countries, later in others). The cutover
+ * date may be changed by the caller by calling {@link
+ * #setGregorianChange(Date) setGregorianChange()}.
+ *
+ * <p>
+ * Historically, in those countries which adopted the Gregorian calendar first,
+ * October 4, 1582 (Julian) was thus followed by October 15, 1582 (Gregorian). This calendar models
+ * this correctly. Before the Gregorian cutover, <code>GregorianCalendar</code>
+ * implements the Julian calendar. The only difference between the Gregorian
+ * and the Julian calendar is the leap year rule. The Julian calendar specifies
+ * leap years every four years, whereas the Gregorian calendar omits century
+ * years which are not divisible by 400.
+ *
+ * <p>
+ * <code>GregorianCalendar</code> implements <em>proleptic</em> Gregorian and
+ * Julian calendars. That is, dates are computed by extrapolating the current
+ * rules indefinitely far backward and forward in time. As a result,
+ * <code>GregorianCalendar</code> may be used for all years to generate
+ * meaningful and consistent results. However, dates obtained using
+ * <code>GregorianCalendar</code> are historically accurate only from March 1, 4
+ * AD onward, when modern Julian calendar rules were adopted. Before this date,
+ * leap year rules were applied irregularly, and before 45 BC the Julian
+ * calendar did not even exist.
+ *
+ * <p>
+ * Prior to the institution of the Gregorian calendar, New Year's Day was
+ * March 25. To avoid confusion, this calendar always uses January 1. A manual
+ * adjustment may be made if desired for dates that are prior to the Gregorian
+ * changeover and which fall between January 1 and March 24.
+ *
+ * <h3><a id="week_and_year">Week Of Year and Week Year</a></h3>
+ *
+ * <p>Values calculated for the {@link Calendar#WEEK_OF_YEAR
+ * WEEK_OF_YEAR} field range from 1 to 53. The first week of a
+ * calendar year is the earliest seven day period starting on {@link
+ * Calendar#getFirstDayOfWeek() getFirstDayOfWeek()} that contains at
+ * least {@link Calendar#getMinimalDaysInFirstWeek()
+ * getMinimalDaysInFirstWeek()} days from that year. It thus depends
+ * on the values of {@code getMinimalDaysInFirstWeek()}, {@code
+ * getFirstDayOfWeek()}, and the day of the week of January 1. Weeks
+ * between week 1 of one year and week 1 of the following year
+ * (exclusive) are numbered sequentially from 2 to 52 or 53 (except
+ * for year(s) involved in the Julian-Gregorian transition).
+ *
+ * <p>The {@code getFirstDayOfWeek()} and {@code
+ * getMinimalDaysInFirstWeek()} values are initialized using
+ * locale-dependent resources when constructing a {@code
+ * GregorianCalendar}. <a id="iso8601_compatible_setting">The week
+ * determination is compatible</a> with the ISO 8601 standard when {@code
+ * getFirstDayOfWeek()} is {@code MONDAY} and {@code
+ * getMinimalDaysInFirstWeek()} is 4, which values are used in locales
+ * where the standard is preferred. These values can explicitly be set by
+ * calling {@link Calendar#setFirstDayOfWeek(int) setFirstDayOfWeek()} and
+ * {@link Calendar#setMinimalDaysInFirstWeek(int)
+ * setMinimalDaysInFirstWeek()}.
+ *
+ * <p>A <a id="week_year"><em>week year</em></a> is in sync with a
+ * {@code WEEK_OF_YEAR} cycle. All weeks between the first and last
+ * weeks (inclusive) have the same <em>week year</em> value.
+ * Therefore, the first and last days of a week year may have
+ * different calendar year values.
+ *
+ * <p>For example, January 1, 1998 is a Thursday. If {@code
+ * getFirstDayOfWeek()} is {@code MONDAY} and {@code
+ * getMinimalDaysInFirstWeek()} is 4 (ISO 8601 standard compatible
+ * setting), then week 1 of 1998 starts on December 29, 1997, and ends
+ * on January 4, 1998. The week year is 1998 for the last three days
+ * of calendar year 1997. If, however, {@code getFirstDayOfWeek()} is
+ * {@code SUNDAY}, then week 1 of 1998 starts on January 4, 1998, and
+ * ends on January 10, 1998; the first three days of 1998 then are
+ * part of week 53 of 1997 and their week year is 1997.
+ *
+ * <h4>Week Of Month</h4>
+ *
+ * <p>Values calculated for the <code>WEEK_OF_MONTH</code> field range from 0
+ * to 6. Week 1 of a month (the days with <code>WEEK_OF_MONTH =
+ * 1</code>) is the earliest set of at least
+ * <code>getMinimalDaysInFirstWeek()</code> contiguous days in that month,
+ * ending on the day before <code>getFirstDayOfWeek()</code>. Unlike
+ * week 1 of a year, week 1 of a month may be shorter than 7 days, need
+ * not start on <code>getFirstDayOfWeek()</code>, and will not include days of
+ * the previous month. Days of a month before week 1 have a
+ * <code>WEEK_OF_MONTH</code> of 0.
+ *
+ * <p>For example, if <code>getFirstDayOfWeek()</code> is <code>SUNDAY</code>
+ * and <code>getMinimalDaysInFirstWeek()</code> is 4, then the first week of
+ * January 1998 is Sunday, January 4 through Saturday, January 10. These days
+ * have a <code>WEEK_OF_MONTH</code> of 1. Thursday, January 1 through
+ * Saturday, January 3 have a <code>WEEK_OF_MONTH</code> of 0. If
+ * <code>getMinimalDaysInFirstWeek()</code> is changed to 3, then January 1
+ * through January 3 have a <code>WEEK_OF_MONTH</code> of 1.
+ *
+ * <h4>Default Fields Values</h4>
+ *
+ * <p>The <code>clear</code> method sets calendar field(s)
+ * undefined. <code>GregorianCalendar</code> uses the following
+ * default value for each calendar field if its value is undefined.
+ *
+ * <table class="striped" style="text-align: left; width: 66%;">
+ * <caption style="display:none">GregorianCalendar default field values</caption>
+ * <thead>
+ * <tr>
+ * <th scope="col">
+ * Field
+ * </th>
+ * <th scope="col">
+ Default Value
+ * </th>
+ * </tr>
+ * </thead>
+ * <tbody>
+ * <tr>
+ * <th scope="row">
+ * <code>ERA</code>
+ * </th>
+ * <td>
+ * <code>AD</code>
+ * </td>
+ * </tr>
+ * <tr>
+ * <th scope="row">
+ * <code>YEAR</code>
+ * </th>
+ * <td>
+ * <code>1970</code>
+ * </td>
+ * </tr>
+ * <tr>
+ * <th scope="row">
+ * <code>MONTH</code>
+ * </th>
+ * <td>
+ * <code>JANUARY</code>
+ * </td>
+ * </tr>
+ * <tr>
+ * <th scope="row">
+ * <code>DAY_OF_MONTH</code>
+ * </th>
+ * <td>
+ * <code>1</code>
+ * </td>
+ * </tr>
+ * <tr>
+ * <th scope="row">
+ * <code>DAY_OF_WEEK</code>
+ * </th>
+ * <td>
+ * <code>the first day of week</code>
+ * </td>
+ * </tr>
+ * <tr>
+ * <th scope="row">
+ * <code>WEEK_OF_MONTH</code>
+ * </th>
+ * <td>
+ * <code>0</code>
+ * </td>
+ * </tr>
+ * <tr>
+ * <th scope="row">
+ * <code>DAY_OF_WEEK_IN_MONTH</code>
+ * </th>
+ * <td>
+ * <code>1</code>
+ * </td>
+ * </tr>
+ * <tr>
+ * <th scope="row">
+ * <code>AM_PM</code>
+ * </th>
+ * <td>
+ * <code>AM</code>
+ * </td>
+ * </tr>
+ * <tr>
+ * <th scope="row">
+ * <code>HOUR, HOUR_OF_DAY, MINUTE, SECOND, MILLISECOND</code>
+ * </th>
+ * <td>
+ * <code>0</code>
+ * </td>
+ * </tr>
+ * </tbody>
+ * </table>
+ * <br>Default values are not applicable for the fields not listed above.
+ *
+ * <p>
+ * <strong>Example:</strong>
+ * <blockquote>
+ * <pre>
+ * // get the supported ids for GMT-08:00 (Pacific Standard Time)
+ * String[] ids = TimeZone.getAvailableIDs(-8 * 60 * 60 * 1000);
+ * // if no ids were returned, something is wrong. get out.
+ * if (ids.length == 0)
+ * System.exit(0);
+ *
+ * // begin output
+ * System.out.println("Current Time");
+ *
+ * // create a Pacific Standard Time time zone
+ * SimpleTimeZone pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, ids[0]);
+ *
+ * // set up rules for Daylight Saving Time
+ * pdt.setStartRule(Calendar.APRIL, 1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
+ * pdt.setEndRule(Calendar.OCTOBER, -1, Calendar.SUNDAY, 2 * 60 * 60 * 1000);
+ *
+ * // create a GregorianCalendar with the Pacific Daylight time zone
+ * // and the current date and time
+ * Calendar calendar = new GregorianCalendar(pdt);
+ * Date trialTime = new Date();
+ * calendar.setTime(trialTime);
+ *
+ * // print out a bunch of interesting things
+ * System.out.println("ERA: " + calendar.get(Calendar.ERA));
+ * System.out.println("YEAR: " + calendar.get(Calendar.YEAR));
+ * System.out.println("MONTH: " + calendar.get(Calendar.MONTH));
+ * System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR));
+ * System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH));
+ * System.out.println("DATE: " + calendar.get(Calendar.DATE));
+ * System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH));
+ * System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR));
+ * System.out.println("DAY_OF_WEEK: " + calendar.get(Calendar.DAY_OF_WEEK));
+ * System.out.println("DAY_OF_WEEK_IN_MONTH: "
+ * + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));
+ * System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM));
+ * System.out.println("HOUR: " + calendar.get(Calendar.HOUR));
+ * System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY));
+ * System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE));
+ * System.out.println("SECOND: " + calendar.get(Calendar.SECOND));
+ * System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND));
+ * System.out.println("ZONE_OFFSET: "
+ * + (calendar.get(Calendar.ZONE_OFFSET)/(60*60*1000)));
+ * System.out.println("DST_OFFSET: "
+ * + (calendar.get(Calendar.DST_OFFSET)/(60*60*1000)));
+
+ * System.out.println("Current Time, with hour reset to 3");
+ * calendar.clear(Calendar.HOUR_OF_DAY); // so doesn't override
+ * calendar.set(Calendar.HOUR, 3);
+ * System.out.println("ERA: " + calendar.get(Calendar.ERA));
+ * System.out.println("YEAR: " + calendar.get(Calendar.YEAR));
+ * System.out.println("MONTH: " + calendar.get(Calendar.MONTH));
+ * System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR));
+ * System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH));
+ * System.out.println("DATE: " + calendar.get(Calendar.DATE));
+ * System.out.println("DAY_OF_MONTH: " + calendar.get(Calendar.DAY_OF_MONTH));
+ * System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR));
+ * System.out.println("DAY_OF_WEEK: " + calendar.get(Calendar.DAY_OF_WEEK));
+ * System.out.println("DAY_OF_WEEK_IN_MONTH: "
+ * + calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));
+ * System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM));
+ * System.out.println("HOUR: " + calendar.get(Calendar.HOUR));
+ * System.out.println("HOUR_OF_DAY: " + calendar.get(Calendar.HOUR_OF_DAY));
+ * System.out.println("MINUTE: " + calendar.get(Calendar.MINUTE));
+ * System.out.println("SECOND: " + calendar.get(Calendar.SECOND));
+ * System.out.println("MILLISECOND: " + calendar.get(Calendar.MILLISECOND));
+ * System.out.println("ZONE_OFFSET: "
+ * + (calendar.get(Calendar.ZONE_OFFSET)/(60*60*1000))); // in hours
+ * System.out.println("DST_OFFSET: "
+ * + (calendar.get(Calendar.DST_OFFSET)/(60*60*1000))); // in hours
+ * </pre>
+ * </blockquote>
+ *
+ * @see TimeZone
+ * @author David Goldsmith, Mark Davis, Chen-Lieh Huang, Alan Liu
+ * @since 1.1
+ */
+public class GregorianCalendar extends Calendar {
+ /*
+ * Implementation Notes
+ *
+ * The epoch is the number of days or milliseconds from some defined
+ * starting point. The epoch for java.util.Date is used here; that is,
+ * milliseconds from January 1, 1970 (Gregorian), midnight UTC. Other
+ * epochs which are used are January 1, year 1 (Gregorian), which is day 1
+ * of the Gregorian calendar, and December 30, year 0 (Gregorian), which is
+ * day 1 of the Julian calendar.
+ *
+ * We implement the proleptic Julian and Gregorian calendars. This means we
+ * implement the modern definition of the calendar even though the
+ * historical usage differs. For example, if the Gregorian change is set
+ * to new Date(Long.MIN_VALUE), we have a pure Gregorian calendar which
+ * labels dates preceding the invention of the Gregorian calendar in 1582 as
+ * if the calendar existed then.
+ *
+ * Likewise, with the Julian calendar, we assume a consistent
+ * 4-year leap year rule, even though the historical pattern of
+ * leap years is irregular, being every 3 years from 45 BCE
+ * through 9 BCE, then every 4 years from 8 CE onwards, with no
+ * leap years in-between. Thus date computations and functions
+ * such as isLeapYear() are not intended to be historically
+ * accurate.
+ */
+
+//////////////////
+// Class Variables
+//////////////////
+
+ /**
+ * Value of the <code>ERA</code> field indicating
+ * the period before the common era (before Christ), also known as BCE.
+ * The sequence of years at the transition from <code>BC</code> to <code>AD</code> is
+ * ..., 2 BC, 1 BC, 1 AD, 2 AD,...
+ *
+ * @see #ERA
+ */
+ public static final int BC = 0;
+
+ /**
+ * Value of the {@link #ERA} field indicating
+ * the period before the common era, the same value as {@link #BC}.
+ *
+ * @see #CE
+ */
+ static final int BCE = 0;
+
+ /**
+ * Value of the <code>ERA</code> field indicating
+ * the common era (Anno Domini), also known as CE.
+ * The sequence of years at the transition from <code>BC</code> to <code>AD</code> is
+ * ..., 2 BC, 1 BC, 1 AD, 2 AD,...
+ *
+ * @see #ERA
+ */
+ public static final int AD = 1;
+
+ /**
+ * Value of the {@link #ERA} field indicating
+ * the common era, the same value as {@link #AD}.
+ *
+ * @see #BCE
+ */
+ static final int CE = 1;
+
+ private static final int EPOCH_OFFSET = 719163; // Fixed date of January 1, 1970 (Gregorian)
+ private static final int EPOCH_YEAR = 1970;
+
+ static final int MONTH_LENGTH[]
+ = {31,28,31,30,31,30,31,31,30,31,30,31}; // 0-based
+ static final int LEAP_MONTH_LENGTH[]
+ = {31,29,31,30,31,30,31,31,30,31,30,31}; // 0-based
+
+ // Useful millisecond constants. Although ONE_DAY and ONE_WEEK can fit
+ // into ints, they must be longs in order to prevent arithmetic overflow
+ // when performing (bug 4173516).
+ private static final int ONE_SECOND = 1000;
+ private static final int ONE_MINUTE = 60*ONE_SECOND;
+ private static final int ONE_HOUR = 60*ONE_MINUTE;
+ private static final long ONE_DAY = 24*ONE_HOUR;
+ private static final long ONE_WEEK = 7*ONE_DAY;
+
+ /*
+ * <pre>
+ * Greatest Least
+ * Field name Minimum Minimum Maximum Maximum
+ * ---------- ------- ------- ------- -------
+ * ERA 0 0 1 1
+ * YEAR 1 1 292269054 292278994
+ * MONTH 0 0 11 11
+ * WEEK_OF_YEAR 1 1 52* 53
+ * WEEK_OF_MONTH 0 0 4* 6
+ * DAY_OF_MONTH 1 1 28* 31
+ * DAY_OF_YEAR 1 1 365* 366
+ * DAY_OF_WEEK 1 1 7 7
+ * DAY_OF_WEEK_IN_MONTH 1 1 4* 6
+ * AM_PM 0 0 1 1
+ * HOUR 0 0 11 11
+ * HOUR_OF_DAY 0 0 23 23
+ * MINUTE 0 0 59 59
+ * SECOND 0 0 59 59
+ * MILLISECOND 0 0 999 999
+ * ZONE_OFFSET -13:00 -13:00 14:00 14:00
+ * DST_OFFSET 0:00 0:00 0:20 2:00
+ * </pre>
+ * *: depends on the Gregorian change date
+ */
+ static final int MIN_VALUES[] = {
+ BCE, // ERA
+ 1, // YEAR
+ JANUARY, // MONTH
+ 1, // WEEK_OF_YEAR
+ 0, // WEEK_OF_MONTH
+ 1, // DAY_OF_MONTH
+ 1, // DAY_OF_YEAR
+ SUNDAY, // DAY_OF_WEEK
+ 1, // DAY_OF_WEEK_IN_MONTH
+ AM, // AM_PM
+ 0, // HOUR
+ 0, // HOUR_OF_DAY
+ 0, // MINUTE
+ 0, // SECOND
+ 0, // MILLISECOND
+ -13*ONE_HOUR, // ZONE_OFFSET (UNIX compatibility)
+ 0 // DST_OFFSET
+ };
+ static final int LEAST_MAX_VALUES[] = {
+ CE, // ERA
+ 292269054, // YEAR
+ DECEMBER, // MONTH
+ 52, // WEEK_OF_YEAR
+ 4, // WEEK_OF_MONTH
+ 28, // DAY_OF_MONTH
+ 365, // DAY_OF_YEAR
+ SATURDAY, // DAY_OF_WEEK
+ 4, // DAY_OF_WEEK_IN
+ PM, // AM_PM
+ 11, // HOUR
+ 23, // HOUR_OF_DAY
+ 59, // MINUTE
+ 59, // SECOND
+ 999, // MILLISECOND
+ 14*ONE_HOUR, // ZONE_OFFSET
+ 20*ONE_MINUTE // DST_OFFSET (historical least maximum)
+ };
+ static final int MAX_VALUES[] = {
+ CE, // ERA
+ 292278994, // YEAR
+ DECEMBER, // MONTH
+ 53, // WEEK_OF_YEAR
+ 6, // WEEK_OF_MONTH
+ 31, // DAY_OF_MONTH
+ 366, // DAY_OF_YEAR
+ SATURDAY, // DAY_OF_WEEK
+ 6, // DAY_OF_WEEK_IN
+ PM, // AM_PM
+ 11, // HOUR
+ 23, // HOUR_OF_DAY
+ 59, // MINUTE
+ 59, // SECOND
+ 999, // MILLISECOND
+ 14*ONE_HOUR, // ZONE_OFFSET
+ 2*ONE_HOUR // DST_OFFSET (double summer time)
+ };
+
+ // Proclaim serialization compatibility with JDK 1.1
+ @SuppressWarnings("FieldNameHidesFieldInSuperclass")
+ static final long serialVersionUID = -8125100834729963327L;
+
+ // Reference to the sun.util.calendar.Gregorian instance (singleton).
+ private static final Gregorian gcal =
+ CalendarSystem.getGregorianCalendar();
+
+ // Reference to the JulianCalendar instance (singleton), set as needed. See
+ // getJulianCalendarSystem().
+ private static JulianCalendar jcal;
+
+ // JulianCalendar eras. See getJulianCalendarSystem().
+ private static Era[] jeras;
+
+ // The default value of gregorianCutover.
+ static final long DEFAULT_GREGORIAN_CUTOVER = -12219292800000L;
+
+/////////////////////
+// Instance Variables
+/////////////////////
+
+ /**
+ * The point at which the Gregorian calendar rules are used, measured in
+ * milliseconds from the standard epoch. Default is October 15, 1582
+ * (Gregorian) 00:00:00 UTC or -12219292800000L. For this value, October 4,
+ * 1582 (Julian) is followed by October 15, 1582 (Gregorian). This
+ * corresponds to Julian day number 2299161.
+ * @serial
+ */
+ private long gregorianCutover = DEFAULT_GREGORIAN_CUTOVER;
+
+ /**
+ * The fixed date of the gregorianCutover.
+ */
+ private transient long gregorianCutoverDate =
+ (((DEFAULT_GREGORIAN_CUTOVER + 1)/ONE_DAY) - 1) + EPOCH_OFFSET; // == 577736
+
+ /**
+ * The normalized year of the gregorianCutover in Gregorian, with
+ * 0 representing 1 BCE, -1 representing 2 BCE, etc.
+ */
+ private transient int gregorianCutoverYear = 1582;
+
+ /**
+ * The normalized year of the gregorianCutover in Julian, with 0
+ * representing 1 BCE, -1 representing 2 BCE, etc.
+ */
+ private transient int gregorianCutoverYearJulian = 1582;
+
+ /**
+ * gdate always has a sun.util.calendar.Gregorian.Date instance to
+ * avoid overhead of creating it. The assumption is that most
+ * applications will need only Gregorian calendar calculations.
+ */
+ private transient BaseCalendar.Date gdate;
+
+ /**
+ * Reference to either gdate or a JulianCalendar.Date
+ * instance. After calling complete(), this value is guaranteed to
+ * be set.
+ */
+ private transient BaseCalendar.Date cdate;
+
+ /**
+ * The CalendarSystem used to calculate the date in cdate. After
+ * calling complete(), this value is guaranteed to be set and
+ * consistent with the cdate value.
+ */
+ private transient BaseCalendar calsys;
+
+ /**
+ * Temporary int[2] to get time zone offsets. zoneOffsets[0] gets
+ * the GMT offset value and zoneOffsets[1] gets the DST saving
+ * value.
+ */
+ private transient int[] zoneOffsets;
+
+ /**
+ * Temporary storage for saving original fields[] values in
+ * non-lenient mode.
+ */
+ private transient int[] originalFields;
+
+///////////////
+// Constructors
+///////////////
+
+ /**
+ * Constructs a default <code>GregorianCalendar</code> using the current time
+ * in the default time zone with the default
+ * {@link Locale.Category#FORMAT FORMAT} locale.
+ */
+ public GregorianCalendar() {
+ this(TimeZone.getDefaultRef(), Locale.getDefault(Locale.Category.FORMAT));
+ setZoneShared(true);
+ }
+
+ /**
+ * Constructs a <code>GregorianCalendar</code> based on the current time
+ * in the given time zone with the default
+ * {@link Locale.Category#FORMAT FORMAT} locale.
+ *
+ * @param zone the given time zone.
+ */
+ public GregorianCalendar(TimeZone zone) {
+ this(zone, Locale.getDefault(Locale.Category.FORMAT));
+ }
+
+ /**
+ * Constructs a <code>GregorianCalendar</code> based on the current time
+ * in the default time zone with the given locale.
+ *
+ * @param aLocale the given locale.
+ */
+ public GregorianCalendar(Locale aLocale) {
+ this(TimeZone.getDefaultRef(), aLocale);
+ setZoneShared(true);
+ }
+
+ /**
+ * Constructs a <code>GregorianCalendar</code> based on the current time
+ * in the given time zone with the given locale.
+ *
+ * @param zone the given time zone.
+ * @param aLocale the given locale.
+ */
+ public GregorianCalendar(TimeZone zone, Locale aLocale) {
+ super(zone, aLocale);
+ gdate = (BaseCalendar.Date) gcal.newCalendarDate(zone);
+ setTimeInMillis(System.currentTimeMillis());
+ }
+
+ /**
+ * Constructs a <code>GregorianCalendar</code> with the given date set
+ * in the default time zone with the default locale.
+ *
+ * @param year the value used to set the <code>YEAR</code> calendar field in the calendar.
+ * @param month the value used to set the <code>MONTH</code> calendar field in the calendar.
+ * Month value is 0-based. e.g., 0 for January.
+ * @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar.
+ */
+ public GregorianCalendar(int year, int month, int dayOfMonth) {
+ this(year, month, dayOfMonth, 0, 0, 0, 0);
+ }
+
+ /**
+ * Constructs a <code>GregorianCalendar</code> with the given date
+ * and time set for the default time zone with the default locale.
+ *
+ * @param year the value used to set the <code>YEAR</code> calendar field in the calendar.
+ * @param month the value used to set the <code>MONTH</code> calendar field in the calendar.
+ * Month value is 0-based. e.g., 0 for January.
+ * @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar.
+ * @param hourOfDay the value used to set the <code>HOUR_OF_DAY</code> calendar field
+ * in the calendar.
+ * @param minute the value used to set the <code>MINUTE</code> calendar field
+ * in the calendar.
+ */
+ public GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay,
+ int minute) {
+ this(year, month, dayOfMonth, hourOfDay, minute, 0, 0);
+ }
+
+ /**
+ * Constructs a GregorianCalendar with the given date
+ * and time set for the default time zone with the default locale.
+ *
+ * @param year the value used to set the <code>YEAR</code> calendar field in the calendar.
+ * @param month the value used to set the <code>MONTH</code> calendar field in the calendar.
+ * Month value is 0-based. e.g., 0 for January.
+ * @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar.
+ * @param hourOfDay the value used to set the <code>HOUR_OF_DAY</code> calendar field
+ * in the calendar.
+ * @param minute the value used to set the <code>MINUTE</code> calendar field
+ * in the calendar.
+ * @param second the value used to set the <code>SECOND</code> calendar field
+ * in the calendar.
+ */
+ public GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay,
+ int minute, int second) {
+ this(year, month, dayOfMonth, hourOfDay, minute, second, 0);
+ }
+
+ /**
+ * Constructs a <code>GregorianCalendar</code> with the given date
+ * and time set for the default time zone with the default locale.
+ *
+ * @param year the value used to set the <code>YEAR</code> calendar field in the calendar.
+ * @param month the value used to set the <code>MONTH</code> calendar field in the calendar.
+ * Month value is 0-based. e.g., 0 for January.
+ * @param dayOfMonth the value used to set the <code>DAY_OF_MONTH</code> calendar field in the calendar.
+ * @param hourOfDay the value used to set the <code>HOUR_OF_DAY</code> calendar field
+ * in the calendar.
+ * @param minute the value used to set the <code>MINUTE</code> calendar field
+ * in the calendar.
+ * @param second the value used to set the <code>SECOND</code> calendar field
+ * in the calendar.
+ * @param millis the value used to set the <code>MILLISECOND</code> calendar field
+ */
+ GregorianCalendar(int year, int month, int dayOfMonth,
+ int hourOfDay, int minute, int second, int millis) {
+ super();
+ gdate = (BaseCalendar.Date) gcal.newCalendarDate(getZone());
+ this.set(YEAR, year);
+ this.set(MONTH, month);
+ this.set(DAY_OF_MONTH, dayOfMonth);
+
+ // Set AM_PM and HOUR here to set their stamp values before
+ // setting HOUR_OF_DAY (6178071).
+ if (hourOfDay >= 12 && hourOfDay <= 23) {
+ // If hourOfDay is a valid PM hour, set the correct PM values
+ // so that it won't throw an exception in case it's set to
+ // non-lenient later.
+ this.internalSet(AM_PM, PM);
+ this.internalSet(HOUR, hourOfDay - 12);
+ } else {
+ // The default value for AM_PM is AM.
+ // We don't care any out of range value here for leniency.
+ this.internalSet(HOUR, hourOfDay);
+ }
+ // The stamp values of AM_PM and HOUR must be COMPUTED. (6440854)
+ setFieldsComputed(HOUR_MASK|AM_PM_MASK);
+
+ this.set(HOUR_OF_DAY, hourOfDay);
+ this.set(MINUTE, minute);
+ this.set(SECOND, second);
+ // should be changed to set() when this constructor is made
+ // public.
+ this.internalSet(MILLISECOND, millis);
+ }
+
+ /**
+ * Constructs an empty GregorianCalendar.
+ *
+ * @param zone the given time zone
+ * @param aLocale the given locale
+ * @param flag the flag requesting an empty instance
+ */
+ GregorianCalendar(TimeZone zone, Locale locale, boolean flag) {
+ super(zone, locale);
+ gdate = (BaseCalendar.Date) gcal.newCalendarDate(getZone());
+ }
+
+/////////////////
+// Public methods
+/////////////////
+
+ /**
+ * Sets the <code>GregorianCalendar</code> change date. This is the point when the switch
+ * from Julian dates to Gregorian dates occurred. Default is October 15,
+ * 1582 (Gregorian). Previous to this, dates will be in the Julian calendar.
+ * <p>
+ * To obtain a pure Julian calendar, set the change date to
+ * <code>Date(Long.MAX_VALUE)</code>. To obtain a pure Gregorian calendar,
+ * set the change date to <code>Date(Long.MIN_VALUE)</code>.
+ *
+ * @param date the given Gregorian cutover date.
+ */
+ public void setGregorianChange(Date date) {
+ long cutoverTime = date.getTime();
+ if (cutoverTime == gregorianCutover) {
+ return;
+ }
+ // Before changing the cutover date, make sure to have the
+ // time of this calendar.
+ complete();
+ setGregorianChange(cutoverTime);
+ }
+
+ private void setGregorianChange(long cutoverTime) {
+ gregorianCutover = cutoverTime;
+ gregorianCutoverDate = CalendarUtils.floorDivide(cutoverTime, ONE_DAY)
+ + EPOCH_OFFSET;
+
+ // To provide the "pure" Julian calendar as advertised.
+ // Strictly speaking, the last millisecond should be a
+ // Gregorian date. However, the API doc specifies that setting
+ // the cutover date to Long.MAX_VALUE will make this calendar
+ // a pure Julian calendar. (See 4167995)
+ if (cutoverTime == Long.MAX_VALUE) {
+ gregorianCutoverDate++;
+ }
+
+ BaseCalendar.Date d = getGregorianCutoverDate();
+
+ // Set the cutover year (in the Gregorian year numbering)
+ gregorianCutoverYear = d.getYear();
+
+ BaseCalendar julianCal = getJulianCalendarSystem();
+ d = (BaseCalendar.Date) julianCal.newCalendarDate(TimeZone.NO_TIMEZONE);
+ julianCal.getCalendarDateFromFixedDate(d, gregorianCutoverDate - 1);
+ gregorianCutoverYearJulian = d.getNormalizedYear();
+
+ if (time < gregorianCutover) {
+ // The field values are no longer valid under the new
+ // cutover date.
+ setUnnormalized();
+ }
+ }
+
+ /**
+ * Gets the Gregorian Calendar change date. This is the point when the
+ * switch from Julian dates to Gregorian dates occurred. Default is
+ * October 15, 1582 (Gregorian). Previous to this, dates will be in the Julian
+ * calendar.
+ *
+ * @return the Gregorian cutover date for this <code>GregorianCalendar</code> object.
+ */
+ public final Date getGregorianChange() {
+ return new Date(gregorianCutover);
+ }
+
+ /**
+ * Determines if the given year is a leap year. Returns <code>true</code> if
+ * the given year is a leap year. To specify BC year numbers,
+ * <code>1 - year number</code> must be given. For example, year BC 4 is
+ * specified as -3.
+ *
+ * @param year the given year.
+ * @return <code>true</code> if the given year is a leap year; <code>false</code> otherwise.
+ */
+ public boolean isLeapYear(int year) {
+ if ((year & 3) != 0) {
+ return false;
+ }
+
+ if (year > gregorianCutoverYear) {
+ return (year%100 != 0) || (year%400 == 0); // Gregorian
+ }
+ if (year < gregorianCutoverYearJulian) {
+ return true; // Julian
+ }
+ boolean gregorian;
+ // If the given year is the Gregorian cutover year, we need to
+ // determine which calendar system to be applied to February in the year.
+ if (gregorianCutoverYear == gregorianCutoverYearJulian) {
+ BaseCalendar.Date d = getCalendarDate(gregorianCutoverDate); // Gregorian
+ gregorian = d.getMonth() < BaseCalendar.MARCH;
+ } else {
+ gregorian = year == gregorianCutoverYear;
+ }
+ return gregorian ? (year%100 != 0) || (year%400 == 0) : true;
+ }
+
+ /**
+ * Returns {@code "gregory"} as the calendar type.
+ *
+ * @return {@code "gregory"}
+ * @since 1.8
+ */
+ @Override
+ public String getCalendarType() {
+ return "gregory";
+ }
+
+ /**
+ * Compares this <code>GregorianCalendar</code> to the specified
+ * <code>Object</code>. The result is <code>true</code> if and
+ * only if the argument is a <code>GregorianCalendar</code> object
+ * that represents the same time value (millisecond offset from
+ * the <a href="Calendar.html#Epoch">Epoch</a>) under the same
+ * <code>Calendar</code> parameters and Gregorian change date as
+ * this object.
+ *
+ * @param obj the object to compare with.
+ * @return <code>true</code> if this object is equal to <code>obj</code>;
+ * <code>false</code> otherwise.
+ * @see Calendar#compareTo(Calendar)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ return obj instanceof GregorianCalendar &&
+ super.equals(obj) &&
+ gregorianCutover == ((GregorianCalendar)obj).gregorianCutover;
+ }
+
+ /**
+ * Generates the hash code for this <code>GregorianCalendar</code> object.
+ */
+ @Override
+ public int hashCode() {
+ return super.hashCode() ^ (int)gregorianCutoverDate;
+ }
+
+ /**
+ * Adds the specified (signed) amount of time to the given calendar field,
+ * based on the calendar's rules.
+ *
+ * <p><em>Add rule 1</em>. The value of <code>field</code>
+ * after the call minus the value of <code>field</code> before the
+ * call is <code>amount</code>, modulo any overflow that has occurred in
+ * <code>field</code>. Overflow occurs when a field value exceeds its
+ * range and, as a result, the next larger field is incremented or
+ * decremented and the field value is adjusted back into its range.</p>
+ *
+ * <p><em>Add rule 2</em>. If a smaller field is expected to be
+ * invariant, but it is impossible for it to be equal to its
+ * prior value because of changes in its minimum or maximum after
+ * <code>field</code> is changed, then its value is adjusted to be as close
+ * as possible to its expected value. A smaller field represents a
+ * smaller unit of time. <code>HOUR</code> is a smaller field than
+ * <code>DAY_OF_MONTH</code>. No adjustment is made to smaller fields
+ * that are not expected to be invariant. The calendar system
+ * determines what fields are expected to be invariant.</p>
+ *
+ * @param field the calendar field.
+ * @param amount the amount of date or time to be added to the field.
+ * @exception IllegalArgumentException if <code>field</code> is
+ * <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or unknown,
+ * or if any calendar fields have out-of-range values in
+ * non-lenient mode.
+ */
+ @Override
+ public void add(int field, int amount) {
+ // If amount == 0, do nothing even the given field is out of
+ // range. This is tested by JCK.
+ if (amount == 0) {
+ return; // Do nothing!
+ }
+
+ if (field < 0 || field >= ZONE_OFFSET) {
+ throw new IllegalArgumentException();
+ }
+
+ // Sync the time and calendar fields.
+ complete();
+
+ if (field == YEAR) {
+ int year = internalGet(YEAR);
+ if (internalGetEra() == CE) {
+ year += amount;
+ if (year > 0) {
+ set(YEAR, year);
+ } else { // year <= 0
+ set(YEAR, 1 - year);
+ // if year == 0, you get 1 BCE.
+ set(ERA, BCE);
+ }
+ }
+ else { // era == BCE
+ year -= amount;
+ if (year > 0) {
+ set(YEAR, year);
+ } else { // year <= 0
+ set(YEAR, 1 - year);
+ // if year == 0, you get 1 CE
+ set(ERA, CE);
+ }
+ }
+ pinDayOfMonth();
+ } else if (field == MONTH) {
+ int month = internalGet(MONTH) + amount;
+ int year = internalGet(YEAR);
+ int y_amount;
+
+ if (month >= 0) {
+ y_amount = month/12;
+ } else {
+ y_amount = (month+1)/12 - 1;
+ }
+ if (y_amount != 0) {
+ if (internalGetEra() == CE) {
+ year += y_amount;
+ if (year > 0) {
+ set(YEAR, year);
+ } else { // year <= 0
+ set(YEAR, 1 - year);
+ // if year == 0, you get 1 BCE
+ set(ERA, BCE);
+ }
+ }
+ else { // era == BCE
+ year -= y_amount;
+ if (year > 0) {
+ set(YEAR, year);
+ } else { // year <= 0
+ set(YEAR, 1 - year);
+ // if year == 0, you get 1 CE
+ set(ERA, CE);
+ }
+ }
+ }
+
+ if (month >= 0) {
+ set(MONTH, month % 12);
+ } else {
+ // month < 0
+ month %= 12;
+ if (month < 0) {
+ month += 12;
+ }
+ set(MONTH, JANUARY + month);
+ }
+ pinDayOfMonth();
+ } else if (field == ERA) {
+ int era = internalGet(ERA) + amount;
+ if (era < 0) {
+ era = 0;
+ }
+ if (era > 1) {
+ era = 1;
+ }
+ set(ERA, era);
+ } else {
+ long delta = amount;
+ long timeOfDay = 0;
+ switch (field) {
+ // Handle the time fields here. Convert the given
+ // amount to milliseconds and call setTimeInMillis.
+ case HOUR:
+ case HOUR_OF_DAY:
+ delta *= 60 * 60 * 1000; // hours to minutes
+ break;
+
+ case MINUTE:
+ delta *= 60 * 1000; // minutes to seconds
+ break;
+
+ case SECOND:
+ delta *= 1000; // seconds to milliseconds
+ break;
+
+ case MILLISECOND:
+ break;
+
+ // Handle week, day and AM_PM fields which involves
+ // time zone offset change adjustment. Convert the
+ // given amount to the number of days.
+ case WEEK_OF_YEAR:
+ case WEEK_OF_MONTH:
+ case DAY_OF_WEEK_IN_MONTH:
+ delta *= 7;
+ break;
+
+ case DAY_OF_MONTH: // synonym of DATE
+ case DAY_OF_YEAR:
+ case DAY_OF_WEEK:
+ break;
+
+ case AM_PM:
+ // Convert the amount to the number of days (delta)
+ // and +12 or -12 hours (timeOfDay).
+ delta = amount / 2;
+ timeOfDay = 12 * (amount % 2);
+ break;
+ }
+
+ // The time fields don't require time zone offset change
+ // adjustment.
+ if (field >= HOUR) {
+ setTimeInMillis(time + delta);
+ return;
+ }
+
+ // The rest of the fields (week, day or AM_PM fields)
+ // require time zone offset (both GMT and DST) change
+ // adjustment.
+
+ // Translate the current time to the fixed date and time
+ // of the day.
+ long fd = getCurrentFixedDate();
+ timeOfDay += internalGet(HOUR_OF_DAY);
+ timeOfDay *= 60;
+ timeOfDay += internalGet(MINUTE);
+ timeOfDay *= 60;
+ timeOfDay += internalGet(SECOND);
+ timeOfDay *= 1000;
+ timeOfDay += internalGet(MILLISECOND);
+ if (timeOfDay >= ONE_DAY) {
+ fd++;
+ timeOfDay -= ONE_DAY;
+ } else if (timeOfDay < 0) {
+ fd--;
+ timeOfDay += ONE_DAY;
+ }
+
+ fd += delta; // fd is the expected fixed date after the calculation
+ int zoneOffset = internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET);
+ setTimeInMillis((fd - EPOCH_OFFSET) * ONE_DAY + timeOfDay - zoneOffset);
+ zoneOffset -= internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET);
+ // If the time zone offset has changed, then adjust the difference.
+ if (zoneOffset != 0) {
+ setTimeInMillis(time + zoneOffset);
+ long fd2 = getCurrentFixedDate();
+ // If the adjustment has changed the date, then take
+ // the previous one.
+ if (fd2 != fd) {
+ setTimeInMillis(time - zoneOffset);
+ }
+ }
+ }
+ }
+
+ /**
+ * Adds or subtracts (up/down) a single unit of time on the given time
+ * field without changing larger fields.
+ * <p>
+ * <em>Example</em>: Consider a <code>GregorianCalendar</code>
+ * originally set to December 31, 1999. Calling {@link #roll(int,boolean) roll(Calendar.MONTH, true)}
+ * sets the calendar to January 31, 1999. The <code>YEAR</code> field is unchanged
+ * because it is a larger field than <code>MONTH</code>.</p>
+ *
+ * @param up indicates if the value of the specified calendar field is to be
+ * rolled up or rolled down. Use <code>true</code> if rolling up, <code>false</code> otherwise.
+ * @exception IllegalArgumentException if <code>field</code> is
+ * <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or unknown,
+ * or if any calendar fields have out-of-range values in
+ * non-lenient mode.
+ * @see #add(int,int)
+ * @see #set(int,int)
+ */
+ @Override
+ public void roll(int field, boolean up) {
+ roll(field, up ? +1 : -1);
+ }
+
+ /**
+ * Adds a signed amount to the specified calendar field without changing larger fields.
+ * A negative roll amount means to subtract from field without changing
+ * larger fields. If the specified amount is 0, this method performs nothing.
+ *
+ * <p>This method calls {@link #complete()} before adding the
+ * amount so that all the calendar fields are normalized. If there
+ * is any calendar field having an out-of-range value in non-lenient mode, then an
+ * <code>IllegalArgumentException</code> is thrown.
+ *
+ * <p>
+ * <em>Example</em>: Consider a <code>GregorianCalendar</code>
+ * originally set to August 31, 1999. Calling <code>roll(Calendar.MONTH,
+ * 8)</code> sets the calendar to April 30, <strong>1999</strong>. Using a
+ * <code>GregorianCalendar</code>, the <code>DAY_OF_MONTH</code> field cannot
+ * be 31 in the month April. <code>DAY_OF_MONTH</code> is set to the closest possible
+ * value, 30. The <code>YEAR</code> field maintains the value of 1999 because it
+ * is a larger field than <code>MONTH</code>.
+ * <p>
+ * <em>Example</em>: Consider a <code>GregorianCalendar</code>
+ * originally set to Sunday June 6, 1999. Calling
+ * <code>roll(Calendar.WEEK_OF_MONTH, -1)</code> sets the calendar to
+ * Tuesday June 1, 1999, whereas calling
+ * <code>add(Calendar.WEEK_OF_MONTH, -1)</code> sets the calendar to
+ * Sunday May 30, 1999. This is because the roll rule imposes an
+ * additional constraint: The <code>MONTH</code> must not change when the
+ * <code>WEEK_OF_MONTH</code> is rolled. Taken together with add rule 1,
+ * the resultant date must be between Tuesday June 1 and Saturday June
+ * 5. According to add rule 2, the <code>DAY_OF_WEEK</code>, an invariant
+ * when changing the <code>WEEK_OF_MONTH</code>, is set to Tuesday, the
+ * closest possible value to Sunday (where Sunday is the first day of the
+ * week).</p>
+ *
+ * @param field the calendar field.
+ * @param amount the signed amount to add to <code>field</code>.
+ * @exception IllegalArgumentException if <code>field</code> is
+ * <code>ZONE_OFFSET</code>, <code>DST_OFFSET</code>, or unknown,
+ * or if any calendar fields have out-of-range values in
+ * non-lenient mode.
+ * @see #roll(int,boolean)
+ * @see #add(int,int)
+ * @see #set(int,int)
+ * @since 1.2
+ */
+ @Override
+ public void roll(int field, int amount) {
+ // If amount == 0, do nothing even the given field is out of
+ // range. This is tested by JCK.
+ if (amount == 0) {
+ return;
+ }
+
+ if (field < 0 || field >= ZONE_OFFSET) {
+ throw new IllegalArgumentException();
+ }
+
+ // Sync the time and calendar fields.
+ complete();
+
+ int min = getMinimum(field);
+ int max = getMaximum(field);
+
+ switch (field) {
+ case AM_PM:
+ case ERA:
+ case YEAR:
+ case MINUTE:
+ case SECOND:
+ case MILLISECOND:
+ // These fields are handled simply, since they have fixed minima
+ // and maxima. The field DAY_OF_MONTH is almost as simple. Other
+ // fields are complicated, since the range within they must roll
+ // varies depending on the date.
+ break;
+
+ case HOUR:
+ case HOUR_OF_DAY:
+ {
+ int rolledValue = getRolledValue(internalGet(field), amount, min, max);
+ int hourOfDay = rolledValue;
+ if (field == HOUR && internalGet(AM_PM) == PM) {
+ hourOfDay += 12;
+ }
+
+ // Create the current date/time value to perform wall-clock-based
+ // roll.
+ CalendarDate d = calsys.getCalendarDate(time, getZone());
+ d.setHours(hourOfDay);
+ time = calsys.getTime(d);
+
+ // If we stay on the same wall-clock time, try the next or previous hour.
+ if (internalGet(HOUR_OF_DAY) == d.getHours()) {
+ hourOfDay = getRolledValue(rolledValue, amount > 0 ? +1 : -1, min, max);
+ if (field == HOUR && internalGet(AM_PM) == PM) {
+ hourOfDay += 12;
+ }
+ d.setHours(hourOfDay);
+ time = calsys.getTime(d);
+ }
+ // Get the new hourOfDay value which might have changed due to a DST transition.
+ hourOfDay = d.getHours();
+ // Update the hour related fields
+ internalSet(HOUR_OF_DAY, hourOfDay);
+ internalSet(AM_PM, hourOfDay / 12);
+ internalSet(HOUR, hourOfDay % 12);
+
+ // Time zone offset and/or daylight saving might have changed.
+ int zoneOffset = d.getZoneOffset();
+ int saving = d.getDaylightSaving();
+ internalSet(ZONE_OFFSET, zoneOffset - saving);
+ internalSet(DST_OFFSET, saving);
+ return;
+ }
+
+ case MONTH:
+ // Rolling the month involves both pinning the final value to [0, 11]
+ // and adjusting the DAY_OF_MONTH if necessary. We only adjust the
+ // DAY_OF_MONTH if, after updating the MONTH field, it is illegal.
+ // E.g., <jan31>.roll(MONTH, 1) -> <feb28> or <feb29>.
+ {
+ if (!isCutoverYear(cdate.getNormalizedYear())) {
+ int mon = (internalGet(MONTH) + amount) % 12;
+ if (mon < 0) {
+ mon += 12;
+ }
+ set(MONTH, mon);
+
+ // Keep the day of month in the range. We don't want to spill over
+ // into the next month; e.g., we don't want jan31 + 1 mo -> feb31 ->
+ // mar3.
+ int monthLen = monthLength(mon);
+ if (internalGet(DAY_OF_MONTH) > monthLen) {
+ set(DAY_OF_MONTH, monthLen);
+ }
+ } else {
+ // We need to take care of different lengths in
+ // year and month due to the cutover.
+ int yearLength = getActualMaximum(MONTH) + 1;
+ int mon = (internalGet(MONTH) + amount) % yearLength;
+ if (mon < 0) {
+ mon += yearLength;
+ }
+ set(MONTH, mon);
+ int monthLen = getActualMaximum(DAY_OF_MONTH);
+ if (internalGet(DAY_OF_MONTH) > monthLen) {
+ set(DAY_OF_MONTH, monthLen);
+ }
+ }
+ return;
+ }
+
+ case WEEK_OF_YEAR:
+ {
+ int y = cdate.getNormalizedYear();
+ max = getActualMaximum(WEEK_OF_YEAR);
+ set(DAY_OF_WEEK, internalGet(DAY_OF_WEEK));
+ int woy = internalGet(WEEK_OF_YEAR);
+ int value = woy + amount;
+ if (!isCutoverYear(y)) {
+ int weekYear = getWeekYear();
+ if (weekYear == y) {
+ // If the new value is in between min and max
+ // (exclusive), then we can use the value.
+ if (value > min && value < max) {
+ set(WEEK_OF_YEAR, value);
+ return;
+ }
+ long fd = getCurrentFixedDate();
+ // Make sure that the min week has the current DAY_OF_WEEK
+ // in the calendar year
+ long day1 = fd - (7 * (woy - min));
+ if (calsys.getYearFromFixedDate(day1) != y) {
+ min++;
+ }
+
+ // Make sure the same thing for the max week
+ fd += 7 * (max - internalGet(WEEK_OF_YEAR));
+ if (calsys.getYearFromFixedDate(fd) != y) {
+ max--;
+ }
+ } else {
+ // When WEEK_OF_YEAR and YEAR are out of sync,
+ // adjust woy and amount to stay in the calendar year.
+ if (weekYear > y) {
+ if (amount < 0) {
+ amount++;
+ }
+ woy = max;
+ } else {
+ if (amount > 0) {
+ amount -= woy - max;
+ }
+ woy = min;
+ }
+ }
+ set(field, getRolledValue(woy, amount, min, max));
+ return;
+ }
+
+ // Handle cutover here.
+ long fd = getCurrentFixedDate();
+ BaseCalendar cal;
+ if (gregorianCutoverYear == gregorianCutoverYearJulian) {
+ cal = getCutoverCalendarSystem();
+ } else if (y == gregorianCutoverYear) {
+ cal = gcal;
+ } else {
+ cal = getJulianCalendarSystem();
+ }
+ long day1 = fd - (7 * (woy - min));
+ // Make sure that the min week has the current DAY_OF_WEEK
+ if (cal.getYearFromFixedDate(day1) != y) {
+ min++;
+ }
+
+ // Make sure the same thing for the max week
+ fd += 7 * (max - woy);
+ cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem();
+ if (cal.getYearFromFixedDate(fd) != y) {
+ max--;
+ }
+ // value: the new WEEK_OF_YEAR which must be converted
+ // to month and day of month.
+ value = getRolledValue(woy, amount, min, max) - 1;
+ BaseCalendar.Date d = getCalendarDate(day1 + value * 7);
+ set(MONTH, d.getMonth() - 1);
+ set(DAY_OF_MONTH, d.getDayOfMonth());
+ return;
+ }
+
+ case WEEK_OF_MONTH:
+ {
+ boolean isCutoverYear = isCutoverYear(cdate.getNormalizedYear());
+ // dow: relative day of week from first day of week
+ int dow = internalGet(DAY_OF_WEEK) - getFirstDayOfWeek();
+ if (dow < 0) {
+ dow += 7;
+ }
+
+ long fd = getCurrentFixedDate();
+ long month1; // fixed date of the first day (usually 1) of the month
+ int monthLength; // actual month length
+ if (isCutoverYear) {
+ month1 = getFixedDateMonth1(cdate, fd);
+ monthLength = actualMonthLength();
+ } else {
+ month1 = fd - internalGet(DAY_OF_MONTH) + 1;
+ monthLength = calsys.getMonthLength(cdate);
+ }
+
+ // the first day of week of the month.
+ long monthDay1st = BaseCalendar.getDayOfWeekDateOnOrBefore(month1 + 6,
+ getFirstDayOfWeek());
+ // if the week has enough days to form a week, the
+ // week starts from the previous month.
+ if ((int)(monthDay1st - month1) >= getMinimalDaysInFirstWeek()) {
+ monthDay1st -= 7;
+ }
+ max = getActualMaximum(field);
+
+ // value: the new WEEK_OF_MONTH value
+ int value = getRolledValue(internalGet(field), amount, 1, max) - 1;
+
+ // nfd: fixed date of the rolled date
+ long nfd = monthDay1st + value * 7 + dow;
+
+ // Unlike WEEK_OF_YEAR, we need to change day of week if the
+ // nfd is out of the month.
+ if (nfd < month1) {
+ nfd = month1;
+ } else if (nfd >= (month1 + monthLength)) {
+ nfd = month1 + monthLength - 1;
+ }
+ int dayOfMonth;
+ if (isCutoverYear) {
+ // If we are in the cutover year, convert nfd to
+ // its calendar date and use dayOfMonth.
+ BaseCalendar.Date d = getCalendarDate(nfd);
+ dayOfMonth = d.getDayOfMonth();
+ } else {
+ dayOfMonth = (int)(nfd - month1) + 1;
+ }
+ set(DAY_OF_MONTH, dayOfMonth);
+ return;
+ }
+
+ case DAY_OF_MONTH:
+ {
+ if (!isCutoverYear(cdate.getNormalizedYear())) {
+ max = calsys.getMonthLength(cdate);
+ break;
+ }
+
+ // Cutover year handling
+ long fd = getCurrentFixedDate();
+ long month1 = getFixedDateMonth1(cdate, fd);
+ // It may not be a regular month. Convert the date and range to
+ // the relative values, perform the roll, and
+ // convert the result back to the rolled date.
+ int value = getRolledValue((int)(fd - month1), amount, 0, actualMonthLength() - 1);
+ BaseCalendar.Date d = getCalendarDate(month1 + value);
+ assert d.getMonth()-1 == internalGet(MONTH);
+ set(DAY_OF_MONTH, d.getDayOfMonth());
+ return;
+ }
+
+ case DAY_OF_YEAR:
+ {
+ max = getActualMaximum(field);
+ if (!isCutoverYear(cdate.getNormalizedYear())) {
+ break;
+ }
+
+ // Handle cutover here.
+ long fd = getCurrentFixedDate();
+ long jan1 = fd - internalGet(DAY_OF_YEAR) + 1;
+ int value = getRolledValue((int)(fd - jan1) + 1, amount, min, max);
+ BaseCalendar.Date d = getCalendarDate(jan1 + value - 1);
+ set(MONTH, d.getMonth() - 1);
+ set(DAY_OF_MONTH, d.getDayOfMonth());
+ return;
+ }
+
+ case DAY_OF_WEEK:
+ {
+ if (!isCutoverYear(cdate.getNormalizedYear())) {
+ // If the week of year is in the same year, we can
+ // just change DAY_OF_WEEK.
+ int weekOfYear = internalGet(WEEK_OF_YEAR);
+ if (weekOfYear > 1 && weekOfYear < 52) {
+ set(WEEK_OF_YEAR, weekOfYear); // update stamp[WEEK_OF_YEAR]
+ max = SATURDAY;
+ break;
+ }
+ }
+
+ // We need to handle it in a different way around year
+ // boundaries and in the cutover year. Note that
+ // changing era and year values violates the roll
+ // rule: not changing larger calendar fields...
+ amount %= 7;
+ if (amount == 0) {
+ return;
+ }
+ long fd = getCurrentFixedDate();
+ long dowFirst = BaseCalendar.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek());
+ fd += amount;
+ if (fd < dowFirst) {
+ fd += 7;
+ } else if (fd >= dowFirst + 7) {
+ fd -= 7;
+ }
+ BaseCalendar.Date d = getCalendarDate(fd);
+ set(ERA, (d.getNormalizedYear() <= 0 ? BCE : CE));
+ set(d.getYear(), d.getMonth() - 1, d.getDayOfMonth());
+ return;
+ }
+
+ case DAY_OF_WEEK_IN_MONTH:
+ {
+ min = 1; // after normalized, min should be 1.
+ if (!isCutoverYear(cdate.getNormalizedYear())) {
+ int dom = internalGet(DAY_OF_MONTH);
+ int monthLength = calsys.getMonthLength(cdate);
+ int lastDays = monthLength % 7;
+ max = monthLength / 7;
+ int x = (dom - 1) % 7;
+ if (x < lastDays) {
+ max++;
+ }
+ set(DAY_OF_WEEK, internalGet(DAY_OF_WEEK));
+ break;
+ }
+
+ // Cutover year handling
+ long fd = getCurrentFixedDate();
+ long month1 = getFixedDateMonth1(cdate, fd);
+ int monthLength = actualMonthLength();
+ int lastDays = monthLength % 7;
+ max = monthLength / 7;
+ int x = (int)(fd - month1) % 7;
+ if (x < lastDays) {
+ max++;
+ }
+ int value = getRolledValue(internalGet(field), amount, min, max) - 1;
+ fd = month1 + value * 7 + x;
+ BaseCalendar cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem();
+ BaseCalendar.Date d = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.NO_TIMEZONE);
+ cal.getCalendarDateFromFixedDate(d, fd);
+ set(DAY_OF_MONTH, d.getDayOfMonth());
+ return;
+ }
+ }
+
+ set(field, getRolledValue(internalGet(field), amount, min, max));
+ }
+
+ /**
+ * Returns the minimum value for the given calendar field of this
+ * <code>GregorianCalendar</code> instance. The minimum value is
+ * defined as the smallest value returned by the {@link
+ * Calendar#get(int) get} method for any possible time value,
+ * taking into consideration the current values of the
+ * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
+ * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
+ * {@link #getGregorianChange() getGregorianChange} and
+ * {@link Calendar#getTimeZone() getTimeZone} methods.
+ *
+ * @param field the calendar field.
+ * @return the minimum value for the given calendar field.
+ * @see #getMaximum(int)
+ * @see #getGreatestMinimum(int)
+ * @see #getLeastMaximum(int)
+ * @see #getActualMinimum(int)
+ * @see #getActualMaximum(int)
+ */
+ @Override
+ public int getMinimum(int field) {
+ return MIN_VALUES[field];
+ }
+
+ /**
+ * Returns the maximum value for the given calendar field of this
+ * <code>GregorianCalendar</code> instance. The maximum value is
+ * defined as the largest value returned by the {@link
+ * Calendar#get(int) get} method for any possible time value,
+ * taking into consideration the current values of the
+ * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
+ * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
+ * {@link #getGregorianChange() getGregorianChange} and
+ * {@link Calendar#getTimeZone() getTimeZone} methods.
+ *
+ * @param field the calendar field.
+ * @return the maximum value for the given calendar field.
+ * @see #getMinimum(int)
+ * @see #getGreatestMinimum(int)
+ * @see #getLeastMaximum(int)
+ * @see #getActualMinimum(int)
+ * @see #getActualMaximum(int)
+ */
+ @Override
+ public int getMaximum(int field) {
+ switch (field) {
+ case MONTH:
+ case DAY_OF_MONTH:
+ case DAY_OF_YEAR:
+ case WEEK_OF_YEAR:
+ case WEEK_OF_MONTH:
+ case DAY_OF_WEEK_IN_MONTH:
+ case YEAR:
+ {
+ // On or after Gregorian 200-3-1, Julian and Gregorian
+ // calendar dates are the same or Gregorian dates are
+ // larger (i.e., there is a "gap") after 300-3-1.
+ if (gregorianCutoverYear > 200) {
+ break;
+ }
+ // There might be "overlapping" dates.
+ GregorianCalendar gc = (GregorianCalendar) clone();
+ gc.setLenient(true);
+ gc.setTimeInMillis(gregorianCutover);
+ int v1 = gc.getActualMaximum(field);
+ gc.setTimeInMillis(gregorianCutover-1);
+ int v2 = gc.getActualMaximum(field);
+ return Math.max(MAX_VALUES[field], Math.max(v1, v2));
+ }
+ }
+ return MAX_VALUES[field];
+ }
+
+ /**
+ * Returns the highest minimum value for the given calendar field
+ * of this <code>GregorianCalendar</code> instance. The highest
+ * minimum value is defined as the largest value returned by
+ * {@link #getActualMinimum(int)} for any possible time value,
+ * taking into consideration the current values of the
+ * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
+ * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
+ * {@link #getGregorianChange() getGregorianChange} and
+ * {@link Calendar#getTimeZone() getTimeZone} methods.
+ *
+ * @param field the calendar field.
+ * @return the highest minimum value for the given calendar field.
+ * @see #getMinimum(int)
+ * @see #getMaximum(int)
+ * @see #getLeastMaximum(int)
+ * @see #getActualMinimum(int)
+ * @see #getActualMaximum(int)
+ */
+ @Override
+ public int getGreatestMinimum(int field) {
+ if (field == DAY_OF_MONTH) {
+ BaseCalendar.Date d = getGregorianCutoverDate();
+ long mon1 = getFixedDateMonth1(d, gregorianCutoverDate);
+ d = getCalendarDate(mon1);
+ return Math.max(MIN_VALUES[field], d.getDayOfMonth());
+ }
+ return MIN_VALUES[field];
+ }
+
+ /**
+ * Returns the lowest maximum value for the given calendar field
+ * of this <code>GregorianCalendar</code> instance. The lowest
+ * maximum value is defined as the smallest value returned by
+ * {@link #getActualMaximum(int)} for any possible time value,
+ * taking into consideration the current values of the
+ * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
+ * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
+ * {@link #getGregorianChange() getGregorianChange} and
+ * {@link Calendar#getTimeZone() getTimeZone} methods.
+ *
+ * @param field the calendar field
+ * @return the lowest maximum value for the given calendar field.
+ * @see #getMinimum(int)
+ * @see #getMaximum(int)
+ * @see #getGreatestMinimum(int)
+ * @see #getActualMinimum(int)
+ * @see #getActualMaximum(int)
+ */
+ @Override
+ public int getLeastMaximum(int field) {
+ switch (field) {
+ case MONTH:
+ case DAY_OF_MONTH:
+ case DAY_OF_YEAR:
+ case WEEK_OF_YEAR:
+ case WEEK_OF_MONTH:
+ case DAY_OF_WEEK_IN_MONTH:
+ case YEAR:
+ {
+ GregorianCalendar gc = (GregorianCalendar) clone();
+ gc.setLenient(true);
+ gc.setTimeInMillis(gregorianCutover);
+ int v1 = gc.getActualMaximum(field);
+ gc.setTimeInMillis(gregorianCutover-1);
+ int v2 = gc.getActualMaximum(field);
+ return Math.min(LEAST_MAX_VALUES[field], Math.min(v1, v2));
+ }
+ }
+ return LEAST_MAX_VALUES[field];
+ }
+
+ /**
+ * Returns the minimum value that this calendar field could have,
+ * taking into consideration the given time value and the current
+ * values of the
+ * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
+ * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
+ * {@link #getGregorianChange() getGregorianChange} and
+ * {@link Calendar#getTimeZone() getTimeZone} methods.
+ *
+ * <p>For example, if the Gregorian change date is January 10,
+ * 1970 and the date of this <code>GregorianCalendar</code> is
+ * January 20, 1970, the actual minimum value of the
+ * <code>DAY_OF_MONTH</code> field is 10 because the previous date
+ * of January 10, 1970 is December 27, 1996 (in the Julian
+ * calendar). Therefore, December 28, 1969 to January 9, 1970
+ * don't exist.
+ *
+ * @param field the calendar field
+ * @return the minimum of the given field for the time value of
+ * this <code>GregorianCalendar</code>
+ * @see #getMinimum(int)
+ * @see #getMaximum(int)
+ * @see #getGreatestMinimum(int)
+ * @see #getLeastMaximum(int)
+ * @see #getActualMaximum(int)
+ * @since 1.2
+ */
+ @Override
+ public int getActualMinimum(int field) {
+ if (field == DAY_OF_MONTH) {
+ GregorianCalendar gc = getNormalizedCalendar();
+ int year = gc.cdate.getNormalizedYear();
+ if (year == gregorianCutoverYear || year == gregorianCutoverYearJulian) {
+ long month1 = getFixedDateMonth1(gc.cdate, gc.calsys.getFixedDate(gc.cdate));
+ BaseCalendar.Date d = getCalendarDate(month1);
+ return d.getDayOfMonth();
+ }
+ }
+ return getMinimum(field);
+ }
+
+ /**
+ * Returns the maximum value that this calendar field could have,
+ * taking into consideration the given time value and the current
+ * values of the
+ * {@link Calendar#getFirstDayOfWeek() getFirstDayOfWeek},
+ * {@link Calendar#getMinimalDaysInFirstWeek() getMinimalDaysInFirstWeek},
+ * {@link #getGregorianChange() getGregorianChange} and
+ * {@link Calendar#getTimeZone() getTimeZone} methods.
+ * For example, if the date of this instance is February 1, 2004,
+ * the actual maximum value of the <code>DAY_OF_MONTH</code> field
+ * is 29 because 2004 is a leap year, and if the date of this
+ * instance is February 1, 2005, it's 28.
+ *
+ * <p>This method calculates the maximum value of {@link
+ * Calendar#WEEK_OF_YEAR WEEK_OF_YEAR} based on the {@link
+ * Calendar#YEAR YEAR} (calendar year) value, not the <a
+ * href="#week_year">week year</a>. Call {@link
+ * #getWeeksInWeekYear()} to get the maximum value of {@code
+ * WEEK_OF_YEAR} in the week year of this {@code GregorianCalendar}.
+ *
+ * @param field the calendar field
+ * @return the maximum of the given field for the time value of
+ * this <code>GregorianCalendar</code>
+ * @see #getMinimum(int)
+ * @see #getMaximum(int)
+ * @see #getGreatestMinimum(int)
+ * @see #getLeastMaximum(int)
+ * @see #getActualMinimum(int)
+ * @since 1.2
+ */
+ @Override
+ public int getActualMaximum(int field) {
+ final int fieldsForFixedMax = ERA_MASK|DAY_OF_WEEK_MASK|HOUR_MASK|AM_PM_MASK|
+ HOUR_OF_DAY_MASK|MINUTE_MASK|SECOND_MASK|MILLISECOND_MASK|
+ ZONE_OFFSET_MASK|DST_OFFSET_MASK;
+ if ((fieldsForFixedMax & (1<<field)) != 0) {
+ return getMaximum(field);
+ }
+
+ GregorianCalendar gc = getNormalizedCalendar();
+ BaseCalendar.Date date = gc.cdate;
+ BaseCalendar cal = gc.calsys;
+ int normalizedYear = date.getNormalizedYear();
+
+ int value = -1;
+ switch (field) {
+ case MONTH:
+ {
+ if (!gc.isCutoverYear(normalizedYear)) {
+ value = DECEMBER;
+ break;
+ }
+
+ // January 1 of the next year may or may not exist.
+ long nextJan1;
+ do {
+ nextJan1 = gcal.getFixedDate(++normalizedYear, BaseCalendar.JANUARY, 1, null);
+ } while (nextJan1 < gregorianCutoverDate);
+ BaseCalendar.Date d = (BaseCalendar.Date) date.clone();
+ cal.getCalendarDateFromFixedDate(d, nextJan1 - 1);
+ value = d.getMonth() - 1;
+ }
+ break;
+
+ case DAY_OF_MONTH:
+ {
+ value = cal.getMonthLength(date);
+ if (!gc.isCutoverYear(normalizedYear) || date.getDayOfMonth() == value) {
+ break;
+ }
+
+ // Handle cutover year.
+ long fd = gc.getCurrentFixedDate();
+ if (fd >= gregorianCutoverDate) {
+ break;
+ }
+ int monthLength = gc.actualMonthLength();
+ long monthEnd = gc.getFixedDateMonth1(gc.cdate, fd) + monthLength - 1;
+ // Convert the fixed date to its calendar date.
+ BaseCalendar.Date d = gc.getCalendarDate(monthEnd);
+ value = d.getDayOfMonth();
+ }
+ break;
+
+ case DAY_OF_YEAR:
+ {
+ if (!gc.isCutoverYear(normalizedYear)) {
+ value = cal.getYearLength(date);
+ break;
+ }
+
+ // Handle cutover year.
+ long jan1;
+ if (gregorianCutoverYear == gregorianCutoverYearJulian) {
+ BaseCalendar cocal = gc.getCutoverCalendarSystem();
+ jan1 = cocal.getFixedDate(normalizedYear, 1, 1, null);
+ } else if (normalizedYear == gregorianCutoverYearJulian) {
+ jan1 = cal.getFixedDate(normalizedYear, 1, 1, null);
+ } else {
+ jan1 = gregorianCutoverDate;
+ }
+ // January 1 of the next year may or may not exist.
+ long nextJan1 = gcal.getFixedDate(++normalizedYear, 1, 1, null);
+ if (nextJan1 < gregorianCutoverDate) {
+ nextJan1 = gregorianCutoverDate;
+ }
+ assert jan1 <= cal.getFixedDate(date.getNormalizedYear(), date.getMonth(),
+ date.getDayOfMonth(), date);
+ assert nextJan1 >= cal.getFixedDate(date.getNormalizedYear(), date.getMonth(),
+ date.getDayOfMonth(), date);
+ value = (int)(nextJan1 - jan1);
+ }
+ break;
+
+ case WEEK_OF_YEAR:
+ {
+ if (!gc.isCutoverYear(normalizedYear)) {
+ // Get the day of week of January 1 of the year
+ CalendarDate d = cal.newCalendarDate(TimeZone.NO_TIMEZONE);
+ d.setDate(date.getYear(), BaseCalendar.JANUARY, 1);
+ int dayOfWeek = cal.getDayOfWeek(d);
+ // Normalize the day of week with the firstDayOfWeek value
+ dayOfWeek -= getFirstDayOfWeek();
+ if (dayOfWeek < 0) {
+ dayOfWeek += 7;
+ }
+ value = 52;
+ int magic = dayOfWeek + getMinimalDaysInFirstWeek() - 1;
+ if ((magic == 6) ||
+ (date.isLeapYear() && (magic == 5 || magic == 12))) {
+ value++;
+ }
+ break;
+ }
+
+ if (gc == this) {
+ gc = (GregorianCalendar) gc.clone();
+ }
+ int maxDayOfYear = getActualMaximum(DAY_OF_YEAR);
+ gc.set(DAY_OF_YEAR, maxDayOfYear);
+ value = gc.get(WEEK_OF_YEAR);
+ if (internalGet(YEAR) != gc.getWeekYear()) {
+ gc.set(DAY_OF_YEAR, maxDayOfYear - 7);
+ value = gc.get(WEEK_OF_YEAR);
+ }
+ }
+ break;
+
+ case WEEK_OF_MONTH:
+ {
+ if (!gc.isCutoverYear(normalizedYear)) {
+ CalendarDate d = cal.newCalendarDate(null);
+ d.setDate(date.getYear(), date.getMonth(), 1);
+ int dayOfWeek = cal.getDayOfWeek(d);
+ int monthLength = cal.getMonthLength(d);
+ dayOfWeek -= getFirstDayOfWeek();
+ if (dayOfWeek < 0) {
+ dayOfWeek += 7;
+ }
+ int nDaysFirstWeek = 7 - dayOfWeek; // # of days in the first week
+ value = 3;
+ if (nDaysFirstWeek >= getMinimalDaysInFirstWeek()) {
+ value++;
+ }
+ monthLength -= nDaysFirstWeek + 7 * 3;
+ if (monthLength > 0) {
+ value++;
+ if (monthLength > 7) {
+ value++;
+ }
+ }
+ break;
+ }
+
+ // Cutover year handling
+ if (gc == this) {
+ gc = (GregorianCalendar) gc.clone();
+ }
+ int y = gc.internalGet(YEAR);
+ int m = gc.internalGet(MONTH);
+ do {
+ value = gc.get(WEEK_OF_MONTH);
+ gc.add(WEEK_OF_MONTH, +1);
+ } while (gc.get(YEAR) == y && gc.get(MONTH) == m);
+ }
+ break;
+
+ case DAY_OF_WEEK_IN_MONTH:
+ {
+ // may be in the Gregorian cutover month
+ int ndays, dow1;
+ int dow = date.getDayOfWeek();
+ if (!gc.isCutoverYear(normalizedYear)) {
+ BaseCalendar.Date d = (BaseCalendar.Date) date.clone();
+ ndays = cal.getMonthLength(d);
+ d.setDayOfMonth(1);
+ cal.normalize(d);
+ dow1 = d.getDayOfWeek();
+ } else {
+ // Let a cloned GregorianCalendar take care of the cutover cases.
+ if (gc == this) {
+ gc = (GregorianCalendar) clone();
+ }
+ ndays = gc.actualMonthLength();
+ gc.set(DAY_OF_MONTH, gc.getActualMinimum(DAY_OF_MONTH));
+ dow1 = gc.get(DAY_OF_WEEK);
+ }
+ int x = dow - dow1;
+ if (x < 0) {
+ x += 7;
+ }
+ ndays -= x;
+ value = (ndays + 6) / 7;
+ }
+ break;
+
+ case YEAR:
+ /* The year computation is no different, in principle, from the
+ * others, however, the range of possible maxima is large. In
+ * addition, the way we know we've exceeded the range is different.
+ * For these reasons, we use the special case code below to handle
+ * this field.
+ *
+ * The actual maxima for YEAR depend on the type of calendar:
+ *
+ * Gregorian = May 17, 292275056 BCE - Aug 17, 292278994 CE
+ * Julian = Dec 2, 292269055 BCE - Jan 3, 292272993 CE
+ * Hybrid = Dec 2, 292269055 BCE - Aug 17, 292278994 CE
+ *
+ * We know we've exceeded the maximum when either the month, date,
+ * time, or era changes in response to setting the year. We don't
+ * check for month, date, and time here because the year and era are
+ * sufficient to detect an invalid year setting. NOTE: If code is
+ * added to check the month and date in the future for some reason,
+ * Feb 29 must be allowed to shift to Mar 1 when setting the year.
+ */
+ {
+ if (gc == this) {
+ gc = (GregorianCalendar) clone();
+ }
+
+ // Calculate the millisecond offset from the beginning
+ // of the year of this calendar and adjust the max
+ // year value if we are beyond the limit in the max
+ // year.
+ long current = gc.getYearOffsetInMillis();
+
+ if (gc.internalGetEra() == CE) {
+ gc.setTimeInMillis(Long.MAX_VALUE);
+ value = gc.get(YEAR);
+ long maxEnd = gc.getYearOffsetInMillis();
+ if (current > maxEnd) {
+ value--;
+ }
+ } else {
+ CalendarSystem mincal = gc.getTimeInMillis() >= gregorianCutover ?
+ gcal : getJulianCalendarSystem();
+ CalendarDate d = mincal.getCalendarDate(Long.MIN_VALUE, getZone());
+ long maxEnd = (cal.getDayOfYear(d) - 1) * 24 + d.getHours();
+ maxEnd *= 60;
+ maxEnd += d.getMinutes();
+ maxEnd *= 60;
+ maxEnd += d.getSeconds();
+ maxEnd *= 1000;
+ maxEnd += d.getMillis();
+ value = d.getYear();
+ if (value <= 0) {
+ assert mincal == gcal;
+ value = 1 - value;
+ }
+ if (current < maxEnd) {
+ value--;
+ }
+ }
+ }
+ break;
+
+ default:
+ throw new ArrayIndexOutOfBoundsException(field);
+ }
+ return value;
+ }
+
+ /**
+ * Returns the millisecond offset from the beginning of this
+ * year. This Calendar object must have been normalized.
+ */
+ private long getYearOffsetInMillis() {
+ long t = (internalGet(DAY_OF_YEAR) - 1) * 24;
+ t += internalGet(HOUR_OF_DAY);
+ t *= 60;
+ t += internalGet(MINUTE);
+ t *= 60;
+ t += internalGet(SECOND);
+ t *= 1000;
+ return t + internalGet(MILLISECOND) -
+ (internalGet(ZONE_OFFSET) + internalGet(DST_OFFSET));
+ }
+
+ @Override
+ public Object clone()
+ {
+ GregorianCalendar other = (GregorianCalendar) super.clone();
+
+ other.gdate = (BaseCalendar.Date) gdate.clone();
+ if (cdate != null) {
+ if (cdate != gdate) {
+ other.cdate = (BaseCalendar.Date) cdate.clone();
+ } else {
+ other.cdate = other.gdate;
+ }
+ }
+ other.originalFields = null;
+ other.zoneOffsets = null;
+ return other;
+ }
+
+ @Override
+ public TimeZone getTimeZone() {
+ TimeZone zone = super.getTimeZone();
+ // To share the zone by CalendarDates
+ gdate.setZone(zone);
+ if (cdate != null && cdate != gdate) {
+ cdate.setZone(zone);
+ }
+ return zone;
+ }
+
+ @Override
+ public void setTimeZone(TimeZone zone) {
+ super.setTimeZone(zone);
+ // To share the zone by CalendarDates
+ gdate.setZone(zone);
+ if (cdate != null && cdate != gdate) {
+ cdate.setZone(zone);
+ }
+ }
+
+ /**
+ * Returns {@code true} indicating this {@code GregorianCalendar}
+ * supports week dates.
+ *
+ * @return {@code true} (always)
+ * @see #getWeekYear()
+ * @see #setWeekDate(int,int,int)
+ * @see #getWeeksInWeekYear()
+ * @since 1.7
+ */
+ @Override
+ public final boolean isWeekDateSupported() {
+ return true;
+ }
+
+ /**
+ * Returns the <a href="#week_year">week year</a> represented by this
+ * {@code GregorianCalendar}. The dates in the weeks between 1 and the
+ * maximum week number of the week year have the same week year value
+ * that may be one year before or after the {@link Calendar#YEAR YEAR}
+ * (calendar year) value.
+ *
+ * <p>This method calls {@link Calendar#complete()} before
+ * calculating the week year.
+ *
+ * @return the week year represented by this {@code GregorianCalendar}.
+ * If the {@link Calendar#ERA ERA} value is {@link #BC}, the year is
+ * represented by 0 or a negative number: BC 1 is 0, BC 2
+ * is -1, BC 3 is -2, and so on.
+ * @throws IllegalArgumentException
+ * if any of the calendar fields is invalid in non-lenient mode.
+ * @see #isWeekDateSupported()
+ * @see #getWeeksInWeekYear()
+ * @see Calendar#getFirstDayOfWeek()
+ * @see Calendar#getMinimalDaysInFirstWeek()
+ * @since 1.7
+ */
+ @Override
+ public int getWeekYear() {
+ int year = get(YEAR); // implicitly calls complete()
+ if (internalGetEra() == BCE) {
+ year = 1 - year;
+ }
+
+ // Fast path for the Gregorian calendar years that are never
+ // affected by the Julian-Gregorian transition
+ if (year > gregorianCutoverYear + 1) {
+ int weekOfYear = internalGet(WEEK_OF_YEAR);
+ if (internalGet(MONTH) == JANUARY) {
+ if (weekOfYear >= 52) {
+ --year;
+ }
+ } else {
+ if (weekOfYear == 1) {
+ ++year;
+ }
+ }
+ return year;
+ }
+
+ // General (slow) path
+ int dayOfYear = internalGet(DAY_OF_YEAR);
+ int maxDayOfYear = getActualMaximum(DAY_OF_YEAR);
+ int minimalDays = getMinimalDaysInFirstWeek();
+
+ // Quickly check the possibility of year adjustments before
+ // cloning this GregorianCalendar.
+ if (dayOfYear > minimalDays && dayOfYear < (maxDayOfYear - 6)) {
+ return year;
+ }
+
+ // Create a clone to work on the calculation
+ GregorianCalendar cal = (GregorianCalendar) clone();
+ cal.setLenient(true);
+ // Use GMT so that intermediate date calculations won't
+ // affect the time of day fields.
+ cal.setTimeZone(TimeZone.getTimeZone("GMT"));
+ // Go to the first day of the year, which is usually January 1.
+ cal.set(DAY_OF_YEAR, 1);
+ cal.complete();
+
+ // Get the first day of the first day-of-week in the year.
+ int delta = getFirstDayOfWeek() - cal.get(DAY_OF_WEEK);
+ if (delta != 0) {
+ if (delta < 0) {
+ delta += 7;
+ }
+ cal.add(DAY_OF_YEAR, delta);
+ }
+ int minDayOfYear = cal.get(DAY_OF_YEAR);
+ if (dayOfYear < minDayOfYear) {
+ if (minDayOfYear <= minimalDays) {
+ --year;
+ }
+ } else {
+ cal.set(YEAR, year + 1);
+ cal.set(DAY_OF_YEAR, 1);
+ cal.complete();
+ int del = getFirstDayOfWeek() - cal.get(DAY_OF_WEEK);
+ if (del != 0) {
+ if (del < 0) {
+ del += 7;
+ }
+ cal.add(DAY_OF_YEAR, del);
+ }
+ minDayOfYear = cal.get(DAY_OF_YEAR) - 1;
+ if (minDayOfYear == 0) {
+ minDayOfYear = 7;
+ }
+ if (minDayOfYear >= minimalDays) {
+ int days = maxDayOfYear - dayOfYear + 1;
+ if (days <= (7 - minDayOfYear)) {
+ ++year;
+ }
+ }
+ }
+ return year;
+ }
+
+ /**
+ * Sets this {@code GregorianCalendar} to the date given by the
+ * date specifiers - <a href="#week_year">{@code weekYear}</a>,
+ * {@code weekOfYear}, and {@code dayOfWeek}. {@code weekOfYear}
+ * follows the <a href="#week_and_year">{@code WEEK_OF_YEAR}
+ * numbering</a>. The {@code dayOfWeek} value must be one of the
+ * {@link Calendar#DAY_OF_WEEK DAY_OF_WEEK} values: {@link
+ * Calendar#SUNDAY SUNDAY} to {@link Calendar#SATURDAY SATURDAY}.
+ *
+ * <p>Note that the numeric day-of-week representation differs from
+ * the ISO 8601 standard, and that the {@code weekOfYear}
+ * numbering is compatible with the standard when {@code
+ * getFirstDayOfWeek()} is {@code MONDAY} and {@code
+ * getMinimalDaysInFirstWeek()} is 4.
+ *
+ * <p>Unlike the {@code set} method, all of the calendar fields
+ * and the instant of time value are calculated upon return.
+ *
+ * <p>If {@code weekOfYear} is out of the valid week-of-year
+ * range in {@code weekYear}, the {@code weekYear}
+ * and {@code weekOfYear} values are adjusted in lenient
+ * mode, or an {@code IllegalArgumentException} is thrown in
+ * non-lenient mode.
+ *
+ * @param weekYear the week year
+ * @param weekOfYear the week number based on {@code weekYear}
+ * @param dayOfWeek the day of week value: one of the constants
+ * for the {@link #DAY_OF_WEEK DAY_OF_WEEK} field:
+ * {@link Calendar#SUNDAY SUNDAY}, ...,
+ * {@link Calendar#SATURDAY SATURDAY}.
+ * @exception IllegalArgumentException
+ * if any of the given date specifiers is invalid,
+ * or if any of the calendar fields are inconsistent
+ * with the given date specifiers in non-lenient mode
+ * @see GregorianCalendar#isWeekDateSupported()
+ * @see Calendar#getFirstDayOfWeek()
+ * @see Calendar#getMinimalDaysInFirstWeek()
+ * @since 1.7
+ */
+ @Override
+ public void setWeekDate(int weekYear, int weekOfYear, int dayOfWeek) {
+ if (dayOfWeek < SUNDAY || dayOfWeek > SATURDAY) {
+ throw new IllegalArgumentException("invalid dayOfWeek: " + dayOfWeek);
+ }
+
+ // To avoid changing the time of day fields by date
+ // calculations, use a clone with the GMT time zone.
+ GregorianCalendar gc = (GregorianCalendar) clone();
+ gc.setLenient(true);
+ int era = gc.get(ERA);
+ gc.clear();
+ gc.setTimeZone(TimeZone.getTimeZone("GMT"));
+ gc.set(ERA, era);
+ gc.set(YEAR, weekYear);
+ gc.set(WEEK_OF_YEAR, 1);
+ gc.set(DAY_OF_WEEK, getFirstDayOfWeek());
+ int days = dayOfWeek - getFirstDayOfWeek();
+ if (days < 0) {
+ days += 7;
+ }
+ days += 7 * (weekOfYear - 1);
+ if (days != 0) {
+ gc.add(DAY_OF_YEAR, days);
+ } else {
+ gc.complete();
+ }
+
+ if (!isLenient() &&
+ (gc.getWeekYear() != weekYear
+ || gc.internalGet(WEEK_OF_YEAR) != weekOfYear
+ || gc.internalGet(DAY_OF_WEEK) != dayOfWeek)) {
+ throw new IllegalArgumentException();
+ }
+
+ set(ERA, gc.internalGet(ERA));
+ set(YEAR, gc.internalGet(YEAR));
+ set(MONTH, gc.internalGet(MONTH));
+ set(DAY_OF_MONTH, gc.internalGet(DAY_OF_MONTH));
+
+ // to avoid throwing an IllegalArgumentException in
+ // non-lenient, set WEEK_OF_YEAR internally
+ internalSet(WEEK_OF_YEAR, weekOfYear);
+ complete();
+ }
+
+ /**
+ * Returns the number of weeks in the <a href="#week_year">week year</a>
+ * represented by this {@code GregorianCalendar}.
+ *
+ * <p>For example, if this {@code GregorianCalendar}'s date is
+ * December 31, 2008 with <a href="#iso8601_compatible_setting">the ISO
+ * 8601 compatible setting</a>, this method will return 53 for the
+ * period: December 29, 2008 to January 3, 2010 while {@link
+ * #getActualMaximum(int) getActualMaximum(WEEK_OF_YEAR)} will return
+ * 52 for the period: December 31, 2007 to December 28, 2008.
+ *
+ * @return the number of weeks in the week year.
+ * @see Calendar#WEEK_OF_YEAR
+ * @see #getWeekYear()
+ * @see #getActualMaximum(int)
+ * @since 1.7
+ */
+ @Override
+ public int getWeeksInWeekYear() {
+ GregorianCalendar gc = getNormalizedCalendar();
+ int weekYear = gc.getWeekYear();
+ if (weekYear == gc.internalGet(YEAR)) {
+ return gc.getActualMaximum(WEEK_OF_YEAR);
+ }
+
+ // Use the 2nd week for calculating the max of WEEK_OF_YEAR
+ if (gc == this) {
+ gc = (GregorianCalendar) gc.clone();
+ }
+ gc.setWeekDate(weekYear, 2, internalGet(DAY_OF_WEEK));
+ return gc.getActualMaximum(WEEK_OF_YEAR);
+ }
+
+/////////////////////////////
+// Time => Fields computation
+/////////////////////////////
+
+ /**
+ * The fixed date corresponding to gdate. If the value is
+ * Long.MIN_VALUE, the fixed date value is unknown. Currently,
+ * Julian calendar dates are not cached.
+ */
+ private transient long cachedFixedDate = Long.MIN_VALUE;
+
+ /**
+ * Converts the time value (millisecond offset from the <a
+ * href="Calendar.html#Epoch">Epoch</a>) to calendar field values.
+ * The time is <em>not</em>
+ * recomputed first; to recompute the time, then the fields, call the
+ * <code>complete</code> method.
+ *
+ * @see Calendar#complete
+ */
+ @Override
+ protected void computeFields() {
+ int mask;
+ if (isPartiallyNormalized()) {
+ // Determine which calendar fields need to be computed.
+ mask = getSetStateFields();
+ int fieldMask = ~mask & ALL_FIELDS;
+ // We have to call computTime in case calsys == null in
+ // order to set calsys and cdate. (6263644)
+ if (fieldMask != 0 || calsys == null) {
+ mask |= computeFields(fieldMask,
+ mask & (ZONE_OFFSET_MASK|DST_OFFSET_MASK));
+ assert mask == ALL_FIELDS;
+ }
+ } else {
+ mask = ALL_FIELDS;
+ computeFields(mask, 0);
+ }
+ // After computing all the fields, set the field state to `COMPUTED'.
+ setFieldsComputed(mask);
+ }
+
+ /**
+ * This computeFields implements the conversion from UTC
+ * (millisecond offset from the Epoch) to calendar
+ * field values. fieldMask specifies which fields to change the
+ * setting state to COMPUTED, although all fields are set to
+ * the correct values. This is required to fix 4685354.
+ *
+ * @param fieldMask a bit mask to specify which fields to change
+ * the setting state.
+ * @param tzMask a bit mask to specify which time zone offset
+ * fields to be used for time calculations
+ * @return a new field mask that indicates what field values have
+ * actually been set.
+ */
+ private int computeFields(int fieldMask, int tzMask) {
+ int zoneOffset = 0;
+ TimeZone tz = getZone();
+ if (zoneOffsets == null) {
+ zoneOffsets = new int[2];
+ }
+ if (tzMask != (ZONE_OFFSET_MASK|DST_OFFSET_MASK)) {
+ if (tz instanceof ZoneInfo) {
+ zoneOffset = ((ZoneInfo)tz).getOffsets(time, zoneOffsets);
+ } else {
+ zoneOffset = tz.getOffset(time);
+ zoneOffsets[0] = tz.getRawOffset();
+ zoneOffsets[1] = zoneOffset - zoneOffsets[0];
+ }
+ }
+ if (tzMask != 0) {
+ if (isFieldSet(tzMask, ZONE_OFFSET)) {
+ zoneOffsets[0] = internalGet(ZONE_OFFSET);
+ }
+ if (isFieldSet(tzMask, DST_OFFSET)) {
+ zoneOffsets[1] = internalGet(DST_OFFSET);
+ }
+ zoneOffset = zoneOffsets[0] + zoneOffsets[1];
+ }
+
+ // By computing time and zoneOffset separately, we can take
+ // the wider range of time+zoneOffset than the previous
+ // implementation.
+ long fixedDate = zoneOffset / ONE_DAY;
+ int timeOfDay = zoneOffset % (int)ONE_DAY;
+ fixedDate += time / ONE_DAY;
+ timeOfDay += (int) (time % ONE_DAY);
+ if (timeOfDay >= ONE_DAY) {
+ timeOfDay -= ONE_DAY;
+ ++fixedDate;
+ } else {
+ while (timeOfDay < 0) {
+ timeOfDay += ONE_DAY;
+ --fixedDate;
+ }
+ }
+ fixedDate += EPOCH_OFFSET;
+
+ int era = CE;
+ int year;
+ if (fixedDate >= gregorianCutoverDate) {
+ // Handle Gregorian dates.
+ assert cachedFixedDate == Long.MIN_VALUE || gdate.isNormalized()
+ : "cache control: not normalized";
+ assert cachedFixedDate == Long.MIN_VALUE ||
+ gcal.getFixedDate(gdate.getNormalizedYear(),
+ gdate.getMonth(),
+ gdate.getDayOfMonth(), gdate)
+ == cachedFixedDate
+ : "cache control: inconsictency" +
+ ", cachedFixedDate=" + cachedFixedDate +
+ ", computed=" +
+ gcal.getFixedDate(gdate.getNormalizedYear(),
+ gdate.getMonth(),
+ gdate.getDayOfMonth(),
+ gdate) +
+ ", date=" + gdate;
+
+ // See if we can use gdate to avoid date calculation.
+ if (fixedDate != cachedFixedDate) {
+ gcal.getCalendarDateFromFixedDate(gdate, fixedDate);
+ cachedFixedDate = fixedDate;
+ }
+
+ year = gdate.getYear();
+ if (year <= 0) {
+ year = 1 - year;
+ era = BCE;
+ }
+ calsys = gcal;
+ cdate = gdate;
+ assert cdate.getDayOfWeek() > 0 : "dow="+cdate.getDayOfWeek()+", date="+cdate;
+ } else {
+ // Handle Julian calendar dates.
+ calsys = getJulianCalendarSystem();
+ cdate = (BaseCalendar.Date) jcal.newCalendarDate(getZone());
+ jcal.getCalendarDateFromFixedDate(cdate, fixedDate);
+ Era e = cdate.getEra();
+ if (e == jeras[0]) {
+ era = BCE;
+ }
+ year = cdate.getYear();
+ }
+
+ // Always set the ERA and YEAR values.
+ internalSet(ERA, era);
+ internalSet(YEAR, year);
+ int mask = fieldMask | (ERA_MASK|YEAR_MASK);
+
+ int month = cdate.getMonth() - 1; // 0-based
+ int dayOfMonth = cdate.getDayOfMonth();
+
+ // Set the basic date fields.
+ if ((fieldMask & (MONTH_MASK|DAY_OF_MONTH_MASK|DAY_OF_WEEK_MASK))
+ != 0) {
+ internalSet(MONTH, month);
+ internalSet(DAY_OF_MONTH, dayOfMonth);
+ internalSet(DAY_OF_WEEK, cdate.getDayOfWeek());
+ mask |= MONTH_MASK|DAY_OF_MONTH_MASK|DAY_OF_WEEK_MASK;
+ }
+
+ if ((fieldMask & (HOUR_OF_DAY_MASK|AM_PM_MASK|HOUR_MASK
+ |MINUTE_MASK|SECOND_MASK|MILLISECOND_MASK)) != 0) {
+ if (timeOfDay != 0) {
+ int hours = timeOfDay / ONE_HOUR;
+ internalSet(HOUR_OF_DAY, hours);
+ internalSet(AM_PM, hours / 12); // Assume AM == 0
+ internalSet(HOUR, hours % 12);
+ int r = timeOfDay % ONE_HOUR;
+ internalSet(MINUTE, r / ONE_MINUTE);
+ r %= ONE_MINUTE;
+ internalSet(SECOND, r / ONE_SECOND);
+ internalSet(MILLISECOND, r % ONE_SECOND);
+ } else {
+ internalSet(HOUR_OF_DAY, 0);
+ internalSet(AM_PM, AM);
+ internalSet(HOUR, 0);
+ internalSet(MINUTE, 0);
+ internalSet(SECOND, 0);
+ internalSet(MILLISECOND, 0);
+ }
+ mask |= (HOUR_OF_DAY_MASK|AM_PM_MASK|HOUR_MASK
+ |MINUTE_MASK|SECOND_MASK|MILLISECOND_MASK);
+ }
+
+ if ((fieldMask & (ZONE_OFFSET_MASK|DST_OFFSET_MASK)) != 0) {
+ internalSet(ZONE_OFFSET, zoneOffsets[0]);
+ internalSet(DST_OFFSET, zoneOffsets[1]);
+ mask |= (ZONE_OFFSET_MASK|DST_OFFSET_MASK);
+ }
+
+ if ((fieldMask & (DAY_OF_YEAR_MASK|WEEK_OF_YEAR_MASK|WEEK_OF_MONTH_MASK|DAY_OF_WEEK_IN_MONTH_MASK)) != 0) {
+ int normalizedYear = cdate.getNormalizedYear();
+ long fixedDateJan1 = calsys.getFixedDate(normalizedYear, 1, 1, cdate);
+ int dayOfYear = (int)(fixedDate - fixedDateJan1) + 1;
+ long fixedDateMonth1 = fixedDate - dayOfMonth + 1;
+ int cutoverGap = 0;
+ int cutoverYear = (calsys == gcal) ? gregorianCutoverYear : gregorianCutoverYearJulian;
+ int relativeDayOfMonth = dayOfMonth - 1;
+
+ // If we are in the cutover year, we need some special handling.
+ if (normalizedYear == cutoverYear) {
+ // Need to take care of the "missing" days.
+ if (gregorianCutoverYearJulian <= gregorianCutoverYear) {
+ // We need to find out where we are. The cutover
+ // gap could even be more than one year. (One
+ // year difference in ~48667 years.)
+ fixedDateJan1 = getFixedDateJan1(cdate, fixedDate);
+ if (fixedDate >= gregorianCutoverDate) {
+ fixedDateMonth1 = getFixedDateMonth1(cdate, fixedDate);
+ }
+ }
+ int realDayOfYear = (int)(fixedDate - fixedDateJan1) + 1;
+ cutoverGap = dayOfYear - realDayOfYear;
+ dayOfYear = realDayOfYear;
+ relativeDayOfMonth = (int)(fixedDate - fixedDateMonth1);
+ }
+ internalSet(DAY_OF_YEAR, dayOfYear);
+ internalSet(DAY_OF_WEEK_IN_MONTH, relativeDayOfMonth / 7 + 1);
+
+ int weekOfYear = getWeekNumber(fixedDateJan1, fixedDate);
+
+ // The spec is to calculate WEEK_OF_YEAR in the
+ // ISO8601-style. This creates problems, though.
+ if (weekOfYear == 0) {
+ // If the date belongs to the last week of the
+ // previous year, use the week number of "12/31" of
+ // the "previous" year. Again, if the previous year is
+ // the Gregorian cutover year, we need to take care of
+ // it. Usually the previous day of January 1 is
+ // December 31, which is not always true in
+ // GregorianCalendar.
+ long fixedDec31 = fixedDateJan1 - 1;
+ long prevJan1 = fixedDateJan1 - 365;
+ if (normalizedYear > (cutoverYear + 1)) {
+ if (CalendarUtils.isGregorianLeapYear(normalizedYear - 1)) {
+ --prevJan1;
+ }
+ } else if (normalizedYear <= gregorianCutoverYearJulian) {
+ if (CalendarUtils.isJulianLeapYear(normalizedYear - 1)) {
+ --prevJan1;
+ }
+ } else {
+ BaseCalendar calForJan1 = calsys;
+ //int prevYear = normalizedYear - 1;
+ int prevYear = getCalendarDate(fixedDec31).getNormalizedYear();
+ if (prevYear == gregorianCutoverYear) {
+ calForJan1 = getCutoverCalendarSystem();
+ if (calForJan1 == jcal) {
+ prevJan1 = calForJan1.getFixedDate(prevYear,
+ BaseCalendar.JANUARY,
+ 1,
+ null);
+ } else {
+ prevJan1 = gregorianCutoverDate;
+ calForJan1 = gcal;
+ }
+ } else if (prevYear <= gregorianCutoverYearJulian) {
+ calForJan1 = getJulianCalendarSystem();
+ prevJan1 = calForJan1.getFixedDate(prevYear,
+ BaseCalendar.JANUARY,
+ 1,
+ null);
+ }
+ }
+ weekOfYear = getWeekNumber(prevJan1, fixedDec31);
+ } else {
+ if (normalizedYear > gregorianCutoverYear ||
+ normalizedYear < (gregorianCutoverYearJulian - 1)) {
+ // Regular years
+ if (weekOfYear >= 52) {
+ long nextJan1 = fixedDateJan1 + 365;
+ if (cdate.isLeapYear()) {
+ nextJan1++;
+ }
+ long nextJan1st = BaseCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
+ getFirstDayOfWeek());
+ int ndays = (int)(nextJan1st - nextJan1);
+ if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) {
+ // The first days forms a week in which the date is included.
+ weekOfYear = 1;
+ }
+ }
+ } else {
+ BaseCalendar calForJan1 = calsys;
+ int nextYear = normalizedYear + 1;
+ if (nextYear == (gregorianCutoverYearJulian + 1) &&
+ nextYear < gregorianCutoverYear) {
+ // In case the gap is more than one year.
+ nextYear = gregorianCutoverYear;
+ }
+ if (nextYear == gregorianCutoverYear) {
+ calForJan1 = getCutoverCalendarSystem();
+ }
+
+ long nextJan1;
+ if (nextYear > gregorianCutoverYear
+ || gregorianCutoverYearJulian == gregorianCutoverYear
+ || nextYear == gregorianCutoverYearJulian) {
+ nextJan1 = calForJan1.getFixedDate(nextYear,
+ BaseCalendar.JANUARY,
+ 1,
+ null);
+ } else {
+ nextJan1 = gregorianCutoverDate;
+ calForJan1 = gcal;
+ }
+
+ long nextJan1st = BaseCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
+ getFirstDayOfWeek());
+ int ndays = (int)(nextJan1st - nextJan1);
+ if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) {
+ // The first days forms a week in which the date is included.
+ weekOfYear = 1;
+ }
+ }
+ }
+ internalSet(WEEK_OF_YEAR, weekOfYear);
+ internalSet(WEEK_OF_MONTH, getWeekNumber(fixedDateMonth1, fixedDate));
+ mask |= (DAY_OF_YEAR_MASK|WEEK_OF_YEAR_MASK|WEEK_OF_MONTH_MASK|DAY_OF_WEEK_IN_MONTH_MASK);
+ }
+ return mask;
+ }
+
+ /**
+ * Returns the number of weeks in a period between fixedDay1 and
+ * fixedDate. The getFirstDayOfWeek-getMinimalDaysInFirstWeek rule
+ * is applied to calculate the number of weeks.
+ *
+ * @param fixedDay1 the fixed date of the first day of the period
+ * @param fixedDate the fixed date of the last day of the period
+ * @return the number of weeks of the given period
+ */
+ private int getWeekNumber(long fixedDay1, long fixedDate) {
+ // We can always use `gcal' since Julian and Gregorian are the
+ // same thing for this calculation.
+ long fixedDay1st = Gregorian.getDayOfWeekDateOnOrBefore(fixedDay1 + 6,
+ getFirstDayOfWeek());
+ int ndays = (int)(fixedDay1st - fixedDay1);
+ assert ndays <= 7;
+ if (ndays >= getMinimalDaysInFirstWeek()) {
+ fixedDay1st -= 7;
+ }
+ int normalizedDayOfPeriod = (int)(fixedDate - fixedDay1st);
+ if (normalizedDayOfPeriod >= 0) {
+ return normalizedDayOfPeriod / 7 + 1;
+ }
+ return CalendarUtils.floorDivide(normalizedDayOfPeriod, 7) + 1;
+ }
+
+ /**
+ * Converts calendar field values to the time value (millisecond
+ * offset from the <a href="Calendar.html#Epoch">Epoch</a>).
+ *
+ * @exception IllegalArgumentException if any calendar fields are invalid.
+ */
+ @Override
+ protected void computeTime() {
+ // In non-lenient mode, perform brief checking of calendar
+ // fields which have been set externally. Through this
+ // checking, the field values are stored in originalFields[]
+ // to see if any of them are normalized later.
+ if (!isLenient()) {
+ if (originalFields == null) {
+ originalFields = new int[FIELD_COUNT];
+ }
+ for (int field = 0; field < FIELD_COUNT; field++) {
+ int value = internalGet(field);
+ if (isExternallySet(field)) {
+ // Quick validation for any out of range values
+ if (value < getMinimum(field) || value > getMaximum(field)) {
+ throw new IllegalArgumentException(getFieldName(field));
+ }
+ }
+ originalFields[field] = value;
+ }
+ }
+
+ // Let the super class determine which calendar fields to be
+ // used to calculate the time.
+ int fieldMask = selectFields();
+
+ // The year defaults to the epoch start. We don't check
+ // fieldMask for YEAR because YEAR is a mandatory field to
+ // determine the date.
+ int year = isSet(YEAR) ? internalGet(YEAR) : EPOCH_YEAR;
+
+ int era = internalGetEra();
+ if (era == BCE) {
+ year = 1 - year;
+ } else if (era != CE) {
+ // Even in lenient mode we disallow ERA values other than CE & BCE.
+ // (The same normalization rule as add()/roll() could be
+ // applied here in lenient mode. But this checking is kept
+ // unchanged for compatibility as of 1.5.)
+ throw new IllegalArgumentException("Invalid era");
+ }
+
+ // If year is 0 or negative, we need to set the ERA value later.
+ if (year <= 0 && !isSet(ERA)) {
+ fieldMask |= ERA_MASK;
+ setFieldsComputed(ERA_MASK);
+ }
+
+ // Calculate the time of day. We rely on the convention that
+ // an UNSET field has 0.
+ long timeOfDay = 0;
+ if (isFieldSet(fieldMask, HOUR_OF_DAY)) {
+ timeOfDay += (long) internalGet(HOUR_OF_DAY);
+ } else {
+ timeOfDay += internalGet(HOUR);
+ // The default value of AM_PM is 0 which designates AM.
+ if (isFieldSet(fieldMask, AM_PM)) {
+ timeOfDay += 12 * internalGet(AM_PM);
+ }
+ }
+ timeOfDay *= 60;
+ timeOfDay += internalGet(MINUTE);
+ timeOfDay *= 60;
+ timeOfDay += internalGet(SECOND);
+ timeOfDay *= 1000;
+ timeOfDay += internalGet(MILLISECOND);
+
+ // Convert the time of day to the number of days and the
+ // millisecond offset from midnight.
+ long fixedDate = timeOfDay / ONE_DAY;
+ timeOfDay %= ONE_DAY;
+ while (timeOfDay < 0) {
+ timeOfDay += ONE_DAY;
+ --fixedDate;
+ }
+
+ // Calculate the fixed date since January 1, 1 (Gregorian).
+ calculateFixedDate: {
+ long gfd, jfd;
+ if (year > gregorianCutoverYear && year > gregorianCutoverYearJulian) {
+ gfd = fixedDate + getFixedDate(gcal, year, fieldMask);
+ if (gfd >= gregorianCutoverDate) {
+ fixedDate = gfd;
+ break calculateFixedDate;
+ }
+ jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask);
+ } else if (year < gregorianCutoverYear && year < gregorianCutoverYearJulian) {
+ jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask);
+ if (jfd < gregorianCutoverDate) {
+ fixedDate = jfd;
+ break calculateFixedDate;
+ }
+ gfd = jfd;
+ } else {
+ jfd = fixedDate + getFixedDate(getJulianCalendarSystem(), year, fieldMask);
+ gfd = fixedDate + getFixedDate(gcal, year, fieldMask);
+ }
+
+ // Now we have to determine which calendar date it is.
+
+ // If the date is relative from the beginning of the year
+ // in the Julian calendar, then use jfd;
+ if (isFieldSet(fieldMask, DAY_OF_YEAR) || isFieldSet(fieldMask, WEEK_OF_YEAR)) {
+ if (gregorianCutoverYear == gregorianCutoverYearJulian) {
+ fixedDate = jfd;
+ break calculateFixedDate;
+ } else if (year == gregorianCutoverYear) {
+ fixedDate = gfd;
+ break calculateFixedDate;
+ }
+ }
+
+ if (gfd >= gregorianCutoverDate) {
+ if (jfd >= gregorianCutoverDate) {
+ fixedDate = gfd;
+ } else {
+ // The date is in an "overlapping" period. No way
+ // to disambiguate it. Determine it using the
+ // previous date calculation.
+ if (calsys == gcal || calsys == null) {
+ fixedDate = gfd;
+ } else {
+ fixedDate = jfd;
+ }
+ }
+ } else {
+ if (jfd < gregorianCutoverDate) {
+ fixedDate = jfd;
+ } else {
+ // The date is in a "missing" period.
+ if (!isLenient()) {
+ throw new IllegalArgumentException("the specified date doesn't exist");
+ }
+ // Take the Julian date for compatibility, which
+ // will produce a Gregorian date.
+ fixedDate = jfd;
+ }
+ }
+ }
+
+ // millis represents local wall-clock time in milliseconds.
+ long millis = (fixedDate - EPOCH_OFFSET) * ONE_DAY + timeOfDay;
+
+ // Compute the time zone offset and DST offset. There are two potential
+ // ambiguities here. We'll assume a 2:00 am (wall time) switchover time
+ // for discussion purposes here.
+ // 1. The transition into DST. Here, a designated time of 2:00 am - 2:59 am
+ // can be in standard or in DST depending. However, 2:00 am is an invalid
+ // representation (the representation jumps from 1:59:59 am Std to 3:00:00 am DST).
+ // We assume standard time.
+ // 2. The transition out of DST. Here, a designated time of 1:00 am - 1:59 am
+ // can be in standard or DST. Both are valid representations (the rep
+ // jumps from 1:59:59 DST to 1:00:00 Std).
+ // Again, we assume standard time.
+ // We use the TimeZone object, unless the user has explicitly set the ZONE_OFFSET
+ // or DST_OFFSET fields; then we use those fields.
+ TimeZone zone = getZone();
+ if (zoneOffsets == null) {
+ zoneOffsets = new int[2];
+ }
+ int tzMask = fieldMask & (ZONE_OFFSET_MASK|DST_OFFSET_MASK);
+ if (tzMask != (ZONE_OFFSET_MASK|DST_OFFSET_MASK)) {
+ if (zone instanceof ZoneInfo) {
+ ((ZoneInfo)zone).getOffsetsByWall(millis, zoneOffsets);
+ } else {
+ int gmtOffset = isFieldSet(fieldMask, ZONE_OFFSET) ?
+ internalGet(ZONE_OFFSET) : zone.getRawOffset();
+ zone.getOffsets(millis - gmtOffset, zoneOffsets);
+ }
+ }
+ if (tzMask != 0) {
+ if (isFieldSet(tzMask, ZONE_OFFSET)) {
+ zoneOffsets[0] = internalGet(ZONE_OFFSET);
+ }
+ if (isFieldSet(tzMask, DST_OFFSET)) {
+ zoneOffsets[1] = internalGet(DST_OFFSET);
+ }
+ }
+
+ // Adjust the time zone offset values to get the UTC time.
+ millis -= zoneOffsets[0] + zoneOffsets[1];
+
+ // Set this calendar's time in milliseconds
+ time = millis;
+
+ int mask = computeFields(fieldMask | getSetStateFields(), tzMask);
+
+ if (!isLenient()) {
+ for (int field = 0; field < FIELD_COUNT; field++) {
+ if (!isExternallySet(field)) {
+ continue;
+ }
+ if (originalFields[field] != internalGet(field)) {
+ String s = originalFields[field] + " -> " + internalGet(field);
+ // Restore the original field values
+ System.arraycopy(originalFields, 0, fields, 0, fields.length);
+ throw new IllegalArgumentException(getFieldName(field) + ": " + s);
+ }
+ }
+ }
+ setFieldsNormalized(mask);
+ }
+
+ /**
+ * Computes the fixed date under either the Gregorian or the
+ * Julian calendar, using the given year and the specified calendar fields.
+ *
+ * @param cal the CalendarSystem to be used for the date calculation
+ * @param year the normalized year number, with 0 indicating the
+ * year 1 BCE, -1 indicating 2 BCE, etc.
+ * @param fieldMask the calendar fields to be used for the date calculation
+ * @return the fixed date
+ * @see Calendar#selectFields
+ */
+ private long getFixedDate(BaseCalendar cal, int year, int fieldMask) {
+ int month = JANUARY;
+ if (isFieldSet(fieldMask, MONTH)) {
+ // No need to check if MONTH has been set (no isSet(MONTH)
+ // call) since its unset value happens to be JANUARY (0).
+ month = internalGet(MONTH);
+
+ // If the month is out of range, adjust it into range
+ if (month > DECEMBER) {
+ year += month / 12;
+ month %= 12;
+ } else if (month < JANUARY) {
+ int[] rem = new int[1];
+ year += CalendarUtils.floorDivide(month, 12, rem);
+ month = rem[0];
+ }
+ }
+
+ // Get the fixed date since Jan 1, 1 (Gregorian). We are on
+ // the first day of either `month' or January in 'year'.
+ long fixedDate = cal.getFixedDate(year, month + 1, 1,
+ cal == gcal ? gdate : null);
+ if (isFieldSet(fieldMask, MONTH)) {
+ // Month-based calculations
+ if (isFieldSet(fieldMask, DAY_OF_MONTH)) {
+ // We are on the first day of the month. Just add the
+ // offset if DAY_OF_MONTH is set. If the isSet call
+ // returns false, that means DAY_OF_MONTH has been
+ // selected just because of the selected
+ // combination. We don't need to add any since the
+ // default value is the 1st.
+ if (isSet(DAY_OF_MONTH)) {
+ // To avoid underflow with DAY_OF_MONTH-1, add
+ // DAY_OF_MONTH, then subtract 1.
+ fixedDate += internalGet(DAY_OF_MONTH);
+ fixedDate--;
+ }
+ } else {
+ if (isFieldSet(fieldMask, WEEK_OF_MONTH)) {
+ long firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6,
+ getFirstDayOfWeek());
+ // If we have enough days in the first week, then
+ // move to the previous week.
+ if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) {
+ firstDayOfWeek -= 7;
+ }
+ if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
+ firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
+ internalGet(DAY_OF_WEEK));
+ }
+ // In lenient mode, we treat days of the previous
+ // months as a part of the specified
+ // WEEK_OF_MONTH. See 4633646.
+ fixedDate = firstDayOfWeek + 7 * (internalGet(WEEK_OF_MONTH) - 1);
+ } else {
+ int dayOfWeek;
+ if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
+ dayOfWeek = internalGet(DAY_OF_WEEK);
+ } else {
+ dayOfWeek = getFirstDayOfWeek();
+ }
+ // We are basing this on the day-of-week-in-month. The only
+ // trickiness occurs if the day-of-week-in-month is
+ // negative.
+ int dowim;
+ if (isFieldSet(fieldMask, DAY_OF_WEEK_IN_MONTH)) {
+ dowim = internalGet(DAY_OF_WEEK_IN_MONTH);
+ } else {
+ dowim = 1;
+ }
+ if (dowim >= 0) {
+ fixedDate = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + (7 * dowim) - 1,
+ dayOfWeek);
+ } else {
+ // Go to the first day of the next week of
+ // the specified week boundary.
+ int lastDate = monthLength(month, year) + (7 * (dowim + 1));
+ // Then, get the day of week date on or before the last date.
+ fixedDate = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + lastDate - 1,
+ dayOfWeek);
+ }
+ }
+ }
+ } else {
+ if (year == gregorianCutoverYear && cal == gcal
+ && fixedDate < gregorianCutoverDate
+ && gregorianCutoverYear != gregorianCutoverYearJulian) {
+ // January 1 of the year doesn't exist. Use
+ // gregorianCutoverDate as the first day of the
+ // year.
+ fixedDate = gregorianCutoverDate;
+ }
+ // We are on the first day of the year.
+ if (isFieldSet(fieldMask, DAY_OF_YEAR)) {
+ // Add the offset, then subtract 1. (Make sure to avoid underflow.)
+ fixedDate += internalGet(DAY_OF_YEAR);
+ fixedDate--;
+ } else {
+ long firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6,
+ getFirstDayOfWeek());
+ // If we have enough days in the first week, then move
+ // to the previous week.
+ if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) {
+ firstDayOfWeek -= 7;
+ }
+ if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
+ int dayOfWeek = internalGet(DAY_OF_WEEK);
+ if (dayOfWeek != getFirstDayOfWeek()) {
+ firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
+ dayOfWeek);
+ }
+ }
+ fixedDate = firstDayOfWeek + 7 * ((long)internalGet(WEEK_OF_YEAR) - 1);
+ }
+ }
+
+ return fixedDate;
+ }
+
+ /**
+ * Returns this object if it's normalized (all fields and time are
+ * in sync). Otherwise, a cloned object is returned after calling
+ * complete() in lenient mode.
+ */
+ private GregorianCalendar getNormalizedCalendar() {
+ GregorianCalendar gc;
+ if (isFullyNormalized()) {
+ gc = this;
+ } else {
+ // Create a clone and normalize the calendar fields
+ gc = (GregorianCalendar) this.clone();
+ gc.setLenient(true);
+ gc.complete();
+ }
+ return gc;
+ }
+
+ /**
+ * Returns the Julian calendar system instance (singleton). 'jcal'
+ * and 'jeras' are set upon the return.
+ */
+ private static synchronized BaseCalendar getJulianCalendarSystem() {
+ if (jcal == null) {
+ jcal = (JulianCalendar) CalendarSystem.forName("julian");
+ jeras = jcal.getEras();
+ }
+ return jcal;
+ }
+
+ /**
+ * Returns the calendar system for dates before the cutover date
+ * in the cutover year. If the cutover date is January 1, the
+ * method returns Gregorian. Otherwise, Julian.
+ */
+ private BaseCalendar getCutoverCalendarSystem() {
+ if (gregorianCutoverYearJulian < gregorianCutoverYear) {
+ return gcal;
+ }
+ return getJulianCalendarSystem();
+ }
+
+ /**
+ * Determines if the specified year (normalized) is the Gregorian
+ * cutover year. This object must have been normalized.
+ */
+ private boolean isCutoverYear(int normalizedYear) {
+ int cutoverYear = (calsys == gcal) ? gregorianCutoverYear : gregorianCutoverYearJulian;
+ return normalizedYear == cutoverYear;
+ }
+
+ /**
+ * Returns the fixed date of the first day of the year (usually
+ * January 1) before the specified date.
+ *
+ * @param date the date for which the first day of the year is
+ * calculated. The date has to be in the cut-over year (Gregorian
+ * or Julian).
+ * @param fixedDate the fixed date representation of the date
+ */
+ private long getFixedDateJan1(BaseCalendar.Date date, long fixedDate) {
+ assert date.getNormalizedYear() == gregorianCutoverYear ||
+ date.getNormalizedYear() == gregorianCutoverYearJulian;
+ if (gregorianCutoverYear != gregorianCutoverYearJulian) {
+ if (fixedDate >= gregorianCutoverDate) {
+ // Dates before the cutover date don't exist
+ // in the same (Gregorian) year. So, no
+ // January 1 exists in the year. Use the
+ // cutover date as the first day of the year.
+ return gregorianCutoverDate;
+ }
+ }
+ // January 1 of the normalized year should exist.
+ BaseCalendar juliancal = getJulianCalendarSystem();
+ return juliancal.getFixedDate(date.getNormalizedYear(), BaseCalendar.JANUARY, 1, null);
+ }
+
+ /**
+ * Returns the fixed date of the first date of the month (usually
+ * the 1st of the month) before the specified date.
+ *
+ * @param date the date for which the first day of the month is
+ * calculated. The date has to be in the cut-over year (Gregorian
+ * or Julian).
+ * @param fixedDate the fixed date representation of the date
+ */
+ private long getFixedDateMonth1(BaseCalendar.Date date, long fixedDate) {
+ assert date.getNormalizedYear() == gregorianCutoverYear ||
+ date.getNormalizedYear() == gregorianCutoverYearJulian;
+ BaseCalendar.Date gCutover = getGregorianCutoverDate();
+ if (gCutover.getMonth() == BaseCalendar.JANUARY
+ && gCutover.getDayOfMonth() == 1) {
+ // The cutover happened on January 1.
+ return fixedDate - date.getDayOfMonth() + 1;
+ }
+
+ long fixedDateMonth1;
+ // The cutover happened sometime during the year.
+ if (date.getMonth() == gCutover.getMonth()) {
+ // The cutover happened in the month.
+ BaseCalendar.Date jLastDate = getLastJulianDate();
+ if (gregorianCutoverYear == gregorianCutoverYearJulian
+ && gCutover.getMonth() == jLastDate.getMonth()) {
+ // The "gap" fits in the same month.
+ fixedDateMonth1 = jcal.getFixedDate(date.getNormalizedYear(),
+ date.getMonth(),
+ 1,
+ null);
+ } else {
+ // Use the cutover date as the first day of the month.
+ fixedDateMonth1 = gregorianCutoverDate;
+ }
+ } else {
+ // The cutover happened before the month.
+ fixedDateMonth1 = fixedDate - date.getDayOfMonth() + 1;
+ }
+
+ return fixedDateMonth1;
+ }
+
+ /**
+ * Returns a CalendarDate produced from the specified fixed date.
+ *
+ * @param fd the fixed date
+ */
+ private BaseCalendar.Date getCalendarDate(long fd) {
+ BaseCalendar cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem();
+ BaseCalendar.Date d = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.NO_TIMEZONE);
+ cal.getCalendarDateFromFixedDate(d, fd);
+ return d;
+ }
+
+ /**
+ * Returns the Gregorian cutover date as a BaseCalendar.Date. The
+ * date is a Gregorian date.
+ */
+ private BaseCalendar.Date getGregorianCutoverDate() {
+ return getCalendarDate(gregorianCutoverDate);
+ }
+
+ /**
+ * Returns the day before the Gregorian cutover date as a
+ * BaseCalendar.Date. The date is a Julian date.
+ */
+ private BaseCalendar.Date getLastJulianDate() {
+ return getCalendarDate(gregorianCutoverDate - 1);
+ }
+
+ /**
+ * Returns the length of the specified month in the specified
+ * year. The year number must be normalized.
+ *
+ * @see #isLeapYear(int)
+ */
+ private int monthLength(int month, int year) {
+ return isLeapYear(year) ? LEAP_MONTH_LENGTH[month] : MONTH_LENGTH[month];
+ }
+
+ /**
+ * Returns the length of the specified month in the year provided
+ * by internalGet(YEAR).
+ *
+ * @see #isLeapYear(int)
+ */
+ private int monthLength(int month) {
+ int year = internalGet(YEAR);
+ if (internalGetEra() == BCE) {
+ year = 1 - year;
+ }
+ return monthLength(month, year);
+ }
+
+ private int actualMonthLength() {
+ int year = cdate.getNormalizedYear();
+ if (year != gregorianCutoverYear && year != gregorianCutoverYearJulian) {
+ return calsys.getMonthLength(cdate);
+ }
+ BaseCalendar.Date date = (BaseCalendar.Date) cdate.clone();
+ long fd = calsys.getFixedDate(date);
+ long month1 = getFixedDateMonth1(date, fd);
+ long next1 = month1 + calsys.getMonthLength(date);
+ if (next1 < gregorianCutoverDate) {
+ return (int)(next1 - month1);
+ }
+ if (cdate != gdate) {
+ date = (BaseCalendar.Date) gcal.newCalendarDate(TimeZone.NO_TIMEZONE);
+ }
+ gcal.getCalendarDateFromFixedDate(date, next1);
+ next1 = getFixedDateMonth1(date, next1);
+ return (int)(next1 - month1);
+ }
+
+ /**
+ * Returns the length (in days) of the specified year. The year
+ * must be normalized.
+ */
+ private int yearLength(int year) {
+ return isLeapYear(year) ? 366 : 365;
+ }
+
+ /**
+ * Returns the length (in days) of the year provided by
+ * internalGet(YEAR).
+ */
+ private int yearLength() {
+ int year = internalGet(YEAR);
+ if (internalGetEra() == BCE) {
+ year = 1 - year;
+ }
+ return yearLength(year);
+ }
+
+ /**
+ * After adjustments such as add(MONTH), add(YEAR), we don't want the
+ * month to jump around. E.g., we don't want Jan 31 + 1 month to go to Mar
+ * 3, we want it to go to Feb 28. Adjustments which might run into this
+ * problem call this method to retain the proper month.
+ */
+ private void pinDayOfMonth() {
+ int year = internalGet(YEAR);
+ int monthLen;
+ if (year > gregorianCutoverYear || year < gregorianCutoverYearJulian) {
+ monthLen = monthLength(internalGet(MONTH));
+ } else {
+ GregorianCalendar gc = getNormalizedCalendar();
+ monthLen = gc.getActualMaximum(DAY_OF_MONTH);
+ }
+ int dom = internalGet(DAY_OF_MONTH);
+ if (dom > monthLen) {
+ set(DAY_OF_MONTH, monthLen);
+ }
+ }
+
+ /**
+ * Returns the fixed date value of this object. The time value and
+ * calendar fields must be in synch.
+ */
+ private long getCurrentFixedDate() {
+ return (calsys == gcal) ? cachedFixedDate : calsys.getFixedDate(cdate);
+ }
+
+ /**
+ * Returns the new value after 'roll'ing the specified value and amount.
+ */
+ private static int getRolledValue(int value, int amount, int min, int max) {
+ assert value >= min && value <= max;
+ int range = max - min + 1;
+ amount %= range;
+ int n = value + amount;
+ if (n > max) {
+ n -= range;
+ } else if (n < min) {
+ n += range;
+ }
+ assert n >= min && n <= max;
+ return n;
+ }
+
+ /**
+ * Returns the ERA. We need a special method for this because the
+ * default ERA is CE, but a zero (unset) ERA is BCE.
+ */
+ private int internalGetEra() {
+ return isSet(ERA) ? internalGet(ERA) : CE;
+ }
+
+ /**
+ * Updates internal state.
+ */
+ private void readObject(ObjectInputStream stream)
+ throws IOException, ClassNotFoundException {
+ stream.defaultReadObject();
+ if (gdate == null) {
+ gdate = (BaseCalendar.Date) gcal.newCalendarDate(getZone());
+ cachedFixedDate = Long.MIN_VALUE;
+ }
+ setGregorianChange(gregorianCutover);
+ }
+
+ /**
+ * Converts this object to a {@code ZonedDateTime} that represents
+ * the same point on the time-line as this {@code GregorianCalendar}.
+ * <p>
+ * Since this object supports a Julian-Gregorian cutover date and
+ * {@code ZonedDateTime} does not, it is possible that the resulting year,
+ * month and day will have different values. The result will represent the
+ * correct date in the ISO calendar system, which will also be the same value
+ * for Modified Julian Days.
+ *
+ * @return a zoned date-time representing the same point on the time-line
+ * as this gregorian calendar
+ * @since 1.8
+ */
+ public ZonedDateTime toZonedDateTime() {
+ return ZonedDateTime.ofInstant(Instant.ofEpochMilli(getTimeInMillis()),
+ getTimeZone().toZoneId());
+ }
+
+ /**
+ * Obtains an instance of {@code GregorianCalendar} with the default locale
+ * from a {@code ZonedDateTime} object.
+ * <p>
+ * Since {@code ZonedDateTime} does not support a Julian-Gregorian cutover
+ * date and uses ISO calendar system, the return GregorianCalendar is a pure
+ * Gregorian calendar and uses ISO 8601 standard for week definitions,
+ * which has {@code MONDAY} as the {@link Calendar#getFirstDayOfWeek()
+ * FirstDayOfWeek} and {@code 4} as the value of the
+ * {@link Calendar#getMinimalDaysInFirstWeek() MinimalDaysInFirstWeek}.
+ * <p>
+ * {@code ZoneDateTime} can store points on the time-line further in the
+ * future and further in the past than {@code GregorianCalendar}. In this
+ * scenario, this method will throw an {@code IllegalArgumentException}
+ * exception.
+ *
+ * @param zdt the zoned date-time object to convert
+ * @return the gregorian calendar representing the same point on the
+ * time-line as the zoned date-time provided
+ * @exception NullPointerException if {@code zdt} is null
+ * @exception IllegalArgumentException if the zoned date-time is too
+ * large to represent as a {@code GregorianCalendar}
+ * @since 1.8
+ */
+ public static GregorianCalendar from(ZonedDateTime zdt) {
+ GregorianCalendar cal = new GregorianCalendar(TimeZone.getTimeZone(zdt.getZone()));
+ cal.setGregorianChange(new Date(Long.MIN_VALUE));
+ cal.setFirstDayOfWeek(MONDAY);
+ cal.setMinimalDaysInFirstWeek(4);
+ try {
+ cal.setTimeInMillis(Math.addExact(Math.multiplyExact(zdt.toEpochSecond(), 1000),
+ zdt.get(ChronoField.MILLI_OF_SECOND)));
+ } catch (ArithmeticException ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ return cal;
+ }
+}