Examples with BaseCalendar sun.util.calendar.BaseCalendar used on opensource projects

Example 6 with BaseCalendar

use of sun.util.calendar.BaseCalendar in project checker-framework by typetools.

the class Date method toGMTString.

/**
 * Creates a string representation of this <tt>Date</tt> object of
 * the form:
 * <blockquote<pre>
 * d mon yyyy hh:mm:ss GMT</pre></blockquote>
 * where:<ul>
 * <li><i>d</i> is the day of the month (<tt>1</tt> through <tt>31</tt>),
 *     as one or two decimal digits.
 * <li><i>mon</i> is the month (<tt>Jan, Feb, Mar, Apr, May, Jun, Jul,
 *     Aug, Sep, Oct, Nov, Dec</tt>).
 * <li><i>yyyy</i> is the year, as four decimal digits.
 * <li><i>hh</i> is the hour of the day (<tt>00</tt> through <tt>23</tt>),
 *     as two decimal digits.
 * <li><i>mm</i> is the minute within the hour (<tt>00</tt> through
 *     <tt>59</tt>), as two decimal digits.
 * <li><i>ss</i> is the second within the minute (<tt>00</tt> through
 *     <tt>61</tt>), as two decimal digits.
 * <li><i>GMT</i> is exactly the ASCII letters "<tt>GMT</tt>" to indicate
 *     Greenwich Mean Time.
 * </ul><p>
 * The result does not depend on the local time zone.
 *
 * @return  a string representation of this date, using the Internet GMT
 *          conventions.
 * @see     java.text.DateFormat
 * @see     java.util.Date#toString()
 * @see     java.util.Date#toLocaleString()
 * @deprecated As of JDK version 1.1,
 * replaced by <code>DateFormat.format(Date date)</code>, using a
 * GMT <code>TimeZone</code>.
 */
@Deprecated
public String toGMTString() {
    // d MMM yyyy HH:mm:ss 'GMT'
    long t = getTime();
    BaseCalendar cal = getCalendarSystem(t);
    BaseCalendar.Date date = (BaseCalendar.Date) cal.getCalendarDate(getTime(), (TimeZone) null);
    StringBuilder sb = new StringBuilder(32);
    // d
    CalendarUtils.sprintf0d(sb, date.getDayOfMonth(), 1).append(' ');
    // MMM
    convertToAbbr(sb, wtb[date.getMonth() - 1 + 2 + 7]).append(' ');
    // yyyy
    sb.append(date.getYear()).append(' ');
    // HH
    CalendarUtils.sprintf0d(sb, date.getHours(), 2).append(':');
    // mm
    CalendarUtils.sprintf0d(sb, date.getMinutes(), 2).append(':');
    // ss
    CalendarUtils.sprintf0d(sb, date.getSeconds(), 2);
    // ' GMT'
    sb.append(" GMT");
    return sb.toString();
}

Example 7 with BaseCalendar

use of sun.util.calendar.BaseCalendar in project checker-framework by typetools.

the class Date method getCalendarDate.

private final BaseCalendar.Date getCalendarDate() {
    if (cdate == null) {
        BaseCalendar cal = getCalendarSystem(fastTime);
        cdate = (BaseCalendar.Date) cal.getCalendarDate(fastTime, TimeZone.getDefaultRef());
    }
    return cdate;
}

Example 8 with BaseCalendar

use of sun.util.calendar.BaseCalendar in project checker-framework by typetools.

the class GregorianCalendar method setGregorianChange.

private void setGregorianChange(long cutoverTime) {
    gregorianCutover = cutoverTime;
    gregorianCutoverDate = CalendarUtils.floorDivide(cutoverTime, ONE_DAY) + EPOCH_OFFSET;
    // 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 jcal = getJulianCalendarSystem();
    d = (BaseCalendar.Date) jcal.newCalendarDate(TimeZone.NO_TIMEZONE);
    jcal.getCalendarDateFromFixedDate(d, gregorianCutoverDate - 1);
    gregorianCutoverYearJulian = d.getNormalizedYear();
    if (time < gregorianCutover) {
        // The field values are no longer valid under the new
        // cutover date.
        setUnnormalized();
    }
}

