You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by te...@apache.org on 2006/08/17 20:35:44 UTC
svn commit: r432326 -
/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/GregorianCalendar.java
Author: tellison
Date: Thu Aug 17 11:35:43 2006
New Revision: 432326
URL: http://svn.apache.org/viewvc?rev=432326&view=rev
Log:
Add new 5.0 annotations, remove unnecessary casts, formatting.
Modified:
incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/GregorianCalendar.java
Modified: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/GregorianCalendar.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/GregorianCalendar.java?rev=432326&r1=432325&r2=432326&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/GregorianCalendar.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/util/GregorianCalendar.java Thu Aug 17 11:35:43 2006
@@ -30,1184 +30,1202 @@
*/
public class GregorianCalendar extends Calendar {
- private static final long serialVersionUID = -8125100834729963327L;
+ private static final long serialVersionUID = -8125100834729963327L;
+
+ /**
+ * Value for the BC era.
+ */
+ public static final int BC = 0;
- /**
- * Value for the BC era.
- */
- public static final int BC = 0;
-
/**
* Value for the AD era.
*/
public static final int AD = 1;
- private long gregorianCutover = -12219292800000l;
+ private long gregorianCutover = -12219292800000l;
+
+ private transient int changeYear = 1582;
+
+ private transient int julianSkew = ((changeYear - 2000) / 400)
+ + julianError() - ((changeYear - 2000) / 100);
+
+ static byte[] DaysInMonth = new byte[] { 31, 28, 31, 30, 31, 30, 31, 31,
+ 30, 31, 30, 31 };
+
+ private static int[] DaysInYear = new int[] { 0, 31, 59, 90, 120, 151, 181,
+ 212, 243, 273, 304, 334 };
- private transient int changeYear = 1582;
+ private static int[] maximums = new int[] { 1, 292278994, 11, 53, 6, 31,
+ 366, 7, 6, 1, 11, 23, 59, 59, 999, 14 * 3600 * 1000, 3600000 };
- private transient int julianSkew = ((changeYear - 2000) / 400)
- + julianError() - ((changeYear - 2000) / 100);
+ private static int[] minimums = new int[] { 0, 1, 0, 1, 0, 1, 1, 1, -1, 0,
+ 0, 0, 0, 0, 0, -13 * 3600 * 1000, 0 };
- static byte[] DaysInMonth = new byte[] { 31, 28, 31, 30, 31, 30, 31, 31,
- 30, 31, 30, 31 };
-
- private static int[] DaysInYear = new int[] { 0, 31, 59, 90, 120, 151, 181,
- 212, 243, 273, 304, 334 };
-
- private static int[] maximums = new int[] { 1, 292278994, 11, 53, 6, 31,
- 366, 7, 6, 1, 11, 23, 59, 59, 999, 14 * 3600 * 1000, 3600000 };
-
- private static int[] minimums = new int[] { 0, 1, 0, 1, 0, 1, 1, 1, -1, 0,
- 0, 0, 0, 0, 0, -13* 3600 * 1000, 0 };
-
- private static int[] leastMaximums = new int[] { 1, 292269054, 11, 52, 4,
- 28, 365, 7, 4, 1, 11, 23, 59, 59, 999, 14 * 3600 * 1000, 3600000 };
-
- private boolean isCached;
-
- private int cachedFields[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-
- private long nextMidnightMillis = 0L;
-
- private long lastMidnightMillis = 0L;
-
- /**
- * Constructs a new GregorianCalendar initialized to the current date and
- * time.
- */
- public GregorianCalendar() {
- this(TimeZone.getDefault(), Locale.getDefault());
- }
-
- /**
- * Constructs a new GregorianCalendar initialized to midnight in the default
- * time zone on the specified date.
- *
- * @param year
- * the year
- * @param month
- * the month
- * @param day
- * the day of the month
- */
- public GregorianCalendar(int year, int month, int day) {
- super(TimeZone.getDefault(), Locale.getDefault());
- set(year, month, day);
- }
-
- /**
- * Constructs a new GregorianCalendar initialized to the specified date and
- * time.
- *
- * @param year
- * the year
- * @param month
- * the month
- * @param day
- * the day of the month
- * @param hour
- * the hour
- * @param minute
- * the minute
- */
- public GregorianCalendar(int year, int month, int day, int hour, int minute) {
- super(TimeZone.getDefault(), Locale.getDefault());
- set(year, month, day, hour, minute);
- }
-
- /**
- * Constructs a new GregorianCalendar initialized to the specified date and
- * time.
- *
- * @param year
- * the year
- * @param month
- * the month
- * @param day
- * the day of the month
- * @param hour
- * the hour
- * @param minute
- * the minute
- * @param second
- * the second
- */
- public GregorianCalendar(int year, int month, int day, int hour,
- int minute, int second) {
- super(TimeZone.getDefault(), Locale.getDefault());
- set(year, month, day, hour, minute, second);
- }
-
- GregorianCalendar(long milliseconds) {
- this(false);
- setTimeInMillis(milliseconds);
- }
-
- /**
- * Constructs a new GregorianCalendar initialized to the current date and
- * time and using the specified Locale.
- *
- * @param locale
- * the Locale
- */
- public GregorianCalendar(Locale locale) {
- this(TimeZone.getDefault(), locale);
- }
-
- /**
- * Constructs a new GregorianCalendar initialized to the current date and
- * time and using the specified TimeZone.
- *
- * @param timezone
- * the TimeZone
- */
- public GregorianCalendar(TimeZone timezone) {
- this(timezone, Locale.getDefault());
- }
-
- /**
- * Constructs a new GregorianCalendar initialized to the current date and
- * time and using the specified TimeZone and Locale.
- *
- * @param timezone
- * the TimeZone
- * @param locale
- * the Locale
- */
- public GregorianCalendar(TimeZone timezone, Locale locale) {
- super(timezone, locale);
- setTimeInMillis(System.currentTimeMillis());
- }
-
- GregorianCalendar(boolean ignored) {
- super(TimeZone.getDefault());
- setFirstDayOfWeek(SUNDAY);
- setMinimalDaysInFirstWeek(1);
- }
-
- /**
- * Adds the specified amount to a Calendar field.
- *
- * @param field
- * the Calendar field to modify
- * @param value
- * the amount to add to the field
- *
- * @exception IllegalArgumentException
- * when the specified field is DST_OFFSET or ZONE_OFFSET.
- */
- public void add(int field, int value) {
- if (value == 0) {
+ private static int[] leastMaximums = new int[] { 1, 292269054, 11, 52, 4,
+ 28, 365, 7, 4, 1, 11, 23, 59, 59, 999, 14 * 3600 * 1000, 3600000 };
+
+ private boolean isCached;
+
+ private int cachedFields[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+ private long nextMidnightMillis = 0L;
+
+ private long lastMidnightMillis = 0L;
+
+ /**
+ * Constructs a new GregorianCalendar initialized to the current date and
+ * time.
+ */
+ public GregorianCalendar() {
+ this(TimeZone.getDefault(), Locale.getDefault());
+ }
+
+ /**
+ * Constructs a new GregorianCalendar initialized to midnight in the default
+ * time zone on the specified date.
+ *
+ * @param year
+ * the year
+ * @param month
+ * the month
+ * @param day
+ * the day of the month
+ */
+ public GregorianCalendar(int year, int month, int day) {
+ super(TimeZone.getDefault(), Locale.getDefault());
+ set(year, month, day);
+ }
+
+ /**
+ * Constructs a new GregorianCalendar initialized to the specified date and
+ * time.
+ *
+ * @param year
+ * the year
+ * @param month
+ * the month
+ * @param day
+ * the day of the month
+ * @param hour
+ * the hour
+ * @param minute
+ * the minute
+ */
+ public GregorianCalendar(int year, int month, int day, int hour, int minute) {
+ super(TimeZone.getDefault(), Locale.getDefault());
+ set(year, month, day, hour, minute);
+ }
+
+ /**
+ * Constructs a new GregorianCalendar initialized to the specified date and
+ * time.
+ *
+ * @param year
+ * the year
+ * @param month
+ * the month
+ * @param day
+ * the day of the month
+ * @param hour
+ * the hour
+ * @param minute
+ * the minute
+ * @param second
+ * the second
+ */
+ public GregorianCalendar(int year, int month, int day, int hour,
+ int minute, int second) {
+ super(TimeZone.getDefault(), Locale.getDefault());
+ set(year, month, day, hour, minute, second);
+ }
+
+ GregorianCalendar(long milliseconds) {
+ this(false);
+ setTimeInMillis(milliseconds);
+ }
+
+ /**
+ * Constructs a new GregorianCalendar initialized to the current date and
+ * time and using the specified Locale.
+ *
+ * @param locale
+ * the Locale
+ */
+ public GregorianCalendar(Locale locale) {
+ this(TimeZone.getDefault(), locale);
+ }
+
+ /**
+ * Constructs a new GregorianCalendar initialized to the current date and
+ * time and using the specified TimeZone.
+ *
+ * @param timezone
+ * the TimeZone
+ */
+ public GregorianCalendar(TimeZone timezone) {
+ this(timezone, Locale.getDefault());
+ }
+
+ /**
+ * Constructs a new GregorianCalendar initialized to the current date and
+ * time and using the specified TimeZone and Locale.
+ *
+ * @param timezone
+ * the TimeZone
+ * @param locale
+ * the Locale
+ */
+ public GregorianCalendar(TimeZone timezone, Locale locale) {
+ super(timezone, locale);
+ setTimeInMillis(System.currentTimeMillis());
+ }
+
+ GregorianCalendar(boolean ignored) {
+ super(TimeZone.getDefault());
+ setFirstDayOfWeek(SUNDAY);
+ setMinimalDaysInFirstWeek(1);
+ }
+
+ /**
+ * Adds the specified amount to a Calendar field.
+ *
+ * @param field
+ * the Calendar field to modify
+ * @param value
+ * the amount to add to the field
+ *
+ * @exception IllegalArgumentException
+ * when the specified field is DST_OFFSET or ZONE_OFFSET.
+ */
+ @Override
+ public void add(int field, int value) {
+ if (value == 0) {
return;
}
- if (field < 0 || field >= ZONE_OFFSET) {
+ if (field < 0 || field >= ZONE_OFFSET) {
throw new IllegalArgumentException();
}
- isCached = false;
+ isCached = false;
- if (field == ERA) {
- complete();
- if (fields[ERA] == AD) {
- if (value >= 0) {
+ if (field == ERA) {
+ complete();
+ if (fields[ERA] == AD) {
+ if (value >= 0) {
return;
}
- set(ERA, BC);
- } else {
- if (value <= 0) {
+ set(ERA, BC);
+ } else {
+ if (value <= 0) {
return;
}
- set(ERA, AD);
- }
- complete();
- return;
- }
-
- if (field == YEAR || field == MONTH) {
- complete();
- if (field == MONTH) {
- int month = fields[MONTH] + value;
- if (month < 0) {
- value = (month - 11) / 12;
- month = 12 + (month % 12);
- } else {
+ set(ERA, AD);
+ }
+ complete();
+ return;
+ }
+
+ if (field == YEAR || field == MONTH) {
+ complete();
+ if (field == MONTH) {
+ int month = fields[MONTH] + value;
+ if (month < 0) {
+ value = (month - 11) / 12;
+ month = 12 + (month % 12);
+ } else {
value = month / 12;
}
- set(MONTH, month % 12);
- }
- set(YEAR, fields[YEAR] + value);
- int days = daysInMonth(isLeapYear(fields[YEAR]), fields[MONTH]);
- if (fields[DATE] > days) {
+ set(MONTH, month % 12);
+ }
+ set(YEAR, fields[YEAR] + value);
+ int days = daysInMonth(isLeapYear(fields[YEAR]), fields[MONTH]);
+ if (fields[DATE] > days) {
set(DATE, days);
}
- complete();
- return;
- }
-
- long multiplier = 0;
- getTimeInMillis(); // Update the time
- switch (field) {
- case MILLISECOND:
- time += value;
- break;
- case SECOND:
- time += value * 1000L;
- break;
- case MINUTE:
- time += value * 60000L;
- break;
- case HOUR:
- case HOUR_OF_DAY:
- time += value * 3600000L;
- break;
- case AM_PM:
- multiplier = 43200000L;
- break;
- case DATE:
- case DAY_OF_YEAR:
- case DAY_OF_WEEK:
- multiplier = 86400000L;
- break;
- case WEEK_OF_YEAR:
- case WEEK_OF_MONTH:
- case DAY_OF_WEEK_IN_MONTH:
- multiplier = 604800000L;
- break;
- }
- if (multiplier > 0) {
- int zoneOffset = getTimeZone().getRawOffset();
- int offset = getOffset(time + zoneOffset);
- time += value * multiplier;
- int newOffset = getOffset(time + zoneOffset);
- // Adjust for moving over a DST boundary
- if (newOffset != offset) {
+ complete();
+ return;
+ }
+
+ long multiplier = 0;
+ getTimeInMillis(); // Update the time
+ switch (field) {
+ case MILLISECOND:
+ time += value;
+ break;
+ case SECOND:
+ time += value * 1000L;
+ break;
+ case MINUTE:
+ time += value * 60000L;
+ break;
+ case HOUR:
+ case HOUR_OF_DAY:
+ time += value * 3600000L;
+ break;
+ case AM_PM:
+ multiplier = 43200000L;
+ break;
+ case DATE:
+ case DAY_OF_YEAR:
+ case DAY_OF_WEEK:
+ multiplier = 86400000L;
+ break;
+ case WEEK_OF_YEAR:
+ case WEEK_OF_MONTH:
+ case DAY_OF_WEEK_IN_MONTH:
+ multiplier = 604800000L;
+ break;
+ }
+ if (multiplier > 0) {
+ int zoneOffset = getTimeZone().getRawOffset();
+ int offset = getOffset(time + zoneOffset);
+ time += value * multiplier;
+ int newOffset = getOffset(time + zoneOffset);
+ // Adjust for moving over a DST boundary
+ if (newOffset != offset) {
time += offset - newOffset;
}
- }
- areFieldsSet = false;
- complete();
- }
+ }
+ areFieldsSet = false;
+ complete();
+ }
/**
* Creates new instance of GregorianCalendar with the same properties.
*
* @return a shallow copy of this GregorianCalendar
*/
- public Object clone(){
- GregorianCalendar thisClone = (GregorianCalendar)super.clone();
+ @Override
+ public Object clone() {
+ GregorianCalendar thisClone = (GregorianCalendar) super.clone();
thisClone.cachedFields = cachedFields.clone();
return thisClone;
}
private final void fullFieldsCalc(long timeVal, int millis, int zoneOffset) {
- long days = timeVal / 86400000;
+ long days = timeVal / 86400000;
- if (millis < 0) {
- millis += 86400000;
- days--;
- }
- // Cannot add ZONE_OFFSET to time as it might overflow
- millis += zoneOffset;
- if (millis < 0) {
- millis += 86400000;
- days--;
- } else if (millis >= 86400000) {
- millis -= 86400000;
- days++;
- }
-
- int dayOfYear = computeYearAndDay(days, timeVal + zoneOffset);
- fields[DAY_OF_YEAR] = dayOfYear;
- int month = dayOfYear / 32;
- boolean leapYear = isLeapYear(fields[YEAR]);
- int date = dayOfYear - daysInYear(leapYear, month);
- if (date > daysInMonth(leapYear, month)) {
- date -= daysInMonth(leapYear, month);
- month++;
- }
- fields[DAY_OF_WEEK] = mod7(days - 3) + 1;
- int dstOffset = fields[YEAR] <= 0 ? 0 : getTimeZone().getOffset(AD,
- fields[YEAR], month, date, fields[DAY_OF_WEEK], millis);
- if (fields[YEAR] > 0) {
+ if (millis < 0) {
+ millis += 86400000;
+ days--;
+ }
+ // Cannot add ZONE_OFFSET to time as it might overflow
+ millis += zoneOffset;
+ if (millis < 0) {
+ millis += 86400000;
+ days--;
+ } else if (millis >= 86400000) {
+ millis -= 86400000;
+ days++;
+ }
+
+ int dayOfYear = computeYearAndDay(days, timeVal + zoneOffset);
+ fields[DAY_OF_YEAR] = dayOfYear;
+ int month = dayOfYear / 32;
+ boolean leapYear = isLeapYear(fields[YEAR]);
+ int date = dayOfYear - daysInYear(leapYear, month);
+ if (date > daysInMonth(leapYear, month)) {
+ date -= daysInMonth(leapYear, month);
+ month++;
+ }
+ fields[DAY_OF_WEEK] = mod7(days - 3) + 1;
+ int dstOffset = fields[YEAR] <= 0 ? 0 : getTimeZone().getOffset(AD,
+ fields[YEAR], month, date, fields[DAY_OF_WEEK], millis);
+ if (fields[YEAR] > 0) {
dstOffset -= zoneOffset;
}
- fields[DST_OFFSET] = dstOffset;
- if (dstOffset != 0) {
- long oldDays = days;
- millis += dstOffset;
- if (millis < 0) {
- millis += 86400000;
- days--;
- } else if (millis >= 86400000) {
- millis -= 86400000;
- days++;
- }
- if (oldDays != days) {
- dayOfYear = computeYearAndDay(days, timeVal - zoneOffset
- + dstOffset);
- fields[DAY_OF_YEAR] = dayOfYear;
- month = dayOfYear / 32;
- leapYear = isLeapYear(fields[YEAR]);
- date = dayOfYear - daysInYear(leapYear, month);
- if (date > daysInMonth(leapYear, month)) {
- date -= daysInMonth(leapYear, month);
- month++;
- }
- fields[DAY_OF_WEEK] = mod7(days - 3) + 1;
- }
- }
-
- fields[MILLISECOND] = (millis % 1000);
- millis /= 1000;
- fields[SECOND] = (millis % 60);
- millis /= 60;
- fields[MINUTE] = (millis % 60);
- millis /= 60;
- fields[HOUR_OF_DAY] = (millis % 24);
- millis /= 24;
- fields[AM_PM] = fields[HOUR_OF_DAY] > 11 ? 1 : 0;
- fields[HOUR] = fields[HOUR_OF_DAY] % 12;
-
- if (fields[YEAR] <= 0) {
- fields[ERA] = BC;
- fields[YEAR] = -fields[YEAR] + 1;
- } else {
+ fields[DST_OFFSET] = dstOffset;
+ if (dstOffset != 0) {
+ long oldDays = days;
+ millis += dstOffset;
+ if (millis < 0) {
+ millis += 86400000;
+ days--;
+ } else if (millis >= 86400000) {
+ millis -= 86400000;
+ days++;
+ }
+ if (oldDays != days) {
+ dayOfYear = computeYearAndDay(days, timeVal - zoneOffset
+ + dstOffset);
+ fields[DAY_OF_YEAR] = dayOfYear;
+ month = dayOfYear / 32;
+ leapYear = isLeapYear(fields[YEAR]);
+ date = dayOfYear - daysInYear(leapYear, month);
+ if (date > daysInMonth(leapYear, month)) {
+ date -= daysInMonth(leapYear, month);
+ month++;
+ }
+ fields[DAY_OF_WEEK] = mod7(days - 3) + 1;
+ }
+ }
+
+ fields[MILLISECOND] = (millis % 1000);
+ millis /= 1000;
+ fields[SECOND] = (millis % 60);
+ millis /= 60;
+ fields[MINUTE] = (millis % 60);
+ millis /= 60;
+ fields[HOUR_OF_DAY] = (millis % 24);
+ millis /= 24;
+ fields[AM_PM] = fields[HOUR_OF_DAY] > 11 ? 1 : 0;
+ fields[HOUR] = fields[HOUR_OF_DAY] % 12;
+
+ if (fields[YEAR] <= 0) {
+ fields[ERA] = BC;
+ fields[YEAR] = -fields[YEAR] + 1;
+ } else {
fields[ERA] = AD;
}
- fields[MONTH] = month;
- fields[DATE] = date;
- fields[DAY_OF_WEEK_IN_MONTH] = (date - 1) / 7 + 1;
- fields[WEEK_OF_MONTH] = (date - 1 + mod7(days - date - 2
- - (getFirstDayOfWeek() - 1))) / 7 + 1;
- int daysFromStart = mod7(days - 3 - (fields[DAY_OF_YEAR] - 1)
- - (getFirstDayOfWeek() - 1));
- int week = (fields[DAY_OF_YEAR] - 1 + daysFromStart) / 7
- + (7 - daysFromStart >= getMinimalDaysInFirstWeek() ? 1 : 0);
- if (week == 0) {
- fields[WEEK_OF_YEAR] = 7 - mod7(daysFromStart
- - (isLeapYear(fields[YEAR] - 1) ? 2 : 1)) >= getMinimalDaysInFirstWeek() ? 53
- : 52;
- } else if (fields[DAY_OF_YEAR] >= (leapYear ? 367 : 366)
- - mod7(daysFromStart + (leapYear ? 2 : 1))) {
- fields[WEEK_OF_YEAR] = 7 - mod7(daysFromStart + (leapYear ? 2 : 1)) >= getMinimalDaysInFirstWeek() ? 1
- : week;
- } else {
- fields[WEEK_OF_YEAR] = week;
- }
- }
-
- private final void cachedFieldsCheckAndGet(long timeVal,
- long newTimeMillis, long newTimeMillisAdjusted, int millis,
- int zoneOffset) {
- int dstOffset = fields[DST_OFFSET];
- if (!isCached
- || newTimeMillis >= nextMidnightMillis
- || newTimeMillis <= lastMidnightMillis
- || cachedFields[4] != zoneOffset
- || (dstOffset == 0 && (newTimeMillisAdjusted >= nextMidnightMillis))
- || (dstOffset != 0 && (newTimeMillisAdjusted <= lastMidnightMillis))) {
- fullFieldsCalc(timeVal, millis, zoneOffset);
- isCached = false;
- } else {
- fields[YEAR] = cachedFields[0];
- fields[MONTH] = cachedFields[1];
- fields[DATE] = cachedFields[2];
- fields[DAY_OF_WEEK] = cachedFields[3];
- fields[ERA] = cachedFields[5];
- fields[WEEK_OF_YEAR] = cachedFields[6];
- fields[WEEK_OF_MONTH] = cachedFields[7];
- fields[DAY_OF_YEAR] = cachedFields[8];
- fields[DAY_OF_WEEK_IN_MONTH] = cachedFields[9];
- }
- }
-
- /**
- * Computes the Calendar fields from the time.
- */
- protected void computeFields() {
- int zoneOffset = getTimeZone().getRawOffset();
-
- fields[ZONE_OFFSET] = zoneOffset;
-
- int millis = (int) (time % 86400000);
- int savedMillis = millis;
- int dstOffset = fields[DST_OFFSET];
- // compute without a change in daylight saving time
- int offset = zoneOffset + dstOffset;
- long newTime = time + offset;
+ fields[MONTH] = month;
+ fields[DATE] = date;
+ fields[DAY_OF_WEEK_IN_MONTH] = (date - 1) / 7 + 1;
+ fields[WEEK_OF_MONTH] = (date - 1 + mod7(days - date - 2
+ - (getFirstDayOfWeek() - 1))) / 7 + 1;
+ int daysFromStart = mod7(days - 3 - (fields[DAY_OF_YEAR] - 1)
+ - (getFirstDayOfWeek() - 1));
+ int week = (fields[DAY_OF_YEAR] - 1 + daysFromStart) / 7
+ + (7 - daysFromStart >= getMinimalDaysInFirstWeek() ? 1 : 0);
+ if (week == 0) {
+ fields[WEEK_OF_YEAR] = 7 - mod7(daysFromStart
+ - (isLeapYear(fields[YEAR] - 1) ? 2 : 1)) >= getMinimalDaysInFirstWeek() ? 53
+ : 52;
+ } else if (fields[DAY_OF_YEAR] >= (leapYear ? 367 : 366)
+ - mod7(daysFromStart + (leapYear ? 2 : 1))) {
+ fields[WEEK_OF_YEAR] = 7 - mod7(daysFromStart + (leapYear ? 2 : 1)) >= getMinimalDaysInFirstWeek() ? 1
+ : week;
+ } else {
+ fields[WEEK_OF_YEAR] = week;
+ }
+ }
- if (time > 0L && newTime < 0L && offset > 0) {
+ private final void cachedFieldsCheckAndGet(long timeVal,
+ long newTimeMillis, long newTimeMillisAdjusted, int millis,
+ int zoneOffset) {
+ int dstOffset = fields[DST_OFFSET];
+ if (!isCached
+ || newTimeMillis >= nextMidnightMillis
+ || newTimeMillis <= lastMidnightMillis
+ || cachedFields[4] != zoneOffset
+ || (dstOffset == 0 && (newTimeMillisAdjusted >= nextMidnightMillis))
+ || (dstOffset != 0 && (newTimeMillisAdjusted <= lastMidnightMillis))) {
+ fullFieldsCalc(timeVal, millis, zoneOffset);
+ isCached = false;
+ } else {
+ fields[YEAR] = cachedFields[0];
+ fields[MONTH] = cachedFields[1];
+ fields[DATE] = cachedFields[2];
+ fields[DAY_OF_WEEK] = cachedFields[3];
+ fields[ERA] = cachedFields[5];
+ fields[WEEK_OF_YEAR] = cachedFields[6];
+ fields[WEEK_OF_MONTH] = cachedFields[7];
+ fields[DAY_OF_YEAR] = cachedFields[8];
+ fields[DAY_OF_WEEK_IN_MONTH] = cachedFields[9];
+ }
+ }
+
+ /**
+ * Computes the Calendar fields from the time.
+ */
+ @Override
+ protected void computeFields() {
+ int zoneOffset = getTimeZone().getRawOffset();
+
+ fields[ZONE_OFFSET] = zoneOffset;
+
+ int millis = (int) (time % 86400000);
+ int savedMillis = millis;
+ int dstOffset = fields[DST_OFFSET];
+ // compute without a change in daylight saving time
+ int offset = zoneOffset + dstOffset;
+ long newTime = time + offset;
+
+ if (time > 0L && newTime < 0L && offset > 0) {
newTime = 0x7fffffffffffffffL;
} else if (time < 0L && newTime > 0L && offset < 0) {
newTime = 0x8000000000000000L;
}
- if (isCached) {
- if (millis < 0) {
- millis += 86400000;
- }
-
- // Cannot add ZONE_OFFSET to time as it might overflow
- millis += zoneOffset;
- millis += dstOffset;
-
- if (millis < 0) {
- millis += 86400000;
- } else if (millis >= 86400000) {
- millis -= 86400000;
- }
-
- fields[MILLISECOND] = (millis % 1000);
- millis /= 1000;
- fields[SECOND] = (millis % 60);
- millis /= 60;
- fields[MINUTE] = (millis % 60);
- millis /= 60;
- fields[HOUR_OF_DAY] = (millis % 24);
- millis /= 24;
- fields[AM_PM] = fields[HOUR_OF_DAY] > 11 ? 1 : 0;
- fields[HOUR] = fields[HOUR_OF_DAY] % 12;
-
- long newTimeAdjusted = newTime;
- if (getTimeZone().useDaylightTime()) {
- int dstSavings = ((SimpleTimeZone) getTimeZone())
- .getDSTSavings();
- newTimeAdjusted += (dstOffset == 0) ? dstSavings : -dstSavings;
- }
+ if (isCached) {
+ if (millis < 0) {
+ millis += 86400000;
+ }
+
+ // Cannot add ZONE_OFFSET to time as it might overflow
+ millis += zoneOffset;
+ millis += dstOffset;
+
+ if (millis < 0) {
+ millis += 86400000;
+ } else if (millis >= 86400000) {
+ millis -= 86400000;
+ }
+
+ fields[MILLISECOND] = (millis % 1000);
+ millis /= 1000;
+ fields[SECOND] = (millis % 60);
+ millis /= 60;
+ fields[MINUTE] = (millis % 60);
+ millis /= 60;
+ fields[HOUR_OF_DAY] = (millis % 24);
+ millis /= 24;
+ fields[AM_PM] = fields[HOUR_OF_DAY] > 11 ? 1 : 0;
+ fields[HOUR] = fields[HOUR_OF_DAY] % 12;
+
+ long newTimeAdjusted = newTime;
+ if (getTimeZone().useDaylightTime()) {
+ int dstSavings = ((SimpleTimeZone) getTimeZone())
+ .getDSTSavings();
+ newTimeAdjusted += (dstOffset == 0) ? dstSavings : -dstSavings;
+ }
- if (newTime > 0L && newTimeAdjusted < 0L && dstOffset == 0) {
+ if (newTime > 0L && newTimeAdjusted < 0L && dstOffset == 0) {
newTimeAdjusted = 0x7fffffffffffffffL;
} else if (newTime < 0L && newTimeAdjusted > 0L && dstOffset != 0) {
newTimeAdjusted = 0x8000000000000000L;
}
- cachedFieldsCheckAndGet(time, newTime, newTimeAdjusted,
- savedMillis, zoneOffset);
- } else {
+ cachedFieldsCheckAndGet(time, newTime, newTimeAdjusted,
+ savedMillis, zoneOffset);
+ } else {
fullFieldsCalc(time, savedMillis, zoneOffset);
}
- for (int i = 0; i < FIELD_COUNT; i++) {
+ for (int i = 0; i < FIELD_COUNT; i++) {
isSet[i] = true;
}
- // Caching
- if (!isCached
- && newTime != 0x7fffffffffffffffL
- && newTime != 0x8000000000000000L
- && (!getTimeZone().useDaylightTime() || getTimeZone() instanceof SimpleTimeZone)) {
- int cacheMillis = 0;
-
- cachedFields[0] = fields[YEAR];
- cachedFields[1] = fields[MONTH];
- cachedFields[2] = fields[DATE];
- cachedFields[3] = fields[DAY_OF_WEEK];
- cachedFields[4] = zoneOffset;
- cachedFields[5] = fields[ERA];
- cachedFields[6] = fields[WEEK_OF_YEAR];
- cachedFields[7] = fields[WEEK_OF_MONTH];
- cachedFields[8] = fields[DAY_OF_YEAR];
- cachedFields[9] = fields[DAY_OF_WEEK_IN_MONTH];
-
- cacheMillis += (23 - fields[HOUR_OF_DAY]) * 60 * 60 * 1000;
- cacheMillis += (59 - fields[MINUTE]) * 60 * 1000;
- cacheMillis += (59 - fields[SECOND]) * 1000;
- nextMidnightMillis = newTime + cacheMillis;
-
- cacheMillis = fields[HOUR_OF_DAY] * 60 * 60 * 1000;
- cacheMillis += fields[MINUTE] * 60 * 1000;
- cacheMillis += fields[SECOND] * 1000;
- lastMidnightMillis = newTime - cacheMillis;
-
- isCached = true;
- }
- }
-
- /**
- * Computes the time from the Calendar fields.
- *
- * @exception IllegalArgumentException
- * when the time cannot be computed from the current field
- * values
- */
- protected void computeTime() {
- if (!isLenient()) {
- if (isSet[HOUR_OF_DAY]) {
- if (fields[HOUR_OF_DAY] < 0 || fields[HOUR_OF_DAY] > 23) {
+ // Caching
+ if (!isCached
+ && newTime != 0x7fffffffffffffffL
+ && newTime != 0x8000000000000000L
+ && (!getTimeZone().useDaylightTime() || getTimeZone() instanceof SimpleTimeZone)) {
+ int cacheMillis = 0;
+
+ cachedFields[0] = fields[YEAR];
+ cachedFields[1] = fields[MONTH];
+ cachedFields[2] = fields[DATE];
+ cachedFields[3] = fields[DAY_OF_WEEK];
+ cachedFields[4] = zoneOffset;
+ cachedFields[5] = fields[ERA];
+ cachedFields[6] = fields[WEEK_OF_YEAR];
+ cachedFields[7] = fields[WEEK_OF_MONTH];
+ cachedFields[8] = fields[DAY_OF_YEAR];
+ cachedFields[9] = fields[DAY_OF_WEEK_IN_MONTH];
+
+ cacheMillis += (23 - fields[HOUR_OF_DAY]) * 60 * 60 * 1000;
+ cacheMillis += (59 - fields[MINUTE]) * 60 * 1000;
+ cacheMillis += (59 - fields[SECOND]) * 1000;
+ nextMidnightMillis = newTime + cacheMillis;
+
+ cacheMillis = fields[HOUR_OF_DAY] * 60 * 60 * 1000;
+ cacheMillis += fields[MINUTE] * 60 * 1000;
+ cacheMillis += fields[SECOND] * 1000;
+ lastMidnightMillis = newTime - cacheMillis;
+
+ isCached = true;
+ }
+ }
+
+ /**
+ * Computes the time from the Calendar fields.
+ *
+ * @exception IllegalArgumentException
+ * when the time cannot be computed from the current field
+ * values
+ */
+ @Override
+ protected void computeTime() {
+ if (!isLenient()) {
+ if (isSet[HOUR_OF_DAY]) {
+ if (fields[HOUR_OF_DAY] < 0 || fields[HOUR_OF_DAY] > 23) {
throw new IllegalArgumentException();
}
- } else if (isSet[HOUR] && (fields[HOUR] < 0 || fields[HOUR] > 11)) {
+ } else if (isSet[HOUR] && (fields[HOUR] < 0 || fields[HOUR] > 11)) {
throw new IllegalArgumentException();
}
- if (isSet[MINUTE] && (fields[MINUTE] < 0 || fields[MINUTE] > 59)) {
+ if (isSet[MINUTE] && (fields[MINUTE] < 0 || fields[MINUTE] > 59)) {
throw new IllegalArgumentException();
}
- if (isSet[SECOND] && (fields[SECOND] < 0 || fields[SECOND] > 59)) {
+ if (isSet[SECOND] && (fields[SECOND] < 0 || fields[SECOND] > 59)) {
throw new IllegalArgumentException();
}
- if (isSet[MILLISECOND]
- && (fields[MILLISECOND] < 0 || fields[MILLISECOND] > 999)) {
+ if (isSet[MILLISECOND]
+ && (fields[MILLISECOND] < 0 || fields[MILLISECOND] > 999)) {
throw new IllegalArgumentException();
}
- if (isSet[WEEK_OF_YEAR]
- && (fields[WEEK_OF_YEAR] < 1 || fields[WEEK_OF_YEAR] > 53)) {
+ if (isSet[WEEK_OF_YEAR]
+ && (fields[WEEK_OF_YEAR] < 1 || fields[WEEK_OF_YEAR] > 53)) {
throw new IllegalArgumentException();
}
- if (isSet[DAY_OF_WEEK]
- && (fields[DAY_OF_WEEK] < 1 || fields[DAY_OF_WEEK] > 7)) {
+ if (isSet[DAY_OF_WEEK]
+ && (fields[DAY_OF_WEEK] < 1 || fields[DAY_OF_WEEK] > 7)) {
throw new IllegalArgumentException();
}
- if (isSet[DAY_OF_WEEK_IN_MONTH]
- && (fields[DAY_OF_WEEK_IN_MONTH] < 1 || fields[DAY_OF_WEEK_IN_MONTH] > 6)) {
+ if (isSet[DAY_OF_WEEK_IN_MONTH]
+ && (fields[DAY_OF_WEEK_IN_MONTH] < 1 || fields[DAY_OF_WEEK_IN_MONTH] > 6)) {
throw new IllegalArgumentException();
}
- if (isSet[WEEK_OF_MONTH]
- && (fields[WEEK_OF_MONTH] < 1 || fields[WEEK_OF_MONTH] > 6)) {
+ if (isSet[WEEK_OF_MONTH]
+ && (fields[WEEK_OF_MONTH] < 1 || fields[WEEK_OF_MONTH] > 6)) {
throw new IllegalArgumentException();
}
- if (isSet[AM_PM] && fields[AM_PM] != AM && fields[AM_PM] != PM) {
+ if (isSet[AM_PM] && fields[AM_PM] != AM && fields[AM_PM] != PM) {
throw new IllegalArgumentException();
}
- if (isSet[HOUR] && (fields[HOUR] < 0 || fields[HOUR] > 11)) {
+ if (isSet[HOUR] && (fields[HOUR] < 0 || fields[HOUR] > 11)) {
throw new IllegalArgumentException();
}
- if (isSet[YEAR]) {
- if (isSet[ERA] && fields[ERA] == BC
- && (fields[YEAR] < 1 || fields[YEAR] > 292269054)) {
+ if (isSet[YEAR]) {
+ if (isSet[ERA] && fields[ERA] == BC
+ && (fields[YEAR] < 1 || fields[YEAR] > 292269054)) {
throw new IllegalArgumentException();
} else if (fields[YEAR] < 1 || fields[YEAR] > 292278994) {
throw new IllegalArgumentException();
}
- }
- if (isSet[MONTH] && (fields[MONTH] < 0 || fields[MONTH] > 11)) {
+ }
+ if (isSet[MONTH] && (fields[MONTH] < 0 || fields[MONTH] > 11)) {
throw new IllegalArgumentException();
}
- }
+ }
- long timeVal;
- long hour = 0;
- if (isSet[HOUR_OF_DAY] && lastTimeFieldSet != HOUR) {
+ long timeVal;
+ long hour = 0;
+ if (isSet[HOUR_OF_DAY] && lastTimeFieldSet != HOUR) {
hour = fields[HOUR_OF_DAY];
} else if (isSet[HOUR]) {
hour = (fields[AM_PM] * 12) + fields[HOUR];
}
- timeVal = hour * 3600000;
+ timeVal = hour * 3600000;
- if (isSet[MINUTE]) {
- timeVal += ((long)fields[MINUTE]) * 60000;
+ if (isSet[MINUTE]) {
+ timeVal += ((long) fields[MINUTE]) * 60000;
}
- if (isSet[SECOND]) {
- timeVal += ((long)fields[SECOND]) * 1000;
+ if (isSet[SECOND]) {
+ timeVal += ((long) fields[SECOND]) * 1000;
}
- if (isSet[MILLISECOND]) {
+ if (isSet[MILLISECOND]) {
timeVal += fields[MILLISECOND];
}
- long days;
- int year = isSet[YEAR] ? fields[YEAR] : 1970;
- if (isSet[ERA]) {
- // Always test for valid ERA, even if the Calendar is lenient
- if (fields[ERA] != BC && fields[ERA] != AD) {
+ long days;
+ int year = isSet[YEAR] ? fields[YEAR] : 1970;
+ if (isSet[ERA]) {
+ // Always test for valid ERA, even if the Calendar is lenient
+ if (fields[ERA] != BC && fields[ERA] != AD) {
throw new IllegalArgumentException();
}
- if (fields[ERA] == BC) {
+ if (fields[ERA] == BC) {
year = 1 - year;
}
- }
+ }
- boolean weekMonthSet = isSet[WEEK_OF_MONTH]
- || isSet[DAY_OF_WEEK_IN_MONTH];
- boolean useMonth = (isSet[DATE] || isSet[MONTH] || weekMonthSet)
- && lastDateFieldSet != DAY_OF_YEAR;
- if (useMonth
- && (lastDateFieldSet == DAY_OF_WEEK || lastDateFieldSet == WEEK_OF_YEAR)) {
- if (isSet[WEEK_OF_YEAR] && isSet[DAY_OF_WEEK]) {
+ boolean weekMonthSet = isSet[WEEK_OF_MONTH]
+ || isSet[DAY_OF_WEEK_IN_MONTH];
+ boolean useMonth = (isSet[DATE] || isSet[MONTH] || weekMonthSet)
+ && lastDateFieldSet != DAY_OF_YEAR;
+ if (useMonth
+ && (lastDateFieldSet == DAY_OF_WEEK || lastDateFieldSet == WEEK_OF_YEAR)) {
+ if (isSet[WEEK_OF_YEAR] && isSet[DAY_OF_WEEK]) {
useMonth = lastDateFieldSet != WEEK_OF_YEAR && weekMonthSet
- && isSet[DAY_OF_WEEK];
+ && isSet[DAY_OF_WEEK];
} else if (isSet[DAY_OF_YEAR]) {
useMonth = isSet[DATE] && isSet[MONTH];
}
- }
+ }
- if (useMonth) {
- int month = fields[MONTH];
- year += month / 12;
- month %= 12;
- if (month < 0) {
- year--;
- month += 12;
- }
- boolean leapYear = isLeapYear(year);
- days = daysFromBaseYear(year) + daysInYear(leapYear, month);
- boolean useDate = isSet[DATE];
- if (useDate
- && (lastDateFieldSet == DAY_OF_WEEK
- || lastDateFieldSet == WEEK_OF_MONTH || lastDateFieldSet == DAY_OF_WEEK_IN_MONTH)) {
- useDate = !(isSet[DAY_OF_WEEK] && weekMonthSet);
- }
- if (useDate) {
- if (!isLenient()
- && (fields[DATE] < 1 || fields[DATE] > daysInMonth(
- leapYear, month))) {
+ if (useMonth) {
+ int month = fields[MONTH];
+ year += month / 12;
+ month %= 12;
+ if (month < 0) {
+ year--;
+ month += 12;
+ }
+ boolean leapYear = isLeapYear(year);
+ days = daysFromBaseYear(year) + daysInYear(leapYear, month);
+ boolean useDate = isSet[DATE];
+ if (useDate
+ && (lastDateFieldSet == DAY_OF_WEEK
+ || lastDateFieldSet == WEEK_OF_MONTH || lastDateFieldSet == DAY_OF_WEEK_IN_MONTH)) {
+ useDate = !(isSet[DAY_OF_WEEK] && weekMonthSet);
+ }
+ if (useDate) {
+ if (!isLenient()
+ && (fields[DATE] < 1 || fields[DATE] > daysInMonth(
+ leapYear, month))) {
throw new IllegalArgumentException();
}
- days += fields[DATE] - 1;
- } else {
- int dayOfWeek;
- if (isSet[DAY_OF_WEEK]) {
- dayOfWeek = fields[DAY_OF_WEEK] - 1;
- } else {
+ days += fields[DATE] - 1;
+ } else {
+ int dayOfWeek;
+ if (isSet[DAY_OF_WEEK]) {
+ dayOfWeek = fields[DAY_OF_WEEK] - 1;
+ } else {
dayOfWeek = getFirstDayOfWeek() - 1;
}
- if (isSet[WEEK_OF_MONTH]
- && lastDateFieldSet != DAY_OF_WEEK_IN_MONTH) {
- int skew = mod7(days - 3 - (getFirstDayOfWeek() - 1));
- days += (fields[WEEK_OF_MONTH] - 1) * 7
- + mod7(skew + dayOfWeek - (days - 3)) - skew;
- } else if (isSet[DAY_OF_WEEK_IN_MONTH]) {
- if (fields[DAY_OF_WEEK_IN_MONTH] >= 0) {
- days += mod7(dayOfWeek - (days - 3))
- + (fields[DAY_OF_WEEK_IN_MONTH] - 1) * 7;
- } else {
- days += daysInMonth(leapYear, month)
- + mod7(dayOfWeek
- - (days + daysInMonth(leapYear, month) - 3))
- + fields[DAY_OF_WEEK_IN_MONTH] * 7;
- }
- }
- }
- } else {
- boolean useWeekYear = isSet[WEEK_OF_YEAR]
- && lastDateFieldSet != DAY_OF_YEAR;
- if (useWeekYear && isSet[DAY_OF_YEAR]) {
+ if (isSet[WEEK_OF_MONTH]
+ && lastDateFieldSet != DAY_OF_WEEK_IN_MONTH) {
+ int skew = mod7(days - 3 - (getFirstDayOfWeek() - 1));
+ days += (fields[WEEK_OF_MONTH] - 1) * 7
+ + mod7(skew + dayOfWeek - (days - 3)) - skew;
+ } else if (isSet[DAY_OF_WEEK_IN_MONTH]) {
+ if (fields[DAY_OF_WEEK_IN_MONTH] >= 0) {
+ days += mod7(dayOfWeek - (days - 3))
+ + (fields[DAY_OF_WEEK_IN_MONTH] - 1) * 7;
+ } else {
+ days += daysInMonth(leapYear, month)
+ + mod7(dayOfWeek
+ - (days + daysInMonth(leapYear, month) - 3))
+ + fields[DAY_OF_WEEK_IN_MONTH] * 7;
+ }
+ }
+ }
+ } else {
+ boolean useWeekYear = isSet[WEEK_OF_YEAR]
+ && lastDateFieldSet != DAY_OF_YEAR;
+ if (useWeekYear && isSet[DAY_OF_YEAR]) {
useWeekYear = isSet[DAY_OF_WEEK];
}
- days = daysFromBaseYear(year);
- if (useWeekYear) {
- int dayOfWeek;
- if (isSet[DAY_OF_WEEK]) {
- dayOfWeek = fields[DAY_OF_WEEK] - 1;
- } else {
+ days = daysFromBaseYear(year);
+ if (useWeekYear) {
+ int dayOfWeek;
+ if (isSet[DAY_OF_WEEK]) {
+ dayOfWeek = fields[DAY_OF_WEEK] - 1;
+ } else {
dayOfWeek = getFirstDayOfWeek() - 1;
}
- int skew = mod7(days - 3 - (getFirstDayOfWeek() - 1));
- days += (fields[WEEK_OF_YEAR] - 1) * 7
- + mod7(skew + dayOfWeek - (days - 3)) - skew;
- if (7 - skew < getMinimalDaysInFirstWeek()) {
+ int skew = mod7(days - 3 - (getFirstDayOfWeek() - 1));
+ days += (fields[WEEK_OF_YEAR] - 1) * 7
+ + mod7(skew + dayOfWeek - (days - 3)) - skew;
+ if (7 - skew < getMinimalDaysInFirstWeek()) {
days += 7;
}
- } else if (isSet[DAY_OF_YEAR]) {
- if (!isLenient()
- && (fields[DAY_OF_YEAR] < 1 || fields[DAY_OF_YEAR] > (365 + (isLeapYear(year) ? 1
- : 0)))) {
+ } else if (isSet[DAY_OF_YEAR]) {
+ if (!isLenient()
+ && (fields[DAY_OF_YEAR] < 1 || fields[DAY_OF_YEAR] > (365 + (isLeapYear(year) ? 1
+ : 0)))) {
throw new IllegalArgumentException();
}
- days += fields[DAY_OF_YEAR] - 1;
- } else if (isSet[DAY_OF_WEEK]) {
- days += mod7(fields[DAY_OF_WEEK] - 1 - (days - 3));
- }
- }
- lastDateFieldSet = 0;
-
- timeVal += days * 86400000;
- // Use local time to compare with the gregorian change
- if (year == changeYear
- && timeVal >= gregorianCutover + julianError() * 86400000) {
+ days += fields[DAY_OF_YEAR] - 1;
+ } else if (isSet[DAY_OF_WEEK]) {
+ days += mod7(fields[DAY_OF_WEEK] - 1 - (days - 3));
+ }
+ }
+ lastDateFieldSet = 0;
+
+ timeVal += days * 86400000;
+ // Use local time to compare with the gregorian change
+ if (year == changeYear
+ && timeVal >= gregorianCutover + julianError() * 86400000) {
timeVal -= julianError() * 86400000;
}
- // It is not possible to simply subtract getOffset(timeVal) from timeVal to get UTC.
+ // It is not possible to simply subtract getOffset(timeVal) from timeVal
+ // to get UTC.
// The trick is needed for the moment when DST transition occurs,
// say 1:00 is a transition time when DST offset becomes +1 hour,
// then wall time in the interval 1:00 - 2:00 is invalid and is
// treated as UTC time.
- long timeValWithoutDST = timeVal - getOffset(timeVal) + getTimeZone().getRawOffset();
+ long timeValWithoutDST = timeVal - getOffset(timeVal)
+ + getTimeZone().getRawOffset();
timeVal -= getOffset(timeValWithoutDST);
- // Need to update wall time in fields, since it was invalid due to DST transition
+ // Need to update wall time in fields, since it was invalid due to DST
+ // transition
this.time = timeVal;
if (timeValWithoutDST != timeVal) {
computeFields();
areFieldsSet = true;
}
- }
+ }
- private int computeYearAndDay(long dayCount, long localTime) {
- int year = 1970;
- long days = dayCount;
- if (localTime < gregorianCutover) {
+ private int computeYearAndDay(long dayCount, long localTime) {
+ int year = 1970;
+ long days = dayCount;
+ if (localTime < gregorianCutover) {
days -= julianSkew;
}
- int approxYears;
+ int approxYears;
- while ((approxYears = (int) (days / 365)) != 0) {
- year = year + approxYears;
- days = dayCount - daysFromBaseYear(year);
- }
- if (days < 0) {
- year = year - 1;
- days = days + 365 + (isLeapYear(year) ? 1 : 0);
- if (year == changeYear && localTime < gregorianCutover) {
+ while ((approxYears = (int) (days / 365)) != 0) {
+ year = year + approxYears;
+ days = dayCount - daysFromBaseYear(year);
+ }
+ if (days < 0) {
+ year = year - 1;
+ days = days + 365 + (isLeapYear(year) ? 1 : 0);
+ if (year == changeYear && localTime < gregorianCutover) {
days -= julianError();
}
- }
- fields[YEAR] = year;
- return (int) days + 1;
- }
-
- private long daysFromBaseYear(int iyear) {
- long year = iyear;
-
- if (year >= 1970) {
- long days = (year - 1970) * (long) 365 + ((year - 1969) / 4);
- if (year > changeYear) {
+ }
+ fields[YEAR] = year;
+ return (int) days + 1;
+ }
+
+ private long daysFromBaseYear(int iyear) {
+ long year = iyear;
+
+ if (year >= 1970) {
+ long days = (year - 1970) * 365 + ((year - 1969) / 4);
+ if (year > changeYear) {
days -= ((year - 1901) / 100) - ((year - 1601) / 400);
} else {
days += julianSkew;
}
- return days;
- } else if (year <= changeYear) {
- return (year - 1970) * (long) 365 + ((year - 1972) / 4)
- + julianSkew;
- }
- return (year - 1970) * (long) 365 + ((year - 1972) / 4)
- - ((year - 2000) / 100) + ((year - 2000) / 400);
-
- }
-
- private int daysInMonth() {
- return daysInMonth(isLeapYear(fields[YEAR]), fields[MONTH]);
- }
+ return days;
+ } else if (year <= changeYear) {
+ return (year - 1970) * 365 + ((year - 1972) / 4) + julianSkew;
+ }
+ return (year - 1970) * 365 + ((year - 1972) / 4)
+ - ((year - 2000) / 100) + ((year - 2000) / 400);
- private int daysInMonth(boolean leapYear, int month) {
- if (leapYear && month == FEBRUARY) {
+ }
+
+ private int daysInMonth() {
+ return daysInMonth(isLeapYear(fields[YEAR]), fields[MONTH]);
+ }
+
+ private int daysInMonth(boolean leapYear, int month) {
+ if (leapYear && month == FEBRUARY) {
return DaysInMonth[month] + 1;
}
- return DaysInMonth[month];
- }
+ return DaysInMonth[month];
+ }
- private int daysInYear() {
- return isLeapYear(fields[YEAR]) ? 366 : 365;
- }
+ private int daysInYear() {
+ return isLeapYear(fields[YEAR]) ? 366 : 365;
+ }
- private int daysInYear(boolean leapYear, int month) {
- if (leapYear && month > FEBRUARY) {
+ private int daysInYear(boolean leapYear, int month) {
+ if (leapYear && month > FEBRUARY) {
return DaysInYear[month] + 1;
}
- return DaysInYear[month];
- }
+ return DaysInYear[month];
+ }
+
+ /**
+ * Compares the specified object to this GregorianCalendar and answer if
+ * they are equal. The object must be an instance of GregorianCalendar and
+ * have the same properties.
+ *
+ * @param object
+ * the object to compare with this object
+ * @return true if the specified object is equal to this GregorianCalendar,
+ * false otherwise
+ *
+ * @exception IllegalArgumentException
+ * when the time is not set and the time cannot be computed
+ * from the current field values
+ *
+ * @see #hashCode
+ */
+ @Override
+ public boolean equals(Object object) {
+ return super.equals(object)
+ && gregorianCutover == ((GregorianCalendar) object).gregorianCutover;
+ }
- /**
- * Compares the specified object to this GregorianCalendar and answer if
- * they are equal. The object must be an instance of GregorianCalendar and
- * have the same properties.
- *
- * @param object
- * the object to compare with this object
- * @return true if the specified object is equal to this GregorianCalendar,
- * false otherwise
- *
- * @exception IllegalArgumentException
- * when the time is not set and the time cannot be computed
- * from the current field values
- *
- * @see #hashCode
- */
- public boolean equals(Object object) {
- return super.equals(object)
- && gregorianCutover == ((GregorianCalendar) object).gregorianCutover;
- }
-
- /**
- * Gets the maximum value of the specified field for the current date. For
- * example, the maximum number of days in the current month.
- *
- * @param field
- * the field
- * @return the maximum value of the specified field
- */
- public int getActualMaximum(int field) {
- int value;
- if ((value = getMaximum(field)) == getLeastMaximum(field)) {
+ /**
+ * Gets the maximum value of the specified field for the current date. For
+ * example, the maximum number of days in the current month.
+ *
+ * @param field
+ * the field
+ * @return the maximum value of the specified field
+ */
+ @Override
+ public int getActualMaximum(int field) {
+ int value;
+ if ((value = getMaximum(field)) == getLeastMaximum(field)) {
return value;
}
- switch (field) {
- case WEEK_OF_YEAR:
- case WEEK_OF_MONTH:
- isCached = false;
- break;
- }
-
- complete();
- long orgTime = time;
- int result = 0;
- switch (field) {
- case WEEK_OF_YEAR:
- set(DATE, 31);
- set(MONTH, DECEMBER);
- result = get(WEEK_OF_YEAR);
- if (result == 1) {
- set(DATE, 31 - 7);
- result = get(WEEK_OF_YEAR);
- }
- areFieldsSet = false;
- break;
- case WEEK_OF_MONTH:
- set(DATE, daysInMonth());
- result = get(WEEK_OF_MONTH);
- areFieldsSet = false;
- break;
- case DATE:
- return daysInMonth();
- case DAY_OF_YEAR:
- return daysInYear();
- case DAY_OF_WEEK_IN_MONTH:
- result = get(DAY_OF_WEEK_IN_MONTH)
- + ((daysInMonth() - get(DATE)) / 7);
- break;
- case YEAR:
- GregorianCalendar clone = (GregorianCalendar) clone();
- if (get(ERA) == AD) {
- clone.setTimeInMillis(Long.MAX_VALUE);
- } else {
- clone.setTimeInMillis(Long.MIN_VALUE);
- }
- result = clone.get(YEAR);
- clone.set(YEAR, get(YEAR));
- if (clone.before(this)) {
- result--;
- }
- break;
- }
- time = orgTime;
- return result;
- }
-
- /**
- * Gets the minimum value of the specified field for the current date. For
- * the gregorian calendar, this value is the same as
- * <code>getMinimum()</code>.
- *
- * @param field
- * the field
- * @return the minimum value of the specified field
- */
- public int getActualMinimum(int field) {
- return getMinimum(field);
- }
-
- /**
- * Gets the greatest minimum value of the specified field. For the gregorian
- * calendar, this value is the same as <code>getMinimum()</code>.
- *
- * @param field
- * the field
- * @return the greatest minimum value of the specified field
- */
- public int getGreatestMinimum(int field) {
- return minimums[field];
- }
-
- /**
- * Answers the gregorian change date of this calendar. This is the date on
- * which the gregorian calendar came into effect.
- *
- * @return a Date which represents the gregorian change date
- */
- public final Date getGregorianChange() {
- return new Date(gregorianCutover);
- }
-
- /**
- * Gets the smallest maximum value of the specified field. For example, 28
- * for the day of month field.
- *
- * @param field
- * the field
- * @return the smallest maximum value of the specified field
- */
- public int getLeastMaximum(int field) {
- return leastMaximums[field];
- }
-
- /**
- * Gets the greatest maximum value of the specified field. For example, 31
- * for the day of month field.
- *
- * @param field
- * the field
- * @return the greatest maximum value of the specified field
- */
- public int getMaximum(int field) {
- return maximums[field];
- }
-
- /**
- * Gets the smallest minimum value of the specified field.
- *
- * @param field
- * the field
- * @return the smallest minimum value of the specified field
- */
- public int getMinimum(int field) {
- return minimums[field];
- }
-
- int getOffset(long localTime) {
- TimeZone timeZone = getTimeZone();
- if (!timeZone.useDaylightTime()) {
+ switch (field) {
+ case WEEK_OF_YEAR:
+ case WEEK_OF_MONTH:
+ isCached = false;
+ break;
+ }
+
+ complete();
+ long orgTime = time;
+ int result = 0;
+ switch (field) {
+ case WEEK_OF_YEAR:
+ set(DATE, 31);
+ set(MONTH, DECEMBER);
+ result = get(WEEK_OF_YEAR);
+ if (result == 1) {
+ set(DATE, 31 - 7);
+ result = get(WEEK_OF_YEAR);
+ }
+ areFieldsSet = false;
+ break;
+ case WEEK_OF_MONTH:
+ set(DATE, daysInMonth());
+ result = get(WEEK_OF_MONTH);
+ areFieldsSet = false;
+ break;
+ case DATE:
+ return daysInMonth();
+ case DAY_OF_YEAR:
+ return daysInYear();
+ case DAY_OF_WEEK_IN_MONTH:
+ result = get(DAY_OF_WEEK_IN_MONTH)
+ + ((daysInMonth() - get(DATE)) / 7);
+ break;
+ case YEAR:
+ GregorianCalendar clone = (GregorianCalendar) clone();
+ if (get(ERA) == AD) {
+ clone.setTimeInMillis(Long.MAX_VALUE);
+ } else {
+ clone.setTimeInMillis(Long.MIN_VALUE);
+ }
+ result = clone.get(YEAR);
+ clone.set(YEAR, get(YEAR));
+ if (clone.before(this)) {
+ result--;
+ }
+ break;
+ }
+ time = orgTime;
+ return result;
+ }
+
+ /**
+ * Gets the minimum value of the specified field for the current date. For
+ * the gregorian calendar, this value is the same as
+ * <code>getMinimum()</code>.
+ *
+ * @param field
+ * the field
+ * @return the minimum value of the specified field
+ */
+ @Override
+ public int getActualMinimum(int field) {
+ return getMinimum(field);
+ }
+
+ /**
+ * Gets the greatest minimum value of the specified field. For the gregorian
+ * calendar, this value is the same as <code>getMinimum()</code>.
+ *
+ * @param field
+ * the field
+ * @return the greatest minimum value of the specified field
+ */
+ @Override
+ public int getGreatestMinimum(int field) {
+ return minimums[field];
+ }
+
+ /**
+ * Answers the gregorian change date of this calendar. This is the date on
+ * which the gregorian calendar came into effect.
+ *
+ * @return a Date which represents the gregorian change date
+ */
+ public final Date getGregorianChange() {
+ return new Date(gregorianCutover);
+ }
+
+ /**
+ * Gets the smallest maximum value of the specified field. For example, 28
+ * for the day of month field.
+ *
+ * @param field
+ * the field
+ * @return the smallest maximum value of the specified field
+ */
+ @Override
+ public int getLeastMaximum(int field) {
+ return leastMaximums[field];
+ }
+
+ /**
+ * Gets the greatest maximum value of the specified field. For example, 31
+ * for the day of month field.
+ *
+ * @param field
+ * the field
+ * @return the greatest maximum value of the specified field
+ */
+ @Override
+ public int getMaximum(int field) {
+ return maximums[field];
+ }
+
+ /**
+ * Gets the smallest minimum value of the specified field.
+ *
+ * @param field
+ * the field
+ * @return the smallest minimum value of the specified field
+ */
+ @Override
+ public int getMinimum(int field) {
+ return minimums[field];
+ }
+
+ int getOffset(long localTime) {
+ TimeZone timeZone = getTimeZone();
+ if (!timeZone.useDaylightTime()) {
return timeZone.getRawOffset();
}
- long dayCount = localTime / 86400000;
- int millis = (int) (localTime % 86400000);
- if (millis < 0) {
- millis += 86400000;
- dayCount--;
- }
-
- int year = 1970;
- long days = dayCount;
- if (localTime < gregorianCutover) {
+ long dayCount = localTime / 86400000;
+ int millis = (int) (localTime % 86400000);
+ if (millis < 0) {
+ millis += 86400000;
+ dayCount--;
+ }
+
+ int year = 1970;
+ long days = dayCount;
+ if (localTime < gregorianCutover) {
days -= julianSkew;
}
- int approxYears;
+ int approxYears;
- while ((approxYears = (int) (days / 365)) != 0) {
- year = year + approxYears;
- days = dayCount - daysFromBaseYear(year);
- }
- if (days < 0) {
- year = year - 1;
- days = days + 365 + (isLeapYear(year) ? 1 : 0);
- if (year == changeYear && localTime < gregorianCutover) {
+ while ((approxYears = (int) (days / 365)) != 0) {
+ year = year + approxYears;
+ days = dayCount - daysFromBaseYear(year);
+ }
+ if (days < 0) {
+ year = year - 1;
+ days = days + 365 + (isLeapYear(year) ? 1 : 0);
+ if (year == changeYear && localTime < gregorianCutover) {
days -= julianError();
}
- }
- if (year <= 0) {
+ }
+ if (year <= 0) {
return timeZone.getRawOffset();
}
- int dayOfYear = (int) days + 1;
+ int dayOfYear = (int) days + 1;
+
+ int month = dayOfYear / 32;
+ boolean leapYear = isLeapYear(year);
+ int date = dayOfYear - daysInYear(leapYear, month);
+ if (date > daysInMonth(leapYear, month)) {
+ date -= daysInMonth(leapYear, month);
+ month++;
+ }
+ int dayOfWeek = mod7(dayCount - 3) + 1;
+ int offset = timeZone.getOffset(AD, year, month, date, dayOfWeek,
+ millis);
+ return offset;
+ }
+
+ /**
+ * Answers an integer hash code for the receiver. Objects which are equal
+ * answer the same value for this method.
+ *
+ * @return the receiver's hash
+ *
+ * @see #equals
+ */
+ @Override
+ public int hashCode() {
+ return super.hashCode()
+ + ((int) (gregorianCutover >>> 32) ^ (int) gregorianCutover);
+ }
- int month = dayOfYear / 32;
- boolean leapYear = isLeapYear(year);
- int date = dayOfYear - daysInYear(leapYear, month);
- if (date > daysInMonth(leapYear, month)) {
- date -= daysInMonth(leapYear, month);
- month++;
- }
- int dayOfWeek = mod7(dayCount - 3) + 1;
- int offset = timeZone.getOffset(AD, year, month, date, dayOfWeek,
- millis);
- return offset;
- }
-
- /**
- * Answers an integer hash code for the receiver. Objects which are equal
- * answer the same value for this method.
- *
- * @return the receiver's hash
- *
- * @see #equals
- */
- public int hashCode() {
- return super.hashCode()
- + ((int) (gregorianCutover >>> 32) ^ (int) gregorianCutover);
- }
-
- /**
- * Answers if the specified year is a leap year.
- *
- * @param year
- * the year
- * @return true if the specified year is a leap year, false otherwise
- */
- public boolean isLeapYear(int year) {
- if (year > changeYear) {
+ /**
+ * Answers if the specified year is a leap year.
+ *
+ * @param year
+ * the year
+ * @return true if the specified year is a leap year, false otherwise
+ */
+ public boolean isLeapYear(int year) {
+ if (year > changeYear) {
return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
}
- return year % 4 == 0;
- }
+ return year % 4 == 0;
+ }
+
+ private int julianError() {
+ return changeYear / 100 - changeYear / 400 - 2;
+ }
- private int julianError() {
- return changeYear / 100 - changeYear / 400 - 2;
- }
-
- private int mod(int value, int mod) {
- int rem = value % mod;
- if (value < 0 && rem < 0) {
+ private int mod(int value, int mod) {
+ int rem = value % mod;
+ if (value < 0 && rem < 0) {
return rem + mod;
}
- return rem;
- }
+ return rem;
+ }
- private int mod7(long num1) {
- int rem = (int) (num1 % 7);
- if (num1 < 0 && rem < 0) {
+ private int mod7(long num1) {
+ int rem = (int) (num1 % 7);
+ if (num1 < 0 && rem < 0) {
return rem + 7;
}
- return rem;
- }
+ return rem;
+ }
- /**
- * Adds the specified amount the specified field and wrap the value of the
- * field when it goes beyond the maximum or minimum value for the current
- * date. Other fields will be adjusted as required to maintain a consistent
- * date.
- *
- * @param field
- * the field to roll
- * @param value
- * the amount to add
- *
- * @exception IllegalArgumentException
- * when an invalid field is specified
- */
- public void roll(int field, int value) {
- if (value == 0) {
+ /**
+ * Adds the specified amount the specified field and wrap the value of the
+ * field when it goes beyond the maximum or minimum value for the current
+ * date. Other fields will be adjusted as required to maintain a consistent
+ * date.
+ *
+ * @param field
+ * the field to roll
+ * @param value
+ * the amount to add
+ *
+ * @exception IllegalArgumentException
+ * when an invalid field is specified
+ */
+ @Override
+ public void roll(int field, int value) {
+ if (value == 0) {
return;
}
- if (field < 0 || field >= ZONE_OFFSET) {
+ if (field < 0 || field >= ZONE_OFFSET) {
throw new IllegalArgumentException();
}
- isCached = false;
+ isCached = false;
- complete();
- int max = -1;
- switch (field) {
- case YEAR:
- max = maximums[field];
- break;
- case WEEK_OF_YEAR:
- case WEEK_OF_MONTH:
- int days,
- day;
- if (field == WEEK_OF_YEAR) {
- days = daysInYear();
- day = DAY_OF_YEAR;
- } else {
- days = daysInMonth();
- day = DATE;
- }
- int mod = mod7(fields[DAY_OF_WEEK] - fields[day]
- - (getFirstDayOfWeek() - 1));
- int maxWeeks = (days - 1 + mod) / 7 + 1;
- int newWeek = mod(fields[field] - 1 + value, maxWeeks) + 1;
- if (newWeek == maxWeeks) {
- if (fields[day] + (newWeek - fields[field]) * 7 > days) {
- set(day, days);
+ complete();
+ int max = -1;
+ switch (field) {
+ case YEAR:
+ max = maximums[field];
+ break;
+ case WEEK_OF_YEAR:
+ case WEEK_OF_MONTH:
+ int days,
+ day;
+ if (field == WEEK_OF_YEAR) {
+ days = daysInYear();
+ day = DAY_OF_YEAR;
} else {
- set(field, newWeek);
+ days = daysInMonth();
+ day = DATE;
}
- } else if (newWeek == 1) {
- int week = (fields[day] - ((fields[day] - 1) / 7 * 7) - 1 + mod) / 7 + 1;
- if (week > 1) {
- set(day, 1);
+ int mod = mod7(fields[DAY_OF_WEEK] - fields[day]
+ - (getFirstDayOfWeek() - 1));
+ int maxWeeks = (days - 1 + mod) / 7 + 1;
+ int newWeek = mod(fields[field] - 1 + value, maxWeeks) + 1;
+ if (newWeek == maxWeeks) {
+ if (fields[day] + (newWeek - fields[field]) * 7 > days) {
+ set(day, days);
+ } else {
+ set(field, newWeek);
+ }
+ } else if (newWeek == 1) {
+ int week = (fields[day] - ((fields[day] - 1) / 7 * 7) - 1 + mod) / 7 + 1;
+ if (week > 1) {
+ set(day, 1);
+ } else {
+ set(field, newWeek);
+ }
} else {
set(field, newWeek);
}
- } else {
- set(field, newWeek);
- }
- break;
- case DATE:
- max = daysInMonth();
- break;
- case DAY_OF_YEAR:
- max = daysInYear();
- break;
- case DAY_OF_WEEK:
- max = maximums[field];
- lastDateFieldSet = WEEK_OF_MONTH;
- break;
- case DAY_OF_WEEK_IN_MONTH:
- max = (fields[DATE] + ((daysInMonth() - fields[DATE]) / 7 * 7) - 1) / 7 + 1;
- break;
-
- case ERA:
- case MONTH:
- case AM_PM:
- case HOUR:
- case HOUR_OF_DAY:
- case MINUTE:
- case SECOND:
- case MILLISECOND:
- set(field, mod(fields[field] + value, maximums[field] + 1));
- if (field == MONTH && fields[DATE] > daysInMonth()) {
- set(DATE, daysInMonth());
- } else if (field == AM_PM) {
- lastTimeFieldSet = HOUR;
- }
- break;
- }
- if (max != -1) {
+ break;
+ case DATE:
+ max = daysInMonth();
+ break;
+ case DAY_OF_YEAR:
+ max = daysInYear();
+ break;
+ case DAY_OF_WEEK:
+ max = maximums[field];
+ lastDateFieldSet = WEEK_OF_MONTH;
+ break;
+ case DAY_OF_WEEK_IN_MONTH:
+ max = (fields[DATE] + ((daysInMonth() - fields[DATE]) / 7 * 7) - 1) / 7 + 1;
+ break;
+
+ case ERA:
+ case MONTH:
+ case AM_PM:
+ case HOUR:
+ case HOUR_OF_DAY:
+ case MINUTE:
+ case SECOND:
+ case MILLISECOND:
+ set(field, mod(fields[field] + value, maximums[field] + 1));
+ if (field == MONTH && fields[DATE] > daysInMonth()) {
+ set(DATE, daysInMonth());
+ } else if (field == AM_PM) {
+ lastTimeFieldSet = HOUR;
+ }
+ break;
+ }
+ if (max != -1) {
set(field, mod(fields[field] - 1 + value, max) + 1);
}
- complete();
- }
+ complete();
+ }
+
+ /**
+ * Increment or decrement the specified field and wrap the value of the
+ * field when it goes beyond the maximum or minimum value for the current
+ * date. Other fields will be adjusted as required to maintain a consistent
+ * date. For example, March 31 will roll to April 30 when rolling the month
+ * field.
+ *
+ * @param field
+ * the field to roll
+ * @param increment
+ * true to increment the field, false to decrement
+ *
+ * @exception IllegalArgumentException
+ * when an invalid field is specified
+ */
+ @Override
+ public void roll(int field, boolean increment) {
+ roll(field, increment ? 1 : -1);
+ }
- /**
- * Increment or decrement the specified field and wrap the value of the
- * field when it goes beyond the maximum or minimum value for the current
- * date. Other fields will be adjusted as required to maintain a consistent
- * date. For example, March 31 will roll to April 30 when rolling the month
- * field.
- *
- * @param field
- * the field to roll
- * @param increment
- * true to increment the field, false to decrement
- *
- * @exception IllegalArgumentException
- * when an invalid field is specified
- */
- public void roll(int field, boolean increment) {
- roll(field, increment ? 1 : -1);
- }
-
- /**
- * Sets the gregorian change date of this calendar.
- *
- * @param date
- * a Date which represents the gregorian change date
- */
- public void setGregorianChange(Date date) {
- gregorianCutover = date.getTime();
- GregorianCalendar cal = new GregorianCalendar(TimeZone.GMT);
- cal.setTime(date);
- changeYear = cal.get(YEAR);
- if (cal.get(ERA) == BC) {
+ /**
+ * Sets the gregorian change date of this calendar.
+ *
+ * @param date
+ * a Date which represents the gregorian change date
+ */
+ public void setGregorianChange(Date date) {
+ gregorianCutover = date.getTime();
+ GregorianCalendar cal = new GregorianCalendar(TimeZone.GMT);
+ cal.setTime(date);
+ changeYear = cal.get(YEAR);
+ if (cal.get(ERA) == BC) {
changeYear = 1 - changeYear;
}
- julianSkew = ((changeYear - 2000) / 400) + julianError()
- - ((changeYear - 2000) / 100);
- isCached = false;
- }
-
- private void writeObject(ObjectOutputStream stream) throws IOException {
- stream.defaultWriteObject();
- }
-
- private void readObject(ObjectInputStream stream) throws IOException,
- ClassNotFoundException {
-
- stream.defaultReadObject();
- setGregorianChange(new Date(gregorianCutover));
- isCached = false;
- }
-
- public void setFirstDayOfWeek(int value) {
- super.setFirstDayOfWeek(value);
- isCached = false;
- }
-
- public void setMinimalDaysInFirstWeek(int value) {
- super.setMinimalDaysInFirstWeek(value);
- isCached = false;
- }
+ julianSkew = ((changeYear - 2000) / 400) + julianError()
+ - ((changeYear - 2000) / 100);
+ isCached = false;
+ }
+
+ private void writeObject(ObjectOutputStream stream) throws IOException {
+ stream.defaultWriteObject();
+ }
+
+ private void readObject(ObjectInputStream stream) throws IOException,
+ ClassNotFoundException {
+
+ stream.defaultReadObject();
+ setGregorianChange(new Date(gregorianCutover));
+ isCached = false;
+ }
+
+ @Override
+ public void setFirstDayOfWeek(int value) {
+ super.setFirstDayOfWeek(value);
+ isCached = false;
+ }
+
+ @Override
+ public void setMinimalDaysInFirstWeek(int value) {
+ super.setMinimalDaysInFirstWeek(value);
+ isCached = false;
+ }
}