jdk-sandbox: comparison jdk/src/share/classes/java/util/GregorianCalendar.java

equal deleted inserted replaced

-:f9ad1aadf3fa
+:c7093e306a34
 }
 }
 }
 if (month >= 0) {
-set(MONTH, (int) (month % 12));
+set(MONTH, month % 12);
 } else {
 // month < 0
 month %= 12;
 if (month < 0) {
 month += 12;
 month1 = fd - internalGet(DAY_OF_MONTH) + 1;
 monthLength = calsys.getMonthLength(cdate);
 }
 // the first day of week of the month.
-long monthDay1st = calsys.getDayOfWeekDateOnOrBefore(month1 + 6,
+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;
 }
 amount %= 7;
 if (amount == 0) {
 return;
 }
 long fd = getCurrentFixedDate();
-long dowFirst = calsys.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek());
+long dowFirst = BaseCalendar.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek());
 fd += amount;
 if (fd < dowFirst) {
 fd += 7;
 } else if (fd >= dowFirst + 7) {
 fd -= 7;
 /**
 * Returns the millisecond offset from the beginning of this
 * year. This Calendar object must have been normalized.
 */
-private final long getYearOffsetInMillis() {
+private long getYearOffsetInMillis() {
 long t = (internalGet(DAY_OF_YEAR) - 1) * 24;
 t += internalGet(HOUR_OF_DAY);
 t *= 60;
 t += internalGet(MINUTE);
 t *= 60;
 if (weekOfYear >= 52) {
 long nextJan1 = fixedDateJan1 + 365;
 if (cdate.isLeapYear()) {
 nextJan1++;
 }
-long nextJan1st = calsys.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
+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 {
 nextJan1 = gregorianCutoverDate;
 calForJan1 = gcal;
 }
-long nextJan1st = calForJan1.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
+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;
 }
 *
 * @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 final int getWeekNumber(long fixedDay1, long fixedDate) {
+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 = gcal.getDayOfWeekDateOnOrBefore(fixedDay1 + 6,
+long fixedDay1st = Gregorian.getDayOfWeekDateOnOrBefore(fixedDay1 + 6,
 getFirstDayOfWeek());
 int ndays = (int)(fixedDay1st - fixedDay1);
 assert ndays <= 7;
 if (ndays >= getMinimalDaysInFirstWeek()) {
 fixedDay1st -= 7;
 }
 fixedDate += internalGet(DAY_OF_MONTH);
 fixedDate--;
 }
 } else {
 if (isFieldSet(fieldMask, WEEK_OF_MONTH)) {
-long firstDayOfWeek = cal.getDayOfWeekDateOnOrBefore(fixedDate + 6,
+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 = cal.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
+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);
 dowim = internalGet(DAY_OF_WEEK_IN_MONTH);
 } else {
 dowim = 1;
 }
 if (dowim >= 0) {
-fixedDate = cal.getDayOfWeekDateOnOrBefore(fixedDate + (7 * dowim) - 1,
+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 = cal.getDayOfWeekDateOnOrBefore(fixedDate + lastDate - 1,
+fixedDate = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + lastDate - 1,
 dayOfWeek);
 }
 }
 }
 } else {
 if (year == gregorianCutoverYear && cal == gcal
 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 = cal.getDayOfWeekDateOnOrBefore(fixedDate + 6,
+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 = cal.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
+firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
 dayOfWeek);
 }
 }
 fixedDate = firstDayOfWeek + 7 * ((long)internalGet(WEEK_OF_YEAR) - 1);
 }
 }
 /**
 * 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 final GregorianCalendar getNormalizedCalendar() {
+private GregorianCalendar getNormalizedCalendar() {
 GregorianCalendar gc;
 if (isFullyNormalized()) {
 gc = this;
 } else {
 // Create a clone and normalize the calendar fields
 /**
 * Returns the Julian calendar system instance (singleton). 'jcal'
 * and 'jeras' are set upon the return.
 */
-synchronized private static final BaseCalendar getJulianCalendarSystem() {
+synchronized private static BaseCalendar getJulianCalendarSystem() {
 if (jcal == null) {
 jcal = (JulianCalendar) CalendarSystem.forName("julian");
 jeras = jcal.getEras();
 }
 return jcal;
 * @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 final long getFixedDateJan1(BaseCalendar.Date date, long fixedDate) {
+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
 * @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 final long getFixedDateMonth1(BaseCalendar.Date date, long fixedDate) {
+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) {
 /**
 * Returns a CalendarDate produced from the specified fixed date.
 *
 * @param fd the fixed date
 */
-private final BaseCalendar.Date getCalendarDate(long fd) {
+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 final BaseCalendar.Date getGregorianCutoverDate() {
+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 final BaseCalendar.Date getLastJulianDate() {
+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 final int monthLength(int month, int year) {
+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 final int monthLength(int month) {
+private int monthLength(int month) {
 int year = internalGet(YEAR);
 if (internalGetEra() == BCE) {
 year = 1 - year;
 }
 return monthLength(month, year);
 }
-private final int actualMonthLength() {
+private int actualMonthLength() {
 int year = cdate.getNormalizedYear();
 if (year != gregorianCutoverYear && year != gregorianCutoverYearJulian) {
 return calsys.getMonthLength(cdate);
 }
 BaseCalendar.Date date = (BaseCalendar.Date) cdate.clone();
 /**
 * Returns the length (in days) of the specified year. The year
 * must be normalized.
 */
-private final int yearLength(int year) {
+private int yearLength(int year) {
 return isLeapYear(year) ? 366 : 365;
 }
 /**
 * Returns the length (in days) of the year provided by
 * internalGet(YEAR).
 */
-private final int yearLength() {
+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 final void pinDayOfMonth() {
+private void pinDayOfMonth() {
 int year = internalGet(YEAR);
 int monthLen;
 if (year > gregorianCutoverYear || year < gregorianCutoverYearJulian) {
 monthLen = monthLength(internalGet(MONTH));
 } else {
 /**
 * Returns the fixed date value of this object. The time value and
 * calendar fields must be in synch.
 */
-private final long getCurrentFixedDate() {
+private long getCurrentFixedDate() {
 return (calsys == gcal) ? cachedFixedDate : calsys.getFixedDate(cdate);
 }
 /**
 * Returns the new value after 'roll'ing the specified value and amount.
 */
-private static final int getRolledValue(int value, int amount, int min, int max) {
+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) {
 /**
 * Returns the ERA.  We need a special method for this because the
 * default ERA is CE, but a zero (unset) ERA is BCE.
 */
-private final int internalGetEra() {
+private int internalGetEra() {
 return isSet(ERA) ? internalGet(ERA) : CE;
 }
 /**
 * Updates internal state.

changeset 11130	c7093e306a34
parent 8521	ab64b8d109b8
child 13583	dc0017b1a452