+2005-11-15 Tom Tromey <tromey@redhat.com>
+
+ classpath/23890:
+ * java/util/Calendar.java (equals): Include other calendar
+ attributes.
+ (hashCode): Updated.
+ * java/util/GregorianCalendar.java (hashCode): New method.
+ (equals): Use super.equals().
+
+2005-11-15 Sven de Marothy <sven@physto.se>
+
+ * java/util/Calendar (setTimeInMillis): Recompute time fields.
+
+2005-11-15 Mark Wielaard <mark@klomp.org>
+
+ * java/util/SimpleTimeZone.java: Removed, fully merged now.
+ * java/util/Date.java: Likewise.
+ * sources.am: Regenerated.
+ * Makefile.in: Regenerated.
+
+2005-11-15 David Gilbert <david.gilbert@object-refinery.com>
+
+ * java/util/Calendar.java: fixed minor problems in API docs,
+ * java/util/Date.java: likewise,
+ * java/util/ResourceBundle.java: likewise,
+ * java/util/SimpleTimeZone.java: likewise,
+
2005-11-15 Jeroen Frijters <jeroen@frijters.net>
* java/io/ObjectInputStream.java
classpath/java/util/Comparator.java \
classpath/java/util/ConcurrentModificationException.java \
java/util/Currency.java \
-java/util/Date.java \
+classpath/java/util/Date.java \
classpath/java/util/Dictionary.java \
classpath/java/util/EmptyStackException.java \
classpath/java/util/Enumeration.java \
classpath/java/util/RandomAccess.java \
java/util/ResourceBundle.java \
classpath/java/util/Set.java \
-java/util/SimpleTimeZone.java \
+classpath/java/util/SimpleTimeZone.java \
classpath/java/util/SortedMap.java \
classpath/java/util/SortedSet.java \
classpath/java/util/Stack.java \
clear();
this.time = time;
isTimeSet = true;
+ computeFields();
}
/**
/**
* Fills any unset fields in the time field list
- * @return true if the specified field has a value.
*/
protected void complete()
{
*/
public boolean equals(Object o)
{
- return (o instanceof Calendar)
- && getTimeInMillis() == ((Calendar) o).getTimeInMillis();
+ if (! (o instanceof Calendar))
+ return false;
+ Calendar cal = (Calendar) o;
+ if (getTimeInMillis() == ((Calendar) o).getTimeInMillis()
+ && cal.getFirstDayOfWeek() == getFirstDayOfWeek()
+ && cal.isLenient() == isLenient()
+ && cal.getMinimalDaysInFirstWeek() == getMinimalDaysInFirstWeek())
+ {
+ TimeZone self = getTimeZone();
+ TimeZone oth = cal.getTimeZone();
+ return self == null ? oth == null : self.equals(oth);
+ }
+ return false;
}
/**
public int hashCode()
{
long time = getTimeInMillis();
- return (int) ((time & 0xffffffffL) ^ (time >> 32));
+ int val = (int) ((time & 0xffffffffL) ^ (time >> 32));
+ val += (getFirstDayOfWeek() + (isLenient() ? 1230 : 1237)
+ + getMinimalDaysInFirstWeek());
+ TimeZone self = getTimeZone();
+ if (self != null)
+ val ^= self.hashCode();
+ return val;
}
/**
+++ /dev/null
-/* java.util.Date
- Copyright (C) 1998, 1999, 2000, 2001, 2005 Free Software Foundation, Inc.
-
-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., 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library. Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module. An independent module is a module which is not derived from
-or based on this library. If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so. If you do not wish to do so, delete this
-exception statement from your version. */
-
-package java.util;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.Serializable;
-
-/**
- * <p>
- * This class represents a specific time in milliseconds since the epoch.
- * The epoch is 1970, January 1 00:00:00.0000 UTC.
- * </p>
- * <p>
- * <code>Date</code> is intended to reflect universal time coordinate (UTC),
- * but this depends on the underlying host environment. Most operating systems
- * don't handle the leap second, which occurs about once every year or
- * so. The leap second is added to the last minute of the day on either
- * the 30th of June or the 31st of December, creating a minute 61 seconds
- * in length.
- * </p>
- * <p>
- * The representations of the date fields are as follows:
- * <ul>
- * <li>
- * Years are specified as the difference between the year
- * and 1900. Thus, the final year used is equal to
- * 1900 + y, where y is the input value.
- * </li>
- * <li>
- * Months are represented using zero-based indexing,
- * making 0 January and 11 December.
- * </li>
- * <li>
- * Dates are represented with the usual values of
- * 1 through to 31.
- * </li>
- * <li>
- * Hours are represented in the twenty-four hour clock,
- * with integer values from 0 to 23. 12am is 0, and
- * 12pm is 12.
- * </li>
- * <li>
- * Minutes are again as usual, with values from 0 to 59.
- * </li>
- * <li>
- * Seconds are represented with the values 0 through to 61,
- * with 60 and 61 being leap seconds (as per the ISO C standard).
- * </li>
- * </ul>
- * </p>
- * <p>
- * Prior to JDK 1.1, this class was the sole class handling date and time
- * related functionality. However, this particular solution was not
- * amenable to internationalization. The new <code>Calendar</code>
- * class should now be used to handle dates and times, with <code>Date</code>
- * being used only for values in milliseconds since the epoch. The
- * <code>Calendar</code> class, and its concrete implementations, handle
- * the interpretation of these values into minutes, hours, days, months
- * and years. The formatting and parsing of dates is left to the
- * <code>DateFormat</code> class, which is able to handle the different
- * types of date format which occur in different locales.
- * </p>
- *
- * @see Calendar
- * @see GregorianCalendar
- * @see java.text.DateFormat
- * @author Jochen Hoenicke
- * @author Per Bothner (bothner@cygnus.com)
- * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
- */
-public class Date
- implements Cloneable, Comparable, Serializable
-{
- /**
- * This is the serialization UID for this class
- * for compatability with Sun's JDK.
- */
- private static final long serialVersionUID = 7523967970034938905L;
-
- /**
- * The time in milliseconds since the epoch.
- */
- private transient long time;
-
- /**
- * An array of week names used to map names to integer values.
- */
- private static final String[] weekNames = { "Sun", "Mon", "Tue", "Wed",
- "Thu", "Fri", "Sat" };
- /**
- * An array of month names used to map names to integer values.
- */
- private static final String[] monthNames = { "Jan", "Feb", "Mar", "Apr",
- "May", "Jun", "Jul", "Aug",
- "Sep", "Oct", "Nov", "Dec" };
- /**
- * Creates a new Date Object representing the current time.
- */
- public Date()
- {
- time = 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;
- }
-
- /**
- * Creates a new Date Object representing the given time.
- *
- * @deprecated use <code>new GregorianCalendar(year+1900, month,
- * day)</code> instead.
- * @param year the difference between the required year and 1900.
- * @param month the month as a value between 0 and 11.
- * @param day the day as a value between 0 and 31.
- */
- public Date(int year, int month, int day)
- {
- this(year, month, day, 0, 0, 0);
- }
-
- /**
- * Creates a new Date Object representing the given time.
- *
- * @deprecated use <code>new GregorianCalendar(year+1900, month,
- * day, hour, min)</code> instead.
- * @param year the difference between the required year and 1900.
- * @param month the month as a value between 0 and 11.
- * @param day the day as a value between 0 and 31.
- * @param hour the hour as a value between 0 and 23, in 24-hour
- * clock notation.
- * @param min the minute as a value between 0 and 59.
- */
- public Date(int year, int month, int day, int hour, int min)
- {
- this(year, month, day, hour, min, 0);
- }
-
- /**
- * Creates a new Date Object representing the given time.
- *
- * @deprecated use <code>new GregorianCalendar(year+1900, month,
- * day, hour, min, sec)</code> instead.
- * @param year the difference between the required year and 1900.
- * @param month the month as a value between 0 and 11.
- * @param day the day as a value between 0 and 31.
- * @param hour the hour as a value between 0 and 23, in 24-hour
- * clock notation.
- * @param min the minute as a value between 0 and 59.
- * @param sec the second as a value between 0 and 61 (with 60
- * and 61 being leap seconds).
- */
- public Date(int year, int month, int day, int hour, int min, int sec)
- {
- GregorianCalendar cal =
- new GregorianCalendar(year + 1900, month, day, hour, min, sec);
- time = cal.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);
- }
-
- /**
- * Returns a copy of this <code>Date</code> object.
- *
- * @return a copy, or null if the object couldn't be
- * cloned.
- * @see Object#clone()
- */
- public Object clone()
- {
- try
- {
- return super.clone();
- }
- catch (CloneNotSupportedException ex)
- {
- return null;
- }
- }
-
- /**
- * Returns the number of milliseconds since the epoch
- * specified by the given arguments. The arguments are
- * interpreted relative to UTC rather than the local
- * time zone.
- *
- * @deprecated Use <code>Calendar</code> with a UTC
- * <code>TimeZone</code> instead.
- * @param year the difference between the required year and 1900.
- * @param month the month as a value between 0 and 11.
- * @param day the day as a value between 0 and 31.
- * @param hour the hour as a value between 0 and 23, in 24-hour
- * clock notation.
- * @param min the minute as a value between 0 and 59.
- * @param sec the second as a value between 0 and 61 (with 60
- * and 61 being leap seconds).
- * @return the time in milliseconds 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;
- }
-
- /**
- * Returns the number of minutes offset used with UTC to give the time
- * represented by this object in the current time zone. The date information
- * from this object is also used to determine whether or not daylight savings
- * time is in effect. For example, the offset for the UK would be 0 if the
- * month of the date object was January, and 1 if the month was August.
- *
- * @deprecated use
- * <code>Calendar.get(Calendar.ZONE_OFFSET)+Calendar.get(Calendar.DST_OFFSET)</code>
- * 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 represent.
- *
- * @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 time 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);
- }
-
- /**
- * 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)
- {
- return (time < when.time) ? -1 : (time == when.time) ? 0 : 1;
- }
-
- /**
- * Compares this Date to another object. This behaves like
- * <code>compareTo(Date)</code>, but it takes a generic object
- * and throws a <code>ClassCastException</code> if obj is
- * not a <code>Date</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)
- {
- return compareTo((Date) obj);
- }
-
- /**
- * Computes the hash code of this <code>Date</code> as the
- * XOR of the most significant and the least significant
- * 32 bits of the 64 bit milliseconds value.
- *
- * @return the hash code.
- */
- public int hashCode()
- {
- return (int) time ^ (int) (time >>> 32);
- }
-
- /**
- * <p>
- * Returns a string representation of this date using
- * the following date format:
- * </p>
- * <p>
- * <code>day mon dd hh:mm:ss zz yyyy</code>
- * </p>
- * <p>where the fields used here are:
- * <ul>
- * <li>
- * <code>day</code> -- the day of the week
- * (Sunday through to Saturday).
- * </li>
- * <li>
- * <code>mon</code> -- the month (Jan to Dec).
- * </li>
- * <li>
- * <code>dd</code> -- the day of the month
- * as two decimal digits (01 to 31).
- * </li>
- * <li>
- * <code>hh</code> -- the hour of the day
- * as two decimal digits in 24-hour clock notation
- * (01 to 23).
- * </li>
- * <li>
- * <code>mm</code> -- the minute of the day
- * as two decimal digits (01 to 59).
- * </li>
- * <li>
- * <code>ss</code> -- the second of the day
- * as two decimal digits (01 to 61).
- * </li>
- * <li>
- * <code>zz</code> -- the time zone information if available.
- * The possible time zones used include the abbreviations
- * recognised by <code>parse()</code> (e.g. GMT, CET, etc.)
- * and may reflect the fact that daylight savings time is in
- * effect. The empty string is used if there is no time zone
- * information.
- * </li>
- * <li>
- * <code>yyyy</code> -- the year as four decimal digits.
- * </li>
- * </ul>
- * <p>
- * The <code>DateFormat</code> class should now be
- * preferred over using this method.
- * </p>
- *
- * @return A string of the form 'day mon dd hh:mm:ss zz yyyy'
- * @see #parse(String)
- * @see DateFormat
- */
- 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);
- }
-
- /**
- * Returns a locale-dependent string representation of this
- * <code>Date</code> object.
- *
- * @deprecated Use DateFormat.format(Date)
- * @return A locale-dependent string representation.
- * @see #parse(String)
- * @see DateFormat
- */
- public String toLocaleString()
- {
- return java.text.DateFormat.getInstance().format(this);
- }
-
- /**
- * <p>
- * Returns a string representation of this <code>Date</code>
- * object using GMT rather than the local timezone.
- * The following date format is used:
- * </p>
- * <p>
- * <code>d mon yyyy hh:mm:ss GMT</code>
- * </p>
- * <p>where the fields used here are:
- * <ul>
- * <li>
- * <code>d</code> -- the day of the month
- * as one or two decimal digits (1 to 31).
- * </li>
- * <li>
- * <code>mon</code> -- the month (Jan to Dec).
- * </li>
- * <li>
- * <code>yyyy</code> -- the year as four decimal digits.
- * </li>
- * <li>
- * <code>hh</code> -- the hour of the day
- * as two decimal digits in 24-hour clock notation
- * (01 to 23).
- * </li>
- * <li>
- * <code>mm</code> -- the minute of the day
- * as two decimal digits (01 to 59).
- * </li>
- * <li>
- * <code>ss</code> -- the second of the day
- * as two decimal digits (01 to 61).
- * </li>
- * <li>
- * <code>GMT</code> -- the literal string "GMT"
- * indicating Greenwich Mean Time as opposed to
- * the local timezone.
- * </li>
- * </ul>
- *
- * @deprecated Use DateFormat.format(Date) with a GMT TimeZone.
- * @return A string of the form 'd mon yyyy hh:mm:ss GMT' using
- * GMT as opposed to the local timezone.
- * @see #parse(String)
- * @see DateFormat
- */
- public String toGMTString()
- {
- java.text.DateFormat format = java.text.DateFormat.getInstance();
- format.setTimeZone(TimeZone.getTimeZone("GMT"));
- return format.format(this);
- }
-
- /**
- * Parses the time zone string.
- *
- * @param tok The token containing the time zone.
- * @param sign The sign (+ or -) used by the time zone.
- * @return An integer representing the number of minutes offset
- * from GMT for the time zone.
- */
- private static int parseTz(String tok, char sign)
- throws IllegalArgumentException
- {
- int num;
-
- try
- {
- // parseInt doesn't handle '+' so strip off sign.
- num = Integer.parseInt(tok.substring(1));
- }
- catch (NumberFormatException ex)
- {
- throw new IllegalArgumentException(tok);
- }
-
- // Convert hours to minutes.
- if (num < 24)
- num *= 60;
- else
- num = (num / 100) * 60 + num % 100;
-
- return sign == '-' ? -num : num;
- }
-
- /**
- * Parses the month string.
- *
- * @param tok the token containing the month.
- * @return An integer between 0 and 11, representing
- * a month from January (0) to December (11),
- * or -1 if parsing failed.
- */
- private static int parseMonth(String tok)
- {
- // Initialize strings for month names.
- // We could possibly use the fields of DateFormatSymbols but that is
- // localized and thus might not match the English words specified.
- String months[] = { "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY",
- "JUNE", "JULY", "AUGUST", "SEPTEMBER", "OCTOBER",
- "NOVEMBER", "DECEMBER" };
-
- int i;
- for (i = 0; i < 12; i++)
- if (months[i].startsWith(tok))
- return i;
-
- // Return -1 if not found.
- return -1;
- }
-
- /**
- * Parses the day of the week string.
- *
- * @param tok the token containing the day of the week.
- * @return true if the token was parsed successfully.
- */
- private static boolean parseDayOfWeek(String tok)
- {
- // Initialize strings for days of the week names.
- // We could possibly use the fields of DateFormatSymbols but that is
- // localized and thus might not match the English words specified.
- String daysOfWeek[] = { "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY",
- "THURSDAY", "FRIDAY", "SATURDAY" };
-
- int i;
- for (i = 0; i < 7; i++)
- if (daysOfWeek[i].startsWith(tok))
- return true;
-
- return false;
- }
-
- /**
- * <p>
- * Parses a String and returns the time, in milliseconds since the
- * epoch, it represents. Most syntaxes are handled, including
- * the IETF date standard "day, dd mon yyyy hh:mm:ss zz" (see
- * <code>toString()</code> for definitions of these fields).
- * Standard U.S. time zone abbreviations are recognised, in
- * addition to time zone offsets in positive or negative minutes.
- * If a time zone is specified, the specified time is assumed to
- * be in UTC and the appropriate conversion is applied, following
- * parsing, to convert this to the local time zone. If no zone
- * is specified, the time is assumed to already be in the local
- * time zone.
- * </p>
- * <p>
- * The method parses the string progressively from left to right.
- * At the end of the parsing process, either a time is returned
- * or an <code>IllegalArgumentException</code> is thrown to signify
- * failure. The ASCII characters A-Z, a-z, 0-9, and ',', '+', '-',
- * ':' and '/' are the only characters permitted within the string,
- * besides whitespace and characters enclosed within parantheses
- * '(' and ')'.
- * </p>
- * <p>
- * A sequence of consecutive digits are recognised as a number,
- * and interpreted as follows:
- * <ul>
- * <li>
- * A number preceded by a sign (+ or -) is taken to be a time zone
- * offset. The time zone offset can be specified in either hours
- * or minutes. The former is assumed if the number is less than 24.
- * Otherwise, the offset is assumed to be in minutes. A - indicates
- * a time zone west of GMT, while a + represents a time zone to the
- * east of GMT. The time zones are always assumed to be relative
- * to GMT, and a (redundant) specification of this can be included
- * with the time zone. For example, '-9', 'utc-9' and 'GMT-9' all
- * represent a time zone nine hours west of GMT. Similarly,
- * '+4', 'ut+4' and 'UTC+4' all give 4 hours east of GMT.
- * </li>
- * <li>
- * A number equal to or greater than 70 is regarded as a year specification.
- * Values lower than 70 are only assumed to indicate a year if both the
- * day of the month and the month itself have already been recognised.
- * Year values less than 100 are interpreted as being relative to the current
- * century when the <code>Date</code> class is initialised.. Given a century,
- * x, the year is assumed to be within the range x - 80 to x + 19. The value
- * itself is then used as a match against the two last digits of one of these
- * years. For example, take x to be 2004. A two-digit year is assumed to fall
- * within the range x - 80 (1924) and x + 19 (2023). Thus, any intepreted value
- * between 0 and 23 is assumed to be 2000 to 2023 and values between 24 and 99
- * are taken as being 1924 to 1999. This only applies for the case of 2004.
- * With a different year, the values will be interpreted differently. 2005
- * will used 0 to 24 as 2000 to 2024 and 25 to 99 as 1925 to 1999, for example.
- * This behaviour differs from that of <code>SimpleDateFormat</code> and is
- * time-dependent (a two-digit year will be interpreted differently depending
- * on the time the code is run).
- * </li>
- * <li>
- * Numbers followed by a colon are interpreted by first an hour, and then
- * as a minute, once an hour has been found.
- * </li>
- * <li>
- * <li>
- * Numbers followed by a slash are regarded first as a month, and then as
- * a day of the month once the month has been found. This follows the
- * U.S. date format of mm/dd, rather than the European dd/mm. Months
- * are converted to the recognised value - 1 before storage, in order
- * to put the number within the range 0 to 11.
- * </li>
- * <li>
- * Numbers followed by commas, whitespace, hyphens or the end of the string
- * are interpreted in the following order: hour, minute, second, day of month.
- * The first type not already recognised in the current string being parsed is
- * assumed.
- * </li>
- * </ul>
- * </p>
- * <p>
- * A sequence of consecutive alphabetic characters is recognised as a word,
- * and interpreted as follows, in a case-insentive fashion:
- * <ul>
- * <li>
- * The characters 'AM' or 'PM' restrict the hour value to a value between 0
- * and 12. In the latter case, 12 is added to the hour value before storage.
- * </li>
- * <li>
- * Any words which match any prefix of one of the days of the week ('Monday',
- * 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday' and 'Sunday'),
- * are simply ignored.
- * </li>
- * <li>
- * Any words which match any prefix of one of the months of the year ('January',
- * 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',
- * 'October', 'November', 'December') are recognised and interpreted as the
- * appropriate value between 0 and 11. The first match made against a
- * month is the one used, in the order specified here. For example, 'Ma' is
- * intepreted as 'March' (2) and not as 'May' (4). Similarly, 'Ju' is 'June',
- * and not 'July'.
- * </li>
- * <li>
- * The words 'GMT', 'UT' and 'UTC' are interpreted as specifying UTC as the
- * time zone in use for this date.
- * </li>
- * <li>
- * The word pairs 'EST'/'EDT', 'CST'/'CDT', 'MST'/'MDT' and 'PST'/'PDT' are
- * interpreted as the appropriate U.S. time zone abbreviation. Each pair
- * is the standard and daylight savings time zone specification, respectively,
- * for each zone within the U.S, these being Eastern Standard/Daylight Time
- * (-5), Central Standard/Daylight Time (-6), Mountain Standard/Daylight Time
- * (-7) and Pacific Standard/Daylight Time (-8).
- * </li>
- * </ul>
- *
- * @param s The String to parse.
- * @return The time in milliseconds since the epoch.
- * @throws IllegalArgumentException if the string fails to parse.
- * @deprecated Use DateFormat.parse(String)
- * @see #toString()
- * @see SimpleDateFormat
- */
- public static long parse(String string)
- {
- // Initialize date/time fields before parsing begins.
- int year = -1;
- int month = -1;
- int day = -1;
- int hour = -1;
- int minute = -1;
- int second = -1;
- int timezone = 0;
- boolean localTimezone = true;
-
- // Trim out any nested stuff in parentheses now to make parsing easier.
- StringBuffer buf = new StringBuffer();
- int parenNesting = 0;
- int len = string.length();
- for (int i = 0; i < len; i++)
- {
- char ch = string.charAt(i);
- if (ch >= 'a' && ch <= 'z')
- ch -= 'a' - 'A';
- if (ch == '(')
- parenNesting++;
- else if (parenNesting == 0)
- buf.append(ch);
- else if (ch == ')')
- parenNesting--;
- }
- int tmpMonth;
-
- // Make all chars upper case to simplify comparisons later.
- // Also ignore commas; treat them as delimiters.
- StringTokenizer strtok = new StringTokenizer(buf.toString(), " \t\n\r,");
-
- while (strtok.hasMoreTokens())
- {
- String tok = strtok.nextToken();
- char firstch = tok.charAt(0);
- if ((firstch == '+' || firstch == '-') && year >= 0)
- {
- timezone = parseTz(tok, firstch);
- localTimezone = false;
- }
- else if (firstch >= '0' && firstch <= '9')
- {
- while (tok != null && tok.length() > 0)
- {
- int punctOffset = tok.length();
- int num = 0;
- int punct;
- for (int i = 0; ; i++)
- {
- if (i >= punctOffset)
- {
- punct = -1;
- break;
- }
- else
- {
- punct = tok.charAt(i);
- if (punct >= '0' && punct <= '9')
- {
- if (num > 999999999) // in case of overflow
- throw new IllegalArgumentException(tok);
- num = 10 * num + (punct - '0');
- }
- else
- {
- punctOffset = i;
- break;
- }
- }
-
- }
-
- if (punct == ':')
- {
- if (hour < 0)
- hour = num;
- else
- minute = num;
- }
- else if ((num >= 70
- && (punct == ' ' || punct == ','
- || punct == '/' || punct < 0))
- || (num < 70 && day >= 0 && month >= 0 && year < 0))
- {
- if (num >= 100)
- year = num;
- else
- {
- int curYear = 1900 + new Date().getYear();
- int firstYear = curYear - 80;
- year = firstYear / 100 * 100 + num;
- if (year < firstYear)
- year += 100;
- }
- }
- else if (punct == '/')
- {
- if (month < 0)
- month = num - 1;
- else
- day = num;
- }
- else if (hour >= 0 && minute < 0)
- minute = num;
- else if (minute >= 0 && second < 0)
- second = num;
- else if (day < 0)
- day = num;
- else
- throw new IllegalArgumentException(tok);
-
- // Advance string if there's more to process in this token.
- if (punct < 0 || punctOffset + 1 >= tok.length())
- tok = null;
- else
- tok = tok.substring(punctOffset + 1);
- }
- }
- else if (firstch >= 'A' && firstch <= 'Z')
- {
- if (tok.equals("AM"))
- {
- if (hour < 1 || hour > 12)
- throw new IllegalArgumentException(tok);
- if (hour == 12)
- hour = 0;
- }
- else if (tok.equals("PM"))
- {
- if (hour < 1 || hour > 12)
- throw new IllegalArgumentException(tok);
- if (hour < 12)
- hour += 12;
- }
- else if (parseDayOfWeek(tok))
- ; // Ignore it; throw the token away.
- else if (tok.equals("UT") || tok.equals("UTC") || tok.equals("GMT"))
- localTimezone = false;
- else if (tok.startsWith("UT") || tok.startsWith("GMT"))
- {
- int signOffset = 3;
- if (tok.charAt(1) == 'T' && tok.charAt(2) != 'C')
- signOffset = 2;
-
- char sign = tok.charAt(signOffset);
- if (sign != '+' && sign != '-')
- throw new IllegalArgumentException(tok);
-
- timezone = parseTz(tok.substring(signOffset), sign);
- localTimezone = false;
- }
- else if ((tmpMonth = parseMonth(tok)) >= 0)
- month = tmpMonth;
- else if (tok.length() == 3 && tok.charAt(2) == 'T')
- {
- // Convert timezone offset from hours to minutes.
- char ch = tok.charAt(0);
- if (ch == 'E')
- timezone = -5 * 60;
- else if (ch == 'C')
- timezone = -6 * 60;
- else if (ch == 'M')
- timezone = -7 * 60;
- else if (ch == 'P')
- timezone = -8 * 60;
- else
- throw new IllegalArgumentException(tok);
-
- // Shift 60 minutes for Daylight Savings Time.
- if (tok.charAt(1) == 'D')
- timezone += 60;
- else if (tok.charAt(1) != 'S')
- throw new IllegalArgumentException(tok);
-
- localTimezone = false;
- }
- else
- throw new IllegalArgumentException(tok);
- }
- else
- throw new IllegalArgumentException(tok);
- }
-
- // Unspecified hours, minutes, or seconds should default to 0.
- if (hour < 0)
- hour = 0;
- if (minute < 0)
- minute = 0;
- if (second < 0)
- second = 0;
-
- // Throw exception if any other fields have not been recognized and set.
- if (year < 0 || month < 0 || day < 0)
- throw new IllegalArgumentException("Missing field");
-
- // Return the time in either local time or relative to GMT as parsed.
- // If no time-zone was specified, get the local one (in minutes) and
- // convert to milliseconds before adding to the UTC.
- GregorianCalendar cal
- = new GregorianCalendar(year, month, day, hour, minute, second);
- if (!localTimezone)
- {
- cal.set(Calendar.ZONE_OFFSET, timezone * 60 * 1000);
- cal.set(Calendar.DST_OFFSET, 0);
- }
- return cal.getTimeInMillis();
- }
-
- /**
- * Returns the difference between the year represented by this
- * <code>Date</code> object and 1900.
- *
- * @return the year minus 1900 represented by this date object.
- * @deprecated Use Calendar instead of Date, and use get(Calendar.YEAR)
- * instead. Note the 1900 difference in the year.
- * @see Calendar
- * @see #setYear(int)
- */
- public int getYear()
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- return cal.get(Calendar.YEAR) - 1900;
- }
-
- /**
- * Sets the year to the specified year, plus 1900. The other
- * fields are only altered as required to match the same date
- * and time in the new year. Usually, this will mean that
- * the fields are not changed at all, but in the case of
- * a leap day or leap second, the fields will change in
- * relation to the existence of such an event in the new year.
- * For example, if the date specifies February the 29th, 2000,
- * then this will become March the 1st if the year is changed
- * to 2001, as 2001 is not a leap year. Similarly, a seconds
- * value of 60 or 61 may result in the seconds becoming 0 and
- * the minute increasing by 1, if the new time does not include
- * a leap second.
- *
- * @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.
- * @see #getYear()
- * @see Calendar
- */
- public void setYear(int year)
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- cal.set(Calendar.YEAR, 1900 + year);
- time = cal.getTimeInMillis();
- }
-
- /**
- * Returns the month represented by this <code>Date</code> object,
- * as a value between 0 (January) and 11 (December).
- *
- * @return the month represented by this date object (zero based).
- * @deprecated Use Calendar instead of Date, and use get(Calendar.MONTH)
- * instead.
- * @see #setMonth(int)
- * @see Calendar
- */
- public int getMonth()
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- return cal.get(Calendar.MONTH);
- }
-
- /**
- * Sets the month to the given value. The other
- * fields are only altered as necessary to match
- * the same date and time in the new month. In most
- * cases, the other fields won't change at all. However,
- * in the case of a shorter month or a leap second, values
- * may be adjusted. For example, if the day of the month
- * is currently 31, and the month value is changed from
- * January (0) to September (8), the date will become
- * October the 1st, as September only has 30 days. Similarly,
- * a seconds value of 60 or 61 (a leap second) may result
- * in the seconds value being reset to 0 and the minutes
- * value being incremented by 1, if the new time does
- * not include a leap second.
- *
- * @param month the month, with a zero-based index
- * from January.
- * @deprecated Use Calendar instead of Date, and use
- * set(Calendar.MONTH, month) instead.
- * @see #getMonth()
- * @see Calendar
- */
- public void setMonth(int month)
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- cal.set(Calendar.MONTH, month);
- time = cal.getTimeInMillis();
- }
-
- /**
- * Returns the day of the month of this <code>Date</code>
- * object, as a value between 0 and 31.
- *
- * @return the day of month represented by this date object.
- * @deprecated Use Calendar instead of Date, and use get(Calendar.DATE)
- * instead.
- * @see Calendar
- * @see #setDate(int)
- */
- public int getDate()
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- return cal.get(Calendar.DATE);
- }
-
- /**
- * Sets the date to the given value. The other
- * fields are only altered as necessary to match
- * the same date and time on the new day of the month. In most
- * cases, the other fields won't change at all. However,
- * in the case of a leap second or the day being out of
- * the range of the current month, values
- * may be adjusted. For example, if the day of the month
- * is currently 30 and the month is June, a new day of the
- * month value of 31 will cause the month to change to July,
- * as June only has 30 days . Similarly,
- * a seconds value of 60 or 61 (a leap second) may result
- * in the seconds value being reset to 0 and the minutes
- * value being incremented by 1, if the new time does
- * not include a leap second.
- *
- * @param date the date.
- * @deprecated Use Calendar instead of Date, and use
- * set(Calendar.DATE, date) instead.
- * @see Calendar
- * @see #getDate()
- */
- public void setDate(int date)
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- cal.set(Calendar.DATE, date);
- time = cal.getTimeInMillis();
- }
-
- /**
- * Returns the day represented by this <code>Date</code>
- * object as an integer between 0 (Sunday) and 6 (Saturday).
- *
- * @return the day represented by this date object.
- * @deprecated Use Calendar instead of Date, and use get(Calendar.DAY_OF_WEEK)
- * instead.
- * @see Calendar
- */
- public int getDay()
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- // For Calendar, Sunday is 1. For Date, Sunday is 0.
- return cal.get(Calendar.DAY_OF_WEEK) - 1;
- }
-
- /**
- * Returns the hours represented by this <code>Date</code>
- * object as an integer between 0 and 23.
- *
- * @return the hours represented by this date object.
- * @deprecated Use Calendar instead of Date, and use get(Calendar.HOUR_OF_DAY)
- * instead.
- * @see Calendar
- * @see #setHours(int)
- */
- public int getHours()
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- return cal.get(Calendar.HOUR_OF_DAY);
- }
-
- /**
- * Sets the hours to the given value. The other
- * fields are only altered as necessary to match
- * the same date and time in the new hour. In most
- * cases, the other fields won't change at all. However,
- * in the case of a leap second, values
- * may be adjusted. For example,
- * a seconds value of 60 or 61 (a leap second) may result
- * in the seconds value being reset to 0 and the minutes
- * value being incremented by 1 if the new hour does
- * not contain a leap second.
- *
- * @param hours the hours.
- * @deprecated Use Calendar instead of Date, and use
- * set(Calendar.HOUR_OF_DAY, hours) instead.
- * @see Calendar
- * @see #getHours()
- */
- public void setHours(int hours)
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- cal.set(Calendar.HOUR_OF_DAY, hours);
- time = cal.getTimeInMillis();
- }
-
- /**
- * Returns the number of minutes represented by the <code>Date</code>
- * object, as an integer between 0 and 59.
- *
- * @return the minutes represented by this date object.
- * @deprecated Use Calendar instead of Date, and use get(Calendar.MINUTE)
- * instead.
- * @see Calendar
- * @see #setMinutes(int)
- */
- public int getMinutes()
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- return cal.get(Calendar.MINUTE);
- }
-
- /**
- * Sets the minutes to the given value. The other
- * fields are only altered as necessary to match
- * the same date and time in the new minute. In most
- * cases, the other fields won't change at all. However,
- * in the case of a leap second, values
- * may be adjusted. For example,
- * a seconds value of 60 or 61 (a leap second) may result
- * in the seconds value being reset to 0 and the minutes
- * value being incremented by 1 if the new minute does
- * not contain a leap second.
- *
- * @param minutes the minutes.
- * @deprecated Use Calendar instead of Date, and use
- * set(Calendar.MINUTE, minutes) instead.
- * @see Calendar
- * @see #getMinutes()
- */
- public void setMinutes(int minutes)
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- cal.set(Calendar.MINUTE, minutes);
- time = cal.getTimeInMillis();
- }
-
- /**
- * Returns the number of seconds represented by the <code>Date</code>
- * object, as an integer between 0 and 61 (60 and 61 being leap seconds).
- *
- * @return the seconds represented by this date object.
- * @deprecated Use Calendar instead of Date, and use get(Calendar.SECOND)
- * instead.
- * @see Calendar
- * @see #setSeconds(int)
- */
- public int getSeconds()
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- return cal.get(Calendar.SECOND);
- }
-
- /**
- * Sets the seconds to the given value. The other
- * fields are only altered as necessary to match
- * the same date and time in the new minute. In most
- * cases, the other fields won't change at all. However,
- * in the case of a leap second, values
- * may be adjusted. For example, setting the
- * seconds value to 60 or 61 (a leap second) may result
- * in the seconds value being reset to 0 and the minutes
- * value being incremented by 1, if the current time does
- * not contain a leap second.
- *
- * @param seconds the seconds.
- * @deprecated Use Calendar instead of Date, and use
- * set(Calendar.SECOND, seconds) instead.
- * @see Calendar
- * @see #getSeconds()
- */
- public void setSeconds(int seconds)
- {
- Calendar cal = Calendar.getInstance();
- cal.setTimeInMillis(time);
- cal.set(Calendar.SECOND, seconds);
- time = cal.getTimeInMillis();
- }
-
- /**
- * Deserializes a <code>Date</code> object from an
- * input stream, setting the time (in milliseconds
- * since the epoch) to the long value read from the
- * stream.
- *
- * @param input the input stream.
- * @throws IOException if an I/O error occurs in the stream.
- * @throws ClassNotFoundException if the class of the
- * serialized object could not be found.
- */
- private void readObject(ObjectInputStream input)
- throws IOException, ClassNotFoundException
- {
- input.defaultReadObject();
- time = input.readLong();
- }
-
- /**
- * Serializes a <code>Date</code> object to an output stream,
- * storing the time (in milliseconds since the epoch) as a long
- * value in the stream.
- *
- * @serialdata A long value representing the offset from the epoch
- * in milliseconds. This is the same value that is returned by the
- * method getTime().
- * @param output the output stream.
- * @throws IOException if an I/O error occurs in the stream.
- */
- private void writeObject(ObjectOutputStream output)
- throws IOException
- {
- output.defaultWriteObject();
- output.writeLong(time);
- }
-
-}
areFieldsSet = isSet[ERA] = isSet[YEAR] = isSet[MONTH] = isSet[WEEK_OF_YEAR] = isSet[WEEK_OF_MONTH] = isSet[DAY_OF_MONTH] = isSet[DAY_OF_YEAR] = isSet[DAY_OF_WEEK] = isSet[DAY_OF_WEEK_IN_MONTH] = isSet[AM_PM] = isSet[HOUR] = isSet[HOUR_OF_DAY] = isSet[MINUTE] = isSet[SECOND] = isSet[MILLISECOND] = isSet[ZONE_OFFSET] = isSet[DST_OFFSET] = true;
}
+
+ /**
+ * Return a hash code for this object, following the general contract
+ * specified by {@link Object#hashCode()}.
+ * @return the hash code
+ */
+ public int hashCode()
+ {
+ int val = (int) ((gregorianCutover >>> 32) ^ (gregorianCutover & 0xffffffff));
+ return super.hashCode() ^ val;
+ }
/**
* Compares the given calendar with this. An object, o, is
return false;
GregorianCalendar cal = (GregorianCalendar) o;
- return (cal.getTimeInMillis() == getTimeInMillis());
+ return (cal.gregorianCutover == gregorianCutover
+ && super.equals(o));
}
/**
*
* @param baseName the name of the ResourceBundle
* @param locale A locale
- * @param classloader a ClassLoader
+ * @param classLoader a ClassLoader
* @return the desired resource bundle
* @throws MissingResourceException if the resource bundle can't be found
* @throws NullPointerException if any argument is null
+++ /dev/null
-/* java.util.SimpleTimeZone
- Copyright (C) 1998, 1999, 2000, 2003, 2004, 2005 Free Software Foundation, Inc.
-
-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., 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library. Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module. An independent module is a module which is not derived from
-or based on this library. If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so. If you do not wish to do so, delete this
-exception statement from your version. */
-
-
-package java.util;
-
-
-/**
- * This class represents a simple time zone offset and handles
- * daylight savings. It can only handle one daylight savings rule, so
- * it can't represent historical changes.
- *
- * This object is tightly bound to the Gregorian calendar. It assumes
- * a regular seven days week, and the month lengths are that of the
- * Gregorian Calendar. It can only handle daylight savings for years
- * lying in the AD era.
- *
- * @see Calendar
- * @see GregorianCalender
- * @author Jochen Hoenicke
- */
-public class SimpleTimeZone extends TimeZone
-{
- /**
- * The raw time zone offset in milliseconds to GMT, ignoring
- * daylight savings.
- * @serial
- */
- private int rawOffset;
-
- /**
- * True, if this timezone uses daylight savings, false otherwise.
- * @serial
- */
- private boolean useDaylight;
-
- /**
- * The daylight savings offset. This is a positive offset in
- * milliseconds with respect to standard time. Typically this
- * is one hour, but for some time zones this may be half an hour.
- * @serial
- * @since JDK1.1.4
- */
- private int dstSavings = 60 * 60 * 1000;
-
- /**
- * The first year, in which daylight savings rules applies.
- * @serial
- */
- private int startYear;
- private static final int DOM_MODE = 1;
- private static final int DOW_IN_MONTH_MODE = 2;
- private static final int DOW_GE_DOM_MODE = 3;
- private static final int DOW_LE_DOM_MODE = 4;
-
- /**
- * The mode of the start rule. This takes one of the following values:
- * <dl>
- * <dt>DOM_MODE (1)</dt>
- * <dd> startDay contains the day in month of the start date,
- * startDayOfWeek is unused. </dd>
- * <dt>DOW_IN_MONTH_MODE (2)</dt>
- * <dd> The startDay gives the day of week in month, and
- * startDayOfWeek the day of week. For example startDay=2 and
- * startDayOfWeek=Calender.SUNDAY specifies that the change is on
- * the second sunday in that month. You must make sure, that this
- * day always exists (ie. don't specify the 5th sunday).
- * </dd>
- * <dt>DOW_GE_DOM_MODE (3)</dt>
- * <dd> The start is on the first startDayOfWeek on or after
- * startDay. For example startDay=13 and
- * startDayOfWeek=Calendar.FRIDAY specifies that the daylight
- * savings start on the first FRIDAY on or after the 13th of that
- * Month. Make sure that the change is always in the given month, or
- * the result is undefined.
- * </dd>
- * <dt>DOW_LE_DOM_MONTH (4)</dt>
- * <dd> The start is on the first startDayOfWeek on or before the
- * startDay. Make sure that the change is always in the given
- * month, or the result is undefined.
- </dd>
- * </dl>
- * @serial */
- private int startMode;
-
- /**
- * The month in which daylight savings start. This is one of the
- * constants Calendar.JANUARY, ..., Calendar.DECEMBER.
- * @serial
- */
- private int startMonth;
-
- /**
- * This variable can have different meanings. See startMode for details
- * @see #startMode;
- * @serial
- */
- private int startDay;
-
- /**
- * This variable specifies the day of week the change takes place. If
- * startMode == DOM_MODE, this is undefined.
- * @serial
- * @see #startMode;
- */
- private int startDayOfWeek;
-
- /**
- * This variable specifies the time of change to daylight savings.
- * This time is given in milliseconds after midnight local
- * standard time.
- * @serial
- */
- private int startTime;
-
- /**
- * This variable specifies the mode that startTime is specified in. By
- * default it is WALL_TIME, but can also be STANDARD_TIME or UTC_TIME. For
- * startTime, STANDARD_TIME and WALL_TIME are equivalent.
- * @serial
- */
- private int startTimeMode = WALL_TIME;
-
- /**
- * The month in which daylight savings ends. This is one of the
- * constants Calendar.JANUARY, ..., Calendar.DECEMBER.
- * @serial
- */
- private int endMonth;
-
- /**
- * This variable gives the mode for the end of daylight savings rule.
- * It can take the same values as startMode.
- * @serial
- * @see #startMode
- */
- private int endMode;
-
- /**
- * This variable can have different meanings. See startMode for details
- * @serial
- * @see #startMode;
- */
- private int endDay;
-
- /**
- * This variable specifies the day of week the change takes place. If
- * endMode == DOM_MODE, this is undefined.
- * @serial
- * @see #startMode;
- */
- private int endDayOfWeek;
-
- /**
- * This variable specifies the time of change back to standard time.
- * This time is given in milliseconds after midnight local
- * standard time.
- * @serial
- */
- private int endTime;
-
- /**
- * This variable specifies the mode that endTime is specified in. By
- * default it is WALL_TIME, but can also be STANDARD_TIME or UTC_TIME.
- * @serial
- */
- private int endTimeMode = WALL_TIME;
-
- /**
- * This variable points to a deprecated array from JDK 1.1. It is
- * ignored in JDK 1.2 but streamed out for compatibility with JDK 1.1.
- * The array contains the lengths of the months in the year and is
- * assigned from a private static final field to avoid allocating
- * the array for every instance of the object.
- * Note that static final fields are not serialized.
- * @serial
- */
- private byte[] monthLength = monthArr;
- private static final byte[] monthArr =
- {
- 31, 28, 31, 30, 31, 30, 31, 31, 30,
- 31, 30, 31
- };
-
- /**
- * The version of the serialized data on the stream.
- * <dl>
- * <dt>0 or not present on stream</dt>
- * <dd> JDK 1.1.3 or earlier, only provides this fields:
- * rawOffset, startDay, startDayOfWeek, startMonth, startTime,
- * startYear, endDay, endDayOfWeek, endMonth, endTime
- * </dd>
- * <dd> JDK 1.1.4 or later. This includes three new fields, namely
- * startMode, endMode and dstSavings. And there is a optional section
- * as described in writeObject.
- * </dd>
- * </dl>
- *
- * XXX - JDK 1.2 Beta 4 docu states 1.1.4, but my 1.1.5 has the old
- * version.
- *
- * When streaming out this class it is always written in the latest
- * version.
- * @serial
- * @since JDK1.1.4
- */
- private int serialVersionOnStream = 2;
- private static final long serialVersionUID = -403250971215465050L;
-
- /**
- * Constant to indicate that start and end times are specified in standard
- * time, without adjusting for daylight savings.
- */
- public static final int STANDARD_TIME = 1;
-
- /**
- * Constant to indicate that start and end times are specified in wall
- * time, adjusting for daylight savings. This is the default.
- */
- public static final int WALL_TIME = 0;
-
- /**
- * Constant to indicate that start and end times are specified in UTC.
- */
- public static final int UTC_TIME = 2;
-
- /**
- * Create a <code>SimpleTimeZone</code> with the given time offset
- * from GMT and without daylight savings.
- * @param rawOffset the time offset from GMT in milliseconds.
- * @param id The identifier of this time zone.
- */
- public SimpleTimeZone(int rawOffset, String id)
- {
- this.rawOffset = rawOffset;
- setID(id);
- useDaylight = false;
- startYear = 0;
- }
-
- /**
- * Create a <code>SimpleTimeZone</code> with the given time offset
- * from GMT and with daylight savings. The start/end parameters
- * can have different meaning (replace WEEKDAY with a real day of
- * week). Only the first two meanings were supported by earlier
- * versions of jdk.
- *
- * <dl>
- * <dt><code>day > 0, dayOfWeek = Calendar.WEEKDAY</code></dt>
- * <dd>The start/end of daylight savings is on the <code>day</code>-th
- * <code>WEEKDAY</code> in the given month. </dd>
- * <dt><code>day < 0, dayOfWeek = Calendar.WEEKDAY</code></dt>
- * <dd>The start/end of daylight savings is on the <code>-day</code>-th
- * <code>WEEKDAY</code> counted from the <i>end</i> of the month. </dd>
- * <dt><code>day > 0, dayOfWeek = 0</code></dt>
- * <dd>The start/end of daylight is on the <code>day</code>-th day of
- * the month. </dd>
- * <dt><code>day > 0, dayOfWeek = -Calendar.WEEKDAY</code></dt>
- * <dd>The start/end of daylight is on the first WEEKDAY on or after
- * the <code>day</code>-th day of the month. You must make sure that
- * this day lies in the same month. </dd>
- * <dt><code>day < 0, dayOfWeek = -Calendar.WEEKDAY</code></dt>
- * <dd>The start/end of daylight is on the first WEEKDAY on or
- * <i>before</i> the <code>-day</code>-th day of the month. You
- * must make sure that this day lies in the same month. </dd>
- * </dl>
- *
- * If you give a non existing month, a day that is zero, or too big,
- * or a dayOfWeek that is too big, the result is undefined.
- *
- * The start rule must have a different month than the end rule.
- * This restriction shouldn't hurt for all possible time zones.
- *
- * @param rawOffset The time offset from GMT in milliseconds.
- * @param id The identifier of this time zone.
- * @param startMonth The start month of daylight savings; use the
- * constants in Calendar.
- * @param startday A day in month or a day of week number, as
- * described above.
- * @param startDayOfWeek The start rule day of week; see above.
- * @param startTime A time in millis in standard time.
- * @param endMonth The end month of daylight savings; use the
- * constants in Calendar.
- * @param endday A day in month or a day of week number, as
- * described above.
- * @param endDayOfWeek The end rule day of week; see above.
- * @param endTime A time in millis in standard time.
- * @throws IllegalArgumentException if parameters are invalid or out of
- * range.
- */
- public SimpleTimeZone(int rawOffset, String id, int startMonth,
- int startDayOfWeekInMonth, int startDayOfWeek,
- int startTime, int endMonth, int endDayOfWeekInMonth,
- int endDayOfWeek, int endTime)
- {
- this.rawOffset = rawOffset;
- setID(id);
- useDaylight = true;
-
- setStartRule(startMonth, startDayOfWeekInMonth, startDayOfWeek, startTime);
- setEndRule(endMonth, endDayOfWeekInMonth, endDayOfWeek, endTime);
- if (startMonth == endMonth)
- throw new IllegalArgumentException("startMonth and endMonth must be different");
- this.startYear = 0;
- }
-
- /**
- * This constructs a new SimpleTimeZone that supports a daylight savings
- * rule. The parameter are the same as for the constructor above, except
- * there is the additional dstSavaings parameter.
- *
- * @param dstSavings the amount of savings for daylight savings
- * time in milliseconds. This must be positive.
- * @since 1.2
- */
- public SimpleTimeZone(int rawOffset, String id, int startMonth,
- int startDayOfWeekInMonth, int startDayOfWeek,
- int startTime, int endMonth, int endDayOfWeekInMonth,
- int endDayOfWeek, int endTime, int dstSavings)
- {
- this(rawOffset, id, startMonth, startDayOfWeekInMonth, startDayOfWeek,
- startTime, endMonth, endDayOfWeekInMonth, endDayOfWeek, endTime);
-
- this.dstSavings = dstSavings;
- }
-
- /**
- * This constructs a new SimpleTimeZone that supports a daylight savings
- * rule. The parameter are the same as for the constructor above, except
- * there are the additional startTimeMode, endTimeMode, and dstSavings
- * parameters.
- *
- * @param startTimeMode the mode that start times are specified in. One of
- * WALL_TIME, STANDARD_TIME, or UTC_TIME.
- * @param endTimeMode the mode that end times are specified in. One of
- * WALL_TIME, STANDARD_TIME, or UTC_TIME.
- * @param dstSavings the amount of savings for daylight savings
- * time in milliseconds. This must be positive.
- * @throws IllegalArgumentException if parameters are invalid or out of
- * range.
- * @since 1.4
- */
- public SimpleTimeZone(int rawOffset, String id, int startMonth,
- int startDayOfWeekInMonth, int startDayOfWeek,
- int startTime, int startTimeMode, int endMonth,
- int endDayOfWeekInMonth, int endDayOfWeek,
- int endTime, int endTimeMode, int dstSavings)
- {
- this.rawOffset = rawOffset;
- setID(id);
- useDaylight = true;
-
- if (startTimeMode < WALL_TIME || startTimeMode > UTC_TIME)
- throw new IllegalArgumentException("startTimeMode must be one of WALL_TIME, STANDARD_TIME, or UTC_TIME");
- if (endTimeMode < WALL_TIME || endTimeMode > UTC_TIME)
- throw new IllegalArgumentException("endTimeMode must be one of WALL_TIME, STANDARD_TIME, or UTC_TIME");
- this.startTimeMode = startTimeMode;
- this.endTimeMode = endTimeMode;
-
- setStartRule(startMonth, startDayOfWeekInMonth, startDayOfWeek, startTime);
- setEndRule(endMonth, endDayOfWeekInMonth, endDayOfWeek, endTime);
- if (startMonth == endMonth)
- throw new IllegalArgumentException("startMonth and endMonth must be different");
- this.startYear = 0;
-
- this.dstSavings = dstSavings;
- }
-
- /**
- * Sets the first year, where daylight savings applies. The daylight
- * savings rule never apply for years in the BC era. Note that this
- * is gregorian calendar specific.
- * @param year the start year.
- */
- public void setStartYear(int year)
- {
- startYear = year;
- useDaylight = true;
- }
-
- /**
- * Checks if the month, day, dayOfWeek arguments are in range and
- * returns the mode of the rule.
- * @param month the month parameter as in the constructor
- * @param day the day parameter as in the constructor
- * @param dayOfWeek the day of week parameter as in the constructor
- * @return the mode of this rule see startMode.
- * @exception IllegalArgumentException if parameters are out of range.
- * @see #SimpleTimeZone(int, String, int, int, int, int, int, int, int, int)
- * @see #startMode
- */
- private int checkRule(int month, int day, int dayOfWeek)
- {
- if (month < 0 || month > 11)
- throw new IllegalArgumentException("month out of range");
-
- int daysInMonth = getDaysInMonth(month, 1);
- if (dayOfWeek == 0)
- {
- if (day <= 0 || day > daysInMonth)
- throw new IllegalArgumentException("day out of range");
- return DOM_MODE;
- }
- else if (dayOfWeek > 0)
- {
- if (Math.abs(day) > (daysInMonth + 6) / 7)
- throw new IllegalArgumentException("dayOfWeekInMonth out of range");
- if (dayOfWeek > Calendar.SATURDAY)
- throw new IllegalArgumentException("dayOfWeek out of range");
- return DOW_IN_MONTH_MODE;
- }
- else
- {
- if (day == 0 || Math.abs(day) > daysInMonth)
- throw new IllegalArgumentException("day out of range");
- if (dayOfWeek < -Calendar.SATURDAY)
- throw new IllegalArgumentException("dayOfWeek out of range");
- if (day < 0)
- return DOW_LE_DOM_MODE;
- else
- return DOW_GE_DOM_MODE;
- }
- }
-
- /**
- * Sets the daylight savings start rule. You must also set the
- * end rule with <code>setEndRule</code> or the result of
- * getOffset is undefined. For the parameters see the ten-argument
- * constructor above.
- *
- * @param month The month where daylight savings start, zero
- * based. You should use the constants in Calendar.
- * @param day A day of month or day of week in month.
- * @param dayOfWeek The day of week where daylight savings start.
- * @param time The time in milliseconds standard time where daylight
- * savings start.
- * @see SimpleTimeZone
- */
- public void setStartRule(int month, int day, int dayOfWeek, int time)
- {
- this.startMode = checkRule(month, day, dayOfWeek);
- this.startMonth = month;
- this.startDay = day;
- this.startDayOfWeek = Math.abs(dayOfWeek);
- if (this.startTimeMode == WALL_TIME || this.startTimeMode == STANDARD_TIME)
- this.startTime = time;
- else
- // Convert from UTC to STANDARD
- this.startTime = time + this.rawOffset;
- useDaylight = true;
- }
-
- /**
- * Sets the daylight savings start rule. You must also set the
- * end rule with <code>setEndRule</code> or the result of
- * getOffset is undefined. For the parameters see the ten-argument
- * constructor above.
- *
- * Note that this API isn't incredibly well specified. It appears that the
- * after flag must override the parameters, since normally, the day and
- * dayofweek can select this. I.e., if day < 0 and dayOfWeek < 0, on or
- * before mode is chosen. But if after == true, this implementation
- * overrides the signs of the other arguments. And if dayOfWeek == 0, it
- * falls back to the behavior in the other APIs. I guess this should be
- * checked against Sun's implementation.
- *
- * @param month The month where daylight savings start, zero
- * based. You should use the constants in Calendar.
- * @param day A day of month or day of week in month.
- * @param dayOfWeek The day of week where daylight savings start.
- * @param time The time in milliseconds standard time where daylight
- * savings start.
- * @param after If true, day and dayOfWeek specify first day of week on or
- * after day, else first day of week on or before.
- * @since 1.2
- * @see SimpleTimeZone
- */
- public void setStartRule(int month, int day, int dayOfWeek, int time,
- boolean after)
- {
- // FIXME: XXX: Validate that checkRule and offset processing work with on
- // or before mode.
- this.startDay = after ? Math.abs(day) : -Math.abs(day);
- this.startDayOfWeek = after ? Math.abs(dayOfWeek) : -Math.abs(dayOfWeek);
- this.startMode = (dayOfWeek != 0)
- ? (after ? DOW_GE_DOM_MODE : DOW_LE_DOM_MODE)
- : checkRule(month, day, dayOfWeek);
- this.startDay = Math.abs(this.startDay);
- this.startDayOfWeek = Math.abs(this.startDayOfWeek);
-
- this.startMonth = month;
-
- if (this.startTimeMode == WALL_TIME || this.startTimeMode == STANDARD_TIME)
- this.startTime = time;
- else
- // Convert from UTC to STANDARD
- this.startTime = time + this.rawOffset;
- useDaylight = true;
- }
-
- /**
- * Sets the daylight savings start rule. You must also set the
- * end rule with <code>setEndRule</code> or the result of
- * getOffset is undefined. For the parameters see the ten-argument
- * constructor above.
- *
- * @param month The month where daylight savings start, zero
- * based. You should use the constants in Calendar.
- * @param day A day of month or day of week in month.
- * @param time The time in milliseconds standard time where daylight
- * savings start.
- * @see SimpleTimeZone
- * @since 1.2
- */
- public void setStartRule(int month, int day, int time)
- {
- setStartRule(month, day, 0, time);
- }
-
- /**
- * Sets the daylight savings end rule. You must also set the
- * start rule with <code>setStartRule</code> or the result of
- * getOffset is undefined. For the parameters see the ten-argument
- * constructor above.
- *
- * @param month The end month of daylight savings.
- * @param day A day in month, or a day of week in month.
- * @param dayOfWeek A day of week, when daylight savings ends.
- * @param time A time in millis in standard time.
- * @see #setStartRule
- */
- public void setEndRule(int month, int day, int dayOfWeek, int time)
- {
- this.endMode = checkRule(month, day, dayOfWeek);
- this.endMonth = month;
- this.endDay = day;
- this.endDayOfWeek = Math.abs(dayOfWeek);
- if (this.endTimeMode == WALL_TIME)
- this.endTime = time;
- else if (this.endTimeMode == STANDARD_TIME)
- // Convert from STANDARD to DST
- this.endTime = time + this.dstSavings;
- else
- // Convert from UTC to DST
- this.endTime = time + this.rawOffset + this.dstSavings;
- useDaylight = true;
- }
-
- /**
- * Sets the daylight savings end rule. You must also set the
- * start rule with <code>setStartRule</code> or the result of
- * getOffset is undefined. For the parameters see the ten-argument
- * constructor above.
- *
- * Note that this API isn't incredibly well specified. It appears that the
- * after flag must override the parameters, since normally, the day and
- * dayofweek can select this. I.e., if day < 0 and dayOfWeek < 0, on or
- * before mode is chosen. But if after == true, this implementation
- * overrides the signs of the other arguments. And if dayOfWeek == 0, it
- * falls back to the behavior in the other APIs. I guess this should be
- * checked against Sun's implementation.
- *
- * @param month The end month of daylight savings.
- * @param day A day in month, or a day of week in month.
- * @param dayOfWeek A day of week, when daylight savings ends.
- * @param time A time in millis in standard time.
- * @param after If true, day and dayOfWeek specify first day of week on or
- * after day, else first day of week on or before.
- * @since 1.2
- * @see #setStartRule
- */
- public void setEndRule(int month, int day, int dayOfWeek, int time,
- boolean after)
- {
- // FIXME: XXX: Validate that checkRule and offset processing work with on
- // or before mode.
- this.endDay = after ? Math.abs(day) : -Math.abs(day);
- this.endDayOfWeek = after ? Math.abs(dayOfWeek) : -Math.abs(dayOfWeek);
- this.endMode = (dayOfWeek != 0)
- ? (after ? DOW_GE_DOM_MODE : DOW_LE_DOM_MODE)
- : checkRule(month, day, dayOfWeek);
- this.endDay = Math.abs(this.endDay);
- this.endDayOfWeek = Math.abs(endDayOfWeek);
-
- this.endMonth = month;
-
- if (this.endTimeMode == WALL_TIME)
- this.endTime = time;
- else if (this.endTimeMode == STANDARD_TIME)
- // Convert from STANDARD to DST
- this.endTime = time + this.dstSavings;
- else
- // Convert from UTC to DST
- this.endTime = time + this.rawOffset + this.dstSavings;
- useDaylight = true;
- }
-
- /**
- * Sets the daylight savings end rule. You must also set the
- * start rule with <code>setStartRule</code> or the result of
- * getOffset is undefined. For the parameters see the ten-argument
- * constructor above.
- *
- * @param month The end month of daylight savings.
- * @param day A day in month, or a day of week in month.
- * @param dayOfWeek A day of week, when daylight savings ends.
- * @param time A time in millis in standard time.
- * @see #setStartRule
- */
- public void setEndRule(int month, int day, int time)
- {
- setEndRule(month, day, 0, time);
- }
-
- /**
- * Gets the time zone offset, for current date, modified in case of
- * daylight savings. This is the offset to add to UTC to get the local
- * time.
- *
- * In the standard JDK the results given by this method may result in
- * inaccurate results at the end of February or the beginning of March.
- * To avoid this, you should use Calendar instead:
- * <code>offset = cal.get(Calendar.ZONE_OFFSET)
- * + cal.get(Calendar.DST_OFFSET);</code>
- *
- * This version doesn't suffer this inaccuracy.
- *
- * The arguments don't follow the approach for setting start and end rules.
- * The day must be a positive number and dayOfWeek must be a positive value
- * from Calendar. dayOfWeek is redundant, but must match the other values
- * or an inaccurate result may be returned.
- *
- * @param era the era of the given date
- * @param year the year of the given date
- * @param month the month of the given date, 0 for January.
- * @param day the day of month
- * @param dayOfWeek the day of week; this must match the other fields.
- * @param millis the millis in the day (in local standard time)
- * @return the time zone offset in milliseconds.
- * @throws IllegalArgumentException if arguments are incorrect.
- */
- public int getOffset(int era, int year, int month, int day, int dayOfWeek,
- int millis)
- {
- int daysInMonth = getDaysInMonth(month, year);
- if (day < 1 || day > daysInMonth)
- throw new IllegalArgumentException("day out of range");
- if (dayOfWeek < Calendar.SUNDAY || dayOfWeek > Calendar.SATURDAY)
- throw new IllegalArgumentException("dayOfWeek out of range");
- if (month < Calendar.JANUARY || month > Calendar.DECEMBER)
- throw new IllegalArgumentException("month out of range:" + month);
-
- // This method is called by Calendar, so we mustn't use that class.
- int daylightSavings = 0;
- if (useDaylight && era == GregorianCalendar.AD && year >= startYear)
- {
- // This does only work for Gregorian calendars :-(
- // This is mainly because setStartYear doesn't take an era.
- boolean afterStart = ! isBefore(year, month, day, dayOfWeek, millis,
- startMode, startMonth, startDay,
- startDayOfWeek, startTime);
- boolean beforeEnd = isBefore(year, month, day, dayOfWeek,
- millis + dstSavings,
- endMode, endMonth, endDay, endDayOfWeek,
- endTime);
-
- if (startMonth < endMonth)
- // use daylight savings, if the date is after the start of
- // savings, and before the end of savings.
- daylightSavings = afterStart && beforeEnd ? dstSavings : 0;
- else
- // use daylight savings, if the date is before the end of
- // savings, or after the start of savings.
- daylightSavings = beforeEnd || afterStart ? dstSavings : 0;
- }
- return rawOffset + daylightSavings;
- }
-
- /**
- * Returns the time zone offset to GMT in milliseconds, ignoring
- * day light savings.
- * @return the time zone offset.
- */
- public int getRawOffset()
- {
- return rawOffset;
- }
-
- /**
- * Sets the standard time zone offset to GMT.
- * @param rawOffset The time offset from GMT in milliseconds.
- */
- public void setRawOffset(int rawOffset)
- {
- this.rawOffset = rawOffset;
- }
-
- /**
- * Gets the daylight savings offset. This is a positive offset in
- * milliseconds with respect to standard time. Typically this
- * is one hour, but for some time zones this may be half an our.
- * @return the daylight savings offset in milliseconds.
- *
- * @since 1.2
- */
- public int getDSTSavings()
- {
- return dstSavings;
- }
-
- /**
- * Sets the daylight savings offset. This is a positive offset in
- * milliseconds with respect to standard time.
- *
- * @param dstSavings the daylight savings offset in milliseconds.
- *
- * @since 1.2
- */
- public void setDSTSavings(int dstSavings)
- {
- if (dstSavings <= 0)
- throw new IllegalArgumentException("illegal value for dstSavings");
-
- this.dstSavings = dstSavings;
- }
-
- /**
- * Returns if this time zone uses daylight savings time.
- * @return true, if we use daylight savings time, false otherwise.
- */
- public boolean useDaylightTime()
- {
- return useDaylight;
- }
-
- /**
- * Returns the number of days in the given month.
- * Uses gregorian rules prior to 1582 (The default and earliest cutover)
- * @param month The month, zero based; use one of the Calendar constants.
- * @param year The year.
- */
- private int getDaysInMonth(int month, int year)
- {
- if (month == Calendar.FEBRUARY)
- {
- if ((year & 3) != 0)
- return 28;
-
- // Assume default Gregorian cutover,
- // all years prior to this must be Julian
- if (year < 1582)
- return 29;
-
- // Gregorian rules
- return ((year % 100) != 0 || (year % 400) == 0) ? 29 : 28;
- }
- else
- return monthArr[month];
- }
-
- /**
- * Checks if the date given in calXXXX, is before the change between
- * dst and standard time.
- * @param calYear the year of the date to check (for leap day checking).
- * @param calMonth the month of the date to check.
- * @param calDay the day of month of the date to check.
- * @param calDayOfWeek the day of week of the date to check.
- * @param calMillis the millis of day of the date to check (standard time).
- * @param mode the change mode; same semantic as startMode.
- * @param month the change month; same semantic as startMonth.
- * @param day the change day; same semantic as startDay.
- * @param dayOfWeek the change day of week;
- * @param millis the change time in millis since midnight standard time.
- * same semantic as startDayOfWeek.
- * @return true, if cal is before the change, false if cal is on
- * or after the change.
- */
- private boolean isBefore(int calYear, int calMonth, int calDayOfMonth,
- int calDayOfWeek, int calMillis, int mode,
- int month, int day, int dayOfWeek, int millis)
- {
- // This method is called by Calendar, so we mustn't use that class.
- // We have to do all calculations by hand.
- // check the months:
- // XXX - this is not correct:
- // for the DOW_GE_DOM and DOW_LE_DOM modes the change date may
- // be in a different month.
- if (calMonth != month)
- return calMonth < month;
-
- // check the day:
- switch (mode)
- {
- case DOM_MODE:
- if (calDayOfMonth != day)
- return calDayOfMonth < day;
- break;
- case DOW_IN_MONTH_MODE:
- {
- // This computes the day of month of the day of type
- // "dayOfWeek" that lies in the same (sunday based) week as cal.
- calDayOfMonth += (dayOfWeek - calDayOfWeek);
-
- // Now we convert it to 7 based number (to get a one based offset
- // after dividing by 7). If we count from the end of the
- // month, we get want a -7 based number counting the days from
- // the end:
- if (day < 0)
- calDayOfMonth -= getDaysInMonth(calMonth, calYear) + 7;
- else
- calDayOfMonth += 6;
-
- // day > 0 day < 0
- // S M T W T F S S M T W T F S
- // 7 8 9 10 11 12 -36-35-34-33-32-31
- // 13 14 15 16 17 18 19 -30-29-28-27-26-25-24
- // 20 21 22 23 24 25 26 -23-22-21-20-19-18-17
- // 27 28 29 30 31 32 33 -16-15-14-13-12-11-10
- // 34 35 36 -9 -8 -7
- // Now we calculate the day of week in month:
- int week = calDayOfMonth / 7;
-
- // day > 0 day < 0
- // S M T W T F S S M T W T F S
- // 1 1 1 1 1 1 -5 -5 -4 -4 -4 -4
- // 1 2 2 2 2 2 2 -4 -4 -4 -3 -3 -3 -3
- // 2 3 3 3 3 3 3 -3 -3 -3 -2 -2 -2 -2
- // 3 4 4 4 4 4 4 -2 -2 -2 -1 -1 -1 -1
- // 4 5 5 -1 -1 -1
- if (week != day)
- return week < day;
-
- if (calDayOfWeek != dayOfWeek)
- return calDayOfWeek < dayOfWeek;
-
- // daylight savings starts/ends on the given day.
- break;
- }
- case DOW_LE_DOM_MODE:
- // The greatest sunday before or equal December, 12
- // is the same as smallest sunday after or equal December, 6.
- day = Math.abs(day) - 6;
- case DOW_GE_DOM_MODE:
- // Calculate the day of month of the day of type
- // "dayOfWeek" that lies before (or on) the given date.
- calDayOfMonth -= (calDayOfWeek < dayOfWeek ? 7 : 0) + calDayOfWeek
- - dayOfWeek;
- if (calDayOfMonth < day)
- return true;
- if (calDayOfWeek != dayOfWeek || calDayOfMonth >= day + 7)
- return false;
-
- // now we have the same day
- break;
- }
-
- // the millis decides:
- return (calMillis < millis);
- }
-
- /**
- * Determines if the given date is in daylight savings time.
- * @return true, if it is in daylight savings time, false otherwise.
- */
- public boolean inDaylightTime(Date date)
- {
- Calendar cal = Calendar.getInstance(this);
- cal.setTime(date);
- return (cal.get(Calendar.DST_OFFSET) != 0);
- }
-
- /**
- * Generates the hashCode for the SimpleDateFormat object. It is
- * the rawOffset, possibly, if useDaylightSavings is true, xored
- * with startYear, startMonth, startDayOfWeekInMonth, ..., endTime.
- */
- public synchronized int hashCode()
- {
- return rawOffset
- ^ (useDaylight
- ? startMonth ^ startDay ^ startDayOfWeek ^ startTime ^ endMonth
- ^ endDay ^ endDayOfWeek ^ endTime : 0);
- }
-
- public synchronized boolean equals(Object o)
- {
- if (this == o)
- return true;
- if (! (o instanceof SimpleTimeZone))
- return false;
- SimpleTimeZone zone = (SimpleTimeZone) o;
- if (zone.hashCode() != hashCode() || ! getID().equals(zone.getID())
- || rawOffset != zone.rawOffset || useDaylight != zone.useDaylight)
- return false;
- if (! useDaylight)
- return true;
- return (startYear == zone.startYear && startMonth == zone.startMonth
- && startDay == zone.startDay
- && startDayOfWeek == zone.startDayOfWeek
- && startTime == zone.startTime
- && startTimeMode == zone.startTimeMode && endMonth == zone.endMonth
- && endDay == zone.endDay && endDayOfWeek == zone.endDayOfWeek
- && endTime == zone.endTime && endTimeMode == zone.endTimeMode);
- }
-
- /**
- * Test if the other time zone uses the same rule and only
- * possibly differs in ID. This implementation for this particular
- * class will return true if the other object is a SimpleTimeZone,
- * the raw offsets and useDaylight are identical and if useDaylight
- * is true, also the start and end datas are identical.
- * @return true if this zone uses the same rule.
- */
- public boolean hasSameRules(TimeZone other)
- {
- if (this == other)
- return true;
- if (! (other instanceof SimpleTimeZone))
- return false;
- SimpleTimeZone zone = (SimpleTimeZone) other;
- if (zone.hashCode() != hashCode() || rawOffset != zone.rawOffset
- || useDaylight != zone.useDaylight)
- return false;
- if (! useDaylight)
- return true;
- return (startYear == zone.startYear && startMonth == zone.startMonth
- && startDay == zone.startDay
- && startDayOfWeek == zone.startDayOfWeek
- && startTime == zone.startTime
- && startTimeMode == zone.startTimeMode && endMonth == zone.endMonth
- && endDay == zone.endDay && endDayOfWeek == zone.endDayOfWeek
- && endTime == zone.endTime && endTimeMode == zone.endTimeMode);
- }
-
- /**
- * Returns a string representation of this SimpleTimeZone object.
- * @return a string representation of this SimpleTimeZone object.
- */
- public String toString()
- {
- // the test for useDaylight is an incompatibility to jdk1.2, but
- // I think this shouldn't hurt.
- return getClass().getName() + "[" + "id=" + getID() + ",offset="
- + rawOffset + ",dstSavings=" + dstSavings + ",useDaylight="
- + useDaylight
- + (useDaylight
- ? ",startYear=" + startYear + ",startMode=" + startMode
- + ",startMonth=" + startMonth + ",startDay=" + startDay
- + ",startDayOfWeek=" + startDayOfWeek + ",startTime="
- + startTime + ",startTimeMode=" + startTimeMode + ",endMode="
- + endMode + ",endMonth=" + endMonth + ",endDay=" + endDay
- + ",endDayOfWeek=" + endDayOfWeek + ",endTime=" + endTime
- + ",endTimeMode=" + endTimeMode : "") + "]";
- }
-
- /**
- * Reads a serialized simple time zone from stream.
- * @see #writeObject
- */
- private void readObject(java.io.ObjectInputStream input)
- throws java.io.IOException, ClassNotFoundException
- {
- input.defaultReadObject();
- if (serialVersionOnStream == 0)
- {
- // initialize the new fields to default values.
- dstSavings = 60 * 60 * 1000;
- endMode = DOW_IN_MONTH_MODE;
- startMode = DOW_IN_MONTH_MODE;
- startTimeMode = WALL_TIME;
- endTimeMode = WALL_TIME;
- serialVersionOnStream = 2;
- }
- else
- {
- int length = input.readInt();
- byte[] byteArray = new byte[length];
- input.read(byteArray, 0, length);
- if (length >= 4)
- {
- // Lets hope that Sun does extensions to the serialized
- // form in a sane manner.
- startDay = byteArray[0];
- startDayOfWeek = byteArray[1];
- endDay = byteArray[2];
- endDayOfWeek = byteArray[3];
- }
- }
- }
-
- /**
- * Serializes this object to a stream. @serialdata The object is
- * first written in the old JDK 1.1 format, so that it can be read
- * by by the old classes. This means, that the
- * <code>start/endDay(OfWeek)</code>-Fields are written in the
- * DOW_IN_MONTH_MODE rule, since this was the only supported rule
- * in 1.1.
- *
- * In the optional section, we write first the length of an byte
- * array as int and afterwards the byte array itself. The byte
- * array contains in this release four elements, namely the real
- * startDay, startDayOfWeek endDay, endDayOfWeek in that Order.
- * These fields are needed, because for compatibility reasons only
- * approximative values are written to the required section, as
- * described above.
- */
- private void writeObject(java.io.ObjectOutputStream output)
- throws java.io.IOException
- {
- byte[] byteArray = new byte[]
- {
- (byte) startDay, (byte) startDayOfWeek, (byte) endDay,
- (byte) endDayOfWeek
- };
-
- /* calculate the approximation for JDK 1.1 */
- switch (startMode)
- {
- case DOM_MODE:
- startDayOfWeek = Calendar.SUNDAY; // random day of week
-
- // fall through
- case DOW_GE_DOM_MODE:
- case DOW_LE_DOM_MODE:
- startDay = (startDay + 6) / 7;
- }
- switch (endMode)
- {
- case DOM_MODE:
- endDayOfWeek = Calendar.SUNDAY;
-
- // fall through
- case DOW_GE_DOM_MODE:
- case DOW_LE_DOM_MODE:
- endDay = (endDay + 6) / 7;
- }
-
- // the required part:
- output.defaultWriteObject();
- // the optional part:
- output.writeInt(byteArray.length);
- output.write(byteArray, 0, byteArray.length);
- }
-}
classpath/java/util/Comparator.java \
classpath/java/util/ConcurrentModificationException.java \
java/util/Currency.java \
-java/util/Date.java \
+classpath/java/util/Date.java \
classpath/java/util/Dictionary.java \
classpath/java/util/EmptyStackException.java \
classpath/java/util/Enumeration.java \
classpath/java/util/RandomAccess.java \
java/util/ResourceBundle.java \
classpath/java/util/Set.java \
-java/util/SimpleTimeZone.java \
+classpath/java/util/SimpleTimeZone.java \
classpath/java/util/SortedMap.java \
classpath/java/util/SortedSet.java \
classpath/java/util/Stack.java \
projects / platform / upstream / gcc.git / commitdiff