From fc07ebe2a7a5e92f798d5e52f23ff2002efa2b97 Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Thu, 14 Jun 2001 15:41:57 +0000 Subject: [PATCH] re PR libgcj/3144 (java.lang.Date.compareTo() not supported) Fix for PR libgcj/3144: * java/util/Date.java: Merged with Classpath. From-SVN: r43374 --- libjava/ChangeLog | 5 + libjava/java/util/Date.java | 553 ++++++++++++++++++++++++++---------- 2 files changed, 415 insertions(+), 143 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 9dc403c55cb..d632ce11aa2 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,8 @@ +2001-06-14 Tom Tromey + + Fix for PR libgcj/3144: + * java/util/Date.java: Merged with Classpath. + 2001-06-12 Tom Tromey * aclocal.m4, configure: Rebuilt. diff --git a/libjava/java/util/Date.java b/libjava/java/util/Date.java index d3301be3613..edd45f8a929 100644 --- a/libjava/java/util/Date.java +++ b/libjava/java/util/Date.java @@ -1,52 +1,296 @@ -/* 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 - * @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 new GregorianCalendar(year+1900, month, + * day) 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 new GregorianCalendar(year+1900, month, + * day, hour, min) 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 new GregorianCalendar(year+1900, month, + * day) 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 new Date(Date.parse(s)) + * @see #parse + * @deprecated use java.text.DateFormat.parse(s) 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 + * compareTo(Date), but it may throw a + * ClassCastException + * @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) { @@ -134,6 +378,10 @@ public class Date implements java.io.Serializable, Cloneable 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. @@ -331,164 +579,183 @@ public class Date implements java.io.Serializable, Cloneable -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(); } /** @@ -497,10 +764,10 @@ public class Date implements java.io.Serializable, Cloneable * 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); } } -- 2.30.2