--- /dev/null 2013-01-18 16:17:08.886776012 -0800 +++ new/test/sun/util/calendar/zi/ZoneInfoOld.java 2013-02-06 22:33:51.000000000 -0800 @@ -0,0 +1,1047 @@ +/* + * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.lang.ref.SoftReference; +import java.time.ZoneOffset; +import java.time.LocalDateTime; +import java.util.Arrays; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.SimpleTimeZone; +import java.util.TimeZone; + +import sun.util.calendar.CalendarSystem; +import sun.util.calendar.CalendarDate; + +/** + * ZoneInfoOld is an implementation subclass of {@link + * java.util.TimeZone TimeZone} that represents GMT offsets and + * daylight saving time transitions of a time zone. + *

+ * The daylight saving time transitions are described in the {@link + * #transitions transitions} table consisting of a chronological + * sequence of transitions of GMT offset and/or daylight saving time + * changes. Since all transitions are represented in UTC, in theory, + * ZoneInfoOld can be used with any calendar systems except + * for the {@link #getOffset(int,int,int,int,int,int) getOffset} + * method that takes Gregorian calendar date fields. + *

+ * This table covers transitions from 1900 until 2037 (as of version + * 1.4), Before 1900, it assumes that there was no daylight saving + * time and the getOffset methods always return the + * {@link #getRawOffset} value. No Local Mean Time is supported. If a + * specified date is beyond the transition table and this time zone is + * supposed to observe daylight saving time in 2037, it delegates + * operations to a {@link java.util.SimpleTimeZone SimpleTimeZone} + * object created using the daylight saving time schedule as of 2037. + *

+ * The date items, transitions, GMT offset(s), etc. are read from a database + * file. See {@link ZoneInfoFile} for details. + * @see java.util.SimpleTimeZone + * @since 1.4 + */ + +public class ZoneInfoOld extends TimeZone { + + // The constants assume no leap seconds support. + static final int SECOND_IN_MILLIS = 1000; + static final int MINUTE_IN_MILLIS = SECOND_IN_MILLIS * 60; + static final int HOUR_IN_MILLIS = MINUTE_IN_MILLIS * 60; + static final int DAY_IN_MILLIS = HOUR_IN_MILLIS * 24; + + private static final int UTC_TIME = 0; + private static final int STANDARD_TIME = 1; + private static final int WALL_TIME = 2; + + private static final long OFFSET_MASK = 0x0fL; + private static final long DST_MASK = 0xf0L; + private static final int DST_NSHIFT = 4; + // this bit field is reserved for abbreviation support + private static final long ABBR_MASK = 0xf00L; + private static final int TRANSITION_NSHIFT = 12; + + // Flag for supporting JDK backward compatible IDs, such as "EST". + static final boolean USE_OLDMAPPING; + static { + String oldmapping = System.getProperty("sun.timezone.ids.oldmapping", "false").toLowerCase(Locale.ROOT); + USE_OLDMAPPING = (oldmapping.equals("yes") || oldmapping.equals("true")); + } + + // IDs having conflicting data between Olson and JDK 1.1 + static final String[] conflictingIDs = { + "EST", "MST", "HST" + }; + + private static final CalendarSystem gcal = CalendarSystem.getGregorianCalendar(); + + /** + * The raw GMT offset in milliseconds between this zone and GMT. + * Negative offsets are to the west of Greenwich. To obtain local + * standard time, add the offset to GMT time. + * @serial + */ + int rawOffset; + + /** + * Difference in milliseconds from the original GMT offset in case + * the raw offset value has been modified by calling {@link + * #setRawOffset}. The initial value is 0. + * @serial + */ + int rawOffsetDiff = 0; + + /** + * A CRC32 value of all pairs of transition time (in milliseconds + * in long) in local time and its GMT offset (in + * seconds in int) in the chronological order. Byte + * values of each long and int are taken + * in the big endian order (i.e., MSB to LSB). + * @serial + */ + int checksum; + + /** + * The amount of time in milliseconds saved during daylight saving + * time. If useDaylight is false, this value is 0. + * @serial + */ + int dstSavings; + + /** + * This array describes transitions of GMT offsets of this time + * zone, including both raw offset changes and daylight saving + * time changes. + * A long integer consists of four bit fields. + *

+ * If this time zone doesn't observe daylight saving time and has + * never changed any GMT offsets in the past, this value is null. + * @serial + */ + long[] transitions; + + /** + * This array holds all unique offset values in + * milliseconds. Index values to this array are stored in the + * transitions array elements. + * @serial + */ + int[] offsets; + + /** + * SimpleTimeZone parameter values. It has to have either 8 for + * {@link java.util.SimpleTimeZone#SimpleTimeZone(int, String, + * int, int , int , int , int , int , int , int , int) the + * 11-argument SimpleTimeZone constructor} or 10 for {@link + * java.util.SimpleTimeZone#SimpleTimeZone(int, String, int, int, + * int , int , int , int , int , int , int, int, int) the + * 13-argument SimpleTimeZone constructor} parameters. + * @serial + */ + int[] simpleTimeZoneParams; + + /** + * True if the raw GMT offset value would change after the time + * zone data has been generated; false, otherwise. The default + * value is false. + * @serial + */ + boolean willGMTOffsetChange = false; + + /** + * True if the object has been modified after its instantiation. + */ + transient private boolean dirty = false; + + private static final long serialVersionUID = 2653134537216586139L; + + /** + * A constructor. + */ + public ZoneInfoOld() { + } + + /** + * A Constructor for CustomID. + */ + public ZoneInfoOld(String ID, int rawOffset) { + this(ID, rawOffset, 0, 0, null, null, null, false); + } + + /** + * Constructs a ZoneInfoOld instance. + * + * @param ID time zone name + * @param rawOffset GMT offset in milliseconds + * @param dstSavings daylight saving value in milliseconds or 0 + * (zero) if this time zone doesn't observe Daylight Saving Time. + * @param checksum CRC32 value with all transitions table entry + * values + * @param transitions transition table + * @param offsets offset value table + * @param simpleTimeZoneParams parameter values for constructing + * SimpleTimeZone + * @param willGMTOffsetChange the value of willGMTOffsetChange + */ + ZoneInfoOld(String ID, + int rawOffset, + int dstSavings, + int checksum, + long[] transitions, + int[] offsets, + int[] simpleTimeZoneParams, + boolean willGMTOffsetChange) { + setID(ID); + this.rawOffset = rawOffset; + this.dstSavings = dstSavings; + this.checksum = checksum; + this.transitions = transitions; + this.offsets = offsets; + this.simpleTimeZoneParams = simpleTimeZoneParams; + this.willGMTOffsetChange = willGMTOffsetChange; + } + + /** + * Returns the difference in milliseconds between local time and UTC + * of given time, taking into account both the raw offset and the + * effect of daylight savings. + * + * @param date the milliseconds in UTC + * @return the milliseconds to add to UTC to get local wall time + */ + public int getOffset(long date) { + return getOffsets(date, null, UTC_TIME); + } + + public int getOffsets(long utc, int[] offsets) { + return getOffsets(utc, offsets, UTC_TIME); + } + + public int getOffsetsByStandard(long standard, int[] offsets) { + return getOffsets(standard, offsets, STANDARD_TIME); + } + + public int getOffsetsByWall(long wall, int[] offsets) { + return getOffsets(wall, offsets, WALL_TIME); + } + + private int getOffsets(long date, int[] offsets, int type) { + // if dst is never observed, there is no transition. + if (transitions == null) { + int offset = getLastRawOffset(); + if (offsets != null) { + offsets[0] = offset; + offsets[1] = 0; + } + return offset; + } + + date -= rawOffsetDiff; + int index = getTransitionIndex(date, type); + + // prior to the transition table, returns the raw offset. + // FIXME: should support LMT. + if (index < 0) { + int offset = getLastRawOffset(); + if (offsets != null) { + offsets[0] = offset; + offsets[1] = 0; + } + return offset; + } + + if (index < transitions.length) { + long val = transitions[index]; + int offset = this.offsets[(int)(val & OFFSET_MASK)] + rawOffsetDiff; + if (offsets != null) { + int dst = (int)((val >>> DST_NSHIFT) & 0xfL); + int save = (dst == 0) ? 0 : this.offsets[dst]; + offsets[0] = offset - save; + offsets[1] = save; + } + return offset; + } + + // beyond the transitions, delegate to SimpleTimeZone if there + // is a rule; otherwise, return rawOffset. + SimpleTimeZone tz = getLastRule(); + if (tz != null) { + int rawoffset = tz.getRawOffset(); + long msec = date; + if (type != UTC_TIME) { + msec -= rawOffset; + } + int dstoffset = tz.getOffset(msec) - rawOffset; + + // Check if it's in a standard-to-daylight transition. + if (dstoffset > 0 && tz.getOffset(msec - dstoffset) == rawoffset) { + dstoffset = 0; + } + + if (offsets != null) { + offsets[0] = rawoffset; + offsets[1] = dstoffset; + } + return rawoffset + dstoffset; + } + int offset = getLastRawOffset(); + if (offsets != null) { + offsets[0] = offset; + offsets[1] = 0; + } + return offset; + } + + private int getTransitionIndex(long date, int type) { + int low = 0; + int high = transitions.length - 1; + + while (low <= high) { + int mid = (low + high) / 2; + long val = transitions[mid]; + long midVal = val >> TRANSITION_NSHIFT; // sign extended + if (type != UTC_TIME) { + midVal += offsets[(int)(val & OFFSET_MASK)]; // wall time + } + if (type == STANDARD_TIME) { + int dstIndex = (int)((val >>> DST_NSHIFT) & 0xfL); + if (dstIndex != 0) { + midVal -= offsets[dstIndex]; // make it standard time + } + } + + if (midVal < date) { + low = mid + 1; + } else if (midVal > date) { + high = mid - 1; + } else { + return mid; + } + } + + // if beyond the transitions, returns that index. + if (low >= transitions.length) { + return low; + } + return low - 1; + } + + /** + * Returns the difference in milliseconds between local time and + * UTC, taking into account both the raw offset and the effect of + * daylight savings, for the specified date and time. This method + * assumes that the start and end month are distinct. This method + * assumes a Gregorian calendar for calculations. + *

+ * Note: In general, clients should use + * {@link Calendar#ZONE_OFFSET Calendar.get(ZONE_OFFSET)} + + * {@link Calendar#DST_OFFSET Calendar.get(DST_OFFSET)} + * instead of calling this method. + * + * @param era The era of the given date. The value must be either + * GregorianCalendar.AD or GregorianCalendar.BC. + * @param year The year in the given date. + * @param month The month in the given date. Month is 0-based. e.g., + * 0 for January. + * @param day The day-in-month of the given date. + * @param dayOfWeek The day-of-week of the given date. + * @param millis The milliseconds in day in standard local time. + * @return The milliseconds to add to UTC to get local time. + */ + public int getOffset(int era, int year, int month, int day, + int dayOfWeek, int milliseconds) { + if (milliseconds < 0 || milliseconds >= DAY_IN_MILLIS) { + throw new IllegalArgumentException(); + } + + if (era == java.util.GregorianCalendar.BC) { // BC + year = 1 - year; + } else if (era != java.util.GregorianCalendar.AD) { + throw new IllegalArgumentException(); + } + + CalendarDate date = gcal.newCalendarDate(null); + date.setDate(year, month + 1, day); + if (gcal.validate(date) == false) { + throw new IllegalArgumentException(); + } + + // bug-for-bug compatible argument checking + if (dayOfWeek < java.util.GregorianCalendar.SUNDAY + || dayOfWeek > java.util.GregorianCalendar.SATURDAY) { + throw new IllegalArgumentException(); + } + + if (transitions == null) { + return getLastRawOffset(); + } + + long dateInMillis = gcal.getTime(date) + milliseconds; + dateInMillis -= (long) rawOffset; // make it UTC + return getOffsets(dateInMillis, null, UTC_TIME); + } + + /** + * Sets the base time zone offset from GMT. This operation + * modifies all the transitions of this ZoneInfoOld object, including + * historical ones, if applicable. + * + * @param offsetMillis the base time zone offset to GMT. + * @see getRawOffset + */ + public synchronized void setRawOffset(int offsetMillis) { + if (offsetMillis == rawOffset + rawOffsetDiff) { + return; + } + rawOffsetDiff = offsetMillis - rawOffset; + if (lastRule != null) { + lastRule.setRawOffset(offsetMillis); + } + dirty = true; + } + + /** + * Returns the GMT offset of the current date. This GMT offset + * value is not modified during Daylight Saving Time. + * + * @return the GMT offset value in milliseconds to add to UTC time + * to get local standard time + */ + public int getRawOffset() { + if (!willGMTOffsetChange) { + return rawOffset + rawOffsetDiff; + } + + int[] offsets = new int[2]; + getOffsets(System.currentTimeMillis(), offsets, UTC_TIME); + return offsets[0]; + } + + public boolean isDirty() { + return dirty; + } + + int getLastRawOffset() { + return rawOffset + rawOffsetDiff; + } + + /** + * Queries if this time zone uses Daylight Saving Time in the last known rule. + */ + public boolean useDaylightTime() { + return (simpleTimeZoneParams != null); + } + + @Override + public boolean observesDaylightTime() { + if (simpleTimeZoneParams != null) { + return true; + } + if (transitions == null) { + return false; + } + + // Look up the transition table to see if it's in DST right + // now or if there's any standard-to-daylight transition at + // any future. + long utc = System.currentTimeMillis() - rawOffsetDiff; + int index = getTransitionIndex(utc, UTC_TIME); + + // before transitions in the transition table + if (index < 0) { + return false; + } + + // the time is in the table range. + for (int i = index; i < transitions.length; i++) { + if ((transitions[i] & DST_MASK) != 0) { + return true; + } + } + // No further DST is observed. + return false; + } + + /** + * Queries if the specified date is in Daylight Saving Time. + */ + public boolean inDaylightTime(Date date) { + if (date == null) { + throw new NullPointerException(); + } + + if (transitions == null) { + return false; + } + + long utc = date.getTime() - rawOffsetDiff; + int index = getTransitionIndex(utc, UTC_TIME); + + // before transitions in the transition table + if (index < 0) { + return false; + } + + // the time is in the table range. + if (index < transitions.length) { + return (transitions[index] & DST_MASK) != 0; + } + + // beyond the transition table + SimpleTimeZone tz = getLastRule(); + if (tz != null) { + return tz.inDaylightTime(date); + } + return false; + } + + /** + * Returns the amount of time in milliseconds that the clock is advanced + * during daylight saving time is in effect in its last daylight saving time rule. + * + * @return the number of milliseconds the time is advanced with respect to + * standard time when daylight saving time is in effect. + */ + public int getDSTSavings() { + return dstSavings; + } + +// /** +// * @return the last year in the transition table or -1 if this +// * time zone doesn't observe any daylight saving time. +// */ +// public int getMaxTransitionYear() { +// if (transitions == null) { +// return -1; +// } +// long val = transitions[transitions.length - 1]; +// int offset = this.offsets[(int)(val & OFFSET_MASK)] + rawOffsetDiff; +// val = (val >> TRANSITION_NSHIFT) + offset; +// CalendarDate lastDate = Gregorian.getCalendarDate(val); +// return lastDate.getYear(); +// } + + /** + * Returns a string representation of this time zone. + * @return the string + */ + public String toString() { + return getClass().getName() + + "[id=\"" + getID() + "\"" + + ",offset=" + getLastRawOffset() + + ",dstSavings=" + dstSavings + + ",useDaylight=" + useDaylightTime() + + ",transitions=" + ((transitions != null) ? transitions.length : 0) + + ",lastRule=" + (lastRule == null ? getLastRuleInstance() : lastRule) + + "]"; + } + + /** + * Gets all available IDs supported in the Java run-time. + * + * @return an array of time zone IDs. + */ + public static String[] getAvailableIDs() { + List idList = ZoneInfoFile.getZoneIDs(); + List excluded = ZoneInfoFile.getExcludedZones(); + if (excluded != null) { + // List all zones from the idList and excluded lists + List list = new ArrayList<>(idList.size() + excluded.size()); + list.addAll(idList); + list.addAll(excluded); + idList = list; + } + String[] ids = new String[idList.size()]; + return idList.toArray(ids); + } + + /** + * Gets all available IDs that have the same value as the + * specified raw GMT offset. + * + * @param rawOffset the GMT offset in milliseconds. This + * value should not include any daylight saving time. + * + * @return an array of time zone IDs. + */ + public static String[] getAvailableIDs(int rawOffset) { + String[] result; + List matched = new ArrayList<>(); + List IDs = ZoneInfoFile.getZoneIDs(); + int[] rawOffsets = ZoneInfoFile.getRawOffsets(); + + loop: + for (int index = 0; index < rawOffsets.length; index++) { + if (rawOffsets[index] == rawOffset) { + byte[] indices = ZoneInfoFile.getRawOffsetIndices(); + for (int i = 0; i < indices.length; i++) { + if (indices[i] == index) { + matched.add(IDs.get(i++)); + while (i < indices.length && indices[i] == index) { + matched.add(IDs.get(i++)); + } + break loop; + } + } + } + } + + // We need to add any zones from the excluded zone list that + // currently have the same GMT offset as the specified + // rawOffset. The zones returned by this method may not be + // correct as of return to the caller if any GMT offset + // transition is happening during this GMT offset checking... + List excluded = ZoneInfoFile.getExcludedZones(); + if (excluded != null) { + for (String id : excluded) { + TimeZone zi = getTimeZone(id); + if (zi != null && zi.getRawOffset() == rawOffset) { + matched.add(id); + } + } + } + + result = new String[matched.size()]; + matched.toArray(result); + return result; + } + + /** + * Gets the ZoneInfoOld for the given ID. + * + * @param ID the ID for a ZoneInfoOld. See TimeZone for detail. + * + * @return the specified ZoneInfoOld object, or null if there is no + * time zone of the ID. + */ + public static TimeZone getTimeZone(String ID) { + String givenID = null; + + /* + * If old JDK compatibility is specified, get the old alias + * name. + */ + if (USE_OLDMAPPING) { + String compatibleID = TzIDOldMapping.MAP.get(ID); + if (compatibleID != null) { + givenID = ID; + ID = compatibleID; + } + } + + ZoneInfoOld zi = ZoneInfoFile.getZoneInfoOld(ID); + if (zi == null) { + // if we can't create an object for the ID, try aliases. + try { + Map map = getAliasTable(); + String alias = ID; + while ((alias = map.get(alias)) != null) { + zi = ZoneInfoFile.getZoneInfoOld(alias); + if (zi != null) { + zi.setID(ID); + zi = ZoneInfoFile.addToCache(ID, zi); + zi = (ZoneInfoOld) zi.clone(); + break; + } + } + } catch (Exception e) { + // ignore exceptions + } + } + + if (givenID != null && zi != null) { + zi.setID(givenID); + } + return zi; + } + + private transient SimpleTimeZone lastRule; + + /** + * Returns a SimpleTimeZone object representing the last GMT + * offset and DST schedule or null if this time zone doesn't + * observe DST. + */ + synchronized SimpleTimeZone getLastRule() { + if (lastRule == null) { + lastRule = getLastRuleInstance(); + } + return lastRule; + } + + /** + * Returns a SimpleTimeZone object that represents the last + * known daylight saving time rules. + * + * @return a SimpleTimeZone object or null if this time zone + * doesn't observe DST. + */ + public SimpleTimeZone getLastRuleInstance() { + if (simpleTimeZoneParams == null) { + return null; + } + if (simpleTimeZoneParams.length == 10) { + return new SimpleTimeZone(getLastRawOffset(), getID(), + simpleTimeZoneParams[0], + simpleTimeZoneParams[1], + simpleTimeZoneParams[2], + simpleTimeZoneParams[3], + simpleTimeZoneParams[4], + simpleTimeZoneParams[5], + simpleTimeZoneParams[6], + simpleTimeZoneParams[7], + simpleTimeZoneParams[8], + simpleTimeZoneParams[9], + dstSavings); + } + return new SimpleTimeZone(getLastRawOffset(), getID(), + simpleTimeZoneParams[0], + simpleTimeZoneParams[1], + simpleTimeZoneParams[2], + simpleTimeZoneParams[3], + simpleTimeZoneParams[4], + simpleTimeZoneParams[5], + simpleTimeZoneParams[6], + simpleTimeZoneParams[7], + dstSavings); + } + + /** + * Returns a copy of this ZoneInfoOld. + */ + public Object clone() { + ZoneInfoOld zi = (ZoneInfoOld) super.clone(); + zi.lastRule = null; + return zi; + } + + /** + * Returns a hash code value calculated from the GMT offset and + * transitions. + * @return a hash code of this time zone + */ + public int hashCode() { + return getLastRawOffset() ^ checksum; + } + + /** + * Compares the equity of two ZoneInfoOld objects. + * + * @param obj the object to be compared with + * @return true if given object is same as this ZoneInfoOld object, + * false otherwise. + */ + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof ZoneInfoOld)) { + return false; + } + ZoneInfoOld that = (ZoneInfoOld) obj; + return (getID().equals(that.getID()) + && (getLastRawOffset() == that.getLastRawOffset()) + && (checksum == that.checksum)); + } + + /** + * Returns true if this zone has the same raw GMT offset value and + * transition table as another zone info. If the specified + * TimeZone object is not a ZoneInfoOld instance, this method returns + * true if the specified TimeZone object has the same raw GMT + * offset value with no daylight saving time. + * + * @param other the ZoneInfoOld object to be compared with + * @return true if the given TimeZone has the same + * GMT offset and transition information; false, otherwise. + */ + public boolean hasSameRules(TimeZone other) { + if (this == other) { + return true; + } + if (other == null) { + return false; + } + if (!(other instanceof ZoneInfoOld)) { + if (getRawOffset() != other.getRawOffset()) { + return false; + } + // if both have the same raw offset and neither observes + // DST, they have the same rule. + if ((transitions == null) + && (useDaylightTime() == false) + && (other.useDaylightTime() == false)) { + return true; + } + return false; + } + if (getLastRawOffset() != ((ZoneInfoOld)other).getLastRawOffset()) { + return false; + } + return (checksum == ((ZoneInfoOld)other).checksum); + } + + private static SoftReference> aliasTable; + + static Map getCachedAliasTable() { + Map aliases = null; + + SoftReference> cache = aliasTable; + if (cache != null) { + aliases = cache.get(); + } + return aliases; + } + + /** + * Returns a Map from alias time zone IDs to their standard + * time zone IDs. + * + * @return the Map that holds the mappings from alias time zone IDs + * to their standard time zone IDs, or null if + * ZoneInfoOldMappings file is not available. + */ + public synchronized static Map getAliasTable() { + Map aliases = getCachedAliasTable(); + if (aliases == null) { + aliases = ZoneInfoFile.getZoneAliases(); + if (aliases != null) { + if (!USE_OLDMAPPING) { + // Remove the conflicting IDs from the alias table. + for (String key : conflictingIDs) { + aliases.remove(key); + } + } + aliasTable = new SoftReference>(aliases); + } + } + return aliases; + } + + private void readObject(ObjectInputStream stream) + throws IOException, ClassNotFoundException { + stream.defaultReadObject(); + // We don't know how this object from 1.4.x or earlier has + // been mutated. So it should always be marked as `dirty'. + dirty = true; + } + + ////////////////////////////////////////////////////////////// + public boolean equalsTo(ZoneInfoOld other) { + return (getID().equals(other.getID()) + && (getLastRawOffset() == other.getLastRawOffset()) + && (dstSavings == other.dstSavings) + && (willGMTOffsetChange == other.willGMTOffsetChange) + && (checksum == other.checksum) + && equalsTransOffsets(other) + && (Arrays.equals(simpleTimeZoneParams, other.simpleTimeZoneParams) || + getLastRule().equals(other.getLastRule()))); + } + + private boolean equalsTransOffsets(ZoneInfoOld other) { + if (transitions == null) { + return (other.transitions == null && + Arrays.equals(offsets, other.offsets)); + } + if (other.transitions == null || + transitions.length != other.transitions.length) { + return false; + } + // if offsets and other.offsets have different order + // the last 4-bit in trans are different. + for (int i = 0; i < transitions.length; i++) { + long val = transitions[i]; + int dst = (int)((val >>> DST_NSHIFT) & 0xfL); + int save = (dst == 0) ? 0 : offsets[dst] / 1000; + int off = offsets[(int)(val & OFFSET_MASK)]/1000; + long second = (val >> TRANSITION_NSHIFT)/1000; + + val = other.transitions[i]; + int dstO = (int)((val >>> DST_NSHIFT) & 0xfL); + int saveO = (dstO == 0) ? 0 : other.offsets[dstO] / 1000; + int offO = other.offsets[(int)(val & OFFSET_MASK)]/1000; + long secondO = (val >> TRANSITION_NSHIFT)/1000; + if ((dst == 0) != (dstO == 0) || save != saveO || off != offO || second != secondO) + return false; + } + return true; + } + + private int transToString(long val, int off_old, int[] offsets, StringBuilder sb) { + int dst = (int)((val >>> DST_NSHIFT) & 0xfL); + int save = (dst == 0) ? 0 : offsets[dst] / 1000; + int off = offsets[(int)(val & OFFSET_MASK)]/1000; + long second = (val >> TRANSITION_NSHIFT)/1000; + ZoneOffset offset_old = ZoneOffset.ofTotalSeconds(off_old); + ZoneOffset offset = ZoneOffset.ofTotalSeconds(off); + sb.append(" " + LocalDateTime.ofEpochSecond(second, 0, offset_old)); + + sb.append(" [utc=" + second + + " raw=" + Long.toHexString(val >> TRANSITION_NSHIFT) + + ", offset=" + off + "/" + offset + ", saving=" + save + "]"); + return off; + } + + public String diffsTo(ZoneInfoOld other) { + + int rawOffset0 = other.rawOffset; + int checksum0 = other.checksum; + int dstSavings0 = other.dstSavings; + long[] transitions0 = other.transitions; + int[] offsets0 = other.offsets; + int[] simpleTimeZoneParams0 = other.simpleTimeZoneParams; + boolean willGMTOffsetChange0 = other.willGMTOffsetChange; + + + //return getClass().getName() + + StringBuilder sb = new StringBuilder(); + sb.append("******************************\n" + + getID() + " : " + other.getID()); + // ROC is excluded by ZoneInfoOld + if ("ROC".equals(getID())) { + return sb.toString(); + } + if (rawOffset != rawOffset0 || + dstSavings != dstSavings0 || + checksum != checksum0 || + willGMTOffsetChange != willGMTOffsetChange0 || + (simpleTimeZoneParams != null ) != (simpleTimeZoneParams0 != null) || + (transitions != null && transitions0 != null && + transitions.length != transitions0.length)) + { + sb.append("\n offset=" + getLastRawOffset() + + ",dstSavings=" + dstSavings + + ",useDaylight=" + useDaylightTime() + + ",transitions=" + ((transitions != null) ? transitions.length : 0) + + ",offsets=" + ((offsets != null) ? offsets.length : 0) + + ",checksum=" + checksum + + ",gmtChanged=" + willGMTOffsetChange) + .append("\n[NG]offset=" + rawOffset0 + + ",dstSavings=" + dstSavings0 + + ",useDaylight=" + (simpleTimeZoneParams != null) + + ",transitions=" + ((transitions0 != null) ? transitions0.length : 0) + + ",offsets=" + ((offsets0 != null) ? offsets0.length : 0) + + ",checksum=" + checksum0 + + ",gmtChanged=" + willGMTOffsetChange0 + + ""); + } + // offsets + if (!Arrays.equals(offsets, offsets0)) { + sb.append("\n offset.len=" + ((offsets != null)? offsets.length : "null") + + " " + ((offsets0 != null)? offsets0.length : "null")); + if (offsets != null && offsets0.length != 0) { + int len = Math.min(offsets.length, offsets0.length); + int i = 0; + for (i = 0; i < len; i++) { + sb.append("\n " + + ZoneOffset.ofTotalSeconds(offsets[i]/1000) + " " + + ZoneOffset.ofTotalSeconds(offsets0[i]/1000)); + } + for (; i < offsets0.length; i++) { + sb.append("\n " + ZoneOffset.ofTotalSeconds(offsets0[i]/1000)); + } + } + } + // trans + int offset = 0; + int offset0 = 0; + if (!equalsTransOffsets(other)) { + sb.append("\n -------------"); + if ((transitions == null) != (transitions0 == null)) { + sb.append("\n (NG) Different trans(null) :" + + transitions + ", " + transitions0); + if (transitions != null) { + for (int i = 0; i < transitions.length; i++) { + sb.append("\n (NG)"); + offset = transToString(transitions[i], offset, offsets, sb); + } + } + } else { + if (transitions.length != transitions0.length) { + sb.append("\n (NG) Different trans size :" + + transitions.length + ", " + transitions0.length); + } + int length = Math.min(transitions.length, transitions0.length); + for (int i = 0; i < length; i++) { + // sb.append("\n[" + i + "] "); + // offset = transToString(transitions[i], offset, offsets, sb); + long val = transitions[i]; + int dst = (int)((val >>> DST_NSHIFT) & 0xfL); + int save = (dst == 0) ? 0 : offsets[dst] / 1000; + int off = offsets[(int)(val & OFFSET_MASK)]/1000; + long second = (val >> TRANSITION_NSHIFT)/1000; + sb.append("\n "); + offset = transToString(transitions[i], offset, offsets, sb); + if (transitions0 == null || i >= transitions0.length) { + sb.append("\n "); + offset = transToString(transitions[i], offset, offsets, sb); + sb.append("\n (NG) trans0 is null or < trans.length"); + } else { + long val0 = transitions0[i]; + int dst0 = (int)((val0 >>> DST_NSHIFT) & 0xfL); + int save0 = (dst0 == 0) ? 0 : offsets0[dst0] / 1000; + int off0 = offsets0[(int)(val0 & OFFSET_MASK)]/1000; + long second0 = (val0 >> TRANSITION_NSHIFT)/1000; + if (save != save0 || off != off0 || second != second0) { + sb.append("\n (NG)"); + } else { + sb.append("\n (OK)"); + } + offset0 = transToString(transitions0[i], offset0, offsets0, sb); + sb.append("\n -----"); + } + } + } + } + SimpleTimeZone stz = getLastRuleInstance(); + if (stz != null) { + SimpleTimeZone stz0 = other.getLastRule(); + if (!stz.hasSameRules(stz0)) { + sb.append("\n -------------") + .append("\n SimpleTimeZone (NG)") + .append("\n stz=" + stz) + .append("\n stz0=" + stz0); + } + } + sb.append("\n -------------"); + return sb.toString(); + } +}