src/share/classes/java/time/chrono/ChronoLocalDateTime.java

Print this page

        

*** 57,67 **** * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ ! package java.time.temporal; import static java.time.temporal.ChronoField.EPOCH_DAY; import static java.time.temporal.ChronoField.NANO_OF_DAY; import static java.time.temporal.ChronoUnit.NANOS; --- 57,67 ---- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ ! package java.time.chrono; import static java.time.temporal.ChronoField.EPOCH_DAY; import static java.time.temporal.ChronoField.NANO_OF_DAY; import static java.time.temporal.ChronoUnit.NANOS;
*** 70,79 **** --- 70,88 ---- import java.time.LocalDateTime; import java.time.LocalTime; import java.time.ZoneId; import java.time.ZoneOffset; import java.time.format.DateTimeFormatter; + import java.time.temporal.ChronoField; + import java.time.temporal.Queries; + import java.time.temporal.Temporal; + import java.time.temporal.TemporalAccessor; + import java.time.temporal.TemporalAdjuster; + import java.time.temporal.TemporalAmount; + import java.time.temporal.TemporalField; + import java.time.temporal.TemporalQuery; + import java.time.temporal.TemporalUnit; import java.time.zone.ZoneRules; import java.util.Comparator; import java.util.Objects; /**
*** 82,92 **** * <p> * <b>Most applications should declare method signatures, fields and variables * as {@link LocalDateTime}, not this interface.</b> * <p> * A {@code ChronoLocalDateTime} is the abstract representation of a local date-time ! * where the {@code Chrono chronology}, or calendar system, is pluggable. * The date-time is defined in terms of fields expressed by {@link TemporalField}, * where most common implementations are defined in {@link ChronoField}. * The chronology defines how the calendar system operates and the meaning of * the standard fields. * --- 91,101 ---- * <p> * <b>Most applications should declare method signatures, fields and variables * as {@link LocalDateTime}, not this interface.</b> * <p> * A {@code ChronoLocalDateTime} is the abstract representation of a local date-time ! * where the {@code Chronology chronology}, or calendar system, is pluggable. * The date-time is defined in terms of fields expressed by {@link TemporalField}, * where most common implementations are defined in {@link ChronoField}. * The chronology defines how the calendar system operates and the meaning of * the standard fields. *
*** 101,114 **** * <h3>Specification for implementors</h3> * This interface must be implemented with care to ensure other classes operate correctly. * All implementations that can be instantiated must be final, immutable and thread-safe. * Subclasses should be Serializable wherever possible. * ! * @param <C> the chronology of this date-time * @since 1.8 */ ! public interface ChronoLocalDateTime<C extends Chrono<C>> extends Temporal, TemporalAdjuster, Comparable<ChronoLocalDateTime<?>> { /** * Comparator for two {@code ChronoLocalDateTime} instances ignoring the chronology. * <p> --- 110,123 ---- * <h3>Specification for implementors</h3> * This interface must be implemented with care to ensure other classes operate correctly. * All implementations that can be instantiated must be final, immutable and thread-safe. * Subclasses should be Serializable wherever possible. * ! * @param <D> the concrete type for the date of this date-time * @since 1.8 */ ! public interface ChronoLocalDateTime<D extends ChronoLocalDate<D>> extends Temporal, TemporalAdjuster, Comparable<ChronoLocalDateTime<?>> { /** * Comparator for two {@code ChronoLocalDateTime} instances ignoring the chronology. * <p>
*** 123,135 **** */ Comparator<ChronoLocalDateTime<?>> DATE_TIME_COMPARATOR = new Comparator<ChronoLocalDateTime<?>>() { @Override public int compare(ChronoLocalDateTime<?> datetime1, ChronoLocalDateTime<?> datetime2) { ! int cmp = Long.compare(datetime1.getDate().toEpochDay(), datetime2.getDate().toEpochDay()); if (cmp == 0) { ! cmp = Long.compare(datetime1.getTime().toNanoOfDay(), datetime2.getTime().toNanoOfDay()); } return cmp; } }; --- 132,144 ---- */ Comparator<ChronoLocalDateTime<?>> DATE_TIME_COMPARATOR = new Comparator<ChronoLocalDateTime<?>>() { @Override public int compare(ChronoLocalDateTime<?> datetime1, ChronoLocalDateTime<?> datetime2) { ! int cmp = Long.compare(datetime1.toLocalDate().toEpochDay(), datetime2.toLocalDate().toEpochDay()); if (cmp == 0) { ! cmp = Long.compare(datetime1.toLocalTime().toNanoOfDay(), datetime2.toLocalTime().toNanoOfDay()); } return cmp; } };
*** 139,217 **** * This returns a local date with the same year, month and day * as this date-time. * * @return the date part of this date-time, not null */ ! ChronoLocalDate<C> getDate() ; /** * Gets the local time part of this date-time. * <p> * This returns a local time with the same hour, minute, second and * nanosecond as this date-time. * * @return the time part of this date-time, not null */ ! LocalTime getTime(); //----------------------------------------------------------------------- // override for covariant return type /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! public default ChronoLocalDateTime<C> with(TemporalAdjuster adjuster) { ! return getDate().getChrono().ensureChronoLocalDateTime(Temporal.super.with(adjuster)); } /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! ChronoLocalDateTime<C> with(TemporalField field, long newValue); /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! public default ChronoLocalDateTime<C> plus(TemporalAdder adder) { ! return getDate().getChrono().ensureChronoLocalDateTime(Temporal.super.plus(adder)); } /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! ChronoLocalDateTime<C> plus(long amountToAdd, TemporalUnit unit); /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! public default ChronoLocalDateTime<C> minus(TemporalSubtractor subtractor) { ! return getDate().getChrono().ensureChronoLocalDateTime(Temporal.super.minus(subtractor)); } /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! public default ChronoLocalDateTime<C> minus(long amountToSubtract, TemporalUnit unit) { ! return getDate().getChrono().ensureChronoLocalDateTime(Temporal.super.minus(amountToSubtract, unit)); } //----------------------------------------------------------------------- /** * Queries this date-time using the specified query. --- 148,228 ---- * This returns a local date with the same year, month and day * as this date-time. * * @return the date part of this date-time, not null */ ! D toLocalDate() ; /** * Gets the local time part of this date-time. * <p> * This returns a local time with the same hour, minute, second and * nanosecond as this date-time. * * @return the time part of this date-time, not null */ ! LocalTime toLocalTime(); + @Override // Override to provide javadoc + public boolean isSupported(TemporalField field); //----------------------------------------------------------------------- // override for covariant return type /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! public default ChronoLocalDateTime<D> with(TemporalAdjuster adjuster) { ! return (ChronoLocalDateTime<D>)(toLocalDate().getChronology().ensureChronoLocalDateTime(Temporal.super.with(adjuster))); } /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! ChronoLocalDateTime<D> with(TemporalField field, long newValue); /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! public default ChronoLocalDateTime<D> plus(TemporalAmount amount) { ! return (ChronoLocalDateTime<D>)(toLocalDate().getChronology().ensureChronoLocalDateTime(Temporal.super.plus(amount))); } /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! ChronoLocalDateTime<D> plus(long amountToAdd, TemporalUnit unit); /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! public default ChronoLocalDateTime<D> minus(TemporalAmount amount) { ! return (ChronoLocalDateTime<D>)(toLocalDate().getChronology().ensureChronoLocalDateTime(Temporal.super.minus(amount))); } /** * {@inheritDoc} * @throws DateTimeException {@inheritDoc} * @throws ArithmeticException {@inheritDoc} */ @Override ! public default ChronoLocalDateTime<D> minus(long amountToSubtract, TemporalUnit unit) { ! return (ChronoLocalDateTime<D>)(toLocalDate().getChronology().ensureChronoLocalDateTime(Temporal.super.minus(amountToSubtract, unit))); } //----------------------------------------------------------------------- /** * Queries this date-time using the specified query.
*** 232,251 **** * @throws ArithmeticException if numeric overflow occurs (defined by the query) */ @SuppressWarnings("unchecked") @Override public default <R> R query(TemporalQuery<R> query) { - if (query == Queries.chrono()) { - return (R) getDate().getChrono(); - } - if (query == Queries.precision()) { - return (R) NANOS; - } - // inline TemporalAccessor.super.query(query) as an optimization if (query == Queries.zoneId() || query == Queries.zone() || query == Queries.offset()) { return null; } return query.queryFrom(this); } /** * Adjusts the specified temporal object to have the same date and time as this object. --- 243,263 ---- * @throws ArithmeticException if numeric overflow occurs (defined by the query) */ @SuppressWarnings("unchecked") @Override public default <R> R query(TemporalQuery<R> query) { if (query == Queries.zoneId() || query == Queries.zone() || query == Queries.offset()) { return null; + } else if (query == Queries.localTime()) { + return (R) toLocalTime(); + } else if (query == Queries.chronology()) { + return (R) toLocalDate().getChronology(); + } else if (query == Queries.precision()) { + return (R) NANOS; } + // inline TemporalAccessor.super.query(query) as an optimization + // non-JDK classes are not permitted to make this optimization return query.queryFrom(this); } /** * Adjusts the specified temporal object to have the same date and time as this object.
*** 273,291 **** * @throws ArithmeticException if numeric overflow occurs */ @Override public default Temporal adjustInto(Temporal temporal) { return temporal ! .with(EPOCH_DAY, getDate().toEpochDay()) ! .with(NANO_OF_DAY, getTime().toNanoOfDay()); } //----------------------------------------------------------------------- /** ! * Returns a zoned date-time formed from this date-time and the specified time-zone. * <p> ! * This creates a zoned date-time matching the input date-time as closely as possible. * Time-zone rules, such as daylight savings, mean that not every local date-time * is valid for the specified zone, thus the local date-time may be adjusted. * <p> * The local date-time is resolved to a single instant on the time-line. * This is achieved by finding a valid offset from UTC/Greenwich for the local --- 285,304 ---- * @throws ArithmeticException if numeric overflow occurs */ @Override public default Temporal adjustInto(Temporal temporal) { return temporal ! .with(EPOCH_DAY, toLocalDate().toEpochDay()) ! .with(NANO_OF_DAY, toLocalTime().toNanoOfDay()); } //----------------------------------------------------------------------- /** ! * Combines this time with a time-zone to create a {@code ChronoZonedDateTime}. * <p> ! * This returns a {@code ChronoZonedDateTime} formed from this date-time at the ! * specified time-zone. The result will match this date-time as closely as possible. * Time-zone rules, such as daylight savings, mean that not every local date-time * is valid for the specified zone, thus the local date-time may be adjusted. * <p> * The local date-time is resolved to a single instant on the time-line. * This is achieved by finding a valid offset from UTC/Greenwich for the local
*** 300,316 **** * For a typical one hour daylight savings change, the local date-time will be * moved one hour later into the offset typically corresponding to "summer". * <p> * To obtain the later offset during an overlap, call * {@link ChronoZonedDateTime#withLaterOffsetAtOverlap()} on the result of this method. - * <p> - * This instance is immutable and unaffected by this method call. * * @param zone the time-zone to use, not null * @return the zoned date-time formed from this date-time, not null */ ! ChronoZonedDateTime<C> atZone(ZoneId zone); //----------------------------------------------------------------------- /** * Converts this date-time to an {@code Instant}. * <p> --- 313,327 ---- * For a typical one hour daylight savings change, the local date-time will be * moved one hour later into the offset typically corresponding to "summer". * <p> * To obtain the later offset during an overlap, call * {@link ChronoZonedDateTime#withLaterOffsetAtOverlap()} on the result of this method. * * @param zone the time-zone to use, not null * @return the zoned date-time formed from this date-time, not null */ ! ChronoZonedDateTime<D> atZone(ZoneId zone); //----------------------------------------------------------------------- /** * Converts this date-time to an {@code Instant}. * <p>
*** 322,332 **** * * @param offset the offset to use for the conversion, not null * @return an {@code Instant} representing the same instant, not null */ public default Instant toInstant(ZoneOffset offset) { ! return Instant.ofEpochSecond(toEpochSecond(offset), getTime().getNano()); } /** * Converts this date-time to the number of seconds from the epoch * of 1970-01-01T00:00:00Z. --- 333,343 ---- * * @param offset the offset to use for the conversion, not null * @return an {@code Instant} representing the same instant, not null */ public default Instant toInstant(ZoneOffset offset) { ! return Instant.ofEpochSecond(toEpochSecond(offset), toLocalTime().getNano()); } /** * Converts this date-time to the number of seconds from the epoch * of 1970-01-01T00:00:00Z.
*** 341,352 **** * @param offset the offset to use for the conversion, not null * @return the number of seconds from the epoch of 1970-01-01T00:00:00Z */ public default long toEpochSecond(ZoneOffset offset) { Objects.requireNonNull(offset, "offset"); ! long epochDay = getDate().toEpochDay(); ! long secs = epochDay * 86400 + getTime().toSecondOfDay(); secs -= offset.getTotalSeconds(); return secs; } //----------------------------------------------------------------------- --- 352,363 ---- * @param offset the offset to use for the conversion, not null * @return the number of seconds from the epoch of 1970-01-01T00:00:00Z */ public default long toEpochSecond(ZoneOffset offset) { Objects.requireNonNull(offset, "offset"); ! long epochDay = toLocalDate().toEpochDay(); ! long secs = epochDay * 86400 + toLocalTime().toSecondOfDay(); secs -= offset.getTotalSeconds(); return secs; } //-----------------------------------------------------------------------
*** 376,390 **** * @param other the other date-time to compare to, not null * @return the comparator value, negative if less, positive if greater */ @Override public default int compareTo(ChronoLocalDateTime<?> other) { ! int cmp = getDate().compareTo(other.getDate()); if (cmp == 0) { ! cmp = getTime().compareTo(other.getTime()); if (cmp == 0) { ! cmp = getDate().getChrono().compareTo(other.getDate().getChrono()); } } return cmp; } --- 387,401 ---- * @param other the other date-time to compare to, not null * @return the comparator value, negative if less, positive if greater */ @Override public default int compareTo(ChronoLocalDateTime<?> other) { ! int cmp = toLocalDate().compareTo(other.toLocalDate()); if (cmp == 0) { ! cmp = toLocalTime().compareTo(other.toLocalTime()); if (cmp == 0) { ! cmp = toLocalDate().getChronology().compareTo(other.toLocalDate().getChronology()); } } return cmp; }
*** 401,414 **** * * @param other the other date-time to compare to, not null * @return true if this is after the specified date-time */ public default boolean isAfter(ChronoLocalDateTime<?> other) { ! long thisEpDay = this.getDate().toEpochDay(); ! long otherEpDay = other.getDate().toEpochDay(); return thisEpDay > otherEpDay || ! (thisEpDay == otherEpDay && this.getTime().toNanoOfDay() > other.getTime().toNanoOfDay()); } /** * Checks if this date-time is before the specified date-time ignoring the chronology. * <p> --- 412,425 ---- * * @param other the other date-time to compare to, not null * @return true if this is after the specified date-time */ public default boolean isAfter(ChronoLocalDateTime<?> other) { ! long thisEpDay = this.toLocalDate().toEpochDay(); ! long otherEpDay = other.toLocalDate().toEpochDay(); return thisEpDay > otherEpDay || ! (thisEpDay == otherEpDay && this.toLocalTime().toNanoOfDay() > other.toLocalTime().toNanoOfDay()); } /** * Checks if this date-time is before the specified date-time ignoring the chronology. * <p>
*** 422,435 **** * * @param other the other date-time to compare to, not null * @return true if this is before the specified date-time */ public default boolean isBefore(ChronoLocalDateTime<?> other) { ! long thisEpDay = this.getDate().toEpochDay(); ! long otherEpDay = other.getDate().toEpochDay(); return thisEpDay < otherEpDay || ! (thisEpDay == otherEpDay && this.getTime().toNanoOfDay() < other.getTime().toNanoOfDay()); } /** * Checks if this date-time is equal to the specified date-time ignoring the chronology. * <p> --- 433,446 ---- * * @param other the other date-time to compare to, not null * @return true if this is before the specified date-time */ public default boolean isBefore(ChronoLocalDateTime<?> other) { ! long thisEpDay = this.toLocalDate().toEpochDay(); ! long otherEpDay = other.toLocalDate().toEpochDay(); return thisEpDay < otherEpDay || ! (thisEpDay == otherEpDay && this.toLocalTime().toNanoOfDay() < other.toLocalTime().toNanoOfDay()); } /** * Checks if this date-time is equal to the specified date-time ignoring the chronology. * <p>
*** 444,455 **** * @param other the other date-time to compare to, not null * @return true if the underlying date-time is equal to the specified date-time on the timeline */ public default boolean isEqual(ChronoLocalDateTime<?> other) { // Do the time check first, it is cheaper than computing EPOCH day. ! return this.getTime().toNanoOfDay() == other.getTime().toNanoOfDay() && ! this.getDate().toEpochDay() == other.getDate().toEpochDay(); } /** * Checks if this date-time is equal to another date-time, including the chronology. * <p> --- 455,466 ---- * @param other the other date-time to compare to, not null * @return true if the underlying date-time is equal to the specified date-time on the timeline */ public default boolean isEqual(ChronoLocalDateTime<?> other) { // Do the time check first, it is cheaper than computing EPOCH day. ! return this.toLocalTime().toNanoOfDay() == other.toLocalTime().toNanoOfDay() && ! this.toLocalDate().toEpochDay() == other.toLocalDate().toEpochDay(); } /** * Checks if this date-time is equal to another date-time, including the chronology. * <p>
*** 483,499 **** /** * Outputs this date-time as a {@code String} using the formatter. * <p> * The default implementation must behave as follows: * <pre> ! * return formatter.print(this); * </pre> * * @param formatter the formatter to use, not null * @return the formatted date-time string, not null * @throws DateTimeException if an error occurs during printing */ public default String toString(DateTimeFormatter formatter) { Objects.requireNonNull(formatter, "formatter"); ! return formatter.print(this); } } --- 494,510 ---- /** * Outputs this date-time as a {@code String} using the formatter. * <p> * The default implementation must behave as follows: * <pre> ! * return formatter.format(this); * </pre> * * @param formatter the formatter to use, not null * @return the formatted date-time string, not null * @throws DateTimeException if an error occurs during printing */ public default String toString(DateTimeFormatter formatter) { Objects.requireNonNull(formatter, "formatter"); ! return formatter.format(this); } }