-/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
+/* java.util.Date
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
- This file is part of libgcj.
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.util;
-import java.text.*;
/**
+ * This class represents a specific time in milliseconds since the epoch.
+ * The epoch is 1970, January 1 00:00:00.0000 UTC.
+ *
+ * Date is intended to reflect universal time coordinate (UTC), but doesn't
+ * handle the leap seconds.
+ *
+ * Prior to jdk 1.1 this class was the sole Time class and had also
+ * calendar functionality. But this can't be localized, so a new Calendar
+ * class was created, that you should use instead. The functions which
+ * get or return a year, month, day etc. are all deprecated and shouldn't be
+ * used. Use Calendar instead.
+ *
+ * @see Calendar
+ * @see GregorianCalendar
+ * @see java.text.DateFormat
+ * @author Jochen Hoenicke
* @author Per Bothner <bothner@cygnus.com>
- * @date October 24, 1998.
- */
-
-/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3,
- * "The Java Language Specification", ISBN 0-201-63451-1,
- * and O'Reilly's "Java in a Nutshell".
- * Status: Need to re-write toString().
- * Missing: ToGMTString.
*/
-public class Date implements java.io.Serializable, Cloneable
+public class Date implements Cloneable, Comparable, java.io.Serializable
{
+ /**
+ * This is the serialization UID for this class
+ */
private static final long serialVersionUID = 7523967970034938905L;
- transient private long millis;
+ /**
+ * The time in milliseconds since the epoch.
+ */
+ private transient long time;
+
+ /**
+ * Creates a new Date Object representing the current time.
+ */
+ public Date()
+ {
+ time = System.currentTimeMillis();
+ }
- public Date() { millis = System.currentTimeMillis(); }
+ /**
+ * Creates a new Date Object representing the given time.
+ * @param time the time in milliseconds since the epoch.
+ */
+ public Date(long time)
+ {
+ this.time = time;
+ }
- public Date(long millis) { this.millis = millis; }
+ /**
+ * Creates a new Date Object representing the given time.
+ * @deprecated use <code>new GregorianCalendar(year+1900, month,
+ * day)</code> instead.
+ */
+ public Date(int year, int month, int day)
+ {
+ time = new GregorianCalendar(year + 1900, month, day).getTimeInMillis();
+ }
+
+ /**
+ * Creates a new Date Object representing the given time.
+ * @deprecated use <code>new GregorianCalendar(year+1900, month,
+ * day, hour, min)</code> instead.
+ */
+ public Date(int year, int month, int day, int hour, int min)
+ {
+ time =
+ new GregorianCalendar(year + 1900, month, day, hour,
+ min).getTimeInMillis();
+ }
+
+ /*
+ * Creates a new Date Object representing the given time.
+ * @deprecated use <code>new GregorianCalendar(year+1900, month,
+ * day)</code> instead.
+ */
+ public Date(int year, int month, int day, int hour, int min, int sec)
+ {
+ time =
+ new GregorianCalendar(year + 1900, month, day, hour, min,
+ sec).getTimeInMillis();
+ }
+
+ /**
+ * Creates a new Date from the given string representation. This
+ * does the same as <code>new Date(Date.parse(s))</code>
+ * @see #parse
+ * @deprecated use <code>java.text.DateFormat.parse(s)</code> instead.
+ */
+ public Date(String s)
+ {
+ time = parse(s);
+ }
+
+ public Object clone()
+ {
+ try
+ {
+ return super.clone();
+ }
+ catch (CloneNotSupportedException ex)
+ {
+ return null;
+ }
+ }
+
+ /**
+ * @deprecated Use Calendar with a UTC TimeZone instead.
+ * @return the time in millis since the epoch.
+ */
+ public static long UTC(int year, int month, int date,
+ int hrs, int min, int sec)
+ {
+ GregorianCalendar cal =
+ new GregorianCalendar(year + 1900, month, date, hrs, min, sec);
+ cal.set(Calendar.ZONE_OFFSET, 0);
+ cal.set(Calendar.DST_OFFSET, 0);
+ return cal.getTimeInMillis();
+ }
+
+ /**
+ * Gets the time represented by this Object
+ * @return the time in milliseconds since the epoch.
+ */
+ public long getTime()
+ {
+ return time;
+ }
+
+ /**
+ * @deprecated use
+ * Calendar.get(Calendar.ZONE_OFFSET)+Calendar.get(Calendar.DST_OFFSET)
+ * instead.
+ * @return The time zone offset in minutes of the local time zone
+ * relative to UTC. The time represented by this object is used to
+ * determine if we should use daylight savings.
+ */
+ public int getTimezoneOffset()
+ {
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ return (cal.get(Calendar.ZONE_OFFSET)
+ + cal.get(Calendar.DST_OFFSET)) / (60 * 1000);
+ }
+
+ /**
+ * Sets the time which this Object should represented.
+ * @param time the time in milliseconds since the epoch. */
+ public void setTime(long time)
+ {
+ this.time = time;
+ }
+
+ /**
+ * Tests if this date is after the specified date.
+ * @param when the other date
+ * @return true, if the date represented by this Object is
+ * strictly later than the time represented by when.
+ */
+ public boolean after(Date when)
+ {
+ return time > when.time;
+ }
+
+ /**
+ * Tests if this date is before the specified date.
+ * @param when the other date
+ * @return true, if the date represented by when is strictly later
+ * than the time represented by this object.
+ */
+ public boolean before(Date when)
+ {
+ return time < when.time;
+ }
+
+ /**
+ * Compares two dates for equality.
+ * @param obj the object to compare.
+ * @return true, if obj is a Date object and the date represented
+ * by obj is exactly the same as the time represented by this
+ * object.
+ */
+ public boolean equals(Object obj)
+ {
+ return (obj instanceof Date && time == ((Date) obj).time);
+ }
- public Date(int year, int month, int date, int hours,
- int minutes, int seconds)
+ /**
+ * Compares two dates.
+ * @param when the other date.
+ * @return 0, if the date represented
+ * by obj is exactly the same as the time represented by this
+ * object, a negative if this Date is before the other Date, and
+ * a positive value otherwise.
+ */
+ public int compareTo(Date when)
{
- setTime(year, month, date, hours, minutes, seconds);
+ return (time < when.time) ? -1 : (time == when.time) ? 0 : 1;
}
- public Date(int year, int month, int date, int hours, int minutes)
+ /**
+ * Compares this Date to another. This behaves like
+ * <code>compareTo(Date)</code>, but it may throw a
+ * <code>ClassCastException</code>
+ * @param obj the other date.
+ * @return 0, if the date represented
+ * by obj is exactly the same as the time represented by this
+ * object, a negative if this Date is before the other Date, and
+ * a positive value otherwise.
+ * @exception ClassCastException if obj is not of type Date.
+ */
+ public int compareTo(Object obj)
{
- setTime(year, month, date, hours, minutes, 0);
+ return compareTo((Date) obj);
}
- public Date(int year, int month, int date)
+ public int hashCode()
+ {
+ return (int) time ^ (int) (time >>> 32);
+ }
+
+ private String[] weekNames = { "Sun", "Mon", "Tue", "Wed",
+ "Thu", "Fri", "Sat" };
+
+ private String[] monthNames = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+
+ public String toString()
+ {
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ String day = "0" + cal.get(Calendar.DATE);
+ String hour = "0" + cal.get(Calendar.HOUR_OF_DAY);
+ String min = "0" + cal.get(Calendar.MINUTE);
+ String sec = "0" + cal.get(Calendar.SECOND);
+ String year = "000" + cal.get(Calendar.YEAR);
+ return weekNames[cal.get(Calendar.DAY_OF_WEEK) - 1] + " "
+ + monthNames[cal.get(Calendar.MONTH)] + " "
+ + day.substring(day.length() - 2) + " "
+ + hour.substring(hour.length() - 2) + ":"
+ + min.substring(min.length() - 2) + ":"
+ + sec.substring(sec.length() - 2) + " "
+ +
+ cal.getTimeZone().getDisplayName(cal.getTimeZone().inDaylightTime(this),
+ TimeZone.SHORT) + " " +
+ year.substring(year.length() - 4);
+ }
+
+ /** Format this object in a locale-specific way.
+ * @deprecated Use DateFormat.format(Date)
+ */
+ public String toLocaleString()
{
- setTime(year, month, date, 0, 0, 0);
+ return java.text.DateFormat.getInstance().format(this);
}
- public Date (String s) { this(parse(s)); }
+ /** Format this object in a standard format in the GMT timezone.
+ * @deprecated Use DateFormat.format(Date) with a GMT TimeZone.
+ */
+ public String toGMTString()
+ {
+ java.text.DateFormat format = java.text.DateFormat.getInstance();
+ format.setTimeZone(TimeZone.getTimeZone("GMT"));
+ return format.format(this);
+ }
private static int skipParens(String string, int offset)
{
return false;
}
+ /** Parse a String and return the time it represents.
+ * @param s The String to parse.
+ * @deprecated Use DateFormat.parse(String)
+ */
public static long parse(String string)
{
// Initialize date/time fields before parsing begins.
-timezone * 60 * 1000);
}
- public boolean after (Date when) { return this.millis > when.millis; }
- public boolean before (Date when) { return this.millis < when.millis; }
-
- public boolean equals(Object obj)
- {
- return (obj != null && obj instanceof Date
- && ((Date)obj).millis == this.millis);
- }
-
- public long getTime() { return millis; }
-
- public int hashCode()
- {
- return (int)(millis^(millis>>>32));
- }
-
- private void setTime(int year, int month, int date,
- int hours, int minutes, int seconds)
- {
- Calendar cal = new GregorianCalendar(year+1900, month, date,
- hours, minutes, seconds);
- millis = cal.getTimeInMillis();
- }
-
- public void setTime(long millis) { this.millis = millis; }
-
- private int getField (int fld)
- {
- Calendar cal = new GregorianCalendar();
- cal.setTime(this);
- return cal.get(fld);
- }
-
- public int getYear ()
- {
- return getField(Calendar.YEAR) - 1900;
- }
-
- public int getMonth ()
- {
- return getField(Calendar.MONTH);
- }
-
- public int getDate ()
- {
- return getField(Calendar.DATE);
- }
-
- public int getDay ()
- {
- return getField(Calendar.DAY_OF_WEEK) - 1;
- }
-
- public int getHours ()
- {
- return getField(Calendar.HOUR_OF_DAY);
- }
-
- public int getMinutes ()
- {
- return getField(Calendar.MINUTE);
- }
-
- public int getSeconds ()
+ /**
+ * @return the year minus 1900 represented by this date object.
+ * @deprecated Use Calendar instead of Date, and use get(Calendar.YEAR)
+ * instead. Note about the 1900 difference in year.
+ */
+ public int getYear()
{
- return getField(Calendar.SECOND);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ return cal.get(Calendar.YEAR) - 1900;
}
- private void setField (int fld, int value)
+ /**
+ * Sets the year to year minus 1900, not changing the other fields.
+ * @param year the year minus 1900.
+ * @deprecated Use Calendar instead of Date, and use
+ * set(Calendar.YEAR, year) instead. Note about the 1900
+ * difference in year.
+ */
+ public void setYear(int year)
{
- Calendar cal = new GregorianCalendar();
- cal.setTime(this);
- cal.set(fld, value);
- millis = cal.getTimeInMillis();
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ cal.set(Calendar.YEAR, 1900 + year);
+ time = cal.getTimeInMillis();
}
- public void setYear (int year)
+ /**
+ * @return the month represented by this date object (zero based).
+ * @deprecated Use Calendar instead of Date, and use get(Calendar.MONTH)
+ * instead.
+ */
+ public int getMonth()
{
- setField(Calendar.YEAR, 1900 + year);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ return cal.get(Calendar.MONTH);
}
- public void setMonth (int month)
+ /**
+ * Sets the month to the given value, not changing the other fields.
+ * @param month the month, zero based.
+ * @deprecated Use Calendar instead of Date, and use
+ * set(Calendar.MONTH, month) instead.
+ */
+ public void setMonth(int month)
{
- setField(Calendar.MONTH, month);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ cal.set(Calendar.MONTH, month);
+ time = cal.getTimeInMillis();
}
- public void setDate (int date)
+ /**
+ * @return the day of month represented by this date object.
+ * @deprecated Use Calendar instead of Date, and use get(Calendar.DATE)
+ * instead.
+ */
+ public int getDate()
{
- setField(Calendar.DATE, date);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ return cal.get(Calendar.DATE);
}
- public void setHours (int hours)
+ /**
+ * Sets the date to the given value, not changing the other fields.
+ * @param date the date.
+ * @deprecated Use Calendar instead of Date, and use
+ * set(Calendar.DATE, date) instead.
+ */
+ public void setDate(int date)
{
- setField(Calendar.HOUR_OF_DAY, hours);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ cal.set(Calendar.DATE, date);
+ time = cal.getTimeInMillis();
}
- public void setMinutes (int minutes)
+ /**
+ * @return the day represented by this date object.
+ * @deprecated Use Calendar instead of Date, and use get(Calendar.DAY_OF_WEEK)
+ * instead.
+ */
+ public int getDay()
{
- setField(Calendar.MINUTE, minutes);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ return cal.get(Calendar.DAY_OF_WEEK);
}
- public void setSeconds (int seconds)
+ /**
+ * @return the hours represented by this date object.
+ * @deprecated Use Calendar instead of Date, and use get(Calendar.HOUR_OF_DAY)
+ * instead.
+ */
+ public int getHours()
{
- setField(Calendar.SECOND, seconds);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ return cal.get(Calendar.HOUR_OF_DAY);
}
- public int getTimezoneOffset ()
+ /**
+ * Sets the hours to the given value, not changing the other fields.
+ * @param hours the hours.
+ * @deprecated Use Calendar instead of Date, and use
+ * set(Calendar.HOUR_OF_DAY, hours) instead.
+ */
+ public void setHours(int hours)
{
- Calendar cal = new GregorianCalendar();
- cal.setTime(this);
- return - (cal.get(Calendar.ZONE_OFFSET)
- + cal.get(Calendar.DST_OFFSET)/(60*1000));
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ cal.set(Calendar.HOUR_OF_DAY, hours);
+ time = cal.getTimeInMillis();
}
- public String toString ()
+ /**
+ * @return the minutes represented by this date object.
+ * @deprecated Use Calendar instead of Date, and use get(Calendar.MINUTE)
+ * instead.
+ */
+ public int getMinutes()
{
- // This is slow, but does it matter? There is no particularly
- // fast way to do it, because we need the timezone offset, which
- // we don't store. Unix ctime() doesn't provide this information.
- SimpleDateFormat fmt = new SimpleDateFormat ("E MMM dd HH:mm:ss z yyyy",
- Locale.US);
- fmt.setTimeZone(TimeZone.getDefault());
- return fmt.format(this);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ return cal.get(Calendar.MINUTE);
}
- public String toGMTString ()
+ /**
+ * Sets the minutes to the given value, not changing the other fields.
+ * @param minutes the minutes.
+ * @deprecated Use Calendar instead of Date, and use
+ * set(Calendar.MINUTE, minutes) instead.
+ */
+ public void setMinutes(int minutes)
{
- // This method is deprecated. We don't care if it is very slow.
- SimpleDateFormat fmt = new SimpleDateFormat ("d MMM yyyy HH:mm:ss 'GMT'",
- Locale.US);
- fmt.setTimeZone(TimeZone.getTimeZone("GMT"));
- return fmt.format(this);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ cal.set(Calendar.MINUTE, minutes);
+ time = cal.getTimeInMillis();
}
- public String toLocaleString ()
+ /**
+ * @return the seconds represented by this date object.
+ * @deprecated Use Calendar instead of Date, and use get(Calendar.SECOND)
+ * instead.
+ */
+ public int getSeconds()
{
- // This method is deprecated. We don't care if it is very slow.
- DateFormat fmt = DateFormat.getDateTimeInstance();
- fmt.setTimeZone(TimeZone.getDefault());
- return fmt.format(this);
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ return cal.get(Calendar.SECOND);
}
- public static long UTC (int year, int month, int date,
- int hours, int minutes, int seconds)
+ /**
+ * Sets the seconds to the given value, not changing the other fields.
+ * @param seconds the seconds.
+ * @deprecated Use Calendar instead of Date, and use
+ * set(Calendar.SECOND, seconds) instead.
+ */
+ public void setSeconds(int seconds)
{
- GregorianCalendar cal = new GregorianCalendar (TimeZone.getTimeZone("GMT"));
- cal.set(year+1900, month, date, hours, minutes, seconds);
- return cal.getTimeInMillis();
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(time);
+ cal.set(Calendar.SECOND, seconds);
+ time = cal.getTimeInMillis();
}
/**
* Reads an Object from the stream.
*/
- private void readObject (java.io.ObjectInputStream input)
+ private void readObject(java.io.ObjectInputStream input)
throws java.io.IOException, ClassNotFoundException
{
- input.defaultReadObject ();
- millis = input.readLong ();
+ input.defaultReadObject();
+ time = input.readLong();
}
/**
* in milliseconds. This is the same value that is returned by the
* method getTime().
*/
- private void writeObject (java.io.ObjectOutputStream output)
+ private void writeObject(java.io.ObjectOutputStream output)
throws java.io.IOException
{
- output.defaultWriteObject ();
- output.writeLong (millis);
+ output.defaultWriteObject();
+ output.writeLong(time);
}
}
projects / gcc.git / commitdiff