Example 9 with BaseCalendar

use of sun.util.calendar.BaseCalendar in project checker-framework by typetools.

the class GregorianCalendar method computeFields.

/**
 * 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);
    // 0-based
    int month = cdate.getMonth() - 1;
    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);
            // Assume AM == 0
            internalSet(AM_PM, hours / 12);
            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);
        // 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 = calsys.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 = calForJan1.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;
}

Example 10 with BaseCalendar

use of sun.util.calendar.BaseCalendar in project checker-framework by typetools.

the class SimpleTimeZone method getOffset.

/**
 * Returns the difference in milliseconds between local time and
 * UTC, taking into account both the raw offset and the effect of
 * daylight saving, for the specified date and time.  This method
 * assumes that the start and end month are distinct.  It also
 * uses a default {@link GregorianCalendar} object as its
 * underlying calendar, such as for determining leap years.  Do
 * not use the result of this method with a calendar other than a
 * default <code>GregorianCalendar</code>.
 *
 * <p><em>Note:  In general, clients should use
 * <code>Calendar.get(ZONE_OFFSET) + Calendar.get(DST_OFFSET)</code>
 * instead of calling this method.</em>
 *
 * @param era       The era of the given date.
 * @param year      The year in the given date.
 * @param month     The month in the given date. Month is 0-based. e.g.,
 *                  0 for January.
 * @param day       The day-in-month of the given date.
 * @param dayOfWeek The day-of-week of the given date.
 * @param millis    The milliseconds in day in <em>standard</em> local time.
 * @return          The milliseconds to add to UTC to get local time.
 * @exception       IllegalArgumentException the <code>era</code>,
 *                  <code>month</code>, <code>day</code>, <code>dayOfWeek</code>,
 *                  or <code>millis</code> parameters are out of range
 */
public int getOffset(int era, int year, int month, int day, int dayOfWeek, int millis) {
    if (era != GregorianCalendar.AD && era != GregorianCalendar.BC) {
        throw new IllegalArgumentException("Illegal era " + era);
    }
    int y = year;
    if (era == GregorianCalendar.BC) {
        // adjust y with the GregorianCalendar-style year numbering.
        y = 1 - y;
    }
    // can't be supported by the Java time system.
    if (y >= 292278994) {
        y = 2800 + y % 2800;
    } else if (y <= -292269054) {
        // y %= 28 also produces an equivalent year, but positive
        // year numbers would be convenient to use the UNIX cal
        // command.
        y = (int) CalendarUtils.mod((long) y, 28);
    }
    // convert year to its 1-based month value
    int m = month + 1;
    // First, calculate time as a Gregorian date.
    BaseCalendar cal = gcal;
    BaseCalendar.Date cdate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.NO_TIMEZONE);
    cdate.setDate(y, m, day);
    // normalize cdate
    long time = cal.getTime(cdate);
    // UTC time
    time += millis - rawOffset;
    // style year numbering (..., -1, 0 (BCE 1), 1, 2, ...).
    if (time < GregorianCalendar.DEFAULT_GREGORIAN_CUTOVER) {
        cal = (BaseCalendar) CalendarSystem.forName("julian");
        cdate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.NO_TIMEZONE);
        cdate.setNormalizedDate(y, m, day);
        time = cal.getTime(cdate) + millis - rawOffset;
    }
    if ((cdate.getNormalizedYear() != y) || (cdate.getMonth() != m) || (cdate.getDayOfMonth() != day) || // compatibility.
    (dayOfWeek < Calendar.SUNDAY || dayOfWeek > Calendar.SATURDAY) || (millis < 0 || millis >= (24 * 60 * 60 * 1000))) {
        throw new IllegalArgumentException();
    }
    if (!useDaylight || year < startYear || era != GregorianCalendar.CE) {
        return rawOffset;
    }
    return getOffset(cal, cdate, y, time);
}