Class Timestamps (3.19.4)

Utilities to help create/manipulate protobuf/timestamp.proto. All operations throw an IllegalArgumentException if the input(s) are not valid.

A constant holding the Timestamp of epoch time, 1970-01-01T00:00:00.000000000Z.

A constant holding the maximum valid Timestamp, 9999-12-31T23:59:59.999999999Z.

A constant holding the minimum valid Timestamp, 0001-01-01T00:00:00Z.

Add a duration to a timestamp.

Calculate the difference between two timestamps.

Throws an IllegalArgumentException if the given Timestamp is not valid.

Builds the given builder and throws an IllegalArgumentException if it is not valid. See #checkValid(Timestamp).

Returns a Comparator for Timestamps which sorts in increasing chronological order. Nulls and invalid Timestamps are not allowed (see #isValid). The returned comparator is serializable.

Compares two timestamps. The value returned is identical to what would be returned by: Timestamps.comparator().compare(x, y).

Create a Timestamp from a java.util.Date. If the java.util.Date is a java.sql.Timestamp, full nanonsecond precision is retained.

Create a Timestamp from the number of microseconds elapsed from the epoch.

Create a Timestamp from the number of milliseconds elapsed from the epoch.

Create a Timestamp from the number of nanoseconds elapsed from the epoch.

Create a Timestamp from the number of seconds elapsed from the epoch.

Returns true if the given Timestamp is valid. The seconds value must be in the range [-62,135,596,800, +253,402,300,799] (i.e., between 0001-01-01T00:00:00Z and 9999-12-31T23:59:59Z). The nanos value must be in the range [0, +999,999,999].

Note: Negative second values with fractional seconds must still have non-negative nanos values that count forward in time.

Returns true if the given number of seconds and nanos is a valid Timestamp. The seconds value must be in the range [-62,135,596,800, +253,402,300,799] (i.e., between 0001-01-01T00:00:00Z and 9999-12-31T23:59:59Z). The nanos value must be in the range [0, +999,999,999].

Note: Negative second values with fractional seconds must still have non-negative nanos values that count forward in time.

Parse from RFC 3339 date string to Timestamp. This method accepts all outputs of #toString(Timestamp) and it also accepts any fractional digits (or none) and any offset as long as they fit into nano-seconds precision.

Example of accepted format: "1972-01-01T10:00:20.021-05:00"

Parses a string in RFC 3339 format into a Timestamp.

Identical to #parse(String), but throws an IllegalArgumentException instead of a ParseException if parsing fails.

Subtract a duration from a timestamp.

Convert a Timestamp to the number of microseconds elapsed from the epoch.

The result will be rounded down to the nearest microsecond. E.g., if the timestamp represents "1969-12-31T23:59:59.999999999Z", it will be rounded to -1 microsecond.

Convert a Timestamp to the number of milliseconds elapsed from the epoch.

The result will be rounded down to the nearest millisecond. E.g., if the timestamp represents "1969-12-31T23:59:59.999999999Z", it will be rounded to -1 millisecond.

Convert a Timestamp to the number of nanoseconds elapsed from the epoch.

Convert a Timestamp to the number of seconds elapsed from the epoch.

The result will be rounded down to the nearest second. E.g., if the timestamp represents "1969-12-31T23:59:59.999999999Z", it will be rounded to -1 second.

Convert Timestamp to RFC 3339 date string format. The output will always be Z-normalized and uses 3, 6 or 9 fractional digits as required to represent the exact value. Note that Timestamp can only represent time from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. See https://www.ietf.org/rfc/rfc3339.txt

Example of generated format: "1972-01-01T10:00:20.021Z"