1 /*

     2  * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 /*

    27  * This file is available under and governed by the GNU General Public

    28  * License version 2 only, as published by the Free Software Foundation.

    29  * However, the following notice accompanied the original version of this

    30  * file:

    31  *

    32  * Copyright (c) 2007-2012, Stephen Colebourne & Michael Nascimento Santos

    33  *

    34  * All rights reserved.

    35  *

    36  * Redistribution and use in source and binary forms, with or without

    37  * modification, are permitted provided that the following conditions are met:

    38  *

    39  *  * Redistributions of source code must retain the above copyright notice,

    40  *    this list of conditions and the following disclaimer.

    41  *

    42  *  * Redistributions in binary form must reproduce the above copyright notice,

    43  *    this list of conditions and the following disclaimer in the documentation

    44  *    and/or other materials provided with the distribution.

    45  *

    46  *  * Neither the name of JSR-310 nor the names of its contributors

    47  *    may be used to endorse or promote products derived from this software

    48  *    without specific prior written permission.

    49  *

    50  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    51  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    52  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    53  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

    54  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    55  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    56  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    57  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

    58  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

    59  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

    60  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    61  */

    62 package build.tools.tzdb;

    63 

    64 import static build.tools.tzdb.Utils.*;

    65 import static build.tools.tzdb.LocalTime.HOURS_PER_DAY;

    66 import static build.tools.tzdb.LocalTime.MICROS_PER_DAY;

    67 import static build.tools.tzdb.LocalTime.MILLIS_PER_DAY;

    68 import static build.tools.tzdb.LocalTime.MINUTES_PER_DAY;

    69 import static build.tools.tzdb.LocalTime.SECONDS_PER_DAY;

    70 import static build.tools.tzdb.LocalTime.SECONDS_PER_MINUTE;

    71 import static build.tools.tzdb.LocalTime.SECONDS_PER_HOUR;

    72 

    73 import java.util.Objects;

    74 

    75 /**

    76  * A date-time without a time-zone in the ISO-8601 calendar system,

    77  * such as {@code 2007-12-03T10:15:30}.

    78  *

    79  * @since 1.8

    80  */

    81 final class LocalDateTime {

    82 

    83     /**

    84      * The minimum supported {@code LocalDateTime}, '-999999999-01-01T00:00:00'.

    85      * This is the local date-time of midnight at the start of the minimum date.

    86      * This combines {@link LocalDate#MIN} and {@link LocalTime#MIN}.

    87      * This could be used by an application as a "far past" date-time.

    88      */

    89     public static final LocalDateTime MIN = LocalDateTime.of(LocalDate.MIN, LocalTime.MIN);

    90     /**

    91      * The maximum supported {@code LocalDateTime}, '+999999999-12-31T23:59:59.999999999'.

    92      * This is the local date-time just before midnight at the end of the maximum date.

    93      * This combines {@link LocalDate#MAX} and {@link LocalTime#MAX}.

    94      * This could be used by an application as a "far future" date-time.

    95      */

    96     public static final LocalDateTime MAX = LocalDateTime.of(LocalDate.MAX, LocalTime.MAX);

    97 

    98     /**

    99      * The date part.

   100      */

   101     private final LocalDate date;

   102     /**

   103      * The time part.

   104      */

   105     private final LocalTime time;

   106 

   107     /**

   108      * Obtains an instance of {@code LocalDateTime} from year, month,

   109      * day, hour and minute, setting the second and nanosecond to zero.

   110      * <p>

   111      * The day must be valid for the year and month, otherwise an exception will be thrown.

   112      * The second and nanosecond fields will be set to zero.

   113      *

   114      * @param year  the year to represent, from MIN_YEAR to MAX_YEAR

   115      * @param month  the month-of-year to represent, from 1 (January) to 12 (December)

   116      * @param dayOfMonth  the day-of-month to represent, from 1 to 31

   117      * @param hour  the hour-of-day to represent, from 0 to 23

   118      * @param minute  the minute-of-hour to represent, from 0 to 59

   119      * @return the local date-time, not null

   120      * @throws DateTimeException if the value of any field is out of range

   121      * @throws DateTimeException if the day-of-month is invalid for the month-year

   122      */

   123     public static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute) {

   124         LocalDate date = LocalDate.of(year, month, dayOfMonth);

   125         LocalTime time = LocalTime.of(hour, minute);

   126         return new LocalDateTime(date, time);

   127     }

   128 

   129     /**

   130      * Obtains an instance of {@code LocalDateTime} from a date and time.

   131      *

   132      * @param date  the local date, not null

   133      * @param time  the local time, not null

   134      * @return the local date-time, not null

   135      */

   136     public static LocalDateTime of(LocalDate date, LocalTime time) {

   137         Objects.requireNonNull(date, "date");

   138         Objects.requireNonNull(time, "time");

   139         return new LocalDateTime(date, time);

   140     }

   141 

   142     /**

   143      * Obtains an instance of {@code LocalDateTime} using seconds from the

   144      * epoch of 1970-01-01T00:00:00Z.

   145      * <p>

   146      * This allows the {@link ChronoField#INSTANT_SECONDS epoch-second} field

   147      * to be converted to a local date-time. This is primarily intended for

   148      * low-level conversions rather than general application usage.

   149      *

   150      * @param epochSecond  the number of seconds from the epoch of 1970-01-01T00:00:00Z

   151      * @param nanoOfSecond  the nanosecond within the second, from 0 to 999,999,999

   152      * @param offset  the zone offset, not null

   153      * @return the local date-time, not null

   154      * @throws DateTimeException if the result exceeds the supported range

   155      */

   156     public static LocalDateTime ofEpochSecond(long epochSecond, int nanoOfSecond, ZoneOffset offset) {

   157         Objects.requireNonNull(offset, "offset");

   158         long localSecond = epochSecond + offset.getTotalSeconds();  // overflow caught later

   159         long localEpochDay = floorDiv(localSecond, SECONDS_PER_DAY);

   160         int secsOfDay = (int)floorMod(localSecond, SECONDS_PER_DAY);

   161         LocalDate date = LocalDate.ofEpochDay(localEpochDay);

   162         LocalTime time = LocalTime.ofSecondOfDay(secsOfDay);  // ignore nano

   163         return new LocalDateTime(date, time);

   164     }

   165 

   166     /**

   167      * Constructor.

   168      *

   169      * @param date  the date part of the date-time, validated not null

   170      * @param time  the time part of the date-time, validated not null

   171      */

   172     private LocalDateTime(LocalDate date, LocalTime time) {

   173         this.date = date;

   174         this.time = time;

   175     }

   176 

   177     /**

   178      * Returns a copy of this date-time with the new date and time, checking

   179      * to see if a new object is in fact required.

   180      *

   181      * @param newDate  the date of the new date-time, not null

   182      * @param newTime  the time of the new date-time, not null

   183      * @return the date-time, not null

   184      */

   185     private LocalDateTime with(LocalDate newDate, LocalTime newTime) {

   186         if (date == newDate && time == newTime) {

   187             return this;

   188         }

   189         return new LocalDateTime(newDate, newTime);

   190     }

   191 

   192     /**

   193      * Gets the {@code LocalDate} part of this date-time.

   194      * <p>

   195      * This returns a {@code LocalDate} with the same year, month and day

   196      * as this date-time.

   197      *

   198      * @return the date part of this date-time, not null

   199      */

   200     public LocalDate getDate() {

   201         return date;

   202     }

   203 

   204     /**

   205      * Gets the year field.

   206      * <p>

   207      * This method returns the primitive {@code int} value for the year.

   208      * <p>

   209      * The year returned by this method is proleptic as per {@code get(YEAR)}.

   210      * To obtain the year-of-era, use {@code get(YEAR_OF_ERA}.

   211      *

   212      * @return the year, from MIN_YEAR to MAX_YEAR

   213      */

   214     public int getYear() {

   215         return date.getYear();

   216     }

   217 

   218     /**

   219      * Gets the month-of-year field as an int from 1 to 12.

   220      *

   221      * @return the month-of-year

   222      */

   223     public int getMonth() {

   224         return date.getMonth();

   225     }

   226 

   227     /**

   228      * Gets the day-of-month field.

   229      * <p>

   230      * This method returns the primitive {@code int} value for the day-of-month.

   231      *

   232      * @return the day-of-month, from 1 to 31

   233      */

   234     public int getDayOfMonth() {

   235         return date.getDayOfMonth();

   236     }

   237 

   238     /**

   239      * Gets the day-of-week field, which is an integer from 1 to 7.

   240      *

   241      * @return the day-of-week, from 1 to 7

   242      */

   243     public int getDayOfWeek() {

   244         return date.getDayOfWeek();

   245     }

   246 

   247     /**

   248      * Gets the {@code LocalTime} part of this date-time.

   249      * <p>

   250      * This returns a {@code LocalTime} with the same hour, minute, second and

   251      * nanosecond as this date-time.

   252      *

   253      * @return the time part of this date-time, not null

   254      */

   255     public LocalTime getTime() {

   256         return time;

   257     }

   258 

   259     /**

   260      * Gets the hour-of-day field.

   261      *

   262      * @return the hour-of-day, from 0 to 23

   263      */

   264     public int getHour() {

   265         return time.getHour();

   266     }

   267 

   268     /**

   269      * Gets the minute-of-hour field.

   270      *

   271      * @return the minute-of-hour, from 0 to 59

   272      */

   273     public int getMinute() {

   274         return time.getMinute();

   275     }

   276 

   277     /**

   278      * Gets the second-of-minute field.

   279      *

   280      * @return the second-of-minute, from 0 to 59

   281      */

   282     public int getSecond() {

   283         return time.getSecond();

   284     }

   285 

   286     /**

   287      * Converts this date-time to the number of seconds from the epoch

   288      * of 1970-01-01T00:00:00Z.

   289      * <p>

   290      * This combines this local date-time and the specified offset to calculate the

   291      * epoch-second value, which is the number of elapsed seconds from 1970-01-01T00:00:00Z.

   292      * Instants on the time-line after the epoch are positive, earlier are negative.

   293      * <p>

   294      * This default implementation calculates from the epoch-day of the date and the

   295      * second-of-day of the time.

   296      *

   297      * @param offset  the offset to use for the conversion, not null

   298      * @return the number of seconds from the epoch of 1970-01-01T00:00:00Z

   299      */

   300     public long toEpochSecond(ZoneOffset offset) {

   301         Objects.requireNonNull(offset, "offset");

   302         long epochDay = getDate().toEpochDay();

   303         long secs = epochDay * 86400 + getTime().toSecondOfDay();

   304         secs -= offset.getTotalSeconds();

   305         return secs;

   306     }

   307 

   308     /**

   309      * Returns a copy of this {@code LocalDateTime} with the specified period in days added.

   310      * <p>

   311      * This method adds the specified amount to the days field incrementing the

   312      * month and year fields as necessary to ensure the result remains valid.

   313      * The result is only invalid if the maximum/minimum year is exceeded.

   314      * <p>

   315      * For example, 2008-12-31 plus one day would result in 2009-01-01.

   316      * <p>

   317      * This instance is immutable and unaffected by this method call.

   318      *

   319      * @param days  the days to add, may be negative

   320      * @return a {@code LocalDateTime} based on this date-time with the days added, not null

   321      * @throws DateTimeException if the result exceeds the supported date range

   322      */

   323     public LocalDateTime plusDays(long days) {

   324         LocalDate newDate = date.plusDays(days);

   325         return with(newDate, time);

   326     }

   327 

   328     /**

   329      * Returns a copy of this {@code LocalDateTime} with the specified period in seconds added.

   330      * <p>

   331      * This instance is immutable and unaffected by this method call.

   332      *

   333      * @param seconds  the seconds to add, may be negative

   334      * @return a {@code LocalDateTime} based on this date-time with the seconds added, not null

   335      * @throws DateTimeException if the result exceeds the supported date range

   336      */

   337     public LocalDateTime plusSeconds(long seconds) {

   338         return plusWithOverflow(date, 0, 0, seconds, 1);

   339     }

   340 

   341     /**

   342      * Returns a copy of this {@code LocalDateTime} with the specified period added.

   343      * <p>

   344      * This instance is immutable and unaffected by this method call.

   345      *

   346      * @param newDate  the new date to base the calculation on, not null

   347      * @param hours  the hours to add, may be negative

   348      * @param minutes the minutes to add, may be negative

   349      * @param seconds the seconds to add, may be negative

   350      * @param nanos the nanos to add, may be negative

   351      * @param sign  the sign to determine add or subtract

   352      * @return the combined result, not null

   353      */

   354     private LocalDateTime plusWithOverflow(LocalDate newDate, long hours, long minutes, long seconds, int sign) {

   355         if ((hours | minutes | seconds) == 0) {

   356             return with(newDate, time);

   357         }

   358         long totDays = seconds / SECONDS_PER_DAY +                //   max/24*60*60

   359                        minutes / MINUTES_PER_DAY +                //   max/24*60

   360                        hours / HOURS_PER_DAY;                     //   max/24

   361         totDays *= sign;                                          // total max*0.4237...

   362         long totSecs = (seconds % SECONDS_PER_DAY) +

   363                        (minutes % MINUTES_PER_DAY) * SECONDS_PER_MINUTE +

   364                        (hours % HOURS_PER_DAY) * SECONDS_PER_HOUR;

   365         long curSoD = time.toSecondOfDay();

   366         totSecs = totSecs * sign + curSoD;                    // total 432000000000000

   367         totDays += floorDiv(totSecs, SECONDS_PER_DAY);

   368 

   369         int newSoD = (int)floorMod(totSecs, SECONDS_PER_DAY);

   370         LocalTime newTime = (newSoD == curSoD ? time : LocalTime.ofSecondOfDay(newSoD));

   371         return with(newDate.plusDays(totDays), newTime);

   372     }

   373 

   374     /**

   375      * Compares this date-time to another date-time.

   376      * <p>

   377      * The comparison is primarily based on the date-time, from earliest to latest.

   378      * It is "consistent with equals", as defined by {@link Comparable}.

   379      * <p>

   380      * If all the date-times being compared are instances of {@code LocalDateTime},

   381      * then the comparison will be entirely based on the date-time.

   382      * If some dates being compared are in different chronologies, then the

   383      * chronology is also considered, see {@link ChronoLocalDateTime#compareTo}.

   384      *

   385      * @param other  the other date-time to compare to, not null

   386      * @return the comparator value, negative if less, positive if greater

   387      */

   388     public int compareTo(LocalDateTime other) {

   389         int cmp = date.compareTo(other.getDate());

   390         if (cmp == 0) {

   391             cmp = time.compareTo(other.getTime());

   392         }

   393         return cmp;

   394     }

   395 

   396     /**

   397      * Checks if this date-time is equal to another date-time.

   398      * <p>

   399      * Compares this {@code LocalDateTime} with another ensuring that the date-time is the same.

   400      * Only objects of type {@code LocalDateTime} are compared, other types return false.

   401      *

   402      * @param obj  the object to check, null returns false

   403      * @return true if this is equal to the other date-time

   404      */

   405     @Override

   406     public boolean equals(Object obj) {

   407         if (this == obj) {

   408             return true;

   409         }

   410         if (obj instanceof LocalDateTime) {

   411             LocalDateTime other = (LocalDateTime) obj;

   412             return date.equals(other.date) && time.equals(other.time);

   413         }

   414         return false;

   415     }

   416 

   417     /**

   418      * A hash code for this date-time.

   419      *

   420      * @return a suitable hash code

   421      */

   422     @Override

   423     public int hashCode() {

   424         return date.hashCode() ^ time.hashCode();

   425     }

   426 

   427 }