harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r413642 [10/12] - in /incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java: java/sql/ javax/sql/ javax/transaction/ javax/transaction/xa/ org/apache/harmony/sql/internal/common/
Date Mon, 12 Jun 2006 12:13:44 GMT
Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Timestamp.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Timestamp.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Timestamp.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Timestamp.java Mon Jun 12 05:13:42 2006
@@ -13,342 +13,430 @@
  * limitations under the License.
  */
 
-
 package java.sql;
 
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.io.Serializable;
-import java.lang.IllegalArgumentException;
 import java.text.DecimalFormat;
 import java.text.ParsePosition;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 
 /**
- * A Java representation of the SQL TIMESTAMP type.  It provides the capability to represent
- * the SQL TIMESTAMP nanosecond value, in addition to the regular date/time value which has
- * millisecond resolution.
+ * A Java representation of the SQL TIMESTAMP type. It provides the capability
+ * to represent the SQL TIMESTAMP nanosecond value, in addition to the regular
+ * date/time value which has millisecond resolution.
  * <p>
- * The Timestamp class consists of a regular Date/Time value, where only the integral seconds
- * value is stored, plus a nanoseconds value where the fractional seconds are stored.
+ * The Timestamp class consists of a regular Date/Time value, where only the
+ * integral seconds value is stored, plus a nanoseconds value where the
+ * fractional seconds are stored.
  * <p>
- * The addition of the nanosecond value field to the Timestamp object makes it significantly
- * different from the java.util.Date object which it extends.  Users should be cautious in 
- * their use of Timestamp objects and should not assume that they are interchangeable with
- * java.util.Date objects when used outside the confines of the java.sql package.  
+ * The addition of the nanosecond value field to the Timestamp object makes it
+ * significantly different from the java.util.Date object which it extends.
+ * Users should be cautious in their use of Timestamp objects and should not
+ * assume that they are interchangeable with java.util.Date objects when used
+ * outside the confines of the java.sql package.
  * 
  */
 public class Timestamp extends Date {
-	
-	private static final long serialVersionUID = 2745179027874758501L;
-	
-	// The nanoseconds time value of the Timestamp
-	private int nanoseconds;
-
-	/**
-	 * @deprecated Please use the constructor Timestamp( long )
-	 * Returns a Timestamp corresponding to the time specified by the supplied values for Year, Month,
-	 * Date, Hour, Minutes, Seconds and Nanoseconds 
-	 * @param theYear specified as the year minus 1900
-	 * @param theMonth specified as an integer in the range 0 - 11
-	 * @param theDate specified as an integer in the range 1 - 31
-	 * @param theHour specified as an integer in the range 0 - 23
-	 * @param theMinute specified as an integer in the range 0 - 59
-	 * @param theSecond specified as an integer in the range 0 - 59
-	 * @param theNano which defines the nanosecond value of the timestamp specified as an integer
-	 * in the range 0 - 999,999,999
-	 * @throws IllegalArgumentException if any of the parameters is out of range
-	 */
-	public Timestamp( int theYear, int theMonth, int theDate, int theHour, 
-					  int theMinute, int theSecond, int theNano ) 
-					  throws IllegalArgumentException {
- 		super( theYear, theMonth, theDate, theHour, theMinute, theSecond );
- 		if( theNano < 0 || theNano > 999999999 ) throw new IllegalArgumentException();		
-		nanoseconds = theNano;
-	} // end method Timestamp( int, int, int, int, int, int )
-	
-	/**
-	 * Returns a Timestamp object corresponding to the time represented by a supplied time value.
-	 * 
-	 * @param theTime a time value in the format of milliseconds since the Epoch 
-	 * (January 1 1970 00:00:00.000 GMT)
-	 */
-	public Timestamp(long theTime) {
-		super( theTime );
-		// Now set the time for this Timestamp object - which deals with the nanosecond value
-		// as well as the base time
-		this.setTime( theTime );
-		// System.out.println("Clear version of java.sql.Timestamp");
-	} // end method Timestamp( long )
-	
-	/**
-	 * Returns true if this timestamp object is later than the supplied timestamp,
-	 * otherwise returns false.
-	 * @param theTimestamp the timestamp to compare with this timestamp object
-	 * @return true if this timestamp object is later than the supplied timestamp, false
-	 * otherwise
-	 */
-	public boolean after( Timestamp theTimestamp ) {
-		long thisTime = this.getTime();
-		long compareTime = theTimestamp.getTime();
-		
-		// If the time value is later, the timestamp is later
-		if ( thisTime > compareTime ) { return true; }
-		// If the time value is earlier, the timestamp is not later
-		else if ( thisTime < compareTime ) { return false; }
-		// Otherwise the time values are equal in which case the nanoseconds value
-		// determines whether this timestamp is later...
-		else if ( this.getNanos() > theTimestamp.getNanos() ) { return true; }
-		else { return false; } // end if
-		
-	} // end method after( Timestamp )
-    
-	/**
-	 * Returns true if this timestamp object is earlier than the supplied timestamp,
-	 * otherwise returns false.
-	 * @param theTimestamp the timestamp to compare with this timestamp object
-	 * @return true if this timestamp object is earlier than the supplied timestamp, false
-	 * otherwise
-	 */
-	public boolean before( Timestamp theTimestamp ) {
-		long thisTime = this.getTime();
-		long compareTime = theTimestamp.getTime();
-		
-		// If the time value is later, the timestamp is later
-		if ( thisTime < compareTime ) { return true; }
-		// If the time value is earlier, the timestamp is not later
-		else if ( thisTime > compareTime ) { return false; }
-		// Otherwise the time values are equal in which case the nanoseconds value
-		// determines whether this timestamp is later...
-		else if ( this.getNanos() < theTimestamp.getNanos() ) { return true; }
-		else { return false; } // end if
-		
-	} // end method before( Timestamp )
-    
-	/**
-	 * Compares this Timestamp object with a supplied Timestamp object
-	 * @param theObject the timestamp to compare with this timestamp object, passed in as an Object
-	 * @return 0 if the two Timestamp objects are equal in time, a value <0 if this Timestamp object is
-	 * before the supplied Timestamp and a value >0 if this Timestamp object is after the supplied
-	 * Timestamp
-	 * @throws ClassCastException if the supplied object is not a Timestamp object
-	 */
-	public int compareTo( Date theObject ) throws ClassCastException {
-		return this.compareTo( (Timestamp) theObject );
-	} // end method compareTo( Object )
-    
-	/**
-	 * Compares this Timestamp object with a supplied Timestamp object
-	 * @param theTimestamp the timestamp to compare with this timestamp object, passed in as a Timestamp
-	 * @return 0 if the two Timestamp objects are equal in time, a value <0 if this Timestamp object is
-	 * before the supplied Timestamp and a value >0 if this Timestamp object is after the supplied
-	 * Timestamp
-	 */
-	public int compareTo( Timestamp theTimestamp ) {
-		if ( this.before( theTimestamp ) ) { return -1; }
-		else if ( this.after( theTimestamp ) ) { return +1; }
-		else return 0;
-	} // end method compareTo( Timestamp )
-	
-	/**
-	 * Tests to see if this timestamp is equal to a supplied object.
-	 * @param theObject 
-	 * @return true if this Timestamp object is equal to the supplied Timestamp object
-	 * false if the object is not a Timestamp object or if the object is a Timestamp but
-	 * represents a different instant in time
-	 */
+
+    private static final long serialVersionUID = 2745179027874758501L;
+
+    // The nanoseconds time value of the Timestamp
+    private int nanoseconds;
+
+    /**
+     * @deprecated Please use the constructor Timestamp( long ) Returns a
+     *             Timestamp corresponding to the time specified by the supplied
+     *             values for Year, Month, Date, Hour, Minutes, Seconds and
+     *             Nanoseconds
+     * @param theYear
+     *            specified as the year minus 1900
+     * @param theMonth
+     *            specified as an integer in the range 0 - 11
+     * @param theDate
+     *            specified as an integer in the range 1 - 31
+     * @param theHour
+     *            specified as an integer in the range 0 - 23
+     * @param theMinute
+     *            specified as an integer in the range 0 - 59
+     * @param theSecond
+     *            specified as an integer in the range 0 - 59
+     * @param theNano
+     *            which defines the nanosecond value of the timestamp specified
+     *            as an integer in the range 0 - 999,999,999
+     * @throws IllegalArgumentException
+     *             if any of the parameters is out of range
+     */
+    public Timestamp(int theYear, int theMonth, int theDate, int theHour,
+            int theMinute, int theSecond, int theNano)
+            throws IllegalArgumentException {
+        super(theYear, theMonth, theDate, theHour, theMinute, theSecond);
+        if (theNano < 0 || theNano > 999999999) {
+            throw new IllegalArgumentException();
+        }
+        nanoseconds = theNano;
+    }
+
+    /**
+     * Returns a Timestamp object corresponding to the time represented by a
+     * supplied time value.
+     * 
+     * @param theTime
+     *            a time value in the format of milliseconds since the Epoch
+     *            (January 1 1970 00:00:00.000 GMT)
+     */
+    public Timestamp(long theTime) {
+        super(theTime);
+        /*
+         * Now set the time for this Timestamp object - which deals with the
+         * nanosecond value as well as the base time
+         */
+        this.setTime(theTime);
+    }
+
+    /**
+     * Returns true if this timestamp object is later than the supplied
+     * timestamp, otherwise returns false.
+     * 
+     * @param theTimestamp
+     *            the timestamp to compare with this timestamp object
+     * @return true if this timestamp object is later than the supplied
+     *         timestamp, false otherwise
+     */
+    public boolean after(Timestamp theTimestamp) {
+        long thisTime = this.getTime();
+        long compareTime = theTimestamp.getTime();
+
+        // If the time value is later, the timestamp is later
+        if (thisTime > compareTime) {
+            return true;
+        }
+        // If the time value is earlier, the timestamp is not later
+        else if (thisTime < compareTime) {
+            return false;
+        }
+        /*
+         * Otherwise the time values are equal in which case the nanoseconds
+         * value determines whether this timestamp is later...
+         */
+        else if (this.getNanos() > theTimestamp.getNanos()) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Returns true if this timestamp object is earlier than the supplied
+     * timestamp, otherwise returns false.
+     * 
+     * @param theTimestamp
+     *            the timestamp to compare with this timestamp object
+     * @return true if this timestamp object is earlier than the supplied
+     *         timestamp, false otherwise
+     */
+    public boolean before(Timestamp theTimestamp) {
+        long thisTime = this.getTime();
+        long compareTime = theTimestamp.getTime();
+
+        // If the time value is later, the timestamp is later
+        if (thisTime < compareTime) {
+            return true;
+        }
+        // If the time value is earlier, the timestamp is not later
+        else if (thisTime > compareTime) {
+            return false;
+        }
+        /*
+         * Otherwise the time values are equal in which case the nanoseconds
+         * value determines whether this timestamp is later...
+         */
+        else if (this.getNanos() < theTimestamp.getNanos()) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Compares this Timestamp object with a supplied Timestamp object
+     * 
+     * @param theObject
+     *            the timestamp to compare with this timestamp object, passed in
+     *            as an Object
+     * @return 0 if the two Timestamp objects are equal in time, a value <0 if
+     *         this Timestamp object is before the supplied Timestamp and a
+     *         value >0 if this Timestamp object is after the supplied Timestamp
+     * @throws ClassCastException
+     *             if the supplied object is not a Timestamp object
+     */
+    public int compareTo(Date theObject) throws ClassCastException {
+        return this.compareTo((Timestamp) theObject);
+    }
+
+    /**
+     * Compares this Timestamp object with a supplied Timestamp object
+     * 
+     * @param theTimestamp
+     *            the timestamp to compare with this timestamp object, passed in
+     *            as a Timestamp
+     * @return 0 if the two Timestamp objects are equal in time, a value <0 if
+     *         this Timestamp object is before the supplied Timestamp and a
+     *         value >0 if this Timestamp object is after the supplied Timestamp
+     */
+    public int compareTo(Timestamp theTimestamp) {
+        if (this.before(theTimestamp)) {
+            return -1;
+        } else if (this.after(theTimestamp)) {
+            return +1;
+        } else {
+            return 0;
+        }
+    }
+
+    /**
+     * Tests to see if this timestamp is equal to a supplied object.
+     * 
+     * @param theObject
+     * @return true if this Timestamp object is equal to the supplied Timestamp
+     *         object false if the object is not a Timestamp object or if the
+     *         object is a Timestamp but represents a different instant in time
+     */
     public boolean equals(Object theObject) {
         if (theObject instanceof Timestamp) {
             return equals((Timestamp) theObject);
         }
         return false;
-    } // end method equals( Object )
-    
-	/**
-	 * Tests to see if this timestamp is equal to a supplied timestamp.
-	 * @param theTimestamp the timestamp to compare with this timestamp object, passed in as an Object
-	 * @return true if this Timestamp object is equal to the supplied Timestamp object
-	 */
-    public boolean equals( Timestamp theTimestamp ) {
+    }
+
+    /**
+     * Tests to see if this timestamp is equal to a supplied timestamp.
+     * 
+     * @param theTimestamp
+     *            the timestamp to compare with this timestamp object, passed in
+     *            as an Object
+     * @return true if this Timestamp object is equal to the supplied Timestamp
+     *         object
+     */
+    public boolean equals(Timestamp theTimestamp) {
         if (theTimestamp == null) {
             return false;
         }
-    	if( (this.getTime() == theTimestamp.getTime()) && (this.getNanos() == theTimestamp.getNanos()) ) {
-    		return true;
-    	} else {
-    		return false;
-    	}
-    } // end method equals( Timestamp )
-    
+        return (this.getTime() == theTimestamp.getTime())
+                && (this.getNanos() == theTimestamp.getNanos());
+    }
+
     /**
      * Gets this Timestamp's nanosecond value
-     * @return The timestamp's nanosecond value, an integer between 0 and 999,999,999
+     * 
+     * @return The timestamp's nanosecond value, an integer between 0 and
+     *         999,999,999
      */
     public int getNanos() {
-    	return nanoseconds;
-    } // end method getNanos()
-    
+        return nanoseconds;
+    }
+
     /**
-     * Returns the time represented by this Timestamp object, as a long value containing the number of
-     * milliseconds since the Epoch (January 1 1970, 00:00:00.000 GMT)
+     * Returns the time represented by this Timestamp object, as a long value
+     * containing the number of milliseconds since the Epoch (January 1 1970,
+     * 00:00:00.000 GMT)
      */
     public long getTime() {
-    	long theTime = super.getTime();
-    	theTime = theTime + (long)(nanoseconds / 1000000 );
-    	return theTime;
-    } // end method getTime()
-    
+        long theTime = super.getTime();
+        theTime = theTime + (nanoseconds / 1000000);
+        return theTime;
+    }
+
     /**
      * Sets the nanosecond value for this timestamp
      */
     public void setNanos(int n) throws IllegalArgumentException {
-    	if ( (n < 0) || (n > 999999999 ) ) throw new IllegalArgumentException("Nanos value out of range.");
-    	nanoseconds = n;
-    } // end method setNanos( int )
-    
+        if ((n < 0) || (n > 999999999)) {
+            throw new IllegalArgumentException("Nanos value out of range.");
+        }
+        nanoseconds = n;
+    }
+
     /**
-     * Sets the time represented by this Timestamp object to the supplied time, defined as the number
-     * of milliseconds since the Epoch (January 1 1970, 00:00:00.000 GMT)
+     * Sets the time represented by this Timestamp object to the supplied time,
+     * defined as the number of milliseconds since the Epoch (January 1 1970,
+     * 00:00:00.000 GMT)
      */
     public void setTime(long theTime) {
-		// Deal with the nanoseconds value.  The supplied time is in milliseconds - so we must
-		// extract the milliseconds value and multiply by 1000000 to get nanoseconds.
-		// Things are more complex if theTime value is negative, since then the time
-		// value is the time before the Epoch but the nanoseconds value of the Timestamp must
-		// be positive - so we must take the "raw" milliseconds value and subtract it from
-		// 1000 to get to the true nanoseconds value
-		// Simultaneously, recalculate the time value to the exact nearest second and reset 
-		// the Date time value
-		int milliseconds = (int)(theTime % 1000);
-		theTime = theTime - milliseconds;
-		if ( milliseconds < 0 ) {
-			theTime = theTime - 1000;
-			milliseconds = 1000 + milliseconds;	
-		} // end if
-		super.setTime( theTime );
-		setNanos( milliseconds * 1000000 );
-    } // end method setTime( long )
-    
-    /**
-     * Returns the timestamp formatted as a String in the JDBC Timestamp Escape format, which is of the
-     * form "yyyy-mm-dd hh:mm:ss.nnnnnnnnn"
-     * @return A string representing the instant defined by the Timestamp, in JDBC Timestamp 
-     * escape format
+        /*
+         * Deal with the nanoseconds value. The supplied time is in milliseconds -
+         * so we must extract the milliseconds value and multiply by 1000000 to
+         * get nanoseconds. Things are more complex if theTime value is
+         * negative, since then the time value is the time before the Epoch but
+         * the nanoseconds value of the Timestamp must be positive - so we must
+         * take the "raw" milliseconds value and subtract it from 1000 to get to
+         * the true nanoseconds value Simultaneously, recalculate the time value
+         * to the exact nearest second and reset the Date time value
+         */
+        int milliseconds = (int) (theTime % 1000);
+        theTime = theTime - milliseconds;
+        if (milliseconds < 0) {
+            theTime = theTime - 1000;
+            milliseconds = 1000 + milliseconds;
+        }
+        super.setTime(theTime);
+        setNanos(milliseconds * 1000000);
+    }
+
+    /**
+     * Returns the timestamp formatted as a String in the JDBC Timestamp Escape
+     * format, which is of the form "yyyy-mm-dd hh:mm:ss.nnnnnnnnn"
+     * 
+     * @return A string representing the instant defined by the Timestamp, in
+     *         JDBC Timestamp escape format
      */
     public String toString() {
-    	// A SimpleDateFormat will lay out everything except the nanosecond value
-		SimpleDateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
-		
-		// Use a DecimalFormat to lay out the nanosecond value as a simple string of
-		// 9 integers, with leading Zeros
-		DecimalFormat decimalFormat = new DecimalFormat("0");
-		decimalFormat.setMinimumIntegerDigits( 9 );
-		decimalFormat.setMaximumIntegerDigits( 9 );
-		String theNanos = decimalFormat.format( (long) nanoseconds ); 
-		theNanos = stripTrailingZeros( theNanos );
-		// Concatenate the nanosecond value with a dot - and return
-		return (dateFormat.format( this ) + '.' + theNanos);
-    } // end method toString()
-    
+        // A SimpleDateFormat will lay out everything except the nanosecond
+        // value
+        SimpleDateFormat dateFormat = new SimpleDateFormat(
+                "yyyy-MM-dd HH:mm:ss");
+
+        /*
+         * Use a DecimalFormat to lay out the nanosecond value as a simple
+         * string of 9 integers, with leading Zeros
+         */
+        DecimalFormat decimalFormat = new DecimalFormat("0");
+        decimalFormat.setMinimumIntegerDigits(9);
+        decimalFormat.setMaximumIntegerDigits(9);
+        String theNanos = decimalFormat.format(nanoseconds);
+        theNanos = stripTrailingZeros(theNanos);
+        // Concatenate the nanosecond value with a dot - and return
+        return (dateFormat.format(this) + '.' + theNanos);
+    }
+
     /*
-     * Private method to strip trailing '0' characters from a string.
-     * @param inputString the starting string
-     * @return a string with the trailing zeros stripped - will leave
-     * a single 0 at the beginning of the string 
-     */
-    private String stripTrailingZeros( String inputString ) {
-    	String finalString;
-    	
-    	int i;
-    	for( i = inputString.length(); i > 0 ; i-- ) {
-    		if( inputString.charAt(i-1) != '0' ) break;
-    		// If the string has a 0 as its first character, return
-    		// a string with a single '0'
-    		if ( i == 1 ) return "0";
-    	} // end for
-    	
-    	finalString = inputString.substring(0, i);
-    	return finalString;
-    } // end stripTrailingZeros( String )
-    
-    private static String	valueOfExceptionMessage = 
-    	"Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff";
-    /**
-     * Creates a Timestamp object with a time value equal to the time specified by a supplied String
-     * holding the time in JDBC timestamp escape format, which is of the form
-     * "yyyy-mm-dd hh:mm:ss.nnnnnnnnn"
-     * @param s the String containing a time in JDBC timestamp escape format
-     * @return A timestamp object with time value as defined by the supplied String
-     */
-    public static Timestamp valueOf( String s ) throws IllegalArgumentException {
-    	if( s == null ) throw new IllegalArgumentException("null string");
-    	
-    	SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-    	ParsePosition pp = new ParsePosition( 0 );
-    	
-    	// First parse out the yyyy-MM-dd HH:mm:ss component of the String into a Date object
-    	// using the SimpleDateFormat.  This should stop after the seconds value, according to
-    	// the definition of SimpleDateFormat.parse, with the ParsePosition indicating the
-    	// index of the "." which should precede the nanoseconds value
-    	Date theDate;
-    	try {
-    		theDate = df.parse( s, pp );
-    	} catch (Exception e) {
-    		throw new IllegalArgumentException(valueOfExceptionMessage);
-    	} // end try
-    	
-    	if( theDate == null ) throw new IllegalArgumentException(valueOfExceptionMessage);
-    	
-    	/* If we get here, the Date part of the string was OK - now for the nanoseconds
-    	 * value.  Strictly, this requires the remaining part of the String to look like
-    	 * ".nnnnnnnnn".  However, we accept anything with a '.' followed by 1 to 9
-    	 * digits - we also accept nothing (no fractions of a second).
-    	 * Anything else is interpreted as incorrect format which will
-    	 * generate an IllegalArgumentException
-    	 */
-    	int position = pp.getIndex();
-    	int remaining = s.length() - position;
-    	int theNanos;
-    	
-    	if( remaining == 0 ) {
-    	    // First, allow for the case where no fraction of a second is given:
-    	    theNanos = 0;
-    	} else {
-    	    // Case where fraction of a second is specified:
-	    	// Require 1 character plus the "." in the remaining part of the string...
-	    	if( (s.length() - position) < ".n".length() ) throw new IllegalArgumentException(valueOfExceptionMessage);
-	    	
-	    	// If we're strict, we should not allow any EXTRA characters after the 9 digits
-	    	if( (s.length() - position) > ".nnnnnnnnn".length() ) throw new IllegalArgumentException(valueOfExceptionMessage);
-	    	
-	    	// Require the next character to be a "."
-	    	if( s.charAt(position) != '.' ) throw new NumberFormatException("Bad input string format - '" + s.charAt(position) + "' instead of '.'");
-	    	// Get the length of the number string - need to account for the '.'
-	    	int nanoLength = s.length() - position - 1 ;
-	    	    	
-	    	// Get the 9 characters following the "." as an integer
-	    	String theNanoString = s.substring( position+1, position+1+nanoLength );
-	    	// We must adjust for the cases where the nanos String was not 9 characters long
-	    	// by padding out with zeros
-	    	theNanoString = theNanoString + "000000000";
-	    	theNanoString = theNanoString.substring(0, 9);
-	    	
-	    	try {
-	    		theNanos = Integer.parseInt( theNanoString );
-	    	} catch (Exception e) {
-	    		// If we get here, the string was not a number
-	    		throw new IllegalArgumentException(valueOfExceptionMessage);
-	    	} // end try
-    	} // end if
-    	
-    	if ( theNanos < 0 || theNanos > 999999999 ) throw new IllegalArgumentException(valueOfExceptionMessage);
-    	
-    	Timestamp theTimestamp = new Timestamp( theDate.getTime() );
-    	theTimestamp.setNanos( theNanos );
-    	
-    	return theTimestamp;
-    } // end method valueOf( String )
-    
-	
-}
+     * Private method to strip trailing '0' characters from a string. @param
+     * inputString the starting string @return a string with the trailing zeros
+     * stripped - will leave a single 0 at the beginning of the string
+     */
+    private String stripTrailingZeros(String inputString) {
+        String finalString;
+
+        int i;
+        for (i = inputString.length(); i > 0; i--) {
+            if (inputString.charAt(i - 1) != '0') {
+                break;
+            }
+            /*
+             * If the string has a 0 as its first character, return a string
+             * with a single '0'
+             */
+            if (i == 1) {
+                return "0";
+            }
+        }
+
+        finalString = inputString.substring(0, i);
+        return finalString;
+    }
 
