/** * Creates a {@code 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 {@code "yyyy-mm-dd hh:mm:ss.nnnnnnnnn}" * * @param s * the {@code String} containing a time in JDBC timestamp escape * format. * @return A {@code Timestamp} object with time value as defined by the * supplied {@code String}. * @throws IllegalArgumentException * if the provided string is {@code null}. */ public static Timestamp valueOf(String s) { if (s == null) { // sql.3=Argument cannot be null throw new java.lang.IllegalArgumentException("Argument cannot be null"); //$NON-NLS-1$ } // omit trailing whitespaces s = s.trim(); if (!java.util.regex.Pattern.matches(TIME_FORMAT_REGEX, (java.lang.CharSequence) new java.lang.StringJ(s))) { throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } java.text.SimpleDateFormat df = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //$NON-NLS-1$ java.text.ParsePosition pp = new java.text.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 */ java.util.Date theDate; try { theDate = df.parse(s, pp); } catch (Exception e) { throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } if (theDate == null) { throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } /* * 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()) { //$NON-NLS-1$ throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } /* * If we're strict, we should not allow any EXTRA characters after * the 9 digits */ if ((s.length() - position) > ".nnnnnnnnn".length()) { //$NON-NLS-1$ throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } // Require the next character to be a "." if (s.charAt(position) != '.') { // sql.4=Bad input string format: expected '.' not {0} throw new java.lang.NumberFormatException("Bad input string format: expected '.' not " + s.charAt(position)); //$NON-NLS-1$ } // 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"; //$NON-NLS-1$ theNanoString = theNanoString.substring(0, 9); try { theNanos = java.lang.Integer.parseInt(theNanoString); } catch (Exception e) { // If we get here, the string was not a number throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } } if (theNanos < 0 || theNanos > 999999999) { throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } Timestamp theTimestamp = new Timestamp(theDate.getTime()); theTimestamp.setNanos(theNanos); return(theTimestamp); }
/** * Tests to see if this timestamp is equal to a supplied timestamp. * * @param theTimestamp * the timestamp to compare with this {@code Timestamp} object, * passed as an {@code Object}. * @return {@code true} if this {@code Timestamp} object is equal to the * supplied {@code Timestamp} object, {@code false} otherwise. */ public bool equals(Timestamp theTimestamp) { if (theTimestamp == null) { return false; } return (this.getTime() == theTimestamp.getTime()) && (this.getNanos() == theTimestamp.getNanos()); }
/** * Returns {@code true} if this {@code Timestamp} object is earlier than the * supplied timestamp, otherwise returns {@code false}. * * @param theTimestamp * the timestamp to compare with this {@code Timestamp} object. * @return {@code true} if this {@code Timestamp} object is earlier than the * supplied timestamp, {@code false} otherwise. */ public bool 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 {@code Timestamp} object with a supplied {@code Timestamp} * object. * * @param theTimestamp * the timestamp to compare with this {@code Timestamp} object, * passed in as a {@code Timestamp}. * @return one of the following: * <ul> * <li>{@code 0}, if the two {@code Timestamp} objects are * equal in time</li> * <li>{@code < 0}, if this {@code Timestamp} object is before the * supplied {@code Timestamp}</li> * <li> {@code > 0}, if this {@code Timestamp} object is after the * supplied {@code Timestamp}</li> * </ul> */ public int compareTo(Timestamp theTimestamp) { int result = base.compareTo(theTimestamp); if (result == 0) { int thisNano = this.getNanos(); int thatNano = theTimestamp.getNanos(); if (thisNano > thatNano) { return 1; } else if (thisNano == thatNano) { return 0; } else { return -1; } } return result; }
/** * Creates a {@code 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 {@code "yyyy-mm-dd hh:mm:ss.nnnnnnnnn}" * * @param s * the {@code String} containing a time in JDBC timestamp escape * format. * @return A {@code Timestamp} object with time value as defined by the * supplied {@code String}. * @throws IllegalArgumentException * if the provided string is {@code null}. */ public static Timestamp valueOf(String s) { if (s == null) { // sql.3=Argument cannot be null throw new java.lang.IllegalArgumentException("Argument cannot be null"); //$NON-NLS-1$ } // omit trailing whitespaces s = s.trim(); if (!java.util.regex.Pattern.matches(TIME_FORMAT_REGEX, (java.lang.CharSequence)new java.lang.StringJ(s))) { throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } java.text.SimpleDateFormat df = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //$NON-NLS-1$ java.text.ParsePosition pp = new java.text.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 */ java.util.Date theDate; try { theDate = df.parse(s, pp); } catch (Exception e) { throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } if (theDate == null) { throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } /* * 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()) { //$NON-NLS-1$ throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } /* * If we're strict, we should not allow any EXTRA characters after * the 9 digits */ if ((s.length() - position) > ".nnnnnnnnn".length()) { //$NON-NLS-1$ throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } // Require the next character to be a "." if (s.charAt(position) != '.') { // sql.4=Bad input string format: expected '.' not {0} throw new java.lang.NumberFormatException("Bad input string format: expected '.' not " + s.charAt(position)); //$NON-NLS-1$ } // 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"; //$NON-NLS-1$ theNanoString = theNanoString.substring(0, 9); try { theNanos = java.lang.Integer.parseInt(theNanoString); } catch (Exception e) { // If we get here, the string was not a number throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } } if (theNanos < 0 || theNanos > 999999999) { throw new java.lang.IllegalArgumentException("Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff"); //$NON-NLS-1$ } Timestamp theTimestamp = new Timestamp(theDate.getTime()); theTimestamp.setNanos(theNanos); return theTimestamp; }