/*
 * Copyright (c) 2003, 2004, 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.
 */

package sun.util.calendar;

import java.util.Locale;
import java.util.TimeZone;

The AbstractCalendar class provides a framework for implementing a concrete calendar system.

Fixed Date
For implementing a concrete calendar system, each calendar must have the common date numbering, starting from midnight the onset of Monday, January 1, 1 (Gregorian). It is called a fixed date in this class. January 1, 1 (Gregorian) is fixed date 1. (See Nachum Dershowitz and Edward M. Reingold, CALENDRICAL CALCULATION The Millennium Edition, Section 1.2 for details.)

Author:Masayoshi Okutsu
Since:1.5
/** * The <code>AbstractCalendar</code> class provides a framework for * implementing a concrete calendar system. * * <p><a name="fixed_date"></a><B>Fixed Date</B><br> * * For implementing a concrete calendar system, each calendar must * have the common date numbering, starting from midnight the onset of * Monday, January 1, 1 (Gregorian). It is called a <I>fixed date</I> * in this class. January 1, 1 (Gregorian) is fixed date 1. (See * Nachum Dershowitz and Edward M. Reingold, <I>CALENDRICAL * CALCULATION The Millennium Edition</I>, Section 1.2 for details.) * * @author Masayoshi Okutsu * @since 1.5 */
public abstract class AbstractCalendar extends CalendarSystem { // The constants assume no leap seconds support. static final int SECOND_IN_MILLIS = 1000; static final int MINUTE_IN_MILLIS = SECOND_IN_MILLIS * 60; static final int HOUR_IN_MILLIS = MINUTE_IN_MILLIS * 60; static final int DAY_IN_MILLIS = HOUR_IN_MILLIS * 24; // The number of days between January 1, 1 and January 1, 1970 (Gregorian) static final int EPOCH_OFFSET = 719163; private Era[] eras; protected AbstractCalendar() { } public Era getEra(String eraName) { if (eras != null) { for (int i = 0; i < eras.length; i++) { if (eras[i].equals(eraName)) { return eras[i]; } } } return null; } public Era[] getEras() { Era[] e = null; if (eras != null) { e = new Era[eras.length]; System.arraycopy(eras, 0, e, 0, eras.length); } return e; } public void setEra(CalendarDate date, String eraName) { if (eras == null) { return; // should report an error??? } for (int i = 0; i < eras.length; i++) { Era e = eras[i]; if (e != null && e.getName().equals(eraName)) { date.setEra(e); return; } } throw new IllegalArgumentException("unknown era name: " + eraName); } protected void setEras(Era[] eras) { this.eras = eras; } public CalendarDate getCalendarDate() { return getCalendarDate(System.currentTimeMillis(), newCalendarDate()); } public CalendarDate getCalendarDate(long millis) { return getCalendarDate(millis, newCalendarDate()); } public CalendarDate getCalendarDate(long millis, TimeZone zone) { CalendarDate date = newCalendarDate(zone); return getCalendarDate(millis, date); } public CalendarDate getCalendarDate(long millis, CalendarDate date) { int ms = 0; // time of day int zoneOffset = 0; int saving = 0; long days = 0; // fixed date // adjust to local time if `date' has time zone. TimeZone zi = date.getZone(); if (zi != null) { int[] offsets = new int[2]; if (zi instanceof ZoneInfo) { zoneOffset = ((ZoneInfo)zi).getOffsets(millis, offsets); } else { zoneOffset = zi.getOffset(millis); offsets[0] = zi.getRawOffset(); offsets[1] = zoneOffset - offsets[0]; } // We need to calculate the given millis and time zone // offset separately for java.util.GregorianCalendar // compatibility. (i.e., millis + zoneOffset could cause // overflow or underflow, which must be avoided.) Usually // days should be 0 and ms is in the range of -13:00 to // +14:00. However, we need to deal with extreme cases. days = zoneOffset / DAY_IN_MILLIS; ms = zoneOffset % DAY_IN_MILLIS; saving = offsets[1]; } date.setZoneOffset(zoneOffset); date.setDaylightSaving(saving); days += millis / DAY_IN_MILLIS; ms += (int) (millis % DAY_IN_MILLIS); if (ms >= DAY_IN_MILLIS) { // at most ms is (DAY_IN_MILLIS - 1) * 2. ms -= DAY_IN_MILLIS; ++days; } else { // at most ms is (1 - DAY_IN_MILLIS) * 2. Adding one // DAY_IN_MILLIS results in still negative. while (ms < 0) { ms += DAY_IN_MILLIS; --days; } } // convert to fixed date (offset from Jan. 1, 1 (Gregorian)) days += EPOCH_OFFSET; // calculate date fields from the fixed date getCalendarDateFromFixedDate(date, days); // calculate time fields from the time of day setTimeOfDay(date, ms); date.setLeapYear(isLeapYear(date)); date.setNormalized(true); return date; } public long getTime(CalendarDate date) { long gd = getFixedDate(date); long ms = (gd - EPOCH_OFFSET) * DAY_IN_MILLIS + getTimeOfDay(date); int zoneOffset = 0; TimeZone zi = date.getZone(); if (zi != null) { if (date.isNormalized()) { return ms - date.getZoneOffset(); } // adjust time zone and daylight saving int[] offsets = new int[2]; if (date.isStandardTime()) { // 1) 2:30am during starting-DST transition is // intrepreted as 2:30am ST // 2) 5:00pm during DST is still interpreted as 5:00pm ST // 3) 1:30am during ending-DST transition is interpreted // as 1:30am ST (after transition) if (zi instanceof ZoneInfo) { ((ZoneInfo)zi).getOffsetsByStandard(ms, offsets); zoneOffset = offsets[0]; } else { zoneOffset = zi.getOffset(ms - zi.getRawOffset()); } } else { // 1) 2:30am during starting-DST transition is // intrepreted as 3:30am DT // 2) 5:00pm during DST is intrepreted as 5:00pm DT // 3) 1:30am during ending-DST transition is interpreted // as 1:30am DT/0:30am ST (before transition) if (zi instanceof ZoneInfo) { zoneOffset = ((ZoneInfo)zi).getOffsetsByWall(ms, offsets); } else { zoneOffset = zi.getOffset(ms - zi.getRawOffset()); } } } ms -= zoneOffset; getCalendarDate(ms, date); return ms; } protected long getTimeOfDay(CalendarDate date) { long fraction = date.getTimeOfDay(); if (fraction != CalendarDate.TIME_UNDEFINED) { return fraction; } fraction = getTimeOfDayValue(date); date.setTimeOfDay(fraction); return fraction; } public long getTimeOfDayValue(CalendarDate date) { long fraction = date.getHours(); fraction *= 60; fraction += date.getMinutes(); fraction *= 60; fraction += date.getSeconds(); fraction *= 1000; fraction += date.getMillis(); return fraction; } public CalendarDate setTimeOfDay(CalendarDate cdate, int fraction) { if (fraction < 0) { throw new IllegalArgumentException(); } boolean normalizedState = cdate.isNormalized(); int time = fraction; int hours = time / HOUR_IN_MILLIS; time %= HOUR_IN_MILLIS; int minutes = time / MINUTE_IN_MILLIS; time %= MINUTE_IN_MILLIS; int seconds = time / SECOND_IN_MILLIS; time %= SECOND_IN_MILLIS; cdate.setHours(hours); cdate.setMinutes(minutes); cdate.setSeconds(seconds); cdate.setMillis(time); cdate.setTimeOfDay(fraction); if (hours < 24 && normalizedState) { // If this time of day setting doesn't affect the date, // then restore the normalized state. cdate.setNormalized(normalizedState); } return cdate; }
Returns 7 in this default implementation.
Returns:7
/** * Returns 7 in this default implementation. * * @return 7 */
public int getWeekLength() { return 7; } protected abstract boolean isLeapYear(CalendarDate date); public CalendarDate getNthDayOfWeek(int nth, int dayOfWeek, CalendarDate date) { CalendarDate ndate = (CalendarDate) date.clone(); normalize(ndate); long fd = getFixedDate(ndate); long nfd; if (nth > 0) { nfd = 7 * nth + getDayOfWeekDateBefore(fd, dayOfWeek); } else { nfd = 7 * nth + getDayOfWeekDateAfter(fd, dayOfWeek); } getCalendarDateFromFixedDate(ndate, nfd); return ndate; }
Returns a date of the given day of week before the given fixed date.
Params:
  • fixedDate – the fixed date
  • dayOfWeek – the day of week
Returns:the calculated date
/** * Returns a date of the given day of week before the given fixed * date. * * @param fixedDate the fixed date * @param dayOfWeek the day of week * @return the calculated date */
static long getDayOfWeekDateBefore(long fixedDate, int dayOfWeek) { return getDayOfWeekDateOnOrBefore(fixedDate - 1, dayOfWeek); }
Returns a date of the given day of week that is closest to and after the given fixed date.
Params:
  • fixedDate – the fixed date
  • dayOfWeek – the day of week
Returns:the calculated date
/** * Returns a date of the given day of week that is closest to and * after the given fixed date. * * @param fixedDate the fixed date * @param dayOfWeek the day of week * @return the calculated date */
static long getDayOfWeekDateAfter(long fixedDate, int dayOfWeek) { return getDayOfWeekDateOnOrBefore(fixedDate + 7, dayOfWeek); }
Returns a date of the given day of week on or before the given fixed date.
Params:
  • fixedDate – the fixed date
  • dayOfWeek – the day of week
Returns:the calculated date
/** * Returns a date of the given day of week on or before the given fixed * date. * * @param fixedDate the fixed date * @param dayOfWeek the day of week * @return the calculated date */
// public for java.util.GregorianCalendar public static long getDayOfWeekDateOnOrBefore(long fixedDate, int dayOfWeek) { long fd = fixedDate - (dayOfWeek - 1); if (fd >= 0) { return fixedDate - (fd % 7); } return fixedDate - CalendarUtils.mod(fd, 7); }
Returns the fixed date calculated with the specified calendar date. If the specified date is not normalized, its date fields are normalized.
Params:
  • date – a CalendarDate with which the fixed date is calculated
See Also:
  • fixed_date.fixed_date
Returns:the calculated fixed date
/** * Returns the fixed date calculated with the specified calendar * date. If the specified date is not normalized, its date fields * are normalized. * * @param date a <code>CalendarDate</code> with which the fixed * date is calculated * @return the calculated fixed date * @see AbstractCalendar.html#fixed_date */
protected abstract long getFixedDate(CalendarDate date);
Calculates calendar fields from the specified fixed date. This method stores the calculated calendar field values in the specified CalendarDate.
Params:
  • date – a CalendarDate to stored the calculated calendar fields.
  • fixedDate – a fixed date to calculate calendar fields
See Also:
  • fixed_date.fixed_date
/** * Calculates calendar fields from the specified fixed date. This * method stores the calculated calendar field values in the specified * <code>CalendarDate</code>. * * @param date a <code>CalendarDate</code> to stored the * calculated calendar fields. * @param fixedDate a fixed date to calculate calendar fields * @see AbstractCalendar.html#fixed_date */
protected abstract void getCalendarDateFromFixedDate(CalendarDate date, long fixedDate); public boolean validateTime(CalendarDate date) { int t = date.getHours(); if (t < 0 || t >= 24) { return false; } t = date.getMinutes(); if (t < 0 || t >= 60) { return false; } t = date.getSeconds(); // TODO: Leap second support. if (t < 0 || t >= 60) { return false; } t = date.getMillis(); if (t < 0 || t >= 1000) { return false; } return true; } int normalizeTime(CalendarDate date) { long fraction = getTimeOfDay(date); long days = 0; if (fraction >= DAY_IN_MILLIS) { days = fraction / DAY_IN_MILLIS; fraction %= DAY_IN_MILLIS; } else if (fraction < 0) { days = CalendarUtils.floorDivide(fraction, DAY_IN_MILLIS); if (days != 0) { fraction -= DAY_IN_MILLIS * days; // mod(fraction, DAY_IN_MILLIS) } } if (days != 0) { date.setTimeOfDay(fraction); } date.setMillis((int)(fraction % 1000)); fraction /= 1000; date.setSeconds((int)(fraction % 60)); fraction /= 60; date.setMinutes((int)(fraction % 60)); date.setHours((int)(fraction / 60)); return (int)days; } }