Java example source code file (Time.java)

This example Java source code file (Time.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

calendar, calendardate, date, gregorian, month, one_minute, ruleday, simpletimezone, std, string, stringbuilder, sun, time, utc, util, wall, wall_time

The Time.java Java example source code

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

import java.util.Locale;
import sun.util.calendar.CalendarDate;
import sun.util.calendar.CalendarSystem;
import sun.util.calendar.Gregorian;

/**
 * Time class represents the "AT" field and other time related information.
 *
 * @since 1.4
 */
class Time {

    static final Gregorian gcal = CalendarSystem.getGregorianCalendar();

    // type is wall clock time
    private static final int WALL = 1;

    // type is standard time
    private static final int STD = 2;

    // type is UTC
    private static final int UTC = 3;

    // type of representing time
    private int type;

    /**
     * Time from the EPOCH in milliseconds
     */
    private long time;

    /**
     * Current time in milliseconds
     */
    private static final long currentTime = System.currentTimeMillis();

    Time() {
        time = 0L;
    }

    Time(long time) {
        this.time = time;
    }

    void setType(int type) {
        this.type = type;
    }

    long getTime() {
        return time;
    }

    int getType() {
        return type;
    }

    static long getCurrentTime() {
        return currentTime;
    }

    /**
     * @return true if the time is represented in wall-clock time.
     */
    boolean isWall() {
        return type == WALL;
    }

    /**
     * @return true if the time is represented in standard time.
     */
    boolean isSTD() {
        return type == STD;
    }

    /**
     * @return true if the time is represented in UTC time.
     */
    boolean isUTC() {
        return type == UTC;
    }

    /**
     * Converts the type to a string that represents the type in the
     * SimpleTimeZone time mode. (e.g., "SimpleTimeZone.WALL_TIME").
     * @return the converted string or null if the type is undefined.
     */
    String getTypeForSimpleTimeZone() {
        String  stz = "SimpleTimeZone.";
        if (isWall()) {
            return stz+"WALL_TIME";
        }
        else if (isSTD()) {
            return stz+"STANDARD_TIME";
        }
        else if (isUTC()) {
            return stz+"UTC_TIME";
        }
        else {
            return null;
        }
    }

    /**
     * Converts the given Gregorian calendar field values to local time.
     * Local time is represented by the amount of milliseconds from
     * January 1, 1970 0:00 GMT.
     * @param year the year value
     * @param month the Month value
     * @param day the day represented by {@link RuleDay}
     * @param save the amount of daylight time in milliseconds
     * @param gmtOffset the GMT offset in milliseconds
     * @param time the time of the day represented by {@link Time}
     * @return local time
     */
    static long getLocalTime(int year, Month month, RuleDay day, int save,
                             int gmtOffset, Time time) {
        long    t = time.getTime();

        if (time.isSTD())
            t = time.getTime() + save;
        else if (time.isUTC())
            t = time.getTime() + save + gmtOffset;

        return getLocalTime(year, month, day, t);
    }

    /**
     * Converts the given Gregorian calendar field values to local time.
     * Local time is represented by the amount of milliseconds from
     * January 1, 1970 0:00 GMT.
     * @param year the year value
     * @param month the Month value
     * @param day the day value
     * @param time the time of the day in milliseconds
     * @return local time
     */
    static long getLocalTime(int year, Month month, int day, long time) {
        CalendarDate date = gcal.newCalendarDate(null);
        date.setDate(year, month.value(), day);
        long millis = gcal.getTime(date);
        return millis + time;
    }

    /**
     * Equivalent to <code>getLocalTime(year, month, day, (long)time).
     * @param year the year value
     * @param month the Month value
     * @param day the day value
     * @param time the time of the day in milliseconds
     * @return local time
     */
    static long getLocalTime(int year, Month month, int day, int time) {
        return getLocalTime(year, month, day, (long)time);
    }

    /**
     * Equivalent to {@link #getLocalTime(int, Month, RuleDay, int)
     * getLocalTime(year, month, day, (int) time)}.
     * @param year the year value
     * @param month the Month value
     * @param day the day represented by {@link RuleDay}
     * @param time the time of the day represented by {@link Time}
     * @return local time
     */
    static long getLocalTime(int year, Month month, RuleDay day, long time) {
        return getLocalTime(year, month, day, (int) time);
    }

    /**
     * Converts the given Gregorian calendar field values to local time.
     * Local time is represented by the amount of milliseconds from
     * January 1, 1970 0:00 GMT.
     * @param year the year value
     * @param month the Month value
     * @param day the day represented by {@link RuleDay}
     * @param time the time of the day represented by {@link Time}
     * @return local time
     */
    static long getLocalTime(int year, Month month, RuleDay day, int time) {
        CalendarDate cdate = gcal.newCalendarDate(null);
        int monthValue = month.value();

        if (day.isLast()) {     // e.g., "lastSun"
            cdate.setDate(year, monthValue, 1);
            cdate.setDayOfMonth(gcal.getMonthLength(cdate));
            cdate = gcal.getNthDayOfWeek(-1, day.getDayOfWeekNum(), cdate);
        } else if (day.isLater()) { // e.g., "Sun>=1"
            cdate.setDate(year, monthValue, day.getDay());
            cdate = gcal.getNthDayOfWeek(1, day.getDayOfWeekNum(), cdate);
        } else if (day.isExact()) {
            cdate.setDate(year, monthValue, day.getDay());
        } else if (day.isEarlier()) {   // e.g., "Sun<=15"
            cdate.setDate(year, monthValue, day.getDay());
            cdate = gcal.getNthDayOfWeek(-1, day.getDayOfWeekNum(), cdate);
        } else {
            Main.panic("invalid day type: " + day);
        }
        return gcal.getTime(cdate) + time;
    }

    /**
     * Parses the given "AT" field and constructs a Time object.
     * @param the "AT" field string
     * @return the Time object
     */
    static Time parse(String time) {
        int sign;
        int index = 0;
        Time tm;

        if (time.charAt(0) == '-') {
            sign = -1;
            index++;
        } else {
            sign = 1;
        }
        int val = 0;
        int num = 0;
        int countDelim = 0;
        while (index < time.length()) {
            char c = time.charAt(index++);
            if (c == ':') {
                val = val * 60 + num;
                countDelim++;
                num = 0;
                continue;
            }
            int d = Character.digit(c, 10);
            if (d == -1) {
                --index;
                break;
            }
            num = num * 10 + d;
        }
        val = val * 60 + num;
        // convert val to second
        for (; countDelim < 2; countDelim++) {
            val *= 60;
        }
        tm = new Time((long)val * 1000 * sign);
        if (index < time.length()) {
            char c = time.charAt(index++);
            if (c == 's') {
                tm.setType(Time.STD);
            } else if (c == 'u' || c == 'g' || c == 'z') {
                tm.setType(Time.UTC);
            } else if (c == 'w') {
                tm.setType(Time.WALL);
            } else {
                Main.panic("unknown time mode: "+c);
            }
        } else {
            tm.setType(Time.WALL);
        }
        return tm;
    }

    /**
     * Converts the given milliseconds string to a "[+-]hh:mm" string.
     * @param ms the milliseconds string
     */
    static String toGMTFormat(String ms) {
        long sec = Long.parseLong(ms) / 1000;
        char sign;
        if (sec < 0) {
            sign = '-';
            sec = -sec;
        } else {
            sign = '+';
        }
        return String.format((Locale)null, "%c%02d:%02d",
                             sign, sec/3600, (sec%3600)/60);
    }

    /**
     * Converts the given millisecond value to a string for a
     * SimpleTimeZone parameter.
     * @param ms the millisecond value
     * @return the string in a human readable form
     */
    static String toFormedString(int ms) {
        StringBuilder s = new StringBuilder();
        boolean minus = false;

        if (ms < 0) {
            s.append("-");
            minus = true;
            ms = -ms;
        } else if (ms == 0) {
            return "0";
        }

        int hour = ms / (60 * 60 * 1000);
        ms %= (60 * 60 * 1000);
        int minute = ms / (60 * 1000);

        if (hour != 0) {
            if (minus && minute != 0) {
                s.append("(");
            }
            s.append(Integer.toString(hour) + "*ONE_HOUR");
        }

        if (minute != 0) {
            if (hour != 0) {
                s.append("+");
            }
            s.append(Integer.toString(minute) + "*ONE_MINUTE");
            if (minus && hour != 0) {
                s.append(")");
            }
        }

        return s.toString();
    }
}