diff options
Diffstat (limited to 'libjava/classpath/java/sql/Timestamp.java')
| -rw-r--r-- | libjava/classpath/java/sql/Timestamp.java | 315 |
1 files changed, 315 insertions, 0 deletions
diff --git a/libjava/classpath/java/sql/Timestamp.java b/libjava/classpath/java/sql/Timestamp.java new file mode 100644 index 0000000..f3459b2 --- /dev/null +++ b/libjava/classpath/java/sql/Timestamp.java @@ -0,0 +1,315 @@ +/* Time.java -- Wrapper around java.util.Date + Copyright (C) 1999, 2000, 2003, 2004 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.sql; + +import java.text.DecimalFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; + +/** + * This class is a wrapper around java.util.Date to allow the JDBC + * driver to identify the value as a SQL Timestamp. Note that this + * class also adds an additional field for nano-seconds, and so + * is not completely identical to <code>java.util.Date</code> as + * the <code>java.sql.Date</code> and <code>java.sql.Time</code> + * classes are. + * + * @author Aaron M. Renn (arenn@urbanophile.com) + */ +public class Timestamp extends java.util.Date +{ + static final long serialVersionUID = 2745179027874758501L; + + /** + * Used for parsing and formatting this date. + */ + private static SimpleDateFormat dateFormat = + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + private static DecimalFormat decimalFormat = new DecimalFormat("000000000"); + private static StringBuffer sbuf = new StringBuffer(29); + + /** + * The nanosecond value for this object + */ + private int nanos; + + /** + * This method returns a new instance of this class by parsing a + * date in JDBC format into a Java date. + * + * @param str The string to parse. + * @return The resulting <code>java.sql.Timestamp</code> value. + */ + public static Timestamp valueOf(String str) + { + int nanos = 0; + int dot = str.indexOf('.'); + if (dot != -1) + { + if (str.lastIndexOf('.') != dot) + throw new IllegalArgumentException(str); + + int len = str.length() - dot - 1; + if (len < 1 || len > 9) + throw new IllegalArgumentException(str); + + nanos = Integer.parseInt(str.substring(dot + 1)); + for (int i = len; i < 9; i++) + nanos *= 10; + + str = str.substring(0, dot); + + } + + try + { + java.util.Date d; + synchronized (dateFormat) + { + d = (java.util.Date) dateFormat.parseObject(str); + } + + if (d == null) + throw new IllegalArgumentException(str); + + Timestamp ts = new Timestamp(d.getTime() + nanos / 1000000); + ts.nanos = nanos; + return ts; + } + catch (ParseException e) + { + throw new IllegalArgumentException(str); + } + } + + /** + * This method initializes a new instance of this class with the + * specified year, month, and day. + * + * @param year The year for this Timestamp (year - 1900) + * @param month The month for this Timestamp (0-11) + * @param day The day for this Timestamp (1-31) + * @param hour The hour for this Timestamp (0-23) + * @param minute The minute for this Timestamp (0-59) + * @param second The second for this Timestamp (0-59) + * @param nanos The nanosecond value for this Timestamp (0 to 999,999,9999) + * @deprecated + */ + public Timestamp(int year, int month, int day, int hour, int minute, + int second, int nanos) + { + super(year, month, day, hour, minute, second); + this.nanos = nanos; + } + + /** + * This method initializes a new instance of this class with the + * specified time value representing the number of milliseconds since + * Jan 1, 1970 at 12:00 midnight GMT. + * + * @param time The time value to intialize this <code>Time</code> to. + */ + public Timestamp(long date) + { + super(date - (date % 1000)); + nanos = (int) (date % 1000) * 1000000; + } + + /** + * Return the value of this Timestamp as the number of milliseconds + * since Jan 1, 1970 at 12:00 midnight GMT. + */ + public long getTime() + { + return super.getTime() + (nanos / 1000000); + } + + /** + * This method returns this date in JDBC format. + * + * @return This date as a string. + */ + public String toString() + { + synchronized (dateFormat) + { + sbuf.setLength(0); + dateFormat.format(this, sbuf, null); + sbuf.append('.'); + decimalFormat.format(nanos, sbuf, null); + int end = sbuf.length() - 1; + while (end > 20 && sbuf.charAt(end) == '0') + end--; + return sbuf.substring(0, end + 1); + } + } + + /** + * This method returns the nanosecond value for this object. + * @return The nanosecond value for this object. + */ + public int getNanos() + { + return nanos; + } + + /** + * This method sets the nanosecond value for this object. + * + * @param nanos The nanosecond value for this object. + */ + public void setNanos(int nanos) + { + this.nanos = nanos; + } + + /** + * This methods tests whether this object is earlier than the specified + * object. + * + * @param ts The other <code>Timestamp</code> to test against. + * @return <code>true</code> if this object is earlier than the other object, + * <code>false</code> otherwise. + */ + public boolean before(Timestamp ts) + { + long time1 = getTime(); + long time2 = ts.getTime(); + if (time1 < time2 || (time1 == time2 && getNanos() < ts.getNanos())) + return true; + return false; + } + + /** + * This methods tests whether this object is later than the specified + * object. + * + * @param ts The other <code>Timestamp</code> to test against. + * + * @return <code>true</code> if this object is later than the other object, + * <code>false</code> otherwise. + */ + public boolean after(Timestamp ts) + { + long time1 = getTime(); + long time2 = ts.getTime(); + if (time1 > time2 || (time1 == time2 && getNanos() > ts.getNanos())) + return true; + return false; + } + + /** + * This method these the specified <code>Object</code> for equality + * against this object. This will be true if an only if the specified + * object is an instance of <code>Timestamp</code> and has the same + * time value fields. + * + * @param obj The object to test against for equality. + * + * @return <code>true</code> if the specified object is equal to this + * object, <code>false</code> otherwise. + */ + public boolean equals(Object obj) + { + if (!(obj instanceof Timestamp)) + return false; + + return equals((Timestamp) obj); + } + + /** + * This method tests the specified timestamp for equality against this + * object. This will be true if and only if the specified object is + * not <code>null</code> and contains all the same time value fields + * as this object. + * + * @param ts The <code>Timestamp</code> to test against for equality. + * + * @return <code>true</code> if the specified object is equal to this + * object, <code>false</code> otherwise. + */ + public boolean equals(Timestamp ts) + { + if (ts == null) + return false; + + if (ts.getTime() != getTime()) + return false; + + if (ts.getNanos() != getNanos()) + return false; + + return true; + } + + /** + * Compare two Timestamp + * @param when the other Timestamp. + * @return 0, if the date represented + * by obj is exactly the same as the time represented by this + * object, a negative if this Timestamp is before the other Timestamp, and + * a positive value otherwise. + * @since 1.2 + */ + public int compareTo(Timestamp ts) + { + int s = super.compareTo((java.util.Date) ts); + if (s != 0) + return s; + // If Date components were equal, then we check the nanoseconds. + return nanos - ts.nanos; + } + + /** + * Compares this Timestamp to another. This behaves like + * <code>compareTo(Timestamp)</code>, but it may throw a + * <code>ClassCastException</code> + * @param obj the other Timestamp. + * @return 0, if the Timestamp represented + * by obj is exactly the same as the time represented by this + * object, a negative if this Timestamp is before the other Timestamp, and + * a positive value otherwise. + * @exception ClassCastException if obj is not of type Timestamp. + * @since 1.2 + */ + public int compareTo(Object obj) + { + return compareTo((Timestamp) obj); + } +} |