src/java.sql/share/classes/java/sql/Timestamp.java
author alanb
Tue, 15 May 2018 09:33:02 +0100
changeset 50109 ea54197f4fe4
parent 48065 c4f2b6749c86
permissions -rw-r--r--
8203059: (so) Closing a socket channel registered with Selector and with SO_LINGER set to 0 does not reset connection Reviewed-by: chegar
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
43218
8be65fea76fc 8172350: Typo in Timestamp.toString()
lancea
parents: 41889
diff changeset
     2
 * Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 2
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package java.sql;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
15658
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
    28
import java.time.Instant;
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
    29
import java.time.LocalDateTime;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
/**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    32
 * <P>A thin wrapper around {@code java.util.Date} that allows
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    33
 * the JDBC API to identify this as an SQL {@code TIMESTAMP} value.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
 * It adds the ability
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    35
 * to hold the SQL {@code TIMESTAMP} fractional seconds value, by allowing
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
 * the specification of fractional seconds to a precision of nanoseconds.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
 * A Timestamp also provides formatting and
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
 * parsing operations to support the JDBC escape syntax for timestamp values.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
 * <p>The precision of a Timestamp object is calculated to be either:
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
 * <ul>
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    42
 * <li>{@code 19 }, which is the number of characters in yyyy-mm-dd hh:mm:ss
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    43
 * <li> {@code  20 + s }, which is the number
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    44
 * of characters in the yyyy-mm-dd hh:mm:ss.[fff...] and {@code s} represents  the scale of the given Timestamp,
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
 * its fractional seconds precision.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
 *</ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
 *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    48
 * <P><B>Note:</B> This type is a composite of a {@code java.util.Date} and a
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
 * separate nanoseconds value. Only integral seconds are stored in the
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    50
 * {@code java.util.Date} component. The fractional seconds - the nanos - are
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    51
 * separate.  The {@code Timestamp.equals(Object)} method never returns
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    52
 * {@code true} when passed an object
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    53
 * that isn't an instance of {@code java.sql.Timestamp},
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
 * because the nanos component of a date is unknown.
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    55
 * As a result, the {@code Timestamp.equals(Object)}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
 * method is not symmetric with respect to the
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    57
 * {@code java.util.Date.equals(Object)}
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    58
 * method.  Also, the {@code hashCode} method uses the underlying
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    59
 * {@code java.util.Date}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
 * implementation and therefore does not include nanos in its computation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
 * <P>
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    62
 * Due to the differences between the {@code Timestamp} class
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    63
 * and the {@code java.util.Date}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
 * class mentioned above, it is recommended that code not view
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    65
 * {@code Timestamp} values generically as an instance of
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    66
 * {@code java.util.Date}.  The
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    67
 * inheritance relationship between {@code Timestamp}
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    68
 * and {@code java.util.Date} really
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
 * denotes implementation inheritance, and not type inheritance.
44256
12050b22e372 8176721: @since value errors java.sql module
mli
parents: 43218
diff changeset
    70
 *
12050b22e372 8176721: @since value errors java.sql module
mli
parents: 43218
diff changeset
    71
 * @since 1.1
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
public class Timestamp extends java.util.Date {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    76
     * Constructs a {@code Timestamp} object initialized
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
     * with the given values.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
     * @param year the year minus 1900
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
     * @param month 0 to 11
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
     * @param date 1 to 31
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
     * @param hour 0 to 23
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
     * @param minute 0 to 59
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
     * @param second 0 to 59
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
     * @param nano 0 to 999,999,999
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
    86
     * @deprecated instead use the constructor {@code Timestamp(long millis)}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
     * @exception IllegalArgumentException if the nano argument is out of bounds
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
     */