+    private static String valueOfExceptionMessage = "Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff";
 
+    /**
+     * Creates a Timestamp object with a time value equal to the time specified
+     * by a supplied String holding the time in JDBC timestamp escape format,
+     * which is of the form "yyyy-mm-dd hh:mm:ss.nnnnnnnnn"
+     * 
+     * @param s
+     *            the String containing a time in JDBC timestamp escape format
+     * @return A timestamp object with time value as defined by the supplied
+     *         String
+     */
+    public static Timestamp valueOf(String s) throws IllegalArgumentException {
+        if (s == null) {
+            throw new IllegalArgumentException("null string");
+        }
+
+        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        ParsePosition pp = new ParsePosition(0);
+
+        /*
+         * First parse out the yyyy-MM-dd HH:mm:ss component of the String into
+         * a Date object using the SimpleDateFormat. This should stop after the
+         * seconds value, according to the definition of SimpleDateFormat.parse,
+         * with the ParsePosition indicating the index of the "." which should
+         * precede the nanoseconds value
+         */
+        Date theDate;
+        try {
+            theDate = df.parse(s, pp);
+        } catch (Exception e) {
+            throw new IllegalArgumentException(valueOfExceptionMessage);
+        }
+
+        if (theDate == null) {
+            throw new IllegalArgumentException(valueOfExceptionMessage);
+        }
+
+        /*
+         * If we get here, the Date part of the string was OK - now for the
+         * nanoseconds value. Strictly, this requires the remaining part of the
+         * String to look like ".nnnnnnnnn". However, we accept anything with a
+         * '.' followed by 1 to 9 digits - we also accept nothing (no fractions
+         * of a second). Anything else is interpreted as incorrect format which
+         * will generate an IllegalArgumentException
+         */
+        int position = pp.getIndex();
+        int remaining = s.length() - position;
+        int theNanos;
+
+        if (remaining == 0) {
+            // First, allow for the case where no fraction of a second is given:
+            theNanos = 0;
+        } else {
+            /*
+             * Case where fraction of a second is specified: Require 1 character
+             * plus the "." in the remaining part of the string...
+             */
+            if ((s.length() - position) < ".n".length()) {
+                throw new IllegalArgumentException(valueOfExceptionMessage);
+            }
+
+            /*
+             * If we're strict, we should not allow any EXTRA characters after
+             * the 9 digits
+             */
+            if ((s.length() - position) > ".nnnnnnnnn".length()) {
+                throw new IllegalArgumentException(valueOfExceptionMessage);
+            }
+
+            // Require the next character to be a "."
+            if (s.charAt(position) != '.') {
+                throw new NumberFormatException("Bad input string format - '"
+                        + s.charAt(position) + "' instead of '.'");
+            }
+            // Get the length of the number string - need to account for the '.'
+            int nanoLength = s.length() - position - 1;
+
+            // Get the 9 characters following the "." as an integer
+            String theNanoString = s.substring(position + 1, position + 1
+                    + nanoLength);
+            /*
+             * We must adjust for the cases where the nanos String was not 9
+             * characters long by padding out with zeros
+             */
+            theNanoString = theNanoString + "000000000";
+            theNanoString = theNanoString.substring(0, 9);
+
+            try {
+                theNanos = Integer.parseInt(theNanoString);
+            } catch (Exception e) {
+                // If we get here, the string was not a number
+                throw new IllegalArgumentException(valueOfExceptionMessage);
+            }
+        }
+
+        if (theNanos < 0 || theNanos > 999999999) {
+            throw new IllegalArgumentException(valueOfExceptionMessage);
+        }
+
+        Timestamp theTimestamp = new Timestamp(theDate.getTime());
+        theTimestamp.setNanos(theNanos);
+
+        return theTimestamp;
+    }
+}

Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Types.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Types.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Types.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/java/sql/Types.java Mon Jun 12 05:13:42 2006
@@ -11,180 +11,172 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-
-package java.sql;
-
-/**
- * A class which defines constants used to identify generic SQL types, also called JDBC
- * types. The type constant values are equivalent to those in XOPEN.
- * 
- */
-public class Types {
-
-	// Uncomment the following to validate that this version of java.sql.Types is
-	// loaded:
-	// static { System.out.println("Clear version of java.sql.Types loaded!"); }; 
-	
-	/*
-	 * Private constructor to prevent instantiation.
-	 */
-	private Types() {
-		
-	} // end constructor Types()
-	
-	/**
-	 * The type code that identifies the SQL type ARRAY.
-	 */
-	public static final int 	ARRAY 		= 2003 ;
-	
-	/**
-	 * The type code that identifies the SQL type BIGINT.
-	 */
-	public static final int 	BIGINT		= -5 ;
-	
-	/**
-	 * The type code that identifies the SQL type BINARY.
-	 */
-	public static final int 	BINARY		= -2 ;
-	
-	/**
-	 * The type code that identifies the SQL type BIT.
-	 */
-	public static final int 	BIT			= -7 ;
-
-	/**
-	 * The type code that identifies the SQL type BLOB.
-	 */
-	public static final int 	BLOB		= 2004 ;
-    
-	/**
-	 * The type code that identifies the SQL type BOOLEAN.
-	 */
-	public static final int 	BOOLEAN		= 16 ;
-    
-	/**
-	 * The type code that identifies the SQL type CHAR.
-	 */
-	public static final int 	CHAR		= 1 ;
-    
-	/**
-	 * The type code that identifies the SQL type CLOB.
-	 */
-	public static final int 	CLOB		= 2005 ;
-	
-	/**
-	 * The type code that identifies the SQL type DATALINK.
-	 */
-    public static final int 	DATALINK	= 70 ;
-    
-	/**
-	 * The type code that identifies the SQL type DATE.
-	 */
-    public static final int 	DATE		= 91 ;
-    
-	/**
-	 * The type code that identifies the SQL type DECIMAL.
-	 */
-    public static final int 	DECIMAL		= 3 ;
-    
-	/**
-	 * The type code that identifies the SQL type DISTINCT.
-	 */
-    public static final int 	DISTINCT	= 2001 ;
-    
-	/**
-	 * The type code that identifies the SQL type DOUBLE.
-	 */
-    public static final int 	DOUBLE		= 8 ;
-    
-	/**
-	 * The type code that identifies the SQL type FLOAT.
-	 */
-    public static final int 	FLOAT		= 6 ;
-    
-	/**
-	 * The type code that identifies the SQL type INTEGER.
-	 */
-    public static final int 	INTEGER		= 4 ;
-    
-	/**
-	 * The type code that identifies the SQL type JAVA_OBJECT.
-	 */
-    public static final int 	JAVA_OBJECT	= 2000 ;
-    
-	/**
-	 * The type code that identifies the SQL type LONGVARBINARY.
-	 */
-    public static final int 	LONGVARBINARY = -4 ;
-    
-	/**
-	 * The type code that identifies the SQL type LONGVARCHAR.
-	 */
-	public static final int 	LONGVARCHAR	= -1 ;
-	
-	/**
-	 * The type code that identifies the SQL type NULL.
-	 */
-    public static final int 	NULL		= 0 ;
-    
-	/**
-	  * The type code that identifies the SQL type NUMERIC.
-	  */
-	public static final int 	NUMERIC		= 2 ;
-	
-	/**
- 	 * The type code that identifies that the SQL type is database specific and is mapped to
-	 * a Java object, accessed via the methods <code>getObject</code> and <code>setObject</code>.
-	 */
-	public static final int 	OTHER		= 1111 ;
-    
-	/**
-	 * The type code that identifies the SQL type REAL.
-	 */
-	public static final int 	REAL		= 7 ;
-    
-	/**
-	 * The type code that identifies the SQL type REF.
-	 */
-   	public static final int 	REF			= 2006 ;
-    
-	/**
-	 * The type code that identifies the SQL type SMALLINT.
-	 */
-	public static final int 	SMALLINT	= 5 ;
-    
-	/**
-	 * The type code that identifies the SQL type STRUCT.
-	 */
-    public static final int 	STRUCT		= 2002 ;
-    
-	/**
-	 * The type code that identifies the SQL type TIME.
-	 */
-	public static final int 	TIME		= 92 ;
-    
-	/**
-	 * The type code that identifies the SQL type TIMESTAMP.
-	 */
-	public static final int 	TIMESTAMP	= 93 ;
-    
-	/**
-	 * The type code that identifies the SQL type TINYINT.
-	 */
-	public static final int 	TINYINT		= -6 ;
-
-	/**
-	 * The type code that identifies the SQL type VARBINARY.
-	 */
-	public static final int 	VARBINARY	= -3 ;
-    
-	/**
-	 * The type code that identifies the SQL type VARCHAR.
-	 */
-	public static final int 	VARCHAR		= 12 ;
-	
-} // end class Types
-
-
+ */
+
+package java.sql;
+
+/**
+ * A class which defines constants used to identify generic SQL types, also
+ * called JDBC types. The type constant values are equivalent to those in XOPEN.
+ */
+public class Types {
+
+    /*
+     * Private constructor to prevent instantiation.
+     */
+    private Types() {
+        super();
+    }
+
+    /**
+     * The type code that identifies the SQL type ARRAY.
+     */
+    public static final int ARRAY = 2003;
+
+    /**
+     * The type code that identifies the SQL type BIGINT.
+     */
+    public static final int BIGINT = -5;
+
+    /**
+     * The type code that identifies the SQL type BINARY.
+     */
+    public static final int BINARY = -2;
+
+    /**
+     * The type code that identifies the SQL type BIT.
+     */
+    public static final int BIT = -7;
+
+    /**
+     * The type code that identifies the SQL type BLOB.
+     */
+    public static final int BLOB = 2004;
+
+    /**
+     * The type code that identifies the SQL type BOOLEAN.
+     */
+    public static final int BOOLEAN = 16;
+
+    /**
+     * The type code that identifies the SQL type CHAR.
+     */
+    public static final int CHAR = 1;
+
+    /**
+     * The type code that identifies the SQL type CLOB.
+     */
+    public static final int CLOB = 2005;
+
+    /**
+     * The type code that identifies the SQL type DATALINK.
+     */
+    public static final int DATALINK = 70;
+
+    /**
+     * The type code that identifies the SQL type DATE.
+     */
+    public static final int DATE = 91;
+
+    /**
+     * The type code that identifies the SQL type DECIMAL.
+     */
+    public static final int DECIMAL = 3;
+
+    /**
+     * The type code that identifies the SQL type DISTINCT.
+     */
+    public static final int DISTINCT = 2001;
+
+    /**
+     * The type code that identifies the SQL type DOUBLE.
+     */
+    public static final int DOUBLE = 8;
+
+    /**
+     * The type code that identifies the SQL type FLOAT.
+     */
+    public static final int FLOAT = 6;
+
+    /**
+     * The type code that identifies the SQL type INTEGER.
+     */
+    public static final int INTEGER = 4;
+
+    /**
+     * The type code that identifies the SQL type JAVA_OBJECT.
+     */
+    public static final int JAVA_OBJECT = 2000;
+
+    /**
+     * The type code that identifies the SQL type LONGVARBINARY.
+     */
+    public static final int LONGVARBINARY = -4;
+
+    /**
+     * The type code that identifies the SQL type LONGVARCHAR.
+     */
+    public static final int LONGVARCHAR = -1;
+
+    /**
+     * The type code that identifies the SQL type NULL.
+     */
+    public static final int NULL = 0;
+
+    /**
+     * The type code that identifies the SQL type NUMERIC.
+     */
+    public static final int NUMERIC = 2;
+
+    /**
+     * The type code that identifies that the SQL type is database specific and
+     * is mapped to a Java object, accessed via the methods
+     * <code>getObject</code> and <code>setObject</code>.
+     */
+    public static final int OTHER = 1111;
+
+    /**
+     * The type code that identifies the SQL type REAL.
+     */
+    public static final int REAL = 7;
+
+    /**
+     * The type code that identifies the SQL type REF.
+     */
+    public static final int REF = 2006;
+
+    /**
+     * The type code that identifies the SQL type SMALLINT.
+     */
+    public static final int SMALLINT = 5;
+
+    /**
+     * The type code that identifies the SQL type STRUCT.
+     */
+    public static final int STRUCT = 2002;
+
+    /**
+     * The type code that identifies the SQL type TIME.
+     */
+    public static final int TIME = 92;
+
+    /**
+     * The type code that identifies the SQL type TIMESTAMP.
+     */
+    public static final int TIMESTAMP = 93;
+
+    /**
+     * The type code that identifies the SQL type TINYINT.
+     */
+    public static final int TINYINT = -6;
+
+    /**
+     * The type code that identifies the SQL type VARBINARY.
+     */
+    public static final int VARBINARY = -3;
+
+    /**
+     * The type code that identifies the SQL type VARCHAR.
+     */
+    public static final int VARCHAR = 12;
+}

Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEvent.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEvent.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEvent.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEvent.java Mon Jun 12 05:13:42 2006
@@ -11,59 +11,61 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-
-package javax.sql;
-
-import java.util.EventObject;
-import java.sql.SQLException;
-import java.io.Serializable;
-
-/**
- * An Event object which is sent when specific events happen on a PooledConnection object.
- * The events involved are when the application closing the PooledConnection and when an error
- * occurs in the PooledConnection.
- * 
- */
-public class ConnectionEvent extends EventObject implements Serializable {
-	
-	private static final long serialVersionUID = -4843217645290030002L;
-	
-	private SQLException theSQLException;
-
-	/**
-	 * Creates a connection event initialized with a supplied PooledConnection.
-	 * @param theConnection the PooledConnection 
-	 */
-	public ConnectionEvent(PooledConnection theConnection ) {
-		super( theConnection );
-		// System.out.println("Clear Connection Event constructor");
-		theSQLException = null;
-	} // end method ConnectionEvent( PooledConnection )
-	
-	/**
-	 * Creates a ConnectionEvent initialized with a supplied PooledConnection and with
-	 * a supplied SQLException indicating that an error has occurred within the PooledConnection.
-	 * @param theConnection the PooledConnection
-	 * @param theException the SQLException holding information about the error that has occurred,
-	 * which is about to be returned to the application.
-	 */
-	public ConnectionEvent(PooledConnection theConnection, SQLException theException ) {
-		super( theConnection );
-		theSQLException = theException;
-	} // end method ConnectionEvent( PooledConnection, SQLException )
-	
-	/**
-	 * Gets the SQLException which holds information about the error which occurred in the
-	 * PooledConnection.
-	 * @return an SQLException containing information about the error. May be null if no error
-	 * has occurred.
-	 */
-	public SQLException getSQLException() {
-		return theSQLException;
-	} // end method getSQLException()
-	
-} // end class ConnectionEvent
-
-
+ */
+
+package javax.sql;
+
+import java.util.EventObject;
+import java.sql.SQLException;
+import java.io.Serializable;
+
+/**
+ * An Event object which is sent when specific events happen on a
+ * PooledConnection object. The events involved are when the application closing
+ * the PooledConnection and when an error occurs in the PooledConnection.
+ */
+public class ConnectionEvent extends EventObject implements Serializable {
+
+    private static final long serialVersionUID = -4843217645290030002L;
+
+    private SQLException theSQLException;
+
+    /**
+     * Creates a connection event initialized with a supplied PooledConnection.
+     * 
+     * @param theConnection
+     *            the PooledConnection
+     */
+    public ConnectionEvent(PooledConnection theConnection) {
+        super(theConnection);
+        theSQLException = null;
+    }
+
+    /**
+     * Creates a ConnectionEvent initialized with a supplied PooledConnection
+     * and with a supplied SQLException indicating that an error has occurred
+     * within the PooledConnection.
+     * 
+     * @param theConnection
+     *            the PooledConnection
+     * @param theException
+     *            the SQLException holding information about the error that has
+     *            occurred, which is about to be returned to the application.
+     */
+    public ConnectionEvent(PooledConnection theConnection,
+            SQLException theException) {
+        super(theConnection);
+        theSQLException = theException;
+    }
+
+    /**
+     * Gets the SQLException which holds information about the error which
+     * occurred in the PooledConnection.
+     * 
+     * @return an SQLException containing information about the error. May be
+     *         null if no error has occurred.
+     */
+    public SQLException getSQLException() {
+        return theSQLException;
+    }
+}

Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEventListener.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEventListener.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEventListener.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionEventListener.java Mon Jun 12 05:13:42 2006
@@ -11,43 +11,47 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-
-package javax.sql;
-
-import java.util.EventListener;
-
-/**
- * An interface used to receive events generated by a <code>PooledConnection</code>.
- * <p>
- * This interface would typically be implemented by a component which implements Connection
- * Pooling (a Connection Pool Manager).  A Connection will signal events to a ConnectionEventListener
- * either when the application closes a Connection it has been using or when a significant error
- * occurs while the Connection is being used, where the Connection should not be used again.
- * <p>
- * The Connection Pool Manager can return closed Connections to the Pool for later reuse.
- * Connections experiencing an error should be discarded.
- * 
- */
-public interface ConnectionEventListener extends EventListener {
-
-	/**
-	 * Notifies the ConnectionEventListener that an application has called the <code>close</code>
-	 * method on a pooled Connection.
-	 * @param theEvent a ConnectionEvent containing detail about the source of the event.
-	 */
-	public void connectionClosed(ConnectionEvent theEvent);
-	
-	/**
-	 * Notifies the ConnectionEventListener that an error has occurred while a PooledConnection
-	 * was being used and that the PooledConnection can no longer be used for work.  This notification
-	 * is done just before the SQLException passed in the event message is thrown to the application.
-	 * @param theEvent a ConnectionEvent containing detail about the source of the event and the
-	 * SQLException that has occurred.
-	 */
-	public void connectionErrorOccurred(ConnectionEvent theEvent);
-	
-} // end interface ConnectionEventListener
-
-
+ */
+
+package javax.sql;
+
+import java.util.EventListener;
+
+/**
+ * An interface used to receive events generated by a
+ * <code>PooledConnection</code>.
+ * <p>
+ * This interface would typically be implemented by a component which implements
+ * Connection Pooling (a Connection Pool Manager). A Connection will signal
+ * events to a ConnectionEventListener either when the application closes a
+ * Connection it has been using or when a significant error occurs while the
+ * Connection is being used, where the Connection should not be used again.
+ * <p>
+ * The Connection Pool Manager can return closed Connections to the Pool for
+ * later reuse. Connections experiencing an error should be discarded.
+ * 
+ */
+public interface ConnectionEventListener extends EventListener {
+
+    /**
+     * Notifies the ConnectionEventListener that an application has called the
+     * <code>close</code> method on a pooled Connection.
+     * 
+     * @param theEvent
+     *            a ConnectionEvent containing detail about the source of the
+     *            event.
+     */
+    public void connectionClosed(ConnectionEvent theEvent);
+
+    /**
+     * Notifies the ConnectionEventListener that an error has occurred while a
+     * PooledConnection was being used and that the PooledConnection can no
+     * longer be used for work. This notification is done just before the
+     * SQLException passed in the event message is thrown to the application.
+     * 
+     * @param theEvent
+     *            a ConnectionEvent containing detail about the source of the
+     *            event and the SQLException that has occurred.
+     */
+    public void connectionErrorOccurred(ConnectionEvent theEvent);
+}

Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionPoolDataSource.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionPoolDataSource.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionPoolDataSource.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/ConnectionPoolDataSource.java Mon Jun 12 05:13:42 2006
@@ -11,88 +11,111 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-
-package javax.sql;
-
-import java.sql.SQLException;
-import java.io.PrintWriter;
-
-/**
- * An interface for the creation of PooledConnection objects.  Used internally within the package.
- * <p>
- * A class which implements the ConnectionPoolDataSource interface is typically registered with a JNDI
- * naming service directory and is retrieved from there by name.
- * 
- */
-public interface ConnectionPoolDataSource {
-	
-	/**
-	 * Gets the Login Timeout value for this ConnectionPoolDataSource.  The Login Timeout is the maximum time
-	 * in seconds that the ConnectionPoolDataSource will wait when opening a connection to a database. A Timeout
-	 * value of 0 implies either the system default timeout value (if there is one) or that there
-	 * is no timeout.  The default value for the Login Timeout is 0.
-	 * @return the Login Timeout value in seconds.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public int getLoginTimeout() throws SQLException;
-	
-	/**
-	 * Gets the Log Writer for this ConnectionPoolDataSource.
-	 * <p>
-	 * The Log Writer is a stream to which all log and trace messages are sent from this
-	 * ConnectionPoolDataSource. The Log Writer can be null, in which case, log and trace capture is
-	 * disabled.  The default value for the Log Writer when an ConnectionPoolDataSource is created is null.
-	 * Note that the Log Writer for an ConnectionPoolDataSource is not the same as the Log Writer used by
-	 * a <code>DriverManager</code>.
-	 * @return a PrintWriter which is the Log Writer for this ConnectionPoolDataSource. Can be null, in which
-	 * case log writing is disabled for this ConnectionPoolDataSource.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public PrintWriter getLogWriter() throws SQLException;
-	
-	/**
-	 * Create a connection to a database which can then be used as a pooled connection.
-	 * @return a PooledConnection which represents the connection to the database 
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public PooledConnection getPooledConnection() throws SQLException;
-	
-	/**
-	 * Create a connection to a database, using a supplied Username and Password, which can then 
-	 * be used as a pooled connection.
-	 * @param theUser a String containing a User Name for the database
-	 * @param thePassword a String containing the Password for the user identified by 
-	 * <code>theUser</code>
-	 * @return a PooledConnection which represents the connection to the database 
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public PooledConnection getPooledConnection(String theUser, String thePassword) throws SQLException;
-	
-	/**
-	 * Sets the Login Timeout value for this ConnectionPoolDataSource. The Login Timeout is the maximum time
-	 * in seconds that the ConnectionPoolDataSource will wait when opening a connection to a database. A Timeout
-	 * value of 0 implies either the system default timeout value (if there is one) or that there
-	 * is no timeout.  The default value for the Login Timeout is 0.
-	 * @param theTimeout the new Login Timeout value in seconds.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public void setLoginTimeout(int theTimeout) throws SQLException;
-	
-	/**
-	 * Sets the Log Writer for this ConnectionPoolDataSource.
-	 * <p>
-	 * The Log Writer is a stream to which all log and trace messages are sent from this
-	 * ConnectionPoolDataSource. The Log Writer can be null, in which case, log and trace capture is
-	 * disabled.  The default value for the Log Writer when an ConnectionPoolDataSource is created is null.
-	 * Note that the Log Writer for an ConnectionPoolDataSource is not the same as the Log Writer used by
-	 * a <code>DriverManager</code>.
-	 * @param theWriter a PrintWriter to use as the Log Writer for this ConnectionPoolDataSource.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public void setLogWriter(PrintWriter theWriter) throws SQLException;
-
-} // end interface ConnectionPoolDataSource
-
-
+ */
+
+package javax.sql;
+
+import java.sql.SQLException;
+import java.io.PrintWriter;
+
+/**
+ * An interface for the creation of PooledConnection objects. Used internally
+ * within the package.
+ * <p>
+ * A class which implements the ConnectionPoolDataSource interface is typically
+ * registered with a JNDI naming service directory and is retrieved from there
+ * by name.
+ */
+public interface ConnectionPoolDataSource {
+
+    /**
+     * Gets the Login Timeout value for this ConnectionPoolDataSource. The Login
+     * Timeout is the maximum time in seconds that the ConnectionPoolDataSource
+     * will wait when opening a connection to a database. A Timeout value of 0
+     * implies either the system default timeout value (if there is one) or that
+     * there is no timeout. The default value for the Login Timeout is 0.
+     * 
+     * @return the Login Timeout value in seconds.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public int getLoginTimeout() throws SQLException;
+
+    /**
+     * Gets the Log Writer for this ConnectionPoolDataSource.
+     * <p>
+     * The Log Writer is a stream to which all log and trace messages are sent
+     * from this ConnectionPoolDataSource. The Log Writer can be null, in which
+     * case, log and trace capture is disabled. The default value for the Log
+     * Writer when an ConnectionPoolDataSource is created is null. Note that the
+     * Log Writer for an ConnectionPoolDataSource is not the same as the Log
+     * Writer used by a <code>DriverManager</code>.
+     * 
+     * @return a PrintWriter which is the Log Writer for this
+     *         ConnectionPoolDataSource. Can be null, in which case log writing
+     *         is disabled for this ConnectionPoolDataSource.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public PrintWriter getLogWriter() throws SQLException;
+
+    /**
+     * Create a connection to a database which can then be used as a pooled
+     * connection.
+     * 
+     * @return a PooledConnection which represents the connection to the
+     *         database
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public PooledConnection getPooledConnection() throws SQLException;
+
+    /**
+     * Create a connection to a database, using a supplied Username and
+     * Password, which can then be used as a pooled connection.
+     * 
+     * @param theUser
+     *            a String containing a User Name for the database
+     * @param thePassword
+     *            a String containing the Password for the user identified by
+     *            <code>theUser</code>
+     * @return a PooledConnection which represents the connection to the
+     *         database
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public PooledConnection getPooledConnection(String theUser,
+            String thePassword) throws SQLException;
+
+    /**
+     * Sets the Login Timeout value for this ConnectionPoolDataSource. The Login
+     * Timeout is the maximum time in seconds that the ConnectionPoolDataSource
+     * will wait when opening a connection to a database. A Timeout value of 0
+     * implies either the system default timeout value (if there is one) or that
+     * there is no timeout. The default value for the Login Timeout is 0.
+     * 
+     * @param theTimeout
+     *            the new Login Timeout value in seconds.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public void setLoginTimeout(int theTimeout) throws SQLException;
+
+    /**
+     * Sets the Log Writer for this ConnectionPoolDataSource.
+     * <p>
+     * The Log Writer is a stream to which all log and trace messages are sent
+     * from this ConnectionPoolDataSource. The Log Writer can be null, in which
+     * case, log and trace capture is disabled. The default value for the Log
+     * Writer when an ConnectionPoolDataSource is created is null. Note that the
+     * Log Writer for an ConnectionPoolDataSource is not the same as the Log
+     * Writer used by a <code>DriverManager</code>.
+     * 
+     * @param theWriter
+     *            a PrintWriter to use as the Log Writer for this
+     *            ConnectionPoolDataSource.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public void setLogWriter(PrintWriter theWriter) throws SQLException;
+}

Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/DataSource.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/DataSource.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/DataSource.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/DataSource.java Mon Jun 12 05:13:42 2006
@@ -11,108 +11,126 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-
-package javax.sql;
-
-import java.sql.SQLException;
-import java.sql.Connection;
-import java.io.PrintWriter;
-
-/**
- * An interface for the creation of Connection objects which represent a connection to a
- * database.  This interface is an alternative to the <code>java.sql.DriverManager</code>.
- * <p>
- * A class which implements the DataSource interface is typically registered with a JNDI
- * naming service directory and is retrieved from there by name.
- * <p>
- * The DataSource interface is typically implemented by the writer of a JDBC driver.  There
- * are three variants of the DataSource interface, which produce Connections with differing
- * characteristics:
- * <ol>
- * <li>Standard DataSource, which produces standard Connection objects with no special features.</li>
- * <li>Connection Pool DataSource, which produces PooledConnection objects which are able to
- * participate in connection pooling, typically involving a connection pooling manager as an
- * intermediary between applications and the database.</li>
- * <li>Distributed transaction DataSource ("XADataSource"), which produces XAConnection objects
- * which can be used to handle distributed transactions and which typically involve a transaction
- * manager component in the system.  XAConnection objects also typically provide connection
- * pooling capabilities as well as distributed transaction capabilities. </li>
- * </ol>
- * <p>
- * Note that a JDBC driver which is accessed via the DataSource interface is loaded via a JNDI
- * lookup process.  A driver loaded in this way does not register itself with the 
- * <code>DriverManager</code>.
- * 
- */
-public interface DataSource {
-	
-	/**
-	 * Creates a connection to the database represented by this DataSource. 
-	 * @return a Connection object which is a connection to the database.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public Connection getConnection() throws SQLException;
-	
-	/**
-	 * Creates a connection to the database represented by this DataSource, using a supplied 
-	 * Username and Password,. 
-	 * @param theUsername a String containing a User Name for the database
-	 * @param thePassword  a String containing the Password for the user identified by 
-	 * <code>theUsername</code>
-	 * @return a Connection object which is a connection to the database.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public Connection getConnection(String theUsername, String thePassword) throws SQLException;
-
-	/**
-	 * Gets the Login Timeout value for this DataSource.  The Login Timeout is the maximum time
-	 * in seconds that the DataSource will wait when opening a connection to a database. A Timeout
-	 * value of 0 implies either the system default timeout value (if there is one) or that there
-	 * is no timeout.  The default value for the Login Timeout is 0.
-	 * @return the Login Timeout value in seconds.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public int getLoginTimeout() throws SQLException;
-	
-	/**
-	 * Gets the Log Writer for this DataSource.
-	 * <p>
-	 * The Log Writer is a stream to which all log and trace messages are sent from this
-	 * DataSource. The Log Writer can be null, in which case, log and trace capture is
-	 * disabled.  The default value for the Log Writer when an DataSource is created is null.
-	 * Note that the Log Writer for an DataSource is not the same as the Log Writer used by
-	 * a <code>DriverManager</code>.
-	 * @return a PrintWriter which is the Log Writer for this DataSource. Can be null, in which
-	 * case log writing is disabled for this DataSource.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public PrintWriter getLogWriter() throws SQLException;
-	
-	/**
-	 * Sets the Login Timeout value for this DataSource. The Login Timeout is the maximum time
-	 * in seconds that the DataSource will wait when opening a connection to a database. A Timeout
-	 * value of 0 implies either the system default timeout value (if there is one) or that there
-	 * is no timeout.  The default value for the Login Timeout is 0.
-	 * @param theTimeout the new Login Timeout value in seconds.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public void setLoginTimeout( int theTimeout ) throws SQLException;
-	
-	/**
-	 * Sets the Log Writer for this DataSource.
-	 * <p>
-	 * The Log Writer is a stream to which all log and trace messages are sent from this
-	 * DataSource. The Log Writer can be null, in which case, log and trace capture is
-	 * disabled.  The default value for the Log Writer when an DataSource is created is null.
-	 * Note that the Log Writer for an DataSource is not the same as the Log Writer used by
-	 * a <code>DriverManager</code>.
-	 * @param theWriter a PrintWriter to use as the Log Writer for this DataSource.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public void setLogWriter(PrintWriter theWriter) throws SQLException;
-	
-} // end interface DataSource
-
-
+ */
+
+package javax.sql;
+
+import java.sql.SQLException;
+import java.sql.Connection;
+import java.io.PrintWriter;
+
+/**
+ * An interface for the creation of Connection objects which represent a
+ * connection to a database. This interface is an alternative to the
+ * <code>java.sql.DriverManager</code>.
+ * <p>
+ * A class which implements the DataSource interface is typically registered
+ * with a JNDI naming service directory and is retrieved from there by name.
+ * <p>
+ * The DataSource interface is typically implemented by the writer of a JDBC
+ * driver. There are three variants of the DataSource interface, which produce
+ * Connections with differing characteristics:
+ * <ol>
+ * <li>Standard DataSource, which produces standard Connection objects with no
+ * special features.</li>
+ * <li>Connection Pool DataSource, which produces PooledConnection objects
+ * which are able to participate in connection pooling, typically involving a
+ * connection pooling manager as an intermediary between applications and the
+ * database.</li>
+ * <li>Distributed transaction DataSource ("XADataSource"), which produces
+ * XAConnection objects which can be used to handle distributed transactions and
+ * which typically involve a transaction manager component in the system.
+ * XAConnection objects also typically provide connection pooling capabilities
+ * as well as distributed transaction capabilities. </li>
+ * </ol>
+ * <p>
+ * Note that a JDBC driver which is accessed via the DataSource interface is
+ * loaded via a JNDI lookup process. A driver loaded in this way does not
+ * register itself with the <code>DriverManager</code>.
+ */
+public interface DataSource {
+
+    /**
+     * Creates a connection to the database represented by this DataSource.
+     * 
+     * @return a Connection object which is a connection to the database.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public Connection getConnection() throws SQLException;
+
+    /**
+     * Creates a connection to the database represented by this DataSource,
+     * using a supplied Username and Password,.
+     * 
+     * @param theUsername
+     *            a String containing a User Name for the database
+     * @param thePassword
+     *            a String containing the Password for the user identified by
+     *            <code>theUsername</code>
+     * @return a Connection object which is a connection to the database.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public Connection getConnection(String theUsername, String thePassword)
+            throws SQLException;
+
+    /**
+     * Gets the Login Timeout value for this DataSource. The Login Timeout is
+     * the maximum time in seconds that the DataSource will wait when opening a
+     * connection to a database. A Timeout value of 0 implies either the system
+     * default timeout value (if there is one) or that there is no timeout. The
+     * default value for the Login Timeout is 0.
+     * 
+     * @return the Login Timeout value in seconds.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public int getLoginTimeout() throws SQLException;
+
+    /**
+     * Gets the Log Writer for this DataSource.
+     * <p>
+     * The Log Writer is a stream to which all log and trace messages are sent
+     * from this DataSource. The Log Writer can be null, in which case, log and
+     * trace capture is disabled. The default value for the Log Writer when an
+     * DataSource is created is null. Note that the Log Writer for an DataSource
+     * is not the same as the Log Writer used by a <code>DriverManager</code>.
+     * 
+     * @return a PrintWriter which is the Log Writer for this DataSource. Can be
+     *         null, in which case log writing is disabled for this DataSource.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public PrintWriter getLogWriter() throws SQLException;
+
+    /**
+     * Sets the Login Timeout value for this DataSource. The Login Timeout is
+     * the maximum time in seconds that the DataSource will wait when opening a
+     * connection to a database. A Timeout value of 0 implies either the system
+     * default timeout value (if there is one) or that there is no timeout. The
+     * default value for the Login Timeout is 0.
+     * 
+     * @param theTimeout
+     *            the new Login Timeout value in seconds.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public void setLoginTimeout(int theTimeout) throws SQLException;
+
+    /**
+     * Sets the Log Writer for this DataSource.
+     * <p>
+     * The Log Writer is a stream to which all log and trace messages are sent
+     * from this DataSource. The Log Writer can be null, in which case, log and
+     * trace capture is disabled. The default value for the Log Writer when an
+     * DataSource is created is null. Note that the Log Writer for an DataSource
+     * is not the same as the Log Writer used by a <code>DriverManager</code>.
+     * 
+     * @param theWriter
+     *            a PrintWriter to use as the Log Writer for this DataSource.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public void setLogWriter(PrintWriter theWriter) throws SQLException;
+}

Modified: incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/PooledConnection.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/PooledConnection.java?rev=413642&r1=413641&r2=413642&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/PooledConnection.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/sql/src/main/java/javax/sql/PooledConnection.java Mon Jun 12 05:13:42 2006
@@ -11,84 +11,99 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-
-package javax.sql;
-
-import java.sql.SQLException;
-import java.sql.Connection;
-
-/**
- * An interface which provides facilities for handling connections to a database which are pooled.
- * <p>
- * Typically, a PooledConnection is recycled when it is no longer required by an application, 
- * rather than being closed and discarded.  The reason for treating connections in this way is that
- * it can be an expensive process both to establish a connection to a database and to destroy
- * the connection.  Reusing connections through a pool is a way of improving system performance
- * and reducing overhead.
- * <p>
- * It is not intended that an application use the PooledConnection interface directly.  The 
- * PooledConnection interface is intended for use by a component called a Connection Pool
- * Manager, typically part of the infrastructure that supports use of the database by applications.
- * <p>
- * Applications obtain connections to the database by calling the <code>DataSource.getConnection</code> 
- * method.  Under the covers, the Connection Pool Manager will get a PooledConnection object from
- * its connection pool and passes back a Connection object that wraps or references the 
- * PooledConnection object.  A new PooledConnection object will only be created if the pool is
- * empty.
- * <p>
- * When the application is finished using a PooledConnection, the application calls the 
- * <code>Connection.close</code> method. The Connection Pool Manager is notified via a
- * ConnectionEvent from the Connection that this has happened (the Pool Manager registers itself
- * with the Connection before the Connection is given to the application). The Pool Manager
- * removes the underlying PooledConnection object from the Connection and returns it to the pool
- * for reuse - the PooledConnection is thus recycled rather than being destroyed.
- * <p>
- * The connection to the database represented by the PooledConnection is kept open until the
- * PooledConnection object itself is deactivated by the Connection Pool Manager, which calls the
- * <code>PooledConnection.close</code> method.  This is typically done if there are too many
- * inactive connections in the pool, if the PooledConnection encounters a problem that makes it
- * unusable or if the whole system is being shut down. 
- * 
- */
-public interface PooledConnection {
-
-	/**
-	 * Registers the supplied ConnectionEventListener with this PooledConnection.  Once registered,
-	 * the ConnectionEventListener will receive ConnectionEvent events when they occur in the 
-	 * PooledConnection.
-	 * @param theListener an object which implements the ConnectionEventListener interface.
-	 */
-	public void addConnectionEventListener(ConnectionEventListener theListener);
-	
-	/**
-	 * Closes the connection to the database held by this PooledConnection. This method should not
-	 * be called directly by application code - it is intended for use by the Connection Pool
-	 * manager component.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public void close() throws SQLException;
-	
-	/**
-	 * Creates a connection to the database.  This method is typically called by the Connectio
-	 * Pool manager when an application invokes the method <code>DataSource.getConnection</code>
-	 * and there are no PooledConnection objects available in the connection pool.
-	 * @return a Connection object that is a handle to this PooledConnection object.
-	 * @throws SQLException if there is a problem accessing the database.
-	 */
-	public Connection getConnection() throws SQLException;
-	
-	/**
-	 * Deregister the supplied ConnectionEventListener from this PooledConnection.  Once
-	 * deregistered, the ConnectionEventListener will not longer receive events ocurring in the
-	 * PooledConnection. 
-	 * @param theListener an object which implements the ConnectionEventListener interface. This
-	 * object should have previously been registered with the PooledConnection using the 
-	 * <code>addConnectionEventListener</code> method.
-	 */
-	public void removeConnectionEventListener(ConnectionEventListener theListener);
-	
-} // end interface PooledConnection
-
-
+ */
+
+package javax.sql;
+
+import java.sql.SQLException;
+import java.sql.Connection;
+
+/**
+ * An interface which provides facilities for handling connections to a database
+ * which are pooled.
+ * <p>
+ * Typically, a PooledConnection is recycled when it is no longer required by an
+ * application, rather than being closed and discarded. The reason for treating
+ * connections in this way is that it can be an expensive process both to
+ * establish a connection to a database and to destroy the connection. Reusing
+ * connections through a pool is a way of improving system performance and
+ * reducing overhead.
+ * <p>
+ * It is not intended that an application use the PooledConnection interface
+ * directly. The PooledConnection interface is intended for use by a component
+ * called a Connection Pool Manager, typically part of the infrastructure that
+ * supports use of the database by applications.
+ * <p>
+ * Applications obtain connections to the database by calling the
+ * <code>DataSource.getConnection</code> method. Under the covers, the
+ * Connection Pool Manager will get a PooledConnection object from its
+ * connection pool and passes back a Connection object that wraps or references
+ * the PooledConnection object. A new PooledConnection object will only be
+ * created if the pool is empty.
+ * <p>
+ * When the application is finished using a PooledConnection, the application
+ * calls the <code>Connection.close</code> method. The Connection Pool Manager
+ * is notified via a ConnectionEvent from the Connection that this has happened
+ * (the Pool Manager registers itself with the Connection before the Connection
+ * is given to the application). The Pool Manager removes the underlying
+ * PooledConnection object from the Connection and returns it to the pool for
+ * reuse - the PooledConnection is thus recycled rather than being destroyed.
+ * <p>
+ * The connection to the database represented by the PooledConnection is kept
+ * open until the PooledConnection object itself is deactivated by the
+ * Connection Pool Manager, which calls the <code>PooledConnection.close</code>
+ * method. This is typically done if there are too many inactive connections in
+ * the pool, if the PooledConnection encounters a problem that makes it unusable
+ * or if the whole system is being shut down.
+ * 
+ */
+public interface PooledConnection {
+
+    /**
+     * Registers the supplied ConnectionEventListener with this
+     * PooledConnection. Once registered, the ConnectionEventListener will
+     * receive ConnectionEvent events when they occur in the PooledConnection.
+     * 
+     * @param theListener
+     *            an object which implements the ConnectionEventListener
+     *            interface.
+     */
+    public void addConnectionEventListener(ConnectionEventListener theListener);
+
+    /**
+     * Closes the connection to the database held by this PooledConnection. This
+     * method should not be called directly by application code - it is intended
+     * for use by the Connection Pool manager component.
+     * 
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public void close() throws SQLException;
+
+    /**
+     * Creates a connection to the database. This method is typically called by
+     * the Connectio Pool manager when an application invokes the method
+     * <code>DataSource.getConnection</code> and there are no PooledConnection
+     * objects available in the connection pool.
+     * 
+     * @return a Connection object that is a handle to this PooledConnection
+     *         object.
+     * @throws SQLException
+     *             if there is a problem accessing the database.
+     */
+    public Connection getConnection() throws SQLException;
+
+    /**
+     * Deregister the supplied ConnectionEventListener from this
+     * PooledConnection. Once deregistered, the ConnectionEventListener will not
+     * longer receive events ocurring in the PooledConnection.
+     * 
+     * @param theListener
+     *            an object which implements the ConnectionEventListener
+     *            interface. This object should have previously been registered
+     *            with the PooledConnection using the
+     *            <code>addConnectionEventListener</code> method.
+     */
+    public void removeConnectionEventListener(
+            ConnectionEventListener theListener);
+}



Mime
View raw message