java.util.TimeZone Maven / Gradle / Ivy
/*
* Copyright (c) 1996, 2011, 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.
*/
/*
* (C) Copyright Taligent, Inc. 1996 - All Rights Reserved
* (C) Copyright IBM Corp. 1996 - All Rights Reserved
*
* The original version of this source code and documentation is copyrighted
* and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
* materials are provided under terms of a License Agreement between Taligent
* and Sun. This technology is protected by multiple US and International
* patents. This notice and attribution to Taligent may not be removed.
* Taligent is a registered trademark of Taligent, Inc.
*
*/
package java.util;
import java.io.Serializable;
import java.lang.ref.SoftReference;
import java.util.concurrent.ConcurrentHashMap;
import org.apidesign.bck2brwsr.core.JavaScriptBody;
/**
* TimeZone represents a time zone offset, and also figures out daylight
* savings.
*
*
* Typically, you get a TimeZone using getDefault
* which creates a TimeZone based on the time zone where the program
* is running. For example, for a program running in Japan, getDefault
* creates a TimeZone object based on Japanese Standard Time.
*
*
* You can also get a TimeZone using getTimeZone
* along with a time zone ID. For instance, the time zone ID for the
* U.S. Pacific Time zone is "America/Los_Angeles". So, you can get a
* U.S. Pacific Time TimeZone object with:
*
* TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles");
*
* You can use the getAvailableIDs method to iterate through
* all the supported time zone IDs. You can then choose a
* supported ID to get a TimeZone.
* If the time zone you want is not represented by one of the
* supported IDs, then a custom time zone ID can be specified to
* produce a TimeZone. The syntax of a custom time zone ID is:
*
*
* CustomID:
* GMT Sign Hours : Minutes
* GMT Sign Hours Minutes
* GMT Sign Hours
* Sign: one of
* + -
* Hours:
* Digit
* Digit Digit
* Minutes:
* Digit Digit
* Digit: one of
* 0 1 2 3 4 5 6 7 8 9
*
*
* Hours must be between 0 to 23 and Minutes must be
* between 00 to 59. For example, "GMT+10" and "GMT+0010" mean ten
* hours and ten minutes ahead of GMT, respectively.
*
* The format is locale independent and digits must be taken from the
* Basic Latin block of the Unicode standard. No daylight saving time
* transition schedule can be specified with a custom time zone ID. If
* the specified string doesn't match the syntax, "GMT"
* is used.
*
* When creating a TimeZone, the specified custom time
* zone ID is normalized in the following syntax:
*
* NormalizedCustomID:
* GMT Sign TwoDigitHours : Minutes
* Sign: one of
* + -
* TwoDigitHours:
* Digit Digit
* Minutes:
* Digit Digit
* Digit: one of
* 0 1 2 3 4 5 6 7 8 9
*
* For example, TimeZone.getTimeZone("GMT-8").getID() returns "GMT-08:00".
*
* Three-letter time zone IDs
*
* For compatibility with JDK 1.1.x, some other three-letter time zone IDs
* (such as "PST", "CTT", "AST") are also supported. However, their
* use is deprecated because the same abbreviation is often used
* for multiple time zones (for example, "CST" could be U.S. "Central Standard
* Time" and "China Standard Time"), and the Java platform can then only
* recognize one of them.
*
*
* @see Calendar
* @see GregorianCalendar
* @see SimpleTimeZone
* @author Mark Davis, David Goldsmith, Chen-Lieh Huang, Alan Liu
* @since JDK1.1
*/
abstract public class TimeZone implements Serializable, Cloneable {
/**
* Sole constructor. (For invocation by subclass constructors, typically
* implicit.)
*/
public TimeZone() {
}
/**
* A style specifier for getDisplayName() indicating
* a short name, such as "PST."
* @see #LONG
* @since 1.2
*/
public static final int SHORT = 0;
/**
* A style specifier for getDisplayName() indicating
* a long name, such as "Pacific Standard Time."
* @see #SHORT
* @since 1.2
*/
public static final int LONG = 1;
// Constants used internally; unit is milliseconds
private static final int ONE_MINUTE = 60*1000;
private static final int ONE_HOUR = 60*ONE_MINUTE;
private static final int ONE_DAY = 24*ONE_HOUR;
// Proclaim serialization compatibility with JDK 1.1
static final long serialVersionUID = 3581463369166924961L;
/**
* Gets the time zone offset, for current date, modified in case of
* daylight savings. This is the offset to add to UTC to get local time.
*
* This method returns a historically correct offset if an
* underlying TimeZone implementation subclass
* supports historical Daylight Saving Time schedule and GMT
* offset changes.
*
* @param era the era of the given date.
* @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 milliseconds the milliseconds in day in standard
* local time.
*
* @return the offset in milliseconds to add to GMT to get local time.
*
* @see Calendar#ZONE_OFFSET
* @see Calendar#DST_OFFSET
*/
public abstract int getOffset(int era, int year, int month, int day,
int dayOfWeek, int milliseconds);
/**
* Returns the offset of this time zone from UTC at the specified
* date. If Daylight Saving Time is in effect at the specified
* date, the offset value is adjusted with the amount of daylight
* saving.
*
* This method returns a historically correct offset value if an
* underlying TimeZone implementation subclass supports historical
* Daylight Saving Time schedule and GMT offset changes.
*
* @param date the date represented in milliseconds since January 1, 1970 00:00:00 GMT
* @return the amount of time in milliseconds to add to UTC to get local time.
*
* @see Calendar#ZONE_OFFSET
* @see Calendar#DST_OFFSET
* @since 1.4
*/
public int getOffset(long date) {
if (inDaylightTime(new Date(date))) {
return getRawOffset() + getDSTSavings();
}
return getRawOffset();
}
/**
* Gets the raw GMT offset and the amount of daylight saving of this
* time zone at the given time.
* @param date the milliseconds (since January 1, 1970,
* 00:00:00.000 GMT) at which the time zone offset and daylight
* saving amount are found
* @param offset an array of int where the raw GMT offset
* (offset[0]) and daylight saving amount (offset[1]) are stored,
* or null if those values are not needed. The method assumes that
* the length of the given array is two or larger.
* @return the total amount of the raw GMT offset and daylight
* saving at the specified date.
*
* @see Calendar#ZONE_OFFSET
* @see Calendar#DST_OFFSET
*/
int getOffsets(long date, int[] offsets) {
int rawoffset = getRawOffset();
int dstoffset = 0;
if (inDaylightTime(new Date(date))) {
dstoffset = getDSTSavings();
}
if (offsets != null) {
offsets[0] = rawoffset;
offsets[1] = dstoffset;
}
return rawoffset + dstoffset;
}
/**
* Sets the base time zone offset to GMT.
* This is the offset to add to UTC to get local time.
*
* If an underlying TimeZone implementation subclass
* supports historical GMT offset changes, the specified GMT
* offset is set as the latest GMT offset and the difference from
* the known latest GMT offset value is used to adjust all
* historical GMT offset values.
*
* @param offsetMillis the given base time zone offset to GMT.
*/
abstract public void setRawOffset(int offsetMillis);
/**
* Returns the amount of time in milliseconds to add to UTC to get
* standard time in this time zone. Because this value is not
* affected by daylight saving time, it is called raw
* offset.
*
* If an underlying TimeZone implementation subclass
* supports historical GMT offset changes, the method returns the
* raw offset value of the current date. In Honolulu, for example,
* its raw offset changed from GMT-10:30 to GMT-10:00 in 1947, and
* this method always returns -36000000 milliseconds (i.e., -10
* hours).
*
* @return the amount of raw offset time in milliseconds to add to UTC.
* @see Calendar#ZONE_OFFSET
*/
public abstract int getRawOffset();
/**
* Gets the ID of this time zone.
* @return the ID of this time zone.
*/
public String getID()
{
return ID;
}
/**
* Sets the time zone ID. This does not change any other data in
* the time zone object.
* @param ID the new time zone ID.
*/
public void setID(String ID)
{
if (ID == null) {
throw new NullPointerException();
}
this.ID = ID;
}
/**
* Returns a long standard time name of this {@code TimeZone} suitable for
* presentation to the user in the default locale.
*
*
This method is equivalent to:
*
* getDisplayName(false, {@link #LONG},
* Locale.getDefault({@link Locale.Category#DISPLAY}))
*
*
* @return the human-readable name of this time zone in the default locale.
* @since 1.2
* @see #getDisplayName(boolean, int, Locale)
* @see Locale#getDefault(Locale.Category)
* @see Locale.Category
*/
public final String getDisplayName() {
return getDisplayName(false, LONG,
Locale.getDefault(Locale.Category.DISPLAY));
}
/**
* Returns a long standard time name of this {@code TimeZone} suitable for
* presentation to the user in the specified {@code locale}.
*
* This method is equivalent to:
*
* getDisplayName(false, {@link #LONG}, locale)
*
*
* @param locale the locale in which to supply the display name.
* @return the human-readable name of this time zone in the given locale.
* @exception NullPointerException if {@code locale} is {@code null}.
* @since 1.2
* @see #getDisplayName(boolean, int, Locale)
*/
public final String getDisplayName(Locale locale) {
return getDisplayName(false, LONG, locale);
}
/**
* Returns a name in the specified {@code style} of this {@code TimeZone}
* suitable for presentation to the user in the default locale. If the
* specified {@code daylight} is {@code true}, a Daylight Saving Time name
* is returned (even if this {@code TimeZone} doesn't observe Daylight Saving
* Time). Otherwise, a Standard Time name is returned.
*
* This method is equivalent to:
*
* getDisplayName(daylight, style,
* Locale.getDefault({@link Locale.Category#DISPLAY}))
*
*
* @param daylight {@code true} specifying a Daylight Saving Time name, or
* {@code false} specifying a Standard Time name
* @param style either {@link #LONG} or {@link #SHORT}
* @return the human-readable name of this time zone in the default locale.
* @exception IllegalArgumentException if {@code style} is invalid.
* @since 1.2
* @see #getDisplayName(boolean, int, Locale)
* @see Locale#getDefault(Locale.Category)
* @see Locale.Category
* @see java.text.DateFormatSymbols#getZoneStrings()
*/
public final String getDisplayName(boolean daylight, int style) {
return getDisplayName(daylight, style,
Locale.getDefault(Locale.Category.DISPLAY));
}
/**
* Returns a name in the specified {@code style} of this {@code TimeZone}
* suitable for presentation to the user in the specified {@code
* locale}. If the specified {@code daylight} is {@code true}, a Daylight
* Saving Time name is returned (even if this {@code TimeZone} doesn't
* observe Daylight Saving Time). Otherwise, a Standard Time name is
* returned.
*
* When looking up a time zone name, the {@linkplain
* ResourceBundle.Control#getCandidateLocales(String,Locale) default
* Locale search path of ResourceBundle} derived
* from the specified {@code locale} is used. (No {@linkplain
* ResourceBundle.Control#getFallbackLocale(String,Locale) fallback
* Locale} search is performed.) If a time zone name in any
* {@code Locale} of the search path, including {@link Locale#ROOT}, is
* found, the name is returned. Otherwise, a string in the
* normalized custom ID format is returned.
*
* @param daylight {@code true} specifying a Daylight Saving Time name, or
* {@code false} specifying a Standard Time name
* @param style either {@link #LONG} or {@link #SHORT}
* @param locale the locale in which to supply the display name.
* @return the human-readable name of this time zone in the given locale.
* @exception IllegalArgumentException if {@code style} is invalid.
* @exception NullPointerException if {@code locale} is {@code null}.
* @since 1.2
* @see java.text.DateFormatSymbols#getZoneStrings()
*/
public String getDisplayName(boolean daylight, int style, Locale locale) {
if (style != SHORT && style != LONG) {
throw new IllegalArgumentException("Illegal style: " + style);
}
String id = getID();
String[] names = getDisplayNames(id, locale);
if (names == null) {
if (id.startsWith("GMT")) {
char sign = id.charAt(3);
if (sign == '+' || sign == '-') {
return id;
}
}
int offset = getRawOffset();
if (daylight) {
offset += getDSTSavings();
}
// return ZoneInfoFile.toCustomID(offset);
}
int index = daylight ? 3 : 1;
if (style == SHORT) {
index++;
}
return names[index];
}
private static class DisplayNames {
// Cache for managing display names per timezone per locale
// The structure is:
// Map(key=id, value=SoftReference(Map(key=locale, value=displaynames)))
private static final Map>> CACHE =
new ConcurrentHashMap>>();
}
private static final String[] getDisplayNames(String id, Locale locale) {
Map>> displayNames = DisplayNames.CACHE;
SoftReference> ref = displayNames.get(id);
if (ref != null) {
Map perLocale = ref.get();
if (perLocale != null) {
String[] names = perLocale.get(locale);
if (names != null) {
return names;
}
names = null; // TimeZoneNameUtility.retrieveDisplayNames(id, locale);
if (names != null) {
perLocale.put(locale, names);
}
return names;
}
}
String[] names = null; // TimeZoneNameUtility.retrieveDisplayNames(id, locale);
if (names != null) {
Map perLocale = new ConcurrentHashMap();
perLocale.put(locale, names);
ref = new SoftReference>(perLocale);
displayNames.put(id, ref);
}
return names;
}
/**
* Returns the amount of time to be added to local standard time
* to get local wall clock time.
*
* The default implementation returns 3600000 milliseconds
* (i.e., one hour) if a call to {@link #useDaylightTime()}
* returns {@code true}. Otherwise, 0 (zero) is returned.
*
*
If an underlying {@code TimeZone} implementation subclass
* supports historical and future Daylight Saving Time schedule
* changes, this method returns the amount of saving time of the
* last known Daylight Saving Time rule that can be a future
* prediction.
*
*
If the amount of saving time at any given time stamp is
* required, construct a {@link Calendar} with this {@code
* TimeZone} and the time stamp, and call {@link Calendar#get(int)
* Calendar.get}{@code (}{@link Calendar#DST_OFFSET}{@code )}.
*
* @return the amount of saving time in milliseconds
* @since 1.4
* @see #inDaylightTime(Date)
* @see #getOffset(long)
* @see #getOffset(int,int,int,int,int,int)
* @see Calendar#ZONE_OFFSET
*/
public int getDSTSavings() {
if (useDaylightTime()) {
return 3600000;
}
return 0;
}
/**
* Queries if this {@code TimeZone} uses Daylight Saving Time.
*
*
If an underlying {@code TimeZone} implementation subclass
* supports historical and future Daylight Saving Time schedule
* changes, this method refers to the last known Daylight Saving Time
* rule that can be a future prediction and may not be the same as
* the current rule. Consider calling {@link #observesDaylightTime()}
* if the current rule should also be taken into account.
*
* @return {@code true} if this {@code TimeZone} uses Daylight Saving Time,
* {@code false}, otherwise.
* @see #inDaylightTime(Date)
* @see Calendar#DST_OFFSET
*/
public abstract boolean useDaylightTime();
/**
* Returns {@code true} if this {@code TimeZone} is currently in
* Daylight Saving Time, or if a transition from Standard Time to
* Daylight Saving Time occurs at any future time.
*
*
The default implementation returns {@code true} if
* {@code useDaylightTime()} or {@code inDaylightTime(new Date())}
* returns {@code true}.
*
* @return {@code true} if this {@code TimeZone} is currently in
* Daylight Saving Time, or if a transition from Standard Time to
* Daylight Saving Time occurs at any future time; {@code false}
* otherwise.
* @since 1.7
* @see #useDaylightTime()
* @see #inDaylightTime(Date)
* @see Calendar#DST_OFFSET
*/
public boolean observesDaylightTime() {
return useDaylightTime() || inDaylightTime(new Date());
}
/**
* Queries if the given {@code date} is in Daylight Saving Time in
* this time zone.
*
* @param date the given Date.
* @return {@code true} if the given date is in Daylight Saving Time,
* {@code false}, otherwise.
*/
abstract public boolean inDaylightTime(Date date);
/**
* Gets the TimeZone for the given ID.
*
* @param ID the ID for a TimeZone, either an abbreviation
* such as "PST", a full name such as "America/Los_Angeles", or a custom
* ID such as "GMT-8:00". Note that the support of abbreviations is
* for JDK 1.1.x compatibility only and full names should be used.
*
* @return the specified TimeZone, or the GMT zone if the given ID
* cannot be understood.
*/
public static synchronized TimeZone getTimeZone(String ID) {
return getTimeZone(ID, true);
}
private static TimeZone getTimeZone(String ID, boolean fallback) {
// TimeZone tz = ZoneInfo.getTimeZone(ID);
// if (tz == null) {
// tz = parseCustomTimeZone(ID);
// if (tz == null && fallback) {
// tz = new ZoneInfo(GMT_ID, 0);
// }
// }
// return tz;
return TimeZone.NO_TIMEZONE;
}
/**
* Gets the available IDs according to the given time zone offset in milliseconds.
*
* @param rawOffset the given time zone GMT offset in milliseconds.
* @return an array of IDs, where the time zone for that ID has
* the specified GMT offset. For example, "America/Phoenix" and "America/Denver"
* both have GMT-07:00, but differ in daylight saving behavior.
* @see #getRawOffset()
*/
public static synchronized String[] getAvailableIDs(int rawOffset) {
return new String[0];//ZoneInfo.getAvailableIDs(rawOffset);
}
/**
* Gets all the available IDs supported.
* @return an array of IDs.
*/
public static synchronized String[] getAvailableIDs() {
return new String[0];//return ZoneInfo.getAvailableIDs();
}
/**
* Gets the platform defined TimeZone ID.
**/
private static native String getSystemTimeZoneID(String javaHome,
String country);
/**
* Gets the custom time zone ID based on the GMT offset of the
* platform. (e.g., "GMT+08:00")
*/
private static native String getSystemGMTOffsetID();
/**
* Gets the default TimeZone for this host.
* The source of the default TimeZone
* may vary with implementation.
* @return a default TimeZone.
* @see #setDefault
*/
public static TimeZone getDefault() {
return (TimeZone) getDefaultRef().clone();
}
/**
* Returns the reference to the default TimeZone object. This
* method doesn't create a clone.
*/
static TimeZone getDefaultRef() {
TimeZone defaultZone = null;//defaultZoneTL.get();
if (defaultZone == null) {
defaultZone = defaultTimeZone;
if (defaultZone == null) {
// Need to initialize the default time zone.
defaultZone = new TimeZone() {
@Override
public int getOffset(int era, int year, int month, int day, int dayOfWeek, int milliseconds) {
return getRawOffset();
}
@Override
public void setRawOffset(int offsetMillis) {
}
@Override
public int getRawOffset() {
int minutesOff = dateTimezoneOffset();
return -60 * 1000 * minutesOff;
}
@JavaScriptBody(args = { }, body = "return new Date().getTimezoneOffset();")
private native int dateTimezoneOffset();
@Override
public boolean useDaylightTime() {
return false;
}
@Override
public boolean inDaylightTime(Date date) {
return false;
}
};
}
}
// Don't clone here.
return defaultZone;
}
private static boolean hasPermission() {
boolean hasPermission = false;
return hasPermission;
}
/**
* Sets the TimeZone that is
* returned by the getDefault method. If zone
* is null, reset the default to the value it had originally when the
* VM first started.
* @param zone the new default time zone
* @see #getDefault
*/
public static void setDefault(TimeZone zone)
{
if (hasPermission()) {
synchronized (TimeZone.class) {
defaultTimeZone = zone;
// defaultZoneTL.set(null);
}
} else {
//defaultZoneTL.set(zone);
}
}
/**
* Returns true if this zone has the same rule and offset as another zone.
* That is, if this zone differs only in ID, if at all. Returns false
* if the other zone is null.
* @param other the TimeZone object to be compared with
* @return true if the other zone is not null and is the same as this one,
* with the possible exception of the ID
* @since 1.2
*/
public boolean hasSameRules(TimeZone other) {
return other != null && getRawOffset() == other.getRawOffset() &&
useDaylightTime() == other.useDaylightTime();
}
/**
* Creates a copy of this TimeZone.
*
* @return a clone of this TimeZone
*/
public Object clone()
{
try {
TimeZone other = (TimeZone) super.clone();
other.ID = ID;
return other;
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
/**
* The null constant as a TimeZone.
*/
static final TimeZone NO_TIMEZONE = null;
// =======================privates===============================
/**
* The string identifier of this TimeZone. This is a
* programmatic identifier used internally to look up TimeZone
* objects from the system table and also to map them to their localized
* display names. ID values are unique in the system
* table but may not be for dynamically created zones.
* @serial
*/
private String ID;
private static volatile TimeZone defaultTimeZone;
static final String GMT_ID = "GMT";
private static final int GMT_ID_LENGTH = 3;
/**
* Parses a custom time zone identifier and returns a corresponding zone.
* This method doesn't support the RFC 822 time zone format. (e.g., +hhmm)
*
* @param id a string of the custom ID form.
* @return a newly created TimeZone with the given offset and
* no daylight saving time, or null if the id cannot be parsed.
*/
private static final TimeZone parseCustomTimeZone(String id) {
return null;
}
}