jdk-sandbox: comparison jdk/test/sun/util/calendar/zi/ZoneInfoOld.java

equal deleted inserted replaced

-:c588664d547e
+:55b829ca2334
+/*
+* 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;
+/**
+* <code>ZoneInfoOld</code> is an implementation subclass of {@link
+* java.util.TimeZone TimeZone} that represents GMT offsets and
+* daylight saving time transitions of a time zone.
+* <p>
+* 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,
+* <code>ZoneInfoOld</code> 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.
+* <p>
+* 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 <code>getOffset</code> 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.
+* <p>
+* 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
+* <em>standard</em> 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 <code>long</code>) in local time and its GMT offset (in
+* seconds in <code>int</code>) in the chronological order. Byte
+* values of each <code>long</code> and <code>int</code> 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 <code>useDaylight</code> 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.
+* <ul>
+* <li>The most significant 52-bit field represents transition
+* time in milliseconds from Gregorian January 1 1970, 00:00:00
+* GMT.</li>
+* <li>The next 4-bit field is reserved and must be 0.</li>
+* <li>The next 4-bit field is an index value to {@link #offsets
+* offsets[]} for the amount of daylight saving at the
+* transition. If this value is zero, it means that no daylight
+* saving, not the index value zero.</li>
+* <li>The least significant 4-bit field is an index value to
+* {@link #offsets offsets[]} for <em>total</em> GMT offset at the
+* transition.</li>
+* </ul>
+* 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.
+* <p>
+* <em>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.</em>
+*
+* @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 <em>standard</em> 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<String> idList = ZoneInfoFile.getZoneIDs();
+List<String> excluded = ZoneInfoFile.getExcludedZones();
+if (excluded != null) {
+// List all zones from the idList and excluded lists
+List<String> 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<String> matched = new ArrayList<>();
+List<String> 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<String> 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<String, String> 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 <code>ZoneInfoOld</code>.
+*/
+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 <code>TimeZone</code> 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<Map<String, String>> aliasTable;
+static Map<String, String> getCachedAliasTable() {
+Map<String, String> aliases = null;
+SoftReference<Map<String, String>> 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
+*    <code>ZoneInfoOldMappings</code> file is not available.
+*/
+public synchronized static Map<String, String> getAliasTable() {
+Map<String, String> 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<Map<String, String>>(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();
+}
+}

changeset 15658	55b829ca2334
child 23010	6dadb192ad81