| /* |
| * Copyright (c) 2000, 2013, 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(); |
| } |
| } |
