Showing the changes to java/pkg/java/util/Date.java (1 of 18352 files). Show all
Unified · Split
| @@ -0,0 +1,1331 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. | ||
| 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | ||
| 4 | * | ||
| 5 | * This code is free software; you can redistribute it and/or modify it | ||
| 6 | * under the terms of the GNU General Public License version 2 only, as | ||
| 7 | * published by the Free Software Foundation. Oracle designates this | ||
| 8 | * particular file as subject to the "Classpath" exception as provided | ||
| 9 | * by Oracle in the LICENSE file that accompanied this code. | ||
| 10 | * | ||
| 11 | * This code is distributed in the hope that it will be useful, but WITHOUT | ||
| 12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
| 13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
| 14 | * version 2 for more details (a copy is included in the LICENSE file that | ||
| 15 | * accompanied this code). | ||
| 16 | * | ||
| 17 | * You should have received a copy of the GNU General Public License version | ||
| 18 | * 2 along with this work; if not, write to the Free Software Foundation, | ||
| 19 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| 20 | * | ||
| 21 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | ||
| 22 | * or visit www.oracle.com if you need additional information or have any | ||
| 23 | * questions. | ||
| 24 | */ | ||
| 25 | |||
| 26 | package java.util; | ||
| 27 | |||
| 28 | import java.text.DateFormat; | ||
| 29 | import java.io.IOException; | ||
| 30 | import java.io.ObjectOutputStream; | ||
| 31 | import java.io.ObjectInputStream; | ||
| 32 | import java.lang.ref.SoftReference; | ||
| 33 | import sun.util.calendar.BaseCalendar; | ||
| 34 | import sun.util.calendar.CalendarDate; | ||
| 35 | import sun.util.calendar.CalendarSystem; | ||
| 36 | import sun.util.calendar.CalendarUtils; | ||
| 37 | import sun.util.calendar.Era; | ||
| 38 | import sun.util.calendar.Gregorian; | ||
| 39 | import sun.util.calendar.ZoneInfo; | ||
| 40 | |||
| 41 | /** | ||
| 42 | * The class <code>Date</code> represents a specific instant | ||
| 43 | * in time, with millisecond precision. | ||
| 44 | * <p> | ||
| 45 | * Prior to JDK 1.1, the class <code>Date</code> had two additional | ||
| 46 | * functions. It allowed the interpretation of dates as year, month, day, hour, | ||
| 47 | * minute, and second values. It also allowed the formatting and parsing | ||
| 48 | * of date strings. Unfortunately, the API for these functions was not | ||
| 49 | * amenable to internationalization. As of JDK 1.1, the | ||
| 50 | * <code>Calendar</code> class should be used to convert between dates and time | ||
| 51 | * fields and the <code>DateFormat</code> class should be used to format and | ||
| 52 | * parse date strings. | ||
| 53 | * The corresponding methods in <code>Date</code> are deprecated. | ||
| 54 | * <p> | ||
| 55 | * Although the <code>Date</code> class is intended to reflect | ||
| 56 | * coordinated universal time (UTC), it may not do so exactly, | ||
| 57 | * depending on the host environment of the Java Virtual Machine. | ||
| 58 | * Nearly all modern operating systems assume that 1 day = | ||
| 59 | * 24 × 60 × 60 = 86400 seconds | ||
| 60 | * in all cases. In UTC, however, about once every year or two there | ||
| 61 | * is an extra second, called a "leap second." The leap | ||
| 62 | * second is always added as the last second of the day, and always | ||
| 63 | * on December 31 or June 30. For example, the last minute of the | ||
| 64 | * year 1995 was 61 seconds long, thanks to an added leap second. | ||
| 65 | * Most computer clocks are not accurate enough to be able to reflect | ||
| 66 | * the leap-second distinction. | ||
| 67 | * <p> | ||
| 68 | * Some computer standards are defined in terms of Greenwich mean | ||
| 69 | * time (GMT), which is equivalent to universal time (UT). GMT is | ||
| 70 | * the "civil" name for the standard; UT is the | ||
| 71 | * "scientific" name for the same standard. The | ||
| 72 | * distinction between UTC and UT is that UTC is based on an atomic | ||
| 73 | * clock and UT is based on astronomical observations, which for all | ||
| 74 | * practical purposes is an invisibly fine hair to split. Because the | ||
| 75 | * earth's rotation is not uniform (it slows down and speeds up | ||
| 76 | * in complicated ways), UT does not always flow uniformly. Leap | ||
| 77 | * seconds are introduced as needed into UTC so as to keep UTC within | ||
| 78 | * 0.9 seconds of UT1, which is a version of UT with certain | ||
| 79 | * corrections applied. There are other time and date systems as | ||
| 80 | * well; for example, the time scale used by the satellite-based | ||
| 81 | * global positioning system (GPS) is synchronized to UTC but is | ||
| 82 | * <i>not</i> adjusted for leap seconds. An interesting source of | ||
| 83 | * further information is the U.S. Naval Observatory, particularly | ||
| 84 | * the Directorate of Time at: | ||
| 85 | * <blockquote><pre> | ||
| 86 | * <a href=http://tycho.usno.navy.mil>http://tycho.usno.navy.mil</a> | ||
| 87 | * </pre></blockquote> | ||
| 88 | * <p> | ||
| 89 | * and their definitions of "Systems of Time" at: | ||
| 90 | * <blockquote><pre> | ||
| 91 | * <a href=http://tycho.usno.navy.mil/systime.html>http://tycho.usno.navy.mil/systime.html</a> | ||
| 92 | * </pre></blockquote> | ||
| 93 | * <p> | ||
| 94 | * In all methods of class <code>Date</code> that accept or return | ||
| 95 | * year, month, date, hours, minutes, and seconds values, the | ||
| 96 | * following representations are used: | ||
| 97 | * <ul> | ||
| 98 | * <li>A year <i>y</i> is represented by the integer | ||
| 99 | * <i>y</i> <code>- 1900</code>. | ||
| 100 | * <li>A month is represented by an integer from 0 to 11; 0 is January, | ||
| 101 | * 1 is February, and so forth; thus 11 is December. | ||
| 102 | * <li>A date (day of month) is represented by an integer from 1 to 31 | ||
| 103 | * in the usual manner. | ||
| 104 | * <li>An hour is represented by an integer from 0 to 23. Thus, the hour | ||
| 105 | * from midnight to 1 a.m. is hour 0, and the hour from noon to 1 | ||
| 106 | * p.m. is hour 12. | ||
| 107 | * <li>A minute is represented by an integer from 0 to 59 in the usual manner. | ||
| 108 | * <li>A second is represented by an integer from 0 to 61; the values 60 and | ||
| 109 | * 61 occur only for leap seconds and even then only in Java | ||
| 110 | * implementations that actually track leap seconds correctly. Because | ||
| 111 | * of the manner in which leap seconds are currently introduced, it is | ||
| 112 | * extremely unlikely that two leap seconds will occur in the same | ||
| 113 | * minute, but this specification follows the date and time conventions | ||
| 114 | * for ISO C. | ||
| 115 | * </ul> | ||
| 116 | * <p> | ||
| 117 | * In all cases, arguments given to methods for these purposes need | ||
| 118 | * not fall within the indicated ranges; for example, a date may be | ||
| 119 | * specified as January 32 and is interpreted as meaning February 1. | ||
| 120 | * | ||
| 121 | * @author James Gosling | ||
| 122 | * @author Arthur van Hoff | ||
| 123 | * @author Alan Liu | ||
| 124 | * @see java.text.DateFormat | ||
| 125 | * @see java.util.Calendar | ||
| 126 | * @see java.util.TimeZone | ||
| 127 | * @since JDK1.0 | ||
| 128 | */ | ||
| 129 | public class Date | ||
| 130 | implements java.io.Serializable, Cloneable, Comparable<Date> | ||
| 131 | { | ||
| 132 | private static final BaseCalendar gcal = | ||
| 133 | CalendarSystem.getGregorianCalendar(); | ||
| 134 | private static BaseCalendar jcal; | ||
| 135 | |||
| 136 | private transient long fastTime; | ||
| 137 | |||
| 138 | /* | ||
| 139 | * If cdate is null, then fastTime indicates the time in millis. | ||
| 140 | * If cdate.isNormalized() is true, then fastTime and cdate are in | ||
| 141 | * synch. Otherwise, fastTime is ignored, and cdate indicates the | ||
| 142 | * time. | ||
| 143 | */ | ||
| 144 | private transient BaseCalendar.Date cdate; | ||
| 145 | |||
| 146 | // Initialized just before the value is used. See parse(). | ||
| 147 | private static int defaultCenturyStart; | ||
| 148 | |||
| 149 | /* use serialVersionUID from modified java.util.Date for | ||
| 150 | * interoperability with JDK1.1. The Date was modified to write | ||
| 151 | * and read only the UTC time. | ||
| 152 | */ | ||
| 153 | private static final long serialVersionUID = 7523967970034938905L; | ||
| 154 | |||
| 155 | /** | ||
| 156 | * Allocates a <code>Date</code> object and initializes it so that | ||
| 157 | * it represents the time at which it was allocated, measured to the | ||
| 158 | * nearest millisecond. | ||
| 159 | * | ||
| 160 | * @see java.lang.System#currentTimeMillis() | ||
| 161 | */ | ||
| 162 | public Date() { | ||
| 163 | this(System.currentTimeMillis()); | ||
| 164 | } | ||
| 165 | |||
| 166 | /** | ||
| 167 | * Allocates a <code>Date</code> object and initializes it to | ||
| 168 | * represent the specified number of milliseconds since the | ||
| 169 | * standard base time known as "the epoch", namely January 1, | ||
| 170 | * 1970, 00:00:00 GMT. | ||
| 171 | * | ||
| 172 | * @param date the milliseconds since January 1, 1970, 00:00:00 GMT. | ||
| 173 | * @see java.lang.System#currentTimeMillis() | ||
| 174 | */ | ||
| 175 | public Date(long date) { | ||
| 176 | fastTime = date; | ||
| 177 | } | ||
| 178 | |||
| 179 | /** | ||
| 180 | * Allocates a <code>Date</code> object and initializes it so that | ||
| 181 | * it represents midnight, local time, at the beginning of the day | ||
| 182 | * specified by the <code>year</code>, <code>month</code>, and | ||
| 183 | * <code>date</code> arguments. | ||
| 184 | * | ||
| 185 | * @param year the year minus 1900. | ||
| 186 | * @param month the month between 0-11. | ||
| 187 | * @param date the day of the month between 1-31. | ||
| 188 | * @see java.util.Calendar | ||
| 189 | * @deprecated As of JDK version 1.1, | ||
| 190 | * replaced by <code>Calendar.set(year + 1900, month, date)</code> | ||
| 191 | * or <code>GregorianCalendar(year + 1900, month, date)</code>. | ||
| 192 | */ | ||
| 193 | @Deprecated | ||
| 194 | public Date(int year, int month, int date) { | ||
| 195 | this(year, month, date, 0, 0, 0); | ||
| 196 | } | ||
| 197 | |||
| 198 | /** | ||
| 199 | * Allocates a <code>Date</code> object and initializes it so that | ||
| 200 | * it represents the instant at the start of the minute specified by | ||
| 201 | * the <code>year</code>, <code>month</code>, <code>date</code>, | ||
| 202 | * <code>hrs</code>, and <code>min</code> arguments, in the local | ||
| 203 | * time zone. | ||
| 204 | * | ||
| 205 | * @param year the year minus 1900. | ||
| 206 | * @param month the month between 0-11. | ||
| 207 | * @param date the day of the month between 1-31. | ||
| 208 | * @param hrs the hours between 0-23. | ||
| 209 | * @param min the minutes between 0-59. | ||
| 210 | * @see java.util.Calendar | ||
| 211 | * @deprecated As of JDK version 1.1, | ||
| 212 | * replaced by <code>Calendar.set(year + 1900, month, date, | ||
| 213 | * hrs, min)</code> or <code>GregorianCalendar(year + 1900, | ||
| 214 | * month, date, hrs, min)</code>. | ||
| 215 | */ | ||
| 216 | @Deprecated | ||
| 217 | public Date(int year, int month, int date, int hrs, int min) { | ||
| 218 | this(year, month, date, hrs, min, 0); | ||
| 219 | } | ||
| 220 | |||
| 221 | /** | ||
| 222 | * Allocates a <code>Date</code> object and initializes it so that | ||
| 223 | * it represents the instant at the start of the second specified | ||
| 224 | * by the <code>year</code>, <code>month</code>, <code>date</code>, | ||
| 225 | * <code>hrs</code>, <code>min</code>, and <code>sec</code> arguments, | ||
| 226 | * in the local time zone. | ||
| 227 | * | ||
| 228 | * @param year the year minus 1900. | ||
| 229 | * @param month the month between 0-11. | ||
| 230 | * @param date the day of the month between 1-31. | ||
| 231 | * @param hrs the hours between 0-23. | ||
| 232 | * @param min the minutes between 0-59. | ||
| 233 | * @param sec the seconds between 0-59. | ||
| 234 | * @see java.util.Calendar | ||
| 235 | * @deprecated As of JDK version 1.1, | ||
| 236 | * replaced by <code>Calendar.set(year + 1900, month, date, | ||
| 237 | * hrs, min, sec)</code> or <code>GregorianCalendar(year + 1900, | ||
| 238 | * month, date, hrs, min, sec)</code>. | ||
| 239 | */ | ||
| 240 | @Deprecated | ||
| 241 | public Date(int year, int month, int date, int hrs, int min, int sec) { | ||
| 242 | int y = year + 1900; | ||
| 243 | // month is 0-based. So we have to normalize month to support Long.MAX_VALUE. | ||
| 244 | if (month >= 12) { | ||
| 245 | y += month / 12; | ||
| 246 | month %= 12; | ||
| 247 | } else if (month < 0) { | ||
| 248 | y += CalendarUtils.floorDivide(month, 12); | ||
| 249 | month = CalendarUtils.mod(month, 12); | ||
| 250 | } | ||
| 251 | BaseCalendar cal = getCalendarSystem(y); | ||
| 252 | cdate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef()); | ||
| 253 | cdate.setNormalizedDate(y, month + 1, date).setTimeOfDay(hrs, min, sec, 0); | ||
| 254 | getTimeImpl(); | ||
| 255 | cdate = null; | ||
| 256 | } | ||
| 257 | |||
| 258 | /** | ||
| 259 | * Allocates a <code>Date</code> object and initializes it so that | ||
| 260 | * it represents the date and time indicated by the string | ||
| 261 | * <code>s</code>, which is interpreted as if by the | ||
| 262 | * {@link Date#parse} method. | ||
| 263 | * | ||
| 264 | * @param s a string representation of the date. | ||
| 265 | * @see java.text.DateFormat | ||
| 266 | * @see java.util.Date#parse(java.lang.String) | ||
| 267 | * @deprecated As of JDK version 1.1, | ||
| 268 | * replaced by <code>DateFormat.parse(String s)</code>. | ||
| 269 | */ | ||
| 270 | @Deprecated | ||
| 271 | public Date(String s) { | ||
| 272 | this(parse(s)); | ||
| 273 | } | ||
| 274 | |||
| 275 | /** | ||
| 276 | * Return a copy of this object. | ||
| 277 | */ | ||
| 278 | public Object clone() { | ||
| 279 | Date d = null; | ||
| 280 | try { | ||
| 281 | d = (Date)super.clone(); | ||
| 282 | if (cdate != null) { | ||
| 283 | d.cdate = (BaseCalendar.Date) cdate.clone(); | ||
| 284 | } | ||
| 285 | } catch (CloneNotSupportedException e) {} // Won't happen | ||
| 286 | return d; | ||
| 287 | } | ||
| 288 | |||
| 289 | /** | ||
| 290 | * Determines the date and time based on the arguments. The | ||
| 291 | * arguments are interpreted as a year, month, day of the month, | ||
| 292 | * hour of the day, minute within the hour, and second within the | ||
| 293 | * minute, exactly as for the <tt>Date</tt> constructor with six | ||
| 294 | * arguments, except that the arguments are interpreted relative | ||
| 295 | * to UTC rather than to the local time zone. The time indicated is | ||
| 296 | * returned represented as the distance, measured in milliseconds, | ||
| 297 | * of that time from the epoch (00:00:00 GMT on January 1, 1970). | ||
| 298 | * | ||
| 299 | * @param year the year minus 1900. | ||
| 300 | * @param month the month between 0-11. | ||
| 301 | * @param date the day of the month between 1-31. | ||
| 302 | * @param hrs the hours between 0-23. | ||
| 303 | * @param min the minutes between 0-59. | ||
| 304 | * @param sec the seconds between 0-59. | ||
| 305 | * @return the number of milliseconds since January 1, 1970, 00:00:00 GMT for | ||
| 306 | * the date and time specified by the arguments. | ||
| 307 | * @see java.util.Calendar | ||
| 308 | * @deprecated As of JDK version 1.1, | ||
| 309 | * replaced by <code>Calendar.set(year + 1900, month, date, | ||
| 310 | * hrs, min, sec)</code> or <code>GregorianCalendar(year + 1900, | ||
| 311 | * month, date, hrs, min, sec)</code>, using a UTC | ||
| 312 | * <code>TimeZone</code>, followed by <code>Calendar.getTime().getTime()</code>. | ||
| 313 | */ | ||
| 314 | @Deprecated | ||
| 315 | public static long UTC(int year, int month, int date, | ||
| 316 | int hrs, int min, int sec) { | ||
| 317 | int y = year + 1900; | ||
| 318 | // month is 0-based. So we have to normalize month to support Long.MAX_VALUE. | ||
| 319 | if (month >= 12) { | ||
| 320 | y += month / 12; | ||
| 321 | month %= 12; | ||
| 322 | } else if (month < 0) { | ||
| 323 | y += CalendarUtils.floorDivide(month, 12); | ||
| 324 | month = CalendarUtils.mod(month, 12); | ||
| 325 | } | ||
| 326 | int m = month + 1; | ||
| 327 | BaseCalendar cal = getCalendarSystem(y); | ||
| 328 | BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null); | ||
| 329 | udate.setNormalizedDate(y, m, date).setTimeOfDay(hrs, min, sec, 0); | ||
| 330 | |||
| 331 | // Use a Date instance to perform normalization. Its fastTime | ||
| 332 | // is the UTC value after the normalization. | ||
| 333 | Date d = new Date(0); | ||
| 334 | d.normalize(udate); | ||
| 335 | return d.fastTime; | ||
| 336 | } | ||
| 337 | |||
| 338 | /** | ||
| 339 | * Attempts to interpret the string <tt>s</tt> as a representation | ||
| 340 | * of a date and time. If the attempt is successful, the time | ||
| 341 | * indicated is returned represented as the distance, measured in | ||
| 342 | * milliseconds, of that time from the epoch (00:00:00 GMT on | ||
| 343 | * January 1, 1970). If the attempt fails, an | ||
| 344 | * <tt>IllegalArgumentException</tt> is thrown. | ||
| 345 | * <p> | ||
| 346 | * It accepts many syntaxes; in particular, it recognizes the IETF | ||
| 347 | * standard date syntax: "Sat, 12 Aug 1995 13:30:00 GMT". It also | ||
| 348 | * understands the continental U.S. time-zone abbreviations, but for | ||
| 349 | * general use, a time-zone offset should be used: "Sat, 12 Aug 1995 | ||
| 350 | * 13:30:00 GMT+0430" (4 hours, 30 minutes west of the Greenwich | ||
| 351 | * meridian). If no time zone is specified, the local time zone is | ||
| 352 | * assumed. GMT and UTC are considered equivalent. | ||
| 353 | * <p> | ||
| 354 | * The string <tt>s</tt> is processed from left to right, looking for | ||
| 355 | * data of interest. Any material in <tt>s</tt> that is within the | ||
| 356 | * ASCII parenthesis characters <tt>(</tt> and <tt>)</tt> is ignored. | ||
| 357 | * Parentheses may be nested. Otherwise, the only characters permitted | ||
| 358 | * within <tt>s</tt> are these ASCII characters: | ||
| 359 | * <blockquote><pre> | ||
| 360 | * abcdefghijklmnopqrstuvwxyz | ||
| 361 | * ABCDEFGHIJKLMNOPQRSTUVWXYZ | ||
| 362 | * 0123456789,+-:/</pre></blockquote> | ||
| 363 | * and whitespace characters.<p> | ||
| 364 | * A consecutive sequence of decimal digits is treated as a decimal | ||
| 365 | * number:<ul> | ||
| 366 | * <li>If a number is preceded by <tt>+</tt> or <tt>-</tt> and a year | ||
| 367 | * has already been recognized, then the number is a time-zone | ||
| 368 | * offset. If the number is less than 24, it is an offset measured | ||
| 369 | * in hours. Otherwise, it is regarded as an offset in minutes, | ||
| 370 | * expressed in 24-hour time format without punctuation. A | ||
| 371 | * preceding <tt>-</tt> means a westward offset. Time zone offsets | ||
| 372 | * are always relative to UTC (Greenwich). Thus, for example, | ||
| 373 | * <tt>-5</tt> occurring in the string would mean "five hours west | ||
| 374 | * of Greenwich" and <tt>+0430</tt> would mean "four hours and | ||
| 375 | * thirty minutes east of Greenwich." It is permitted for the | ||
| 376 | * string to specify <tt>GMT</tt>, <tt>UT</tt>, or <tt>UTC</tt> | ||
| 377 | * redundantly-for example, <tt>GMT-5</tt> or <tt>utc+0430</tt>. | ||
| 378 | * <li>The number is regarded as a year number if one of the | ||
| 379 | * following conditions is true: | ||
| 380 | * <ul> | ||
| 381 | * <li>The number is equal to or greater than 70 and followed by a | ||
| 382 | * space, comma, slash, or end of string | ||
| 383 | * <li>The number is less than 70, and both a month and a day of | ||
| 384 | * the month have already been recognized</li> | ||
| 385 | * </ul> | ||
| 386 | * If the recognized year number is less than 100, it is | ||
| 387 | * interpreted as an abbreviated year relative to a century of | ||
| 388 | * which dates are within 80 years before and 19 years after | ||
| 389 | * the time when the Date class is initialized. | ||
| 390 | * After adjusting the year number, 1900 is subtracted from | ||
| 391 | * it. For example, if the current year is 1999 then years in | ||
| 392 | * the range 19 to 99 are assumed to mean 1919 to 1999, while | ||
| 393 | * years from 0 to 18 are assumed to mean 2000 to 2018. Note | ||
| 394 | * that this is slightly different from the interpretation of | ||
| 395 | * years less than 100 that is used in {@link java.text.SimpleDateFormat}. | ||
| 396 | * <li>If the number is followed by a colon, it is regarded as an hour, | ||
| 397 | * unless an hour has already been recognized, in which case it is | ||
| 398 | * regarded as a minute. | ||
| 399 | * <li>If the number is followed by a slash, it is regarded as a month | ||
| 400 | * (it is decreased by 1 to produce a number in the range <tt>0</tt> | ||
| 401 | * to <tt>11</tt>), unless a month has already been recognized, in | ||
| 402 | * which case it is regarded as a day of the month. | ||
| 403 | * <li>If the number is followed by whitespace, a comma, a hyphen, or | ||
| 404 | * end of string, then if an hour has been recognized but not a | ||
| 405 | * minute, it is regarded as a minute; otherwise, if a minute has | ||
| 406 | * been recognized but not a second, it is regarded as a second; | ||
| 407 | * otherwise, it is regarded as a day of the month. </ul><p> | ||
| 408 | * A consecutive sequence of letters is regarded as a word and treated | ||
| 409 | * as follows:<ul> | ||
| 410 | * <li>A word that matches <tt>AM</tt>, ignoring case, is ignored (but | ||
| 411 | * the parse fails if an hour has not been recognized or is less | ||
| 412 | * than <tt>1</tt> or greater than <tt>12</tt>). | ||
| 413 | * <li>A word that matches <tt>PM</tt>, ignoring case, adds <tt>12</tt> | ||
| 414 | * to the hour (but the parse fails if an hour has not been | ||
| 415 | * recognized or is less than <tt>1</tt> or greater than <tt>12</tt>). | ||
| 416 | * <li>Any word that matches any prefix of <tt>SUNDAY, MONDAY, TUESDAY, | ||
| 417 | * WEDNESDAY, THURSDAY, FRIDAY</tt>, or <tt>SATURDAY</tt>, ignoring | ||
| 418 | * case, is ignored. For example, <tt>sat, Friday, TUE</tt>, and | ||
| 419 | * <tt>Thurs</tt> are ignored. | ||
| 420 | * <li>Otherwise, any word that matches any prefix of <tt>JANUARY, | ||
| 421 | * FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, | ||
| 422 | * OCTOBER, NOVEMBER</tt>, or <tt>DECEMBER</tt>, ignoring case, and | ||
| 423 | * considering them in the order given here, is recognized as | ||
| 424 | * specifying a month and is converted to a number (<tt>0</tt> to | ||
| 425 | * <tt>11</tt>). For example, <tt>aug, Sept, april</tt>, and | ||
| 426 | * <tt>NOV</tt> are recognized as months. So is <tt>Ma</tt>, which | ||
| 427 | * is recognized as <tt>MARCH</tt>, not <tt>MAY</tt>. | ||
| 428 | * <li>Any word that matches <tt>GMT, UT</tt>, or <tt>UTC</tt>, ignoring | ||
| 429 | * case, is treated as referring to UTC. | ||
| 430 | * <li>Any word that matches <tt>EST, CST, MST</tt>, or <tt>PST</tt>, | ||
| 431 | * ignoring case, is recognized as referring to the time zone in | ||
| 432 | * North America that is five, six, seven, or eight hours west of | ||
| 433 | * Greenwich, respectively. Any word that matches <tt>EDT, CDT, | ||
| 434 | * MDT</tt>, or <tt>PDT</tt>, ignoring case, is recognized as | ||
| 435 | * referring to the same time zone, respectively, during daylight | ||
| 436 | * saving time.</ul><p> | ||
| 437 | * Once the entire string s has been scanned, it is converted to a time | ||
| 438 | * result in one of two ways. If a time zone or time-zone offset has been | ||
| 439 | * recognized, then the year, month, day of month, hour, minute, and | ||
| 440 | * second are interpreted in UTC and then the time-zone offset is | ||
| 441 | * applied. Otherwise, the year, month, day of month, hour, minute, and | ||
| 442 | * second are interpreted in the local time zone. | ||
| 443 | * | ||
| 444 | * @param s a string to be parsed as a date. | ||
| 445 | * @return the number of milliseconds since January 1, 1970, 00:00:00 GMT | ||
| 446 | * represented by the string argument. | ||
| 447 | * @see java.text.DateFormat | ||
| 448 | * @deprecated As of JDK version 1.1, | ||
| 449 | * replaced by <code>DateFormat.parse(String s)</code>. | ||
| 450 | */ | ||
| 451 | @Deprecated | ||
| 452 | public static long parse(String s) { | ||
| 453 | int year = Integer.MIN_VALUE; | ||
| 454 | int mon = -1; | ||
| 455 | int mday = -1; | ||
| 456 | int hour = -1; | ||
| 457 | int min = -1; | ||
| 458 | int sec = -1; | ||
| 459 | int millis = -1; | ||
| 460 | int c = -1; | ||
| 461 | int i = 0; | ||
| 462 | int n = -1; | ||
| 463 | int wst = -1; | ||
| 464 | int tzoffset = -1; | ||
| 465 | int prevc = 0; | ||
| 466 | syntax: | ||
| 467 | { | ||
| 468 | if (s == null) | ||
| 469 | break syntax; | ||
| 470 | int limit = s.length(); | ||
| 471 | while (i < limit) { | ||
| 472 | c = s.charAt(i); | ||
| 473 | i++; | ||
| 474 | if (c <= ' ' || c == ',') | ||
| 475 | continue; | ||
| 476 | if (c == '(') { // skip comments | ||
| 477 | int depth = 1; | ||
| 478 | while (i < limit) { | ||
| 479 | c = s.charAt(i); | ||
| 480 | i++; | ||
| 481 | if (c == '(') depth++; | ||
| 482 | else if (c == ')') | ||
| 483 | if (--depth <= 0) | ||
| 484 | break; | ||
| 485 | } | ||
| 486 | continue; | ||
| 487 | } | ||
| 488 | if ('0' <= c && c <= '9') { | ||
| 489 | n = c - '0'; | ||
| 490 | while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') { | ||
| 491 | n = n * 10 + c - '0'; | ||
| 492 | i++; | ||
| 493 | } | ||
| 494 | if (prevc == '+' || prevc == '-' && year != Integer.MIN_VALUE) { | ||
| 495 | // timezone offset | ||
| 496 | if (n < 24) | ||
| 497 | n = n * 60; // EG. "GMT-3" | ||
| 498 | else | ||
| 499 | n = n % 100 + n / 100 * 60; // eg "GMT-0430" | ||
| 500 | if (prevc == '+') // plus means east of GMT | ||
| 501 | n = -n; | ||
| 502 | if (tzoffset != 0 && tzoffset != -1) | ||
| 503 | break syntax; | ||
| 504 | tzoffset = n; | ||
| 505 | } else if (n >= 70) | ||
| 506 | if (year != Integer.MIN_VALUE) | ||
| 507 | break syntax; | ||
| 508 | else if (c <= ' ' || c == ',' || c == '/' || i >= limit) | ||
| 509 | // year = n < 1900 ? n : n - 1900; | ||
| 510 | year = n; | ||
| 511 | else | ||
| 512 | break syntax; | ||
| 513 | else if (c == ':') | ||
| 514 | if (hour < 0) | ||
| 515 | hour = (byte) n; | ||
| 516 | else if (min < 0) | ||
| 517 | min = (byte) n; | ||
| 518 | else | ||
| 519 | break syntax; | ||
| 520 | else if (c == '/') | ||
| 521 | if (mon < 0) | ||
| 522 | mon = (byte) (n - 1); | ||
| 523 | else if (mday < 0) | ||
| 524 | mday = (byte) n; | ||
| 525 | else | ||
| 526 | break syntax; | ||
| 527 | else if (i < limit && c != ',' && c > ' ' && c != '-') | ||
| 528 | break syntax; | ||
| 529 | else if (hour >= 0 && min < 0) | ||
| 530 | min = (byte) n; | ||
| 531 | else if (min >= 0 && sec < 0) | ||
| 532 | sec = (byte) n; | ||
| 533 | else if (mday < 0) | ||
| 534 | mday = (byte) n; | ||
| 535 | // Handle two-digit years < 70 (70-99 handled above). | ||
| 536 | else if (year == Integer.MIN_VALUE && mon >= 0 && mday >= 0) | ||
| 537 | year = n; | ||
| 538 | else | ||
| 539 | break syntax; | ||
| 540 | prevc = 0; | ||
| 541 | } else if (c == '/' || c == ':' || c == '+' || c == '-') | ||
| 542 | prevc = c; | ||
| 543 | else { | ||
| 544 | int st = i - 1; | ||
| 545 | while (i < limit) { | ||
| 546 | c = s.charAt(i); | ||
| 547 | if (!('A' <= c && c <= 'Z' || 'a' <= c && c <= 'z')) | ||
| 548 | break; | ||
| 549 | i++; | ||
| 550 | } | ||
| 551 | if (i <= st + 1) | ||
| 552 | break syntax; | ||
| 553 | int k; | ||
| 554 | for (k = wtb.length; --k >= 0;) | ||
| 555 | if (wtb[k].regionMatches(true, 0, s, st, i - st)) { | ||
| 556 | int action = ttb[k]; | ||
| 557 | if (action != 0) { | ||
| 558 | if (action == 1) { // pm | ||
| 559 | if (hour > 12 || hour < 1) | ||
| 560 | break syntax; | ||
| 561 | else if (hour < 12) | ||
| 562 | hour += 12; | ||
| 563 | } else if (action == 14) { // am | ||
| 564 | if (hour > 12 || hour < 1) | ||
| 565 | break syntax; | ||
| 566 | else if (hour == 12) | ||
| 567 | hour = 0; | ||
| 568 | } else if (action <= 13) { // month! | ||
| 569 | if (mon < 0) | ||
| 570 | mon = (byte) (action - 2); | ||
| 571 | else | ||
| 572 | break syntax; | ||
| 573 | } else { | ||
| 574 | tzoffset = action - 10000; | ||
| 575 | } | ||
| 576 | } | ||
| 577 | break; | ||
| 578 | } | ||
| 579 | if (k < 0) | ||
| 580 | break syntax; | ||
| 581 | prevc = 0; | ||
| 582 | } | ||
| 583 | } | ||
| 584 | if (year == Integer.MIN_VALUE || mon < 0 || mday < 0) | ||
| 585 | break syntax; | ||
| 586 | // Parse 2-digit years within the correct default century. | ||
| 587 | if (year < 100) { | ||
| 588 | synchronized (Date.class) { | ||
| 589 | if (defaultCenturyStart == 0) { | ||
| 590 | defaultCenturyStart = gcal.getCalendarDate().getYear() - 80; | ||
| 591 | } | ||
| 592 | } | ||
| 593 | year += (defaultCenturyStart / 100) * 100; | ||
| 594 | if (year < defaultCenturyStart) year += 100; | ||
| 595 | } | ||
| 596 | if (sec < 0) | ||
| 597 | sec = 0; | ||
| 598 | if (min < 0) | ||
| 599 | min = 0; | ||
| 600 | if (hour < 0) | ||
| 601 | hour = 0; | ||
| 602 | BaseCalendar cal = getCalendarSystem(year); | ||
| 603 | if (tzoffset == -1) { // no time zone specified, have to use local | ||
| 604 | BaseCalendar.Date ldate = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.getDefaultRef()); | ||
| 605 | ldate.setDate(year, mon + 1, mday); | ||
| 606 | ldate.setTimeOfDay(hour, min, sec, 0); | ||
| 607 | return cal.getTime(ldate); | ||
| 608 | } | ||
| 609 | BaseCalendar.Date udate = (BaseCalendar.Date) cal.newCalendarDate(null); // no time zone | ||
| 610 | udate.setDate(year, mon + 1, mday); | ||
| 611 | udate.setTimeOfDay(hour, min, sec, 0); | ||
| 612 | return cal.getTime(udate) + tzoffset * (60 * 1000); | ||
| 613 | } | ||
| 614 | // syntax error | ||
| 615 | throw new IllegalArgumentException(); | ||
| 616 | } | ||
| 617 | private final static String wtb[] = { | ||
| 618 | "am", "pm", | ||
| 619 | "monday", "tuesday", "wednesday", "thursday", "friday", | ||
| 620 | "saturday", "sunday", | ||
| 621 | "january", "february", "march", "april", "may", "june", | ||
| 622 | "july", "august", "september", "october", "november", "december", | ||
| 623 | "gmt", "ut", "utc", "est", "edt", "cst", "cdt", | ||
| 624 | "mst", "mdt", "pst", "pdt" | ||
| 625 | }; | ||
| 626 | private final static int ttb[] = { | ||
| 627 | 14, 1, 0, 0, 0, 0, 0, 0, 0, | ||
| 628 | 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, | ||
| 629 | 10000 + 0, 10000 + 0, 10000 + 0, // GMT/UT/UTC | ||
| 630 | 10000 + 5 * 60, 10000 + 4 * 60, // EST/EDT | ||
| 631 | 10000 + 6 * 60, 10000 + 5 * 60, // CST/CDT | ||
| 632 | 10000 + 7 * 60, 10000 + 6 * 60, // MST/MDT | ||
| 633 | 10000 + 8 * 60, 10000 + 7 * 60 // PST/PDT | ||
| 634 | }; | ||
| 635 | |||
| 636 | /** | ||
| 637 | * Returns a value that is the result of subtracting 1900 from the | ||
| 638 | * year that contains or begins with the instant in time represented | ||
| 639 | * by this <code>Date</code> object, as interpreted in the local | ||
| 640 | * time zone. | ||
| 641 | * | ||
| 642 | * @return the year represented by this date, minus 1900. | ||
| 643 | * @see java.util.Calendar | ||
| 644 | * @deprecated As of JDK version 1.1, | ||
| 645 | * replaced by <code>Calendar.get(Calendar.YEAR) - 1900</code>. | ||
| 646 | */ | ||
| 647 | @Deprecated | ||
| 648 | public int getYear() { | ||
| 649 | return normalize().getYear() - 1900; | ||
| 650 | } | ||
| 651 | |||
| 652 | /** | ||
| 653 | * Sets the year of this <tt>Date</tt> object to be the specified | ||
| 654 | * value plus 1900. This <code>Date</code> object is modified so | ||
| 655 | * that it represents a point in time within the specified year, | ||
| 656 | * with the month, date, hour, minute, and second the same as | ||
| 657 | * before, as interpreted in the local time zone. (Of course, if | ||
| 658 | * the date was February 29, for example, and the year is set to a | ||
| 659 | * non-leap year, then the new date will be treated as if it were | ||
| 660 | * on March 1.) | ||
| 661 | * | ||
| 662 | * @param year the year value. | ||
| 663 | * @see java.util.Calendar | ||
| 664 | * @deprecated As of JDK version 1.1, | ||
| 665 | * replaced by <code>Calendar.set(Calendar.YEAR, year + 1900)</code>. | ||
| 666 | */ | ||
| 667 | @Deprecated | ||
| 668 | public void setYear(int year) { | ||
| 669 | getCalendarDate().setNormalizedYear(year + 1900); | ||
| 670 | } | ||
| 671 | |||
| 672 | /** | ||
| 673 | * Returns a number representing the month that contains or begins | ||
| 674 | * with the instant in time represented by this <tt>Date</tt> object. | ||
| 675 | * The value returned is between <code>0</code> and <code>11</code>, | ||
| 676 | * with the value <code>0</code> representing January. | ||
| 677 | * | ||
| 678 | * @return the month represented by this date. | ||
| 679 | * @see java.util.Calendar | ||
| 680 | * @deprecated As of JDK version 1.1, | ||
| 681 | * replaced by <code>Calendar.get(Calendar.MONTH)</code>. | ||
| 682 | */ | ||
| 683 | @Deprecated | ||
| 684 | public int getMonth() { | ||
| 685 | return normalize().getMonth() - 1; // adjust 1-based to 0-based | ||
| 686 | } | ||
| 687 | |||
| 688 | /** | ||
| 689 | * Sets the month of this date to the specified value. This | ||
| 690 | * <tt>Date</tt> object is modified so that it represents a point | ||
| 691 | * in time within the specified month, with the year, date, hour, | ||
| 692 | * minute, and second the same as before, as interpreted in the | ||
| 693 | * local time zone. If the date was October 31, for example, and | ||
| 694 | * the month is set to June, then the new date will be treated as | ||
| 695 | * if it were on July 1, because June has only 30 days. | ||
| 696 | * | ||
| 697 | * @param month the month value between 0-11. | ||
| 698 | * @see java.util.Calendar | ||
| 699 | * @deprecated As of JDK version 1.1, | ||
| 700 | * replaced by <code>Calendar.set(Calendar.MONTH, int month)</code>. | ||
| 701 | */ | ||
| 702 | @Deprecated | ||
| 703 | public void setMonth(int month) { | ||
| 704 | int y = 0; | ||
| 705 | if (month >= 12) { | ||
| 706 | y = month / 12; | ||
| 707 | month %= 12; | ||
| 708 | } else if (month < 0) { | ||
| 709 | y = CalendarUtils.floorDivide(month, 12); | ||
| 710 | month = CalendarUtils.mod(month, 12); | ||
| 711 | } | ||
| 712 | BaseCalendar.Date d = getCalendarDate(); | ||
| 713 | if (y != 0) { | ||
| 714 | d.setNormalizedYear(d.getNormalizedYear() + y); | ||
| 715 | } | ||
| 716 | d.setMonth(month + 1); // adjust 0-based to 1-based month numbering | ||
| 717 | } | ||
| 718 | |||
| 719 | /** | ||
| 720 | * Returns the day of the month represented by this <tt>Date</tt> object. | ||
| 721 | * The value returned is between <code>1</code> and <code>31</code> | ||
| 722 | * representing the day of the month that contains or begins with the | ||
| 723 | * instant in time represented by this <tt>Date</tt> object, as | ||
| 724 | * interpreted in the local time zone. | ||
| 725 | * | ||
| 726 | * @return the day of the month represented by this date. | ||
| 727 | * @see java.util.Calendar | ||
| 728 | * @deprecated As of JDK version 1.1, | ||
| 729 | * replaced by <code>Calendar.get(Calendar.DAY_OF_MONTH)</code>. | ||
| 730 | * @deprecated | ||
| 731 | */ | ||
| 732 | @Deprecated | ||
| 733 | public int getDate() { | ||
| 734 | return normalize().getDayOfMonth(); | ||
| 735 | } | ||
| 736 | |||
| 737 | /** | ||
| 738 | * Sets the day of the month of this <tt>Date</tt> object to the | ||
| 739 | * specified value. This <tt>Date</tt> object is modified so that | ||
| 740 | * it represents a point in time within the specified day of the | ||
| 741 | * month, with the year, month, hour, minute, and second the same | ||
| 742 | * as before, as interpreted in the local time zone. If the date | ||
| 743 | * was April 30, for example, and the date is set to 31, then it | ||
| 744 | * will be treated as if it were on May 1, because April has only | ||
| 745 | * 30 days. | ||
| 746 | * | ||
| 747 | * @param date the day of the month value between 1-31. | ||
| 748 | * @see java.util.Calendar | ||
| 749 | * @deprecated As of JDK version 1.1, | ||
| 750 | * replaced by <code>Calendar.set(Calendar.DAY_OF_MONTH, int date)</code>. | ||
| 751 | */ | ||
| 752 | @Deprecated | ||
| 753 | public void setDate(int date) { | ||
| 754 | getCalendarDate().setDayOfMonth(date); | ||
| 755 | } | ||
| 756 | |||
| 757 | /** | ||
| 758 | * Returns the day of the week represented by this date. The | ||
| 759 | * returned value (<tt>0</tt> = Sunday, <tt>1</tt> = Monday, | ||
| 760 | * <tt>2</tt> = Tuesday, <tt>3</tt> = Wednesday, <tt>4</tt> = | ||
| 761 | * Thursday, <tt>5</tt> = Friday, <tt>6</tt> = Saturday) | ||
| 762 | * represents the day of the week that contains or begins with | ||
| 763 | * the instant in time represented by this <tt>Date</tt> object, | ||
| 764 | * as interpreted in the local time zone. | ||
| 765 | * | ||
| 766 | * @return the day of the week represented by this date. | ||
| 767 | * @see java.util.Calendar | ||
| 768 | * @deprecated As of JDK version 1.1, | ||
| 769 | * replaced by <code>Calendar.get(Calendar.DAY_OF_WEEK)</code>. | ||
| 770 | */ | ||
| 771 | @Deprecated | ||
| 772 | public int getDay() { | ||
| 773 | return normalize().getDayOfWeek() - gcal.SUNDAY; | ||
| 774 | } | ||
| 775 | |||
| 776 | /** | ||
| 777 | * Returns the hour represented by this <tt>Date</tt> object. The | ||
| 778 | * returned value is a number (<tt>0</tt> through <tt>23</tt>) | ||
| 779 | * representing the hour within the day that contains or begins | ||
| 780 | * with the instant in time represented by this <tt>Date</tt> | ||
| 781 | * object, as interpreted in the local time zone. | ||
| 782 | * | ||
| 783 | * @return the hour represented by this date. | ||
| 784 | * @see java.util.Calendar | ||
| 785 | * @deprecated As of JDK version 1.1, | ||
| 786 | * replaced by <code>Calendar.get(Calendar.HOUR_OF_DAY)</code>. | ||
| 787 | */ | ||
| 788 | @Deprecated | ||
| 789 | public int getHours() { | ||
| 790 | return normalize().getHours(); | ||
| 791 | } | ||
| 792 | |||
| 793 | /** | ||
| 794 | * Sets the hour of this <tt>Date</tt> object to the specified value. | ||
| 795 | * This <tt>Date</tt> object is modified so that it represents a point | ||
| 796 | * in time within the specified hour of the day, with the year, month, | ||
| 797 | * date, minute, and second the same as before, as interpreted in the | ||
| 798 | * local time zone. | ||
| 799 | * | ||
| 800 | * @param hours the hour value. | ||
| 801 | * @see java.util.Calendar | ||
| 802 | * @deprecated As of JDK version 1.1, | ||
| 803 | * replaced by <code>Calendar.set(Calendar.HOUR_OF_DAY, int hours)</code>. | ||
| 804 | */ | ||
| 805 | @Deprecated | ||
| 806 | public void setHours(int hours) { | ||
| 807 | getCalendarDate().setHours(hours); | ||
| 808 | } | ||
| 809 | |||
| 810 | /** | ||
| 811 | * Returns the number of minutes past the hour represented by this date, | ||
| 812 | * as interpreted in the local time zone. | ||
| 813 | * The value returned is between <code>0</code> and <code>59</code>. | ||
| 814 | * | ||
| 815 | * @return the number of minutes past the hour represented by this date. | ||
| 816 | * @see java.util.Calendar | ||
| 817 | * @deprecated As of JDK version 1.1, | ||
| 818 | * replaced by <code>Calendar.get(Calendar.MINUTE)</code>. | ||
| 819 | */ | ||
| 820 | @Deprecated | ||
| 821 | public int getMinutes() { | ||
| 822 | return normalize().getMinutes(); | ||
| 823 | } | ||
| 824 | |||
| 825 | /** | ||
| 826 | * Sets the minutes of this <tt>Date</tt> object to the specified value. | ||
| 827 | * This <tt>Date</tt> object is modified so that it represents a point | ||
| 828 | * in time within the specified minute of the hour, with the year, month, | ||
| 829 | * date, hour, and second the same as before, as interpreted in the | ||
| 830 | * local time zone. | ||
| 831 | * | ||
| 832 | * @param minutes the value of the minutes. | ||
| 833 | * @see java.util.Calendar | ||
| 834 | * @deprecated As of JDK version 1.1, | ||
| 835 | * replaced by <code>Calendar.set(Calendar.MINUTE, int minutes)</code>. | ||
| 836 | */ | ||
| 837 | @Deprecated | ||
| 838 | public void setMinutes(int minutes) { | ||
| 839 | getCalendarDate().setMinutes(minutes); | ||
| 840 | } | ||
| 841 | |||
| 842 | /** | ||
| 843 | * Returns the number of seconds past the minute represented by this date. | ||
| 844 | * The value returned is between <code>0</code> and <code>61</code>. The | ||
| 845 | * values <code>60</code> and <code>61</code> can only occur on those | ||
| 846 | * Java Virtual Machines that take leap seconds into account. | ||
| 847 | * | ||
| 848 | * @return the number of seconds past the minute represented by this date. | ||
| 849 | * @see java.util.Calendar | ||
| 850 | * @deprecated As of JDK version 1.1, | ||
| 851 | * replaced by <code>Calendar.get(Calendar.SECOND)</code>. | ||
| 852 | */ | ||
| 853 | @Deprecated | ||
| 854 | public int getSeconds() { | ||
| 855 | return normalize().getSeconds(); | ||
| 856 | } | ||
| 857 | |||
| 858 | /** | ||
| 859 | * Sets the seconds of this <tt>Date</tt> to the specified value. | ||
| 860 | * This <tt>Date</tt> object is modified so that it represents a | ||
| 861 | * point in time within the specified second of the minute, with | ||
| 862 | * the year, month, date, hour, and minute the same as before, as | ||
| 863 | * interpreted in the local time zone. | ||
| 864 | * | ||
| 865 | * @param seconds the seconds value. | ||
| 866 | * @see java.util.Calendar | ||
| 867 | * @deprecated As of JDK version 1.1, | ||
| 868 | * replaced by <code>Calendar.set(Calendar.SECOND, int seconds)</code>. | ||
| 869 | */ | ||
| 870 | @Deprecated | ||
| 871 | public void setSeconds(int seconds) { | ||
| 872 | getCalendarDate().setSeconds(seconds); | ||
| 873 | } | ||
| 874 | |||
| 875 | /** | ||
| 876 | * Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT | ||
| 877 | * represented by this <tt>Date</tt> object. | ||
| 878 | * | ||
| 879 | * @return the number of milliseconds since January 1, 1970, 00:00:00 GMT | ||
| 880 | * represented by this date. | ||
| 881 | */ | ||
| 882 | public long getTime() { | ||
| 883 | return getTimeImpl(); | ||
| 884 | } | ||
| 885 | |||
| 886 | private final long getTimeImpl() { | ||
| 887 | if (cdate != null && !cdate.isNormalized()) { | ||
| 888 | normalize(); | ||
| 889 | } | ||
| 890 | return fastTime; | ||
| 891 | } | ||
| 892 | |||
| 893 | /** | ||
| 894 | * Sets this <code>Date</code> object to represent a point in time that is | ||
| 895 | * <code>time</code> milliseconds after January 1, 1970 00:00:00 GMT. | ||
| 896 | * | ||
| 897 | * @param time the number of milliseconds. | ||
| 898 | */ | ||
| 899 | public void setTime(long time) { | ||
| 900 | fastTime = time; | ||
| 901 | cdate = null; | ||
| 902 | } | ||
| 903 | |||
| 904 | /** | ||
| 905 | * Tests if this date is before the specified date. | ||
| 906 | * | ||
| 907 | * @param when a date. | ||
| 908 | * @return <code>true</code> if and only if the instant of time | ||
| 909 | * represented by this <tt>Date</tt> object is strictly | ||
| 910 | * earlier than the instant represented by <tt>when</tt>; | ||
| 911 | * <code>false</code> otherwise. | ||
| 912 | * @exception NullPointerException if <code>when</code> is null. | ||
| 913 | */ | ||
| 914 | public boolean before(Date when) { | ||
| 915 | return getMillisOf(this) < getMillisOf(when); | ||
| 916 | } | ||
| 917 | |||
| 918 | /** | ||
| 919 | * Tests if this date is after the specified date. | ||
| 920 | * | ||
| 921 | * @param when a date. | ||
| 922 | * @return <code>true</code> if and only if the instant represented | ||
| 923 | * by this <tt>Date</tt> object is strictly later than the | ||
| 924 | * instant represented by <tt>when</tt>; | ||
| 925 | * <code>false</code> otherwise. | ||
| 926 | * @exception NullPointerException if <code>when</code> is null. | ||
| 927 | */ | ||
| 928 | public boolean after(Date when) { | ||
| 929 | return getMillisOf(this) > getMillisOf(when); | ||
| 930 | } | ||
| 931 | |||
| 932 | /** | ||
| 933 | * Compares two dates for equality. | ||
| 934 | * The result is <code>true</code> if and only if the argument is | ||
| 935 | * not <code>null</code> and is a <code>Date</code> object that | ||
| 936 | * represents the same point in time, to the millisecond, as this object. | ||
| 937 | * <p> | ||
| 938 | * Thus, two <code>Date</code> objects are equal if and only if the | ||
| 939 | * <code>getTime</code> method returns the same <code>long</code> | ||
| 940 | * value for both. | ||
| 941 | * | ||
| 942 | * @param obj the object to compare with. | ||
| 943 | * @return <code>true</code> if the objects are the same; | ||
| 944 | * <code>false</code> otherwise. | ||
| 945 | * @see java.util.Date#getTime() | ||
| 946 | */ | ||
| 947 | public boolean equals(Object obj) { | ||
| 948 | return obj instanceof Date && getTime() == ((Date) obj).getTime(); | ||
| 949 | } | ||
| 950 | |||
| 951 | /** | ||
| 952 | * Returns the millisecond value of this <code>Date</code> object | ||
| 953 | * without affecting its internal state. | ||
| 954 | */ | ||
| 955 | static final long getMillisOf(Date date) { | ||
| 956 | if (date.cdate == null || date.cdate.isNormalized()) { | ||
| 957 | return date.fastTime; | ||
| 958 | } | ||
| 959 | BaseCalendar.Date d = (BaseCalendar.Date) date.cdate.clone(); | ||
| 960 | return gcal.getTime(d); | ||
| 961 | } | ||
| 962 | |||
| 963 | /** | ||
| 964 | * Compares two Dates for ordering. | ||
| 965 | * | ||
| 966 | * @param anotherDate the <code>Date</code> to be compared. | ||
| 967 | * @return the value <code>0</code> if the argument Date is equal to | ||
| 968 | * this Date; a value less than <code>0</code> if this Date | ||
| 969 | * is before the Date argument; and a value greater than | ||
| 970 | * <code>0</code> if this Date is after the Date argument. | ||
| 971 | * @since 1.2 | ||
| 972 | * @exception NullPointerException if <code>anotherDate</code> is null. | ||
| 973 | */ | ||
| 974 | public int compareTo(Date anotherDate) { | ||
| 975 | long thisTime = getMillisOf(this); | ||
| 976 | long anotherTime = getMillisOf(anotherDate); | ||
| 977 | return (thisTime<anotherTime ? -1 : (thisTime==anotherTime ? 0 : 1)); | ||
| 978 | } | ||
| 979 | |||
| 980 | /** | ||
| 981 | * Returns a hash code value for this object. The result is the | ||
| 982 | * exclusive OR of the two halves of the primitive <tt>long</tt> | ||
| 983 | * value returned by the {@link Date#getTime} | ||
| 984 | * method. That is, the hash code is the value of the expression: | ||
| 985 | * <blockquote><pre> | ||
| 986 | * (int)(this.getTime()^(this.getTime() >>> 32))</pre></blockquote> | ||
| 987 | * | ||
| 988 | * @return a hash code value for this object. | ||
| 989 | */ | ||
| 990 | public int hashCode() { | ||
| 991 | long ht = this.getTime(); | ||
| 992 | return (int) ht ^ (int) (ht >> 32); | ||
| 993 | } | ||
| 994 | |||
| 995 | /** | ||
| 996 | * Converts this <code>Date</code> object to a <code>String</code> | ||
| 997 | * of the form: | ||
| 998 | * <blockquote><pre> | ||
| 999 | * dow mon dd hh:mm:ss zzz yyyy</pre></blockquote> | ||
| 1000 | * where:<ul> | ||
| 1001 | * <li><tt>dow</tt> is the day of the week (<tt>Sun, Mon, Tue, Wed, | ||
| 1002 | * Thu, Fri, Sat</tt>). | ||
| 1003 | * <li><tt>mon</tt> is the month (<tt>Jan, Feb, Mar, Apr, May, Jun, | ||
| 1004 | * Jul, Aug, Sep, Oct, Nov, Dec</tt>). | ||
| 1005 | * <li><tt>dd</tt> is the day of the month (<tt>01</tt> through | ||
| 1006 | * <tt>31</tt>), as two decimal digits. | ||
| 1007 | * <li><tt>hh</tt> is the hour of the day (<tt>00</tt> through | ||
| 1008 | * <tt>23</tt>), as two decimal digits. | ||
| 1009 | * <li><tt>mm</tt> is the minute within the hour (<tt>00</tt> through | ||
| 1010 | * <tt>59</tt>), as two decimal digits. | ||
| 1011 | * <li><tt>ss</tt> is the second within the minute (<tt>00</tt> through | ||
| 1012 | * <tt>61</tt>, as two decimal digits. | ||
| 1013 | * <li><tt>zzz</tt> is the time zone (and may reflect daylight saving | ||
| 1014 | * time). Standard time zone abbreviations include those | ||
| 1015 | * recognized by the method <tt>parse</tt>. If time zone | ||
| 1016 | * information is not available, then <tt>zzz</tt> is empty - | ||
| 1017 | * that is, it consists of no characters at all. | ||
| 1018 | * <li><tt>yyyy</tt> is the year, as four decimal digits. | ||
| 1019 | * </ul> | ||
| 1020 | * | ||
| 1021 | * @return a string representation of this date. | ||
| 1022 | * @see java.util.Date#toLocaleString() | ||
| 1023 | * @see java.util.Date#toGMTString() | ||
| 1024 | */ | ||
| 1025 | public String toString() { | ||
| 1026 | // "EEE MMM dd HH:mm:ss zzz yyyy"; | ||
| 1027 | BaseCalendar.Date date = normalize(); | ||
| 1028 | StringBuilder sb = new StringBuilder(28); | ||
| 1029 | int index = date.getDayOfWeek(); | ||
| 1030 | if (index == gcal.SUNDAY) { | ||
| 1031 | index = 8; | ||
| 1032 | } | ||
| 1033 | convertToAbbr(sb, wtb[index]).append(' '); // EEE | ||
| 1034 | convertToAbbr(sb, wtb[date.getMonth() - 1 + 2 + 7]).append(' '); // MMM | ||
| 1035 | CalendarUtils.sprintf0d(sb, date.getDayOfMonth(), 2).append(' '); // dd | ||
| 1036 | |||
| 1037 | CalendarUtils.sprintf0d(sb, date.getHours(), 2).append(':'); // HH | ||
| 1038 | CalendarUtils.sprintf0d(sb, date.getMinutes(), 2).append(':'); // mm | ||
| 1039 | CalendarUtils.sprintf0d(sb, date.getSeconds(), 2).append(' '); // ss | ||
| 1040 | TimeZone zi = date.getZone(); | ||
| 1041 | if (zi != null) { | ||
| 1042 | sb.append(zi.getDisplayName(date.isDaylightTime(), zi.SHORT, Locale.US)); // zzz | ||
| 1043 | } else { | ||
| 1044 | sb.append("GMT"); | ||
| 1045 | } | ||
| 1046 | sb.append(' ').append(date.getYear()); // yyyy | ||
| 1047 | return sb.toString(); | ||
| 1048 | } | ||
| 1049 | |||
| 1050 | /** | ||
| 1051 | * Converts the given name to its 3-letter abbreviation (e.g., | ||
| 1052 | * "monday" -> "Mon") and stored the abbreviation in the given | ||
| 1053 | * <code>StringBuilder</code>. | ||
| 1054 | */ | ||
| 1055 | private static final StringBuilder convertToAbbr(StringBuilder sb, String name) { | ||
| 1056 | sb.append(Character.toUpperCase(name.charAt(0))); | ||
| 1057 | sb.append(name.charAt(1)).append(name.charAt(2)); | ||
| 1058 | return sb; | ||
| 1059 | } | ||
| 1060 | |||
| 1061 | /** | ||
| 1062 | * Creates a string representation of this <tt>Date</tt> object in an | ||
| 1063 | * implementation-dependent form. The intent is that the form should | ||
| 1064 | * be familiar to the user of the Java application, wherever it may | ||
| 1065 | * happen to be running. The intent is comparable to that of the | ||
| 1066 | * "<code>%c</code>" format supported by the <code>strftime()</code> | ||
| 1067 | * function of ISO C. | ||
| 1068 | * | ||
| 1069 | * @return a string representation of this date, using the locale | ||
| 1070 | * conventions. | ||
| 1071 | * @see java.text.DateFormat | ||
| 1072 | * @see java.util.Date#toString() | ||
| 1073 | * @see java.util.Date#toGMTString() | ||
| 1074 | * @deprecated As of JDK version 1.1, | ||
| 1075 | * replaced by <code>DateFormat.format(Date date)</code>. | ||
| 1076 | */ | ||
| 1077 | @Deprecated | ||
| 1078 | public String toLocaleString() { | ||
| 1079 | DateFormat formatter = DateFormat.getDateTimeInstance(); | ||
| 1080 | return formatter.format(this); | ||
| 1081 | } | ||
| 1082 | |||
| 1083 | /** | ||
| 1084 | * Creates a string representation of this <tt>Date</tt> object of | ||
| 1085 | * the form: | ||
| 1086 | * <blockquote<pre> | ||
| 1087 | * d mon yyyy hh:mm:ss GMT</pre></blockquote> | ||
| 1088 | * where:<ul> | ||
| 1089 | * <li><i>d</i> is the day of the month (<tt>1</tt> through <tt>31</tt>), | ||
| 1090 | * as one or two decimal digits. | ||
| 1091 | * <li><i>mon</i> is the month (<tt>Jan, Feb, Mar, Apr, May, Jun, Jul, | ||
| 1092 | * Aug, Sep, Oct, Nov, Dec</tt>). | ||
| 1093 | * <li><i>yyyy</i> is the year, as four decimal digits. | ||
| 1094 | * <li><i>hh</i> is the hour of the day (<tt>00</tt> through <tt>23</tt>), | ||
| 1095 | * as two decimal digits. | ||
| 1096 | * <li><i>mm</i> is the minute within the hour (<tt>00</tt> through | ||
| 1097 | * <tt>59</tt>), as two decimal digits. | ||
| 1098 | * <li><i>ss</i> is the second within the minute (<tt>00</tt> through | ||
| 1099 | * <tt>61</tt>), as two decimal digits. | ||
| 1100 | * <li><i>GMT</i> is exactly the ASCII letters "<tt>GMT</tt>" to indicate | ||
| 1101 | * Greenwich Mean Time. | ||
| 1102 | * </ul><p> | ||
| 1103 | * The result does not depend on the local time zone. | ||
| 1104 | * | ||
| 1105 | * @return a string representation of this date, using the Internet GMT | ||
| 1106 | * conventions. | ||
| 1107 | * @see java.text.DateFormat | ||
| 1108 | * @see java.util.Date#toString() | ||
| 1109 | * @see java.util.Date#toLocaleString() | ||
| 1110 | * @deprecated As of JDK version 1.1, | ||
| 1111 | * replaced by <code>DateFormat.format(Date date)</code>, using a | ||
| 1112 | * GMT <code>TimeZone</code>. | ||
| 1113 | */ | ||
| 1114 | @Deprecated | ||
| 1115 | public String toGMTString() { | ||
| 1116 | // d MMM yyyy HH:mm:ss 'GMT' | ||
| 1117 | long t = getTime(); | ||
| 1118 | BaseCalendar cal = getCalendarSystem(t); | ||
| 1119 | BaseCalendar.Date date = | ||
| 1120 | (BaseCalendar.Date) cal.getCalendarDate(getTime(), (TimeZone)null); | ||
| 1121 | StringBuilder sb = new StringBuilder(32); | ||
| 1122 | CalendarUtils.sprintf0d(sb, date.getDayOfMonth(), 1).append(' '); // d | ||
| 1123 | convertToAbbr(sb, wtb[date.getMonth() - 1 + 2 + 7]).append(' '); // MMM | ||
| 1124 | sb.append(date.getYear()).append(' '); // yyyy | ||
| 1125 | CalendarUtils.sprintf0d(sb, date.getHours(), 2).append(':'); // HH | ||
| 1126 | CalendarUtils.sprintf0d(sb, date.getMinutes(), 2).append(':'); // mm | ||
| 1127 | CalendarUtils.sprintf0d(sb, date.getSeconds(), 2); // ss | ||
| 1128 | sb.append(" GMT"); // ' GMT' | ||
| 1129 | return sb.toString(); | ||
| 1130 | } | ||
| 1131 | |||
| 1132 | /** | ||
| 1133 | * Returns the offset, measured in minutes, for the local time zone | ||
| 1134 | * relative to UTC that is appropriate for the time represented by | ||
| 1135 | * this <code>Date</code> object. | ||
| 1136 | * <p> | ||
| 1137 | * For example, in Massachusetts, five time zones west of Greenwich: | ||
| 1138 | * <blockquote><pre> | ||
| 1139 | * new Date(96, 1, 14).getTimezoneOffset() returns 300</pre></blockquote> | ||
| 1140 | * because on February 14, 1996, standard time (Eastern Standard Time) | ||
| 1141 | * is in use, which is offset five hours from UTC; but: | ||
| 1142 | * <blockquote><pre> | ||
| 1143 | * new Date(96, 5, 1).getTimezoneOffset() returns 240</pre></blockquote> | ||
| 1144 | * because on June 1, 1996, daylight saving time (Eastern Daylight Time) | ||
| 1145 | * is in use, which is offset only four hours from UTC.<p> | ||
| 1146 | * This method produces the same result as if it computed: | ||
| 1147 | * <blockquote><pre> | ||
| 1148 | * (this.getTime() - UTC(this.getYear(), | ||
| 1149 | * this.getMonth(), | ||
| 1150 | * this.getDate(), | ||
| 1151 | * this.getHours(), | ||
| 1152 | * this.getMinutes(), | ||
| 1153 | * this.getSeconds())) / (60 * 1000) | ||
| 1154 | * </pre></blockquote> | ||
| 1155 | * | ||
| 1156 | * @return the time-zone offset, in minutes, for the current time zone. | ||
| 1157 | * @see java.util.Calendar#ZONE_OFFSET | ||
| 1158 | * @see java.util.Calendar#DST_OFFSET | ||
| 1159 | * @see java.util.TimeZone#getDefault | ||
| 1160 | * @deprecated As of JDK version 1.1, | ||
| 1161 | * replaced by <code>-(Calendar.get(Calendar.ZONE_OFFSET) + | ||
| 1162 | * Calendar.get(Calendar.DST_OFFSET)) / (60 * 1000)</code>. | ||
| 1163 | */ | ||
| 1164 | @Deprecated | ||
| 1165 | public int getTimezoneOffset() { | ||
| 1166 | int zoneOffset; | ||
| 1167 | if (cdate == null) { | ||
| 1168 | TimeZone tz = TimeZone.getDefaultRef(); | ||
| 1169 | if (tz instanceof ZoneInfo) { | ||
| 1170 | zoneOffset = ((ZoneInfo)tz).getOffsets(fastTime, null); | ||
| 1171 | } else { | ||
| 1172 | zoneOffset = tz.getOffset(fastTime); | ||
| 1173 | } | ||
| 1174 | } else { | ||
| 1175 | normalize(); | ||
| 1176 | zoneOffset = cdate.getZoneOffset(); | ||
| 1177 | } | ||
| 1178 | return -zoneOffset/60000; // convert to minutes | ||
| 1179 | } | ||
| 1180 | |||
| 1181 | private final BaseCalendar.Date getCalendarDate() { | ||
| 1182 | if (cdate == null) { | ||
| 1183 | BaseCalendar cal = getCalendarSystem(fastTime); | ||
| 1184 | cdate = (BaseCalendar.Date) cal.getCalendarDate(fastTime, | ||
| 1185 | TimeZone.getDefaultRef()); | ||
| 1186 | } | ||
| 1187 | return cdate; | ||
| 1188 | } | ||
| 1189 | |||
| 1190 | private final BaseCalendar.Date normalize() { | ||
| 1191 | if (cdate == null) { | ||
| 1192 | BaseCalendar cal = getCalendarSystem(fastTime); | ||
| 1193 | cdate = (BaseCalendar.Date) cal.getCalendarDate(fastTime, | ||
| 1194 | TimeZone.getDefaultRef()); | ||
| 1195 | return cdate; | ||
| 1196 | } | ||
| 1197 | |||
| 1198 | // Normalize cdate with the TimeZone in cdate first. This is | ||
| 1199 | // required for the compatible behavior. | ||
| 1200 | if (!cdate.isNormalized()) { | ||
| 1201 | cdate = normalize(cdate); | ||
| 1202 | } | ||
| 1203 | |||
| 1204 | // If the default TimeZone has changed, then recalculate the | ||
| 1205 | // fields with the new TimeZone. | ||
| 1206 | TimeZone tz = TimeZone.getDefaultRef(); | ||
| 1207 | if (tz != cdate.getZone()) { | ||
| 1208 | cdate.setZone(tz); | ||
| 1209 | CalendarSystem cal = getCalendarSystem(cdate); | ||
| 1210 | cal.getCalendarDate(fastTime, cdate); | ||
| 1211 | } | ||
| 1212 | return cdate; | ||
| 1213 | } | ||
| 1214 | |||
| 1215 | // fastTime and the returned data are in sync upon return. | ||
| 1216 | private final BaseCalendar.Date normalize(BaseCalendar.Date date) { | ||
| 1217 | int y = date.getNormalizedYear(); | ||
| 1218 | int m = date.getMonth(); | ||
| 1219 | int d = date.getDayOfMonth(); | ||
| 1220 | int hh = date.getHours(); | ||
| 1221 | int mm = date.getMinutes(); | ||
| 1222 | int ss = date.getSeconds(); | ||
| 1223 | int ms = date.getMillis(); | ||
| 1224 | TimeZone tz = date.getZone(); | ||
| 1225 | |||
| 1226 | // If the specified year can't be handled using a long value | ||
| 1227 | // in milliseconds, GregorianCalendar is used for full | ||
| 1228 | // compatibility with underflow and overflow. This is required | ||
| 1229 | // by some JCK tests. The limits are based max year values - | ||
| 1230 | // years that can be represented by max values of d, hh, mm, | ||
| 1231 | // ss and ms. Also, let GregorianCalendar handle the default | ||
| 1232 | // cutover year so that we don't need to worry about the | ||
| 1233 | // transition here. | ||
| 1234 | if (y == 1582 || y > 280000000 || y < -280000000) { | ||
| 1235 | if (tz == null) { | ||
| 1236 | tz = TimeZone.getTimeZone("GMT"); | ||
| 1237 | } | ||
| 1238 | GregorianCalendar gc = new GregorianCalendar(tz); | ||
| 1239 | gc.clear(); | ||
| 1240 | gc.set(gc.MILLISECOND, ms); | ||
| 1241 | gc.set(y, m-1, d, hh, mm, ss); | ||
| 1242 | fastTime = gc.getTimeInMillis(); | ||
| 1243 | BaseCalendar cal = getCalendarSystem(fastTime); | ||
| 1244 | date = (BaseCalendar.Date) cal.getCalendarDate(fastTime, tz); | ||
| 1245 | return date; | ||
| 1246 | } | ||
| 1247 | |||
| 1248 | BaseCalendar cal = getCalendarSystem(y); | ||
| 1249 | if (cal != getCalendarSystem(date)) { | ||
| 1250 | date = (BaseCalendar.Date) cal.newCalendarDate(tz); | ||
| 1251 | date.setNormalizedDate(y, m, d).setTimeOfDay(hh, mm, ss, ms); | ||
| 1252 | } | ||
| 1253 | // Perform the GregorianCalendar-style normalization. | ||
| 1254 | fastTime = cal.getTime(date); | ||
| 1255 | |||
| 1256 | // In case the normalized date requires the other calendar | ||
| 1257 | // system, we need to recalculate it using the other one. | ||
| 1258 | BaseCalendar ncal = getCalendarSystem(fastTime); | ||
| 1259 | if (ncal != cal) { | ||
| 1260 | date = (BaseCalendar.Date) ncal.newCalendarDate(tz); | ||
| 1261 | date.setNormalizedDate(y, m, d).setTimeOfDay(hh, mm, ss, ms); | ||
| 1262 | fastTime = ncal.getTime(date); | ||
| 1263 | } | ||
| 1264 | return date; | ||
| 1265 | } | ||
| 1266 | |||
| 1267 | /** | ||
| 1268 | * Returns the Gregorian or Julian calendar system to use with the | ||
| 1269 | * given date. Use Gregorian from October 15, 1582. | ||
| 1270 | * | ||
| 1271 | * @param year normalized calendar year (not -1900) | ||
| 1272 | * @return the CalendarSystem to use for the specified date | ||
| 1273 | */ | ||
| 1274 | private static final BaseCalendar getCalendarSystem(int year) { | ||
| 1275 | if (year >= 1582) { | ||
| 1276 | return gcal; | ||
| 1277 | } | ||
| 1278 | return getJulianCalendar(); | ||
| 1279 | } | ||
| 1280 | |||
| 1281 | private static final BaseCalendar getCalendarSystem(long utc) { | ||
| 1282 | // Quickly check if the time stamp given by `utc' is the Epoch | ||
| 1283 | // or later. If it's before 1970, we convert the cutover to | ||
| 1284 | // local time to compare. | ||
| 1285 | if (utc >= 0 | ||
| 1286 | || utc >= GregorianCalendar.DEFAULT_GREGORIAN_CUTOVER | ||
| 1287 | - TimeZone.getDefaultRef().getOffset(utc)) { | ||
| 1288 | return gcal; | ||
| 1289 | } | ||
| 1290 | return getJulianCalendar(); | ||
| 1291 | } | ||
| 1292 | |||
| 1293 | private static final BaseCalendar getCalendarSystem(BaseCalendar.Date cdate) { | ||
| 1294 | if (jcal == null) { | ||
| 1295 | return gcal; | ||
| 1296 | } | ||
| 1297 | if (cdate.getEra() != null) { | ||
| 1298 | return jcal; | ||
| 1299 | } | ||
| 1300 | return gcal; | ||
| 1301 | } | ||
| 1302 | |||
| 1303 | synchronized private static final BaseCalendar getJulianCalendar() { | ||
| 1304 | if (jcal == null) { | ||
| 1305 | jcal = (BaseCalendar) CalendarSystem.forName("julian"); | ||
| 1306 | } | ||
| 1307 | return jcal; | ||
| 1308 | } | ||
| 1309 | |||
| 1310 | /** | ||
| 1311 | * Save the state of this object to a stream (i.e., serialize it). | ||
| 1312 | * | ||
| 1313 | * @serialData The value returned by <code>getTime()</code> | ||
| 1314 | * is emitted (long). This represents the offset from | ||
| 1315 | * January 1, 1970, 00:00:00 GMT in milliseconds. | ||
| 1316 | */ | ||
| 1317 | private void writeObject(ObjectOutputStream s) | ||
| 1318 | throws IOException | ||
| 1319 | { | ||
| 1320 | s.writeLong(getTimeImpl()); | ||
| 1321 | } | ||
| 1322 | |||
| 1323 | /** | ||
| 1324 | * Reconstitute this object from a stream (i.e., deserialize it). | ||
| 1325 | */ | ||
| 1326 | private void readObject(ObjectInputStream s) | ||
| 1327 | throws IOException, ClassNotFoundException | ||
| 1328 | { | ||
| 1329 | fastTime = s.readLong(); | ||
| 1330 | } | ||
| 1331 | } | ||