41889
54d1ff9312ce 8169020: Add since element to JDBC deprecated methods
lancea
parents: 32834
diff changeset
    89
    @Deprecated(since="1.2")
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
    public Timestamp(int year, int month, int date,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
                     int hour, int minute, int second, int nano) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
        super(year, month, date, hour, minute, second);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
        if (nano > 999999999 || nano < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
            throw new IllegalArgumentException("nanos > 999999999 or < 0");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
        nanos = nano;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   100
     * Constructs a {@code Timestamp} object
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
     * using a milliseconds time value. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
     * integral seconds are stored in the underlying date value; the
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   103
     * fractional seconds are stored in the {@code nanos} field of
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   104
     * the {@code Timestamp} object.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
     * @param time milliseconds since January 1, 1970, 00:00:00 GMT.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
     *        A negative number is the number of milliseconds before
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
     *         January 1, 1970, 00:00:00 GMT.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
     * @see java.util.Calendar
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
    public Timestamp(long time) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
        super((time/1000)*1000);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
        nanos = (int)((time%1000) * 1000000);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
        if (nanos < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
            nanos = 1000000000 + nanos;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
            super.setTime(((time/1000)-1)*1000);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   121
     * Sets this {@code Timestamp} object to represent a point in time that is
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   122
     * {@code time} milliseconds after January 1, 1970 00:00:00 GMT.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
     * @param time   the number of milliseconds.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
     * @see #getTime
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
     * @see #Timestamp(long time)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
     * @see java.util.Calendar
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
    public void setTime(long time) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
        super.setTime((time/1000)*1000);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
        nanos = (int)((time%1000) * 1000000);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
        if (nanos < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
            nanos = 1000000000 + nanos;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
            super.setTime(((time/1000)-1)*1000);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
     * Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   140
     * represented by this {@code Timestamp} object.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
     * @return  the number of milliseconds since January 1, 1970, 00:00:00 GMT
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
     *          represented by this date.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
     * @see #setTime
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
    public long getTime() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
        long time = super.getTime();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
        return (time + (nanos / 1000000));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
     * @serial
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
    private int nanos;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   158
     * Converts a {@code String} object in JDBC timestamp escape format to a
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   159
     * {@code Timestamp} value.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   161
     * @param s timestamp in format {@code yyyy-[m]m-[d]d hh:mm:ss[.f...]}.  The
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   162
     * fractional seconds may be omitted. The leading zero for {@code mm}
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   163
     * and {@code dd} may also be omitted.
6540
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   164
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   165
     * @return corresponding {@code Timestamp} value
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
     * @exception java.lang.IllegalArgumentException if the given argument
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   167
     * does not have the format {@code yyyy-[m]m-[d]d hh:mm:ss[.f...]}
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
    public static Timestamp valueOf(String s) {
6540
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   170
        final int YEAR_LENGTH = 4;
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   171
        final int MONTH_LENGTH = 2;
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   172
        final int DAY_LENGTH = 2;
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   173
        final int MAX_MONTH = 12;
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   174
        final int MAX_DAY = 31;
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   175
        int year = 0;
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   176
        int month = 0;
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   177
        int day = 0;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
        int hour;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
        int minute;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
        int second;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
        int a_nanos = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
        int firstDash;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
        int secondDash;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
        int dividingSpace;
26596
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   185
        int firstColon;
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   186
        int secondColon;
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   187
        int period;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
        String formatError = "Timestamp format must be yyyy-mm-dd hh:mm:ss[.fffffffff]";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
        if (s == null) throw new java.lang.IllegalArgumentException("null string");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
        // Split the string into date and time components
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
        s = s.trim();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
        dividingSpace = s.indexOf(' ');
26596
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   195
        if (dividingSpace < 0) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
            throw new java.lang.IllegalArgumentException(formatError);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
        // Parse the date
26596
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   200
        firstDash = s.indexOf('-');
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   201
        secondDash = s.indexOf('-', firstDash+1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
        // Parse the time
26596
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   204
        firstColon = s.indexOf(':', dividingSpace + 1);
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   205
        secondColon = s.indexOf(':', firstColon + 1);
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   206
        period = s.indexOf('.', secondColon + 1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
        // Convert the date
6540
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   209
        boolean parsedDate = false;
26596
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   210
        if (firstDash > 0 && secondDash > 0 && secondDash < dividingSpace - 1) {
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   211
            if (firstDash == YEAR_LENGTH &&
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   212
                    (secondDash - firstDash > 1 && secondDash - firstDash <= MONTH_LENGTH + 1) &&
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   213
                    (dividingSpace - secondDash > 1 && dividingSpace - secondDash <= DAY_LENGTH + 1)) {
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   214
                 year = Integer.parseInt(s, 0, firstDash, 10);
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   215
                 month = Integer.parseInt(s, firstDash + 1, secondDash, 10);
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   216
                 day = Integer.parseInt(s, secondDash + 1, dividingSpace, 10);
6540
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   217
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   218
                if ((month >= 1 && month <= MAX_MONTH) && (day >= 1 && day <= MAX_DAY)) {
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   219
                    parsedDate = true;
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   220
                }
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   221
            }
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   222
        }
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   223
        if (! parsedDate) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
            throw new java.lang.IllegalArgumentException(formatError);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
        // Convert the time; default missing nanos
26596
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   228
        int len = s.length();
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   229
        if (firstColon > 0 && secondColon > 0 && secondColon < len - 1) {
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   230
            hour = Integer.parseInt(s, dividingSpace + 1, firstColon, 10);
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   231
            minute = Integer.parseInt(s, firstColon + 1, secondColon, 10);
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   232
            if (period > 0 && period < len - 1) {
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   233
                second = Integer.parseInt(s, secondColon + 1, period, 10);
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   234
                int nanoPrecision = len - (period + 1);
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   235
                if (nanoPrecision > 9)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
                    throw new java.lang.IllegalArgumentException(formatError);
26596
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   237
                if (!Character.isDigit(s.charAt(period + 1)))
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
                    throw new java.lang.IllegalArgumentException(formatError);
26596
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   239
                int tmpNanos = Integer.parseInt(s, period + 1, len, 10);
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   240
                while (nanoPrecision < 9) {
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   241
                    tmpNanos *= 10;
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   242
                    nanoPrecision++;
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   243
                }
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   244
                a_nanos = tmpNanos;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
            } else if (period > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
                throw new java.lang.IllegalArgumentException(formatError);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
            } else {
26596
85ea379d419a 8055055: Improve numeric parsing in java.sql
redestad
parents: 25991
diff changeset
   248
                second = Integer.parseInt(s, secondColon + 1, len, 10);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
        } else {
6540
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   251
            throw new java.lang.IllegalArgumentException(formatError);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
6540
a4ae668f6125 6589685: JDBC 4.1 updates
lancea
parents: 5506
diff changeset
   254
        return new Timestamp(year - 1900, month - 1, day, hour, minute, second, a_nanos);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
     * Formats a timestamp in JDBC timestamp escape format.
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   259
     *         {@code yyyy-mm-dd hh:mm:ss.fffffffff},
43218
8be65fea76fc 8172350: Typo in Timestamp.toString()
lancea
parents: 41889
diff changeset
   260
     * where {@code fffffffff} indicates nanoseconds.
23590
ffd8b0b70511 8038493: Tidy warnings cleanup for java.sql
yan
parents: 23010
diff changeset
   261
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   262
     * @return a {@code String} object in
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   263
     *           {@code yyyy-mm-dd hh:mm:ss.fffffffff} format
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
     */
11129
f9ad1aadf3fa 7116445: Miscellaneous warnings in the JDBC/RowSet classes
lancea
parents: 9280
diff changeset
   265
    @SuppressWarnings("deprecation")
26597
c840e6631327 8058230: Improve java.sql toString formatting
redestad
parents: 26596
diff changeset
   266
    public String toString() {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
        int year = super.getYear() + 1900;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
        int month = super.getMonth() + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
        int day = super.getDate();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
        int hour = super.getHours();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
        int minute = super.getMinutes();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
        int second = super.getSeconds();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
26597
c840e6631327 8058230: Improve java.sql toString formatting
redestad
parents: 26596
diff changeset
   274
        int trailingZeros = 0;
c840e6631327 8058230: Improve java.sql toString formatting
redestad
parents: 26596
diff changeset
   275
        int tmpNanos = nanos;
c840e6631327 8058230: Improve java.sql toString formatting
redestad
parents: 26596
diff changeset
   276
        if (tmpNanos == 0) {
c840e6631327 8058230: Improve java.sql toString formatting
redestad
parents: 26596
diff changeset
   277
            trailingZeros = 8;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
        } else {
26597
c840e6631327 8058230: Improve java.sql toString formatting
redestad
parents: 26596
diff changeset
   279
            while (tmpNanos % 10 == 0) {
c840e6631327 8058230: Improve java.sql toString formatting
redestad
parents: 26596
diff changeset
   280
                tmpNanos /= 10;
c840e6631327 8058230: Improve java.sql toString formatting
redestad
parents: 26596
diff changeset
   281
                trailingZeros++;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
26621
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   285
        // 8058429: To comply with current JCK tests, we need to deal with year
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   286
        // being any number between 0 and 292278995
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   287
        int count = 10000;
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   288
        int yearSize = 4;
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   289
        do {
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   290
            if (year < count) {
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   291
                break;
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   292
            }
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   293
            yearSize++;
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   294
            count *= 10;
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   295
        } while (count < 1000000000);
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   296
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   297
        char[] buf = new char[25 + yearSize - trailingZeros];
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   298
        Date.formatDecimalInt(year, buf, 0, yearSize);
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   299
        buf[yearSize] = '-';
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   300
        Date.formatDecimalInt(month, buf, yearSize + 1, 2);
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   301
        buf[yearSize + 3] = '-';
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   302
        Date.formatDecimalInt(day, buf, yearSize + 4, 2);
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   303
        buf[yearSize + 6] = ' ';
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   304
        Date.formatDecimalInt(hour, buf, yearSize + 7, 2);
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   305
        buf[yearSize + 9] = ':';
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   306
        Date.formatDecimalInt(minute, buf, yearSize + 10, 2);
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   307
        buf[yearSize + 12] = ':';
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   308
        Date.formatDecimalInt(second, buf, yearSize + 13, 2);
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   309
        buf[yearSize + 15] = '.';
91ab384d2f49 8058429: JCK test api/java_sql/Timestamp/descriptions.html start failing after 8058230
redestad
parents: 26597
diff changeset
   310
        Date.formatDecimalInt(tmpNanos, buf, yearSize + 16, 9 - trailingZeros);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
48065
c4f2b6749c86 8176188: jdk/internal/misc/JavaLangAccess/NewUnsafeString.java failing since 9-b93
redestad
parents: 47216
diff changeset
   312
        return new String(buf);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   316
     * Gets this {@code Timestamp} object's {@code nanos} value.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   318
     * @return this {@code Timestamp} object's fractional seconds component
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
     * @see #setNanos
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
    public int getNanos() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
        return nanos;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   326
     * Sets this {@code Timestamp} object's {@code nanos} field
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
     * to the given value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
     * @param n the new fractional seconds component
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
     * @exception java.lang.IllegalArgumentException if the given argument
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
     *            is greater than 999999999 or less than 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
     * @see #getNanos
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
    public void setNanos(int n) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
        if (n > 999999999 || n < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
            throw new IllegalArgumentException("nanos > 999999999 or < 0");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
        nanos = n;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   342
     * Tests to see if this {@code Timestamp} object is
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   343
     * equal to the given {@code Timestamp} object.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   345
     * @param ts the {@code Timestamp} value to compare with
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   346
     * @return {@code true} if the given {@code Timestamp}
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   347
     *         object is equal to this {@code Timestamp} object;
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   348
     *         {@code false} otherwise
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
    public boolean equals(Timestamp ts) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
        if (super.equals(ts)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
            if  (nanos == ts.nanos) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
                return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   363
     * Tests to see if this {@code Timestamp} object is
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
     * equal to the given object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   366
     * This version of the method {@code equals} has been added
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
     * to fix the incorrect
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   368
     * signature of {@code Timestamp.equals(Timestamp)} and to preserve backward
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
     * compatibility with existing class files.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
     * Note: This method is not symmetric with respect to the
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   372
     * {@code equals(Object)} method in the base class.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   374
     * @param ts the {@code Object} value to compare with
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   375
     * @return {@code true} if the given {@code Object} is an instance
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   376
     *         of a {@code Timestamp} that
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   377
     *         is equal to this {@code Timestamp} object;
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   378
     *         {@code false} otherwise
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
    public boolean equals(java.lang.Object ts) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
      if (ts instanceof Timestamp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
        return this.equals((Timestamp)ts);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
      } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   389
     * Indicates whether this {@code Timestamp} object is
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   390
     * earlier than the given {@code Timestamp} object.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   392
     * @param ts the {@code Timestamp} value to compare with
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   393
     * @return {@code true} if this {@code Timestamp} object is earlier;
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   394
     *        {@code false} otherwise
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
    public boolean before(Timestamp ts) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
        return compareTo(ts) < 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   401
     * Indicates whether this {@code Timestamp} object is
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   402
     * later than the given {@code Timestamp} object.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   404
     * @param ts the {@code Timestamp} value to compare with
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   405
     * @return {@code true} if this {@code Timestamp} object is later;
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   406
     *        {@code false} otherwise
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
    public boolean after(Timestamp ts) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
        return compareTo(ts) > 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   413
     * Compares this {@code Timestamp} object to the given
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   414
     * {@code Timestamp} object.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   416
     * @param   ts   the {@code Timestamp} object to be compared to
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   417
     *                this {@code Timestamp} object
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   418
     * @return  the value {@code 0} if the two {@code Timestamp}
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   419
     *          objects are equal; a value less than {@code 0} if this
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   420
     *          {@code Timestamp} object is before the given argument;
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   421
     *          and a value greater than {@code 0} if this
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   422
     *          {@code Timestamp} object is after the given argument.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
     * @since   1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
    public int compareTo(Timestamp ts) {
7974
676d13726d90 7000693: java.sql.Timestamp compareTo() issues using low values
lancea
parents: 6540
diff changeset
   426
        long thisTime = this.getTime();
676d13726d90 7000693: java.sql.Timestamp compareTo() issues using low values
lancea
parents: 6540
diff changeset
   427
        long anotherTime = ts.getTime();
676d13726d90 7000693: java.sql.Timestamp compareTo() issues using low values
lancea
parents: 6540
diff changeset
   428
        int i = (thisTime<anotherTime ? -1 :(thisTime==anotherTime?0 :1));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
        if (i == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   430
            if (nanos > ts.nanos) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
                    return 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
            } else if (nanos < ts.nanos) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
                return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   435
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
        return i;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   437
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
90ce3da70b43 Initial load
duke
parents:
diff changeset
   439
    /**
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   440
     * Compares this {@code Timestamp} object to the given
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   441
     * {@code Date} object.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
     *
32210
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   443
     * @param o the {@code Date} to be compared to
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   444
     *          this {@code Timestamp} object
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   445
     * @return  the value {@code 0} if this {@code Timestamp} object
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   446
     *          and the given object are equal; a value less than {@code 0}
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   447
     *          if this  {@code Timestamp} object is before the given argument;
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   448
     *          and a value greater than {@code 0} if this
958d823579c3 8133480: replace some <tt> tags (obsolete in html5) in core-libs docs
avstepan
parents: 26621
diff changeset
   449
     *          {@code Timestamp} object is after the given argument.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
     * @since   1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
    public int compareTo(java.util.Date o) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
       if(o instanceof Timestamp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   455
            // When Timestamp instance compare it with a Timestamp
90ce3da70b43 Initial load
duke
parents:
diff changeset
   456
            // Hence it is basically calling this.compareTo((Timestamp))o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   457
            // Note typecasting is safe because o is instance of Timestamp
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
           return compareTo((Timestamp)o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
      } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   460
            // When Date doing a o.compareTo(this)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
            // will give wrong results.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
          Timestamp ts = new Timestamp(o.getTime());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
          return this.compareTo(ts);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
      }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
9280
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   467
    /**
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   468
     * {@inheritDoc}
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   469
     *
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   470
     * The {@code hashCode} method uses the underlying {@code java.util.Date}
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   471
     * implementation and therefore does not include nanos in its computation.
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   472
     *
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   473
     */
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   474
    @Override
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   475
    public int hashCode() {
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   476
        return super.hashCode();
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   477
    }
14b5e598a0fe 7037085: Add hashCode() to Timestamp to address Findbugs warning
lancea
parents: 9035
diff changeset
   478
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
    static final long serialVersionUID = 2745179027874758501L;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
15658
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   481
    private static final int MILLIS_PER_SECOND = 1000;
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   482
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   483
    /**
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   484
     * Obtains an instance of {@code Timestamp} from a {@code LocalDateTime}
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   485
     * object, with the same year, month, day of month, hours, minutes,
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   486
     * seconds and nanos date-time value as the provided {@code LocalDateTime}.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   487
     * <p>
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   488
     * The provided {@code LocalDateTime} is interpreted as the local
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   489
     * date-time in the local time zone.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   490
     *
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   491
     * @param dateTime a {@code LocalDateTime} to convert
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   492
     * @return a {@code Timestamp} object
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   493
     * @exception NullPointerException if {@code dateTime} is null.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   494
     * @since 1.8
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   495
     */
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   496
    @SuppressWarnings("deprecation")
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   497
    public static Timestamp valueOf(LocalDateTime dateTime) {
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   498
        return new Timestamp(dateTime.getYear() - 1900,
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   499
                             dateTime.getMonthValue() - 1,
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   500
                             dateTime.getDayOfMonth(),
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   501
                             dateTime.getHour(),
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   502
                             dateTime.getMinute(),
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   503
                             dateTime.getSecond(),
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   504
                             dateTime.getNano());
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   505
    }
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   506
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   507
    /**
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   508
     * Converts this {@code Timestamp} object to a {@code LocalDateTime}.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   509
     * <p>
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   510
     * The conversion creates a {@code LocalDateTime} that represents the
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   511
     * same year, month, day of month, hours, minutes, seconds and nanos
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   512
     * date-time value as this {@code Timestamp} in the local time zone.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   513
     *
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   514
     * @return a {@code LocalDateTime} object representing the same date-time value
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   515
     * @since 1.8
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   516
     */
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   517
    @SuppressWarnings("deprecation")
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   518
    public LocalDateTime toLocalDateTime() {
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   519
        return LocalDateTime.of(getYear() + 1900,
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   520
                                getMonth() + 1,
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   521
                                getDate(),
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   522
                                getHours(),
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   523
                                getMinutes(),
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   524
                                getSeconds(),
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   525
                                getNanos());
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   526
    }
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   527
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   528
    /**
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   529
     * Obtains an instance of {@code Timestamp} from an {@link Instant} object.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   530
     * <p>
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   531
     * {@code Instant} can store points on the time-line further in the future
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   532
     * and further in the past than {@code Date}. In this scenario, this method
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   533
     * will throw an exception.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   534
     *
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   535
     * @param instant  the instant to convert
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   536
     * @return an {@code Timestamp} representing the same point on the time-line as
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   537
     *  the provided instant
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   538
     * @exception NullPointerException if {@code instant} is null.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   539
     * @exception IllegalArgumentException if the instant is too large to
25976
4de01a56e3ee 8054555: javadoc cleanup for java.sql and javax.sql
lancea
parents: 23590
diff changeset
   540
     *  represent as a {@code Timestamp}
15658
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   541
     * @since 1.8
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   542
     */
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   543
    public static Timestamp from(Instant instant) {
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   544
        try {
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   545
            Timestamp stamp = new Timestamp(instant.getEpochSecond() * MILLIS_PER_SECOND);
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   546
            stamp.nanos = instant.getNano();
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   547
            return stamp;
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   548
        } catch (ArithmeticException ex) {
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   549
            throw new IllegalArgumentException(ex);
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   550
        }
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   551
    }
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   552
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   553
    /**
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   554
     * Converts this {@code Timestamp} object to an {@code Instant}.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   555
     * <p>
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   556
     * The conversion creates an {@code Instant} that represents the same
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   557
     * point on the time-line as this {@code Timestamp}.
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   558
     *
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   559
     * @return an instant representing the same point on the time-line
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   560
     * @since 1.8
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   561
     */
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   562
    @Override
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   563
    public Instant toInstant() {
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   564
        return Instant.ofEpochSecond(super.getTime() / MILLIS_PER_SECOND, nanos);
55b829ca2334 8007392: JSR 310: DateTime API Updates
sherman
parents: 11129
diff changeset
   565
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
}