jdk/make/src/classes/build/tools/tzdb/ZoneRules.java
changeset 21805 c7d7946239de
parent 15289 3ac550392e43
child 25158 e76154c2c239
equal deleted inserted replaced
21804:07b686da11c4 21805:c7d7946239de
       
     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) 2011-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 java.io.DataOutput;
       
    65 import java.io.IOException;
       
    66 import java.io.ObjectOutput;
       
    67 import java.util.Arrays;
       
    68 import java.util.ArrayList;
       
    69 import java.util.List;
       
    70 
       
    71 /**
       
    72  * Duplicated code of javax.time.zone.ZoneRules, ZoneOffsetTransitionRule
       
    73  * and Ser to generate the serialization form output of ZoneRules for
       
    74  * tzdb.jar.
       
    75  *
       
    76  * Implementation here is the copy/paste of ZoneRules, ZoneOffsetTransitionRule
       
    77  * and Ser in javax.time.zone package. Make sure the code here is synchrionozed
       
    78  * with the serialization implementation there.
       
    79  *
       
    80  * @since 1.8
       
    81  */
       
    82 
       
    83 final class ZoneRules {
       
    84 
       
    85     /**
       
    86      * The transitions between standard offsets (epoch seconds), sorted.
       
    87      */
       
    88     private final long[] standardTransitions;
       
    89     /**
       
    90      * The standard offsets.
       
    91      */
       
    92     private final ZoneOffset[] standardOffsets;
       
    93     /**
       
    94      * The transitions between instants (epoch seconds), sorted.
       
    95      */
       
    96     private final long[] savingsInstantTransitions;
       
    97 
       
    98     /**
       
    99      * The wall offsets.
       
   100      */
       
   101     private final ZoneOffset[] wallOffsets;
       
   102     /**
       
   103      * The last rule.
       
   104      */
       
   105     private final ZoneOffsetTransitionRule[] lastRules;
       
   106 
       
   107     /**
       
   108      * Creates an instance.
       
   109      *
       
   110      * @param baseStandardOffset  the standard offset to use before legal rules were set, not null
       
   111      * @param baseWallOffset  the wall offset to use before legal rules were set, not null
       
   112      * @param standardOffsetTransitionList  the list of changes to the standard offset, not null
       
   113      * @param transitionList  the list of transitions, not null
       
   114      * @param lastRules  the recurring last rules, size 16 or less, not null
       
   115      */
       
   116     ZoneRules(ZoneOffset baseStandardOffset,
       
   117               ZoneOffset baseWallOffset,
       
   118               List<ZoneOffsetTransition> standardOffsetTransitionList,
       
   119               List<ZoneOffsetTransition> transitionList,
       
   120               List<ZoneOffsetTransitionRule> lastRules) {
       
   121 
       
   122         this.standardTransitions = new long[standardOffsetTransitionList.size()];
       
   123 
       
   124         this.standardOffsets = new ZoneOffset[standardOffsetTransitionList.size() + 1];
       
   125         this.standardOffsets[0] = baseStandardOffset;
       
   126         for (int i = 0; i < standardOffsetTransitionList.size(); i++) {
       
   127             this.standardTransitions[i] = standardOffsetTransitionList.get(i).toEpochSecond();
       
   128             this.standardOffsets[i + 1] = standardOffsetTransitionList.get(i).getOffsetAfter();
       
   129         }
       
   130 
       
   131         // convert savings transitions to locals
       
   132         List<ZoneOffset> localTransitionOffsetList = new ArrayList<>();
       
   133         localTransitionOffsetList.add(baseWallOffset);
       
   134         for (ZoneOffsetTransition trans : transitionList) {
       
   135             localTransitionOffsetList.add(trans.getOffsetAfter());
       
   136         }
       
   137 
       
   138         this.wallOffsets = localTransitionOffsetList.toArray(new ZoneOffset[localTransitionOffsetList.size()]);
       
   139 
       
   140         // convert savings transitions to instants
       
   141         this.savingsInstantTransitions = new long[transitionList.size()];
       
   142         for (int i = 0; i < transitionList.size(); i++) {
       
   143             this.savingsInstantTransitions[i] = transitionList.get(i).toEpochSecond();
       
   144         }
       
   145 
       
   146         // last rules
       
   147         if (lastRules.size() > 16) {
       
   148             throw new IllegalArgumentException("Too many transition rules");
       
   149         }
       
   150         this.lastRules = lastRules.toArray(new ZoneOffsetTransitionRule[lastRules.size()]);
       
   151     }
       
   152 
       
   153     /** Type for ZoneRules. */
       
   154     static final byte ZRULES = 1;
       
   155 
       
   156     /**
       
   157      * Writes the state to the stream.
       
   158      *
       
   159      * @param out  the output stream, not null
       
   160      * @throws IOException if an error occurs
       
   161      */
       
   162     void writeExternal(DataOutput out) throws IOException {
       
   163         out.writeByte(ZRULES);
       
   164         out.writeInt(standardTransitions.length);
       
   165         for (long trans : standardTransitions) {
       
   166             writeEpochSec(trans, out);
       
   167         }
       
   168         for (ZoneOffset offset : standardOffsets) {
       
   169             writeOffset(offset, out);
       
   170         }
       
   171         out.writeInt(savingsInstantTransitions.length);
       
   172         for (long trans : savingsInstantTransitions) {
       
   173             writeEpochSec(trans, out);
       
   174         }
       
   175         for (ZoneOffset offset : wallOffsets) {
       
   176             writeOffset(offset, out);
       
   177         }
       
   178         out.writeByte(lastRules.length);
       
   179         for (ZoneOffsetTransitionRule rule : lastRules) {
       
   180             writeRule(rule, out);
       
   181         }
       
   182     }
       
   183 
       
   184     /**
       
   185      * Writes the state the ZoneOffset to the stream.
       
   186      *
       
   187      * @param offset  the offset, not null
       
   188      * @param out  the output stream, not null
       
   189      * @throws IOException if an error occurs
       
   190      */
       
   191     static void writeOffset(ZoneOffset offset, DataOutput out) throws IOException {
       
   192         final int offsetSecs = offset.getTotalSeconds();
       
   193         int offsetByte = offsetSecs % 900 == 0 ? offsetSecs / 900 : 127;  // compress to -72 to +72
       
   194         out.writeByte(offsetByte);
       
   195         if (offsetByte == 127) {
       
   196             out.writeInt(offsetSecs);
       
   197         }
       
   198     }
       
   199 
       
   200     /**
       
   201      * Writes the epoch seconds to the stream.
       
   202      *
       
   203      * @param epochSec  the epoch seconds, not null
       
   204      * @param out  the output stream, not null
       
   205      * @throws IOException if an error occurs
       
   206      */
       
   207     static void writeEpochSec(long epochSec, DataOutput out) throws IOException {
       
   208         if (epochSec >= -4575744000L && epochSec < 10413792000L && epochSec % 900 == 0) {  // quarter hours between 1825 and 2300
       
   209             int store = (int) ((epochSec + 4575744000L) / 900);
       
   210             out.writeByte((store >>> 16) & 255);
       
   211             out.writeByte((store >>> 8) & 255);
       
   212             out.writeByte(store & 255);
       
   213         } else {
       
   214             out.writeByte(255);
       
   215             out.writeLong(epochSec);
       
   216         }
       
   217     }
       
   218 
       
   219     /**
       
   220      * Writes the state of the transition rule to the stream.
       
   221      *
       
   222      * @param rule  the transition rule, not null
       
   223      * @param out  the output stream, not null
       
   224      * @throws IOException if an error occurs
       
   225      */
       
   226     static void writeRule(ZoneOffsetTransitionRule rule, DataOutput out) throws IOException {
       
   227         int month = rule.month;
       
   228         byte dom = rule.dom;
       
   229         int dow = rule.dow;
       
   230         LocalTime time = rule.time;
       
   231         boolean timeEndOfDay = rule.timeEndOfDay;
       
   232         TimeDefinition timeDefinition = rule.timeDefinition;
       
   233         ZoneOffset standardOffset = rule.standardOffset;
       
   234         ZoneOffset offsetBefore = rule.offsetBefore;
       
   235         ZoneOffset offsetAfter = rule.offsetAfter;
       
   236 
       
   237         int timeSecs = (timeEndOfDay ? 86400 : time.toSecondOfDay());
       
   238         int stdOffset = standardOffset.getTotalSeconds();
       
   239         int beforeDiff = offsetBefore.getTotalSeconds() - stdOffset;
       
   240         int afterDiff = offsetAfter.getTotalSeconds() - stdOffset;
       
   241         int timeByte = (timeSecs % 3600 == 0 ? (timeEndOfDay ? 24 : time.getHour()) : 31);
       
   242         int stdOffsetByte = (stdOffset % 900 == 0 ? stdOffset / 900 + 128 : 255);
       
   243         int beforeByte = (beforeDiff == 0 || beforeDiff == 1800 || beforeDiff == 3600 ? beforeDiff / 1800 : 3);
       
   244         int afterByte = (afterDiff == 0 || afterDiff == 1800 || afterDiff == 3600 ? afterDiff / 1800 : 3);
       
   245         int dowByte = (dow == -1 ? 0 : dow);
       
   246         int b = (month << 28) +                     // 4 bytes
       
   247                 ((dom + 32) << 22) +                // 6 bytes
       
   248                 (dowByte << 19) +                   // 3 bytes
       
   249                 (timeByte << 14) +                  // 5 bytes
       
   250                 (timeDefinition.ordinal() << 12) +  // 2 bytes
       
   251                 (stdOffsetByte << 4) +              // 8 bytes
       
   252                 (beforeByte << 2) +                 // 2 bytes
       
   253                 afterByte;                          // 2 bytes
       
   254         out.writeInt(b);
       
   255         if (timeByte == 31) {
       
   256             out.writeInt(timeSecs);
       
   257         }
       
   258         if (stdOffsetByte == 255) {
       
   259             out.writeInt(stdOffset);
       
   260         }
       
   261         if (beforeByte == 3) {
       
   262             out.writeInt(offsetBefore.getTotalSeconds());
       
   263         }
       
   264         if (afterByte == 3) {
       
   265             out.writeInt(offsetAfter.getTotalSeconds());
       
   266         }
       
   267     }
       
   268 
       
   269     /**
       
   270      * Checks if this set of rules equals another.
       
   271      * <p>
       
   272      * Two rule sets are equal if they will always result in the same output
       
   273      * for any given input instant or local date-time.
       
   274      * Rules from two different groups may return false even if they are in fact the same.
       
   275      * <p>
       
   276      * This definition should result in implementations comparing their entire state.
       
   277      *
       
   278      * @param otherRules  the other rules, null returns false
       
   279      * @return true if this rules is the same as that specified
       
   280      */
       
   281     @Override
       
   282     public boolean equals(Object otherRules) {
       
   283         if (this == otherRules) {
       
   284            return true;
       
   285         }
       
   286         if (otherRules instanceof ZoneRules) {
       
   287             ZoneRules other = (ZoneRules) otherRules;
       
   288             return Arrays.equals(standardTransitions, other.standardTransitions) &&
       
   289                     Arrays.equals(standardOffsets, other.standardOffsets) &&
       
   290                     Arrays.equals(savingsInstantTransitions, other.savingsInstantTransitions) &&
       
   291                     Arrays.equals(wallOffsets, other.wallOffsets) &&
       
   292                     Arrays.equals(lastRules, other.lastRules);
       
   293         }
       
   294         return false;
       
   295     }
       
   296 
       
   297     /**
       
   298      * Returns a suitable hash code given the definition of {@code #equals}.
       
   299      *
       
   300      * @return the hash code
       
   301      */
       
   302     @Override
       
   303     public int hashCode() {
       
   304         return Arrays.hashCode(standardTransitions) ^
       
   305                 Arrays.hashCode(standardOffsets) ^
       
   306                 Arrays.hashCode(savingsInstantTransitions) ^
       
   307                 Arrays.hashCode(wallOffsets) ^
       
   308                 Arrays.hashCode(lastRules);
       
   309     }
       
   310 
       
   311 }