libjava/java/sql/Timestamp.java

   1 /* Time.java -- Wrapper around java.util.Date
   2    Copyright (C) 1999, 2000 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.sql;
  40
  41 import java.text.SimpleDateFormat;
  42
  43 /**
  44  * This class is a wrapper around java.util.Date to allow the JDBC
  45  * driver to identify the value as a SQL Timestamp.  Note that this
  46  * class also adds an additional field for nano-seconds, and so
  47  * is not completely identical to <code>java.util.Date</code> as
  48  * the <code>java.sql.Date</code> and <code>java.sql.Time</code>
  49  * classes are.
  50  *
  51  * @author Aaron M. Renn (arenn@urbanophile.com)
  52  */
  53 public class Timestamp extends java.util.Date
  54 {
  55   static final long serialVersionUID = 3581463369166924961L;
  56
  57   /**
  58    * Used for parsing and formatting this date.
  59    */
  60   // Millisecond will have to be close enough for now.
  61   private static SimpleDateFormat parse_sdf =
  62     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSSS");
  63
  64   private static SimpleDateFormat format_sdf =
  65     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  66
  67   /**
  68     * The nanosecond value for this object
  69     */
  70   private int nanos;
  71
  72   /**
  73    * This method returns a new instance of this class by parsing a
  74    * date in JDBC format into a Java date.
  75    *
  76    * @param str The string to parse.
  77    * @return The resulting <code>java.sql.Timestamp</code> value.
  78    */
  79   public static Timestamp valueOf(String str)
  80   {
  81     try
  82       {
  83         Date d = (Date) parse_sdf.parseObject(str);
  84         return new Timestamp(d.getTime());
  85       }
  86     catch (Exception e)
  87       {
  88         return null;
  89       }
  90   }
  91
  92   /**
  93    * This method initializes a new instance of this class with the
  94    * specified year, month, and day.
  95    *
  96    * @param year The year for this Timestamp (year - 1900)
  97    * @param month The month for this Timestamp (0-11)
  98    * @param day The day for this Timestamp (1-31)
  99    * @param hour The hour for this Timestamp (0-23)
 100    * @param minute The minute for this Timestamp (0-59)
 101    * @param second The second for this Timestamp (0-59)
 102    * @param nanos The nanosecond value for this Timestamp (0 to 999,999,9999)
 103    * @deprecated
 104    */
 105   public Timestamp(int year, int month, int day, int hour, int minute,
 106     int second, int nanos)
 107   {
 108     super(year, month, day, hour, minute, second);
 109     this.nanos = nanos;
 110   }
 111
 112   /**
 113    * This method initializes a new instance of this class with the
 114    * specified time value representing the number of seconds since
 115    * Jan 1, 1970 at 12:00 midnight GMT.
 116    *
 117    * @param time The time value to intialize this <code>Time</code> to.
 118    */
 119   public Timestamp(long date)
 120   {
 121     super(date);
 122   }
 123
 124   /**
 125    * This method returns this date in JDBC format.
 126    *
 127    * @return This date as a string.
 128    */
 129   public String toString()
 130   {
 131     return format_sdf.format(this) + "." + getNanos();
 132   }
 133
 134   /**
 135     * This method returns the nanosecond value for this object.
 136     * @return The nanosecond value for this object.
 137     */
 138   public int getNanos()
 139   {
 140     return nanos;
 141   }
 142
 143   /**
 144    * This method sets the nanosecond value for this object.
 145    *
 146    * @param nanos The nanosecond value for this object.
 147    */
 148   public void setNanos(int nanos)
 149   {
 150     this.nanos = nanos;
 151   }
 152
 153   /**
 154    * This methods tests whether this object is earlier than the specified
 155    * object.
 156    *
 157    * @param ts The other <code>Timestamp</code> to test against.
 158    * @return <code>true</code> if this object is earlier than the other object,
 159    *         <code>false</code> otherwise.
 160    */
 161   public boolean before(Timestamp ts)
 162   {
 163     if (ts.getTime() > getTime())
 164       return true;
 165
 166     if (ts.getNanos() > getNanos())
 167       return true;
 168
 169     return false;
 170   }
 171
 172   /**
 173    * This methods tests whether this object is later than the specified
 174    * object.
 175    *
 176    * @param ts The other <code>Timestamp</code> to test against.
 177    *
 178    * @return <code>true</code> if this object is later than the other object,
 179    * <code>false</code> otherwise.
 180    */
 181   public boolean after(Timestamp ts)
 182   {
 183     if (ts.getTime() < getTime())
 184       return true;
 185
 186     if (ts.getNanos() < getNanos())
 187       return true;
 188
 189     return false;
 190   }
 191
 192   /**
 193    * This method these the specified <code>Object</code> for equality
 194    * against this object.  This will be true if an only if the specified
 195    * object is an instance of <code>Timestamp</code> and has the same
 196    * time value fields.
 197    *
 198    * @param obj The object to test against for equality.
 199    *
 200    * @return <code>true</code> if the specified object is equal to this
 201    * object, <code>false</code> otherwise.
 202    */
 203   public boolean equals(Object obj)
 204   {
 205     if (obj == null)
 206       return false;
 207
 208     if (!(obj instanceof Timestamp))
 209       return false;
 210
 211     return equals((Timestamp) obj);
 212   }
 213
 214   /**
 215    * This method tests the specified timestamp for equality against this
 216    * object.  This will be true if and only if the specified object is
 217    * not <code>null</code> and contains all the same time value fields
 218    * as this object.
 219    *
 220    * @param ts The <code>Timestamp</code> to test against for equality.
 221    *
 222    * @return <code>true</code> if the specified object is equal to this
 223    * object, <code>false</code> otherwise.
 224    */
 225   public boolean equals(Timestamp ts)
 226   {
 227     if (ts == null)
 228       return false;
 229
 230     if (ts.getTime() != getTime())
 231       return false;
 232
 233     if (ts.getNanos() != getNanos())
 234       return false;
 235
 236     return true;
 237   }
 238
 239   /**
 240    * @since 1.2
 241    */
 242    /*
 243   public int compareTo(Timestamp ts)
 244   {
 245
 246   }*/
 247
 248   /**
 249    * @since 1.2
 250    *//*
 251   public int compareTo(Object obj)
 252   {
 253     return compareTo((Timestamp) obj);
 254   }*/
 255 }