| /* |
| ********************************************************************** |
| * Copyright (c) 2003-2009 International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| * Author: Alan Liu |
| * Created: September 4 2003 |
| * Since: ICU 2.8 |
| ********************************************************************** |
| */ |
| package com.ibm.icu.impl; |
| |
| import java.lang.ref.SoftReference; |
| import java.text.ParsePosition; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.MissingResourceException; |
| import java.util.Set; |
| |
| import com.ibm.icu.text.MessageFormat; |
| import com.ibm.icu.text.NumberFormat; |
| import com.ibm.icu.util.SimpleTimeZone; |
| import com.ibm.icu.util.TimeZone; |
| import com.ibm.icu.util.ULocale; |
| import com.ibm.icu.util.UResourceBundle; |
| import com.ibm.icu.util.UResourceBundleIterator; |
| |
| /** |
| * This class, not to be instantiated, implements the meta-data |
| * missing from the underlying core JDK implementation of time zones. |
| * There are two missing features: Obtaining a list of available zones |
| * for a given country (as defined by the Olson database), and |
| * obtaining a list of equivalent zones for a given zone (as defined |
| * by Olson links). |
| * |
| * This class uses a data class, ZoneMetaData, which is created by the |
| * tool tz2icu. |
| * |
| * @author Alan Liu |
| * @since ICU 2.8 |
| */ |
| public final class ZoneMeta { |
| private static final boolean ASSERT = false; |
| |
| /** |
| * Returns a String array containing all system TimeZone IDs |
| * associated with the given country. These IDs may be passed to |
| * <code>TimeZone.getTimeZone()</code> to construct the |
| * corresponding TimeZone object. |
| * @param country a two-letter ISO 3166 country code, or <code>null</code> |
| * to return zones not associated with any country |
| * @return an array of IDs for system TimeZones in the given |
| * country. If there are none, return a zero-length array. |
| */ |
| public static synchronized String[] getAvailableIDs(String country) { |
| if(!getOlsonMeta()){ |
| return EMPTY; |
| } |
| try{ |
| UResourceBundle top = (ICUResourceBundle)ICUResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "zoneinfo", ICUResourceBundle.ICU_DATA_CLASS_LOADER); |
| UResourceBundle regions = top.get(kREGIONS); |
| UResourceBundle names = top.get(kNAMES); // dereference Zones section |
| UResourceBundle temp = regions.get(country); |
| int[] vector = temp.getIntVector(); |
| if (ASSERT) Assert.assrt("vector.length>0", vector.length>0); |
| String[] ret = new String[vector.length]; |
| for (int i=0; i<vector.length; ++i) { |
| if (ASSERT) Assert.assrt("vector[i] >= 0 && vector[i] < OLSON_ZONE_COUNT", |
| vector[i] >= 0 && vector[i] < OLSON_ZONE_COUNT); |
| ret[i] = names.getString(vector[i]); |
| } |
| return ret; |
| }catch(MissingResourceException ex){ |
| //throw away the exception |
| } |
| return EMPTY; |
| } |
| public static synchronized String[] getAvailableIDs() { |
| if(!getOlsonMeta()){ |
| return EMPTY; |
| } |
| try{ |
| UResourceBundle top = (ICUResourceBundle)ICUResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "zoneinfo", ICUResourceBundle.ICU_DATA_CLASS_LOADER); |
| UResourceBundle names = top.get(kNAMES); // dereference Zones section |
| return names.getStringArray(); |
| }catch(MissingResourceException ex){ |
| //throw away the exception |
| } |
| return EMPTY; |
| } |
| public static synchronized String[] getAvailableIDs(int offset){ |
| if(!getOlsonMeta()){ |
| return EMPTY; |
| } |
| LinkedList vector = new LinkedList(); |
| for (int i=0; i<OLSON_ZONE_COUNT; ++i) { |
| String unistr; |
| if ((unistr=getID(i))!=null) { |
| // This is VERY inefficient. |
| TimeZone z = TimeZone.getTimeZone(unistr); |
| // Make sure we get back the ID we wanted (if the ID is |
| // invalid we get back GMT). |
| if (z != null && z.getID().equals(unistr) && |
| z.getRawOffset() == offset) { |
| vector.add(unistr); |
| } |
| } |
| } |
| if(!vector.isEmpty()){ |
| String[] strings = new String[vector.size()]; |
| return (String[])vector.toArray(strings); |
| } |
| return EMPTY; |
| } |
| private static String getID(int i) { |
| try{ |
| UResourceBundle top = (ICUResourceBundle)ICUResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "zoneinfo", ICUResourceBundle.ICU_DATA_CLASS_LOADER); |
| UResourceBundle names = top.get(kNAMES); // dereference Zones section |
| return names.getString(i); |
| }catch(MissingResourceException ex){ |
| //throw away the exception |
| } |
| return null; |
| } |
| /** |
| * Returns the number of IDs in the equivalency group that |
| * includes the given ID. An equivalency group contains zones |
| * that behave identically to the given zone. |
| * |
| * <p>If there are no equivalent zones, then this method returns |
| * 0. This means either the given ID is not a valid zone, or it |
| * is and there are no other equivalent zones. |
| * @param id a system time zone ID |
| * @return the number of zones in the equivalency group containing |
| * 'id', or zero if there are no equivalent zones. |
| * @see #getEquivalentID |
| */ |
| public static synchronized int countEquivalentIDs(String id) { |
| |
| UResourceBundle res = openOlsonResource(id); |
| int size = res.getSize(); |
| if (size == 4 || size == 6) { |
| UResourceBundle r=res.get(size-1); |
| //result = ures_getSize(&r); // doesn't work |
| int[] v = r.getIntVector(); |
| return v.length; |
| } |
| return 0; |
| } |
| |
| /** |
| * Returns an ID in the equivalency group that includes the given |
| * ID. An equivalency group contains zones that behave |
| * identically to the given zone. |
| * |
| * <p>The given index must be in the range 0..n-1, where n is the |
| * value returned by <code>countEquivalentIDs(id)</code>. For |
| * some value of 'index', the returned value will be equal to the |
| * given id. If the given id is not a valid system time zone, or |
| * if 'index' is out of range, then returns an empty string. |
| * @param id a system time zone ID |
| * @param index a value from 0 to n-1, where n is the value |
| * returned by <code>countEquivalentIDs(id)</code> |
| * @return the ID of the index-th zone in the equivalency group |
| * containing 'id', or an empty string if 'id' is not a valid |
| * system ID or 'index' is out of range |
| * @see #countEquivalentIDs |
| */ |
| public static synchronized String getEquivalentID(String id, int index) { |
| String result=""; |
| UResourceBundle res = openOlsonResource(id); |
| if (res != null) { |
| int zone = -1; |
| int size = res.getSize(); |
| if (size == 4 || size == 6) { |
| UResourceBundle r = res.get(size-1); |
| int[] v = r.getIntVector(); |
| if (index >= 0 && index < v.length) { |
| zone = v[index]; |
| } |
| } |
| if (zone >= 0) { |
| try { |
| UResourceBundle top = UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "zoneinfo", |
| ICUResourceBundle.ICU_DATA_CLASS_LOADER); |
| UResourceBundle ares = top.get(kNAMES); // dereference Zones section |
| result = ares.getString(zone); |
| } catch (MissingResourceException e) { |
| result = ""; |
| } |
| } |
| } |
| return result; |
| } |
| |
| private static String[] getCanonicalInfo(String id) { |
| if (id == null || id.length() == 0) { |
| return null; |
| } |
| if (canonicalMap == null) { |
| Map m = new HashMap(); |
| Set s = new HashSet(); |
| try { |
| UResourceBundle supplementalDataBundle = UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "supplementalData", ICUResourceBundle.ICU_DATA_CLASS_LOADER); |
| |
| UResourceBundle zoneFormatting = supplementalDataBundle.get("zoneFormatting"); |
| UResourceBundleIterator it = zoneFormatting.getIterator(); |
| |
| while ( it.hasNext()) { |
| UResourceBundle temp = it.next(); |
| int resourceType = temp.getType(); |
| |
| switch(resourceType) { |
| case UResourceBundle.TABLE: |
| String [] result = { "", "" }; |
| UResourceBundle zoneInfo = temp; |
| String canonicalID = zoneInfo.getKey().replace(':','/'); |
| String territory = zoneInfo.get("territory").getString(); |
| result[0] = canonicalID; |
| if ( territory.equals("001")) { |
| result[1] = null; |
| } |
| else { |
| result[1] = territory; |
| } |
| m.put(canonicalID,result); |
| try { |
| UResourceBundle aliasBundle = zoneInfo.get("aliases"); |
| String [] aliases = aliasBundle.getStringArray(); |
| for (int i=0 ; i<aliases.length; i++) { |
| m.put(aliases[i],result); |
| } |
| } catch(MissingResourceException ex){ |
| // Disregard if there are no aliases |
| } |
| break; |
| case UResourceBundle.ARRAY: |
| String[] territoryList = temp.getStringArray(); |
| for (int i=0 ; i < territoryList.length; i++) { |
| s.add(territoryList[i]); |
| } |
| break; |
| } |
| } |
| } catch (MissingResourceException e) { |
| // throws away the exception - maps are empty for this case |
| } |
| |
| // Some available Olson zones are not included in CLDR data (such as Asia/Riyadh87). |
| // Also, when we update Olson tzdata, new zones may be added. |
| // This code scans all available zones in zoneinfo.res, and if any of them are |
| // missing, add them to the map. |
| try{ |
| UResourceBundle top = (ICUResourceBundle)ICUResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, |
| "zoneinfo", ICUResourceBundle.ICU_DATA_CLASS_LOADER); |
| UResourceBundle names = top.get(kNAMES); |
| String[] ids = names.getStringArray(); |
| for (int i = 0; i < ids.length; i++) { |
| if (m.containsKey(ids[i])) { |
| // Already included in CLDR data |
| continue; |
| } |
| // Not in CLDR data, but it could be new one whose alias is |
| // available in CLDR |
| String[] tmpinfo = null; |
| int nTzdataEquivalent = TimeZone.countEquivalentIDs(ids[i]); |
| for (int j = 0; j < nTzdataEquivalent; j++) { |
| String alias = TimeZone.getEquivalentID(ids[i], j); |
| if (alias.equals(ids[i])) { |
| continue; |
| } |
| tmpinfo = (String[])m.get(alias); |
| if (tmpinfo != null) { |
| break; |
| } |
| } |
| if (tmpinfo == null) { |
| // Set dereferenced zone ID as the canonical ID |
| UResourceBundle res = getZoneByName(top, ids[i]); |
| String derefID = (res.getSize() == 1) ? ids[res.getInt()] : ids[i]; |
| m.put(ids[i], new String[] {derefID, null}); |
| } else { |
| // Use the canonical ID in the existing entry |
| m.put(ids[i], tmpinfo); |
| } |
| } |
| } catch (MissingResourceException ex) { |
| //throw away the exception |
| } |
| |
| synchronized (ZoneMeta.class) { |
| canonicalMap = m; |
| multiZoneTerritories = s; |
| } |
| } |
| |
| return (String[])canonicalMap.get(id); |
| } |
| |
| private static Map canonicalMap = null; |
| private static Set multiZoneTerritories = null; |
| |
| /** |
| * Return the canonical id for this system tzid, which might be the id itself. |
| * If the given system tzid is not know, return null. |
| */ |
| public static String getCanonicalSystemID(String tzid) { |
| String[] info = getCanonicalInfo(tzid); |
| if (info != null) { |
| return info[0]; |
| } |
| return null; |
| } |
| |
| /** |
| * Return the canonical country code for this tzid. If we have none, or if the time zone |
| * is not associated with a country, return null. |
| */ |
| public static String getCanonicalCountry(String tzid) { |
| String[] info = getCanonicalInfo(tzid); |
| if (info != null) { |
| return info[1]; |
| } |
| return null; |
| } |
| |
| /** |
| * Return the country code if this is a 'single' time zone that can fallback to just |
| * the country, otherwise return null. (Note, one must also check the locale data |
| * to see that there is a localization for the country in order to implement |
| * tr#35 appendix J step 5.) |
| */ |
| public static String getSingleCountry(String tzid) { |
| String[] info = getCanonicalInfo(tzid); |
| if (info != null && info[1] != null && !multiZoneTerritories.contains(info[1])) { |
| return info[1]; |
| } |
| return null; |
| } |
| |
| /** |
| * Returns a time zone location(region) format string defined by UTR#35. |
| * e.g. "Italy Time", "United States (Los Angeles) Time" |
| */ |
| public static String getLocationFormat(String tzid, String city, ULocale locale) { |
| String[] info = getCanonicalInfo(tzid); |
| if (info == null) { |
| return null; // error |
| } |
| |
| String country_code = info[1]; |
| if (country_code == null) { |
| return null; // error! |
| } |
| |
| String country = null; |
| if (country_code != null) { |
| try { |
| ICUResourceBundle rb = |
| (ICUResourceBundle)UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, locale); |
| // |
| // TODO: There is a design bug in UResourceBundle and getLoadingStatus() does not work well. |
| // |
| // if (rb.getLoadingStatus() != ICUResourceBundle.FROM_ROOT && rb.getLoadingStatus() != ICUResourceBundle.FROM_DEFAULT) { |
| // country = ULocale.getDisplayCountry("xx_" + country_code, locale); |
| // } |
| // START WORKAROUND |
| ULocale rbloc = rb.getULocale(); |
| if (!rbloc.equals(ULocale.ROOT) && rbloc.getLanguage().equals(locale.getLanguage())) { |
| country = ULocale.getDisplayCountry("xx_" + country_code, locale); |
| } |
| // END WORKAROUND |
| } catch (MissingResourceException e) { |
| // fall through |
| } |
| if (country == null || country.length() == 0) { |
| country = country_code; |
| } |
| } |
| |
| // This is not behavior specified in tr35, but behavior added by Mark. |
| // TR35 says to display the country _only_ if there is a localization. |
| if (getSingleCountry(tzid) != null) { // single country |
| String regPat = getTZLocalizationInfo(locale, REGION_FORMAT); |
| if (regPat == null) { |
| regPat = DEF_REGION_FORMAT; |
| } |
| MessageFormat mf = new MessageFormat(regPat); |
| return mf.format(new Object[] { country }); |
| } |
| |
| if (city == null) { |
| city = tzid.substring(tzid.lastIndexOf('/')+1).replace('_',' '); |
| } |
| |
| String flbPat = getTZLocalizationInfo(locale, FALLBACK_FORMAT); |
| if (flbPat == null) { |
| flbPat = DEF_FALLBACK_FORMAT; |
| } |
| MessageFormat mf = new MessageFormat(flbPat); |
| |
| return mf.format(new Object[] { city, country }); |
| } |
| |
| private static final String DEF_REGION_FORMAT = "{0}"; |
| private static final String DEF_FALLBACK_FORMAT = "{1} ({0})"; |
| |
| public static final String |
| HOUR = "hourFormat", |
| GMT = "gmtFormat", |
| REGION_FORMAT = "regionFormat", |
| FALLBACK_FORMAT = "fallbackFormat", |
| ZONE_STRINGS = "zoneStrings", |
| FORWARD_SLASH = "/"; |
| |
| /** |
| * Get the index'd tz datum for this locale. Index must be one of the |
| * values PREFIX, HOUR, GMT, REGION_FORMAT, FALLBACK_FORMAT |
| */ |
| public static String getTZLocalizationInfo(ULocale locale, String format) { |
| String result = null; |
| try { |
| ICUResourceBundle bundle = (ICUResourceBundle) ICUResourceBundle.getBundleInstance(locale); |
| result = bundle.getStringWithFallback(ZONE_STRINGS+FORWARD_SLASH+format); |
| } catch (MissingResourceException e) { |
| result = null; |
| } |
| return result; |
| } |
| |
| // private static Set getValidIDs() { |
| // // Construct list of time zones that are valid, according |
| // // to the current underlying core JDK. We have to do this |
| // // at runtime since we don't know what we're running on. |
| // Set valid = new TreeSet(); |
| // valid.addAll(Arrays.asList(java.util.TimeZone.getAvailableIDs())); |
| // return valid; |
| // } |
| |
| /** |
| * Empty string array. |
| */ |
| private static final String[] EMPTY = new String[0]; |
| |
| |
| |
| /** |
| * Given an ID, open the appropriate resource for the given time zone. |
| * Dereference aliases if necessary. |
| * @param id zone id |
| * @return top-level resource bundle |
| */ |
| public static UResourceBundle openOlsonResource(String id) |
| { |
| UResourceBundle res = null; |
| try { |
| ICUResourceBundle top = (ICUResourceBundle)UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "zoneinfo", ICUResourceBundle.ICU_DATA_CLASS_LOADER); |
| res = getZoneByName(top, id); |
| // Dereference if this is an alias. Docs say result should be 1 |
| // but it is 0 in 2.8 (?). |
| if (res.getSize() <= 1) { |
| int deref = res.getInt() + 0; |
| UResourceBundle ares = top.get(kZONES); // dereference Zones section |
| res = (ICUResourceBundle) ares.get(deref); |
| } |
| } catch (MissingResourceException e) { |
| res = null; |
| } |
| return res; |
| } |
| |
| /** |
| * Fetch a specific zone by name. Replaces the getByKey call. |
| * @param top Top timezone resource |
| * @param id Time zone ID |
| * @return the zone's bundle if found, or undefined if error. Reuses oldbundle. |
| */ |
| private static UResourceBundle getZoneByName(UResourceBundle top, String id) throws MissingResourceException { |
| // load the Rules object |
| UResourceBundle tmp = top.get(kNAMES); |
| |
| // search for the string |
| int idx = findInStringArray(tmp, id); |
| |
| if((idx == -1)) { |
| // not found |
| throw new MissingResourceException(kNAMES, ((ICUResourceBundle)tmp).getResPath(), id); |
| //ures_close(oldbundle); |
| //oldbundle = NULL; |
| } else { |
| tmp = top.get(kZONES); // get Zones object from top |
| tmp = tmp.get(idx); // get nth Zone object |
| } |
| return tmp; |
| } |
| private static int findInStringArray(UResourceBundle array, String id){ |
| int start = 0; |
| int limit = array.getSize(); |
| int mid; |
| String u = null; |
| int lastMid = Integer.MAX_VALUE; |
| if((limit < 1)) { |
| return -1; |
| } |
| for (;;) { |
| mid = (int)((start + limit) / 2); |
| if (lastMid == mid) { /* Have we moved? */ |
| break; /* We haven't moved, and it wasn't found. */ |
| } |
| lastMid = mid; |
| u = array.getString(mid); |
| if(u==null){ |
| break; |
| } |
| int r = id.compareTo(u); |
| if(r==0) { |
| return mid; |
| } else if(r<0) { |
| limit = mid; |
| } else { |
| start = mid; |
| } |
| } |
| return -1; |
| } |
| private static final String kREGIONS = "Regions"; |
| private static final String kZONES = "Zones"; |
| private static final String kNAMES = "Names"; |
| private static final String kGMT_ID = "GMT"; |
| private static final String kCUSTOM_TZ_PREFIX = "GMT"; |
| private static ICUCache zoneCache = new SimpleCache(); |
| /** |
| * The Olson data is stored the "zoneinfo" resource bundle. |
| * Sub-resources are organized into three ranges of data: Zones, final |
| * rules, and country tables. There is also a meta-data resource |
| * which has 3 integers: The number of zones, rules, and countries, |
| * respectively. The country count includes the non-country 'Default'. |
| */ |
| static int OLSON_ZONE_START = -1; // starting index of zones |
| static int OLSON_ZONE_COUNT = 0; // count of zones |
| |
| /** |
| * Given a pointer to an open "zoneinfo" resource, load up the Olson |
| * meta-data. Return true if successful. |
| */ |
| private static boolean getOlsonMeta(ICUResourceBundle top) { |
| if (OLSON_ZONE_START < 0 && top != null) { |
| try { |
| UResourceBundle res = top.get(kZONES); |
| OLSON_ZONE_COUNT = res.getSize(); |
| OLSON_ZONE_START = 0; |
| } catch (MissingResourceException e) { |
| // throws away the exception |
| } |
| } |
| return (OLSON_ZONE_START >= 0); |
| } |
| |
| /** |
| * Load up the Olson meta-data. Return true if successful. |
| */ |
| private static boolean getOlsonMeta() { |
| if (OLSON_ZONE_START < 0) { |
| try { |
| ICUResourceBundle top = (ICUResourceBundle)ICUResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "zoneinfo", ICUResourceBundle.ICU_DATA_CLASS_LOADER); |
| getOlsonMeta(top); |
| } catch (MissingResourceException e) { |
| // throws away the exception |
| } |
| } |
| return (OLSON_ZONE_START >= 0); |
| } |
| |
| /** |
| * Lookup the given name in our system zone table. If found, |
| * instantiate a new zone of that name and return it. If not |
| * found, return 0. |
| */ |
| public static TimeZone getSystemTimeZone(String id) { |
| TimeZone z = (TimeZone)zoneCache.get(id); |
| if (z == null) { |
| try{ |
| UResourceBundle top = UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "zoneinfo", ICUResourceBundle.ICU_DATA_CLASS_LOADER); |
| UResourceBundle res = openOlsonResource(id); |
| z = new OlsonTimeZone(top, res); |
| z.setID(id); |
| zoneCache.put(id, z); |
| }catch(Exception ex){ |
| return null; |
| } |
| } |
| return (TimeZone)z.clone(); |
| } |
| |
| public static TimeZone getGMT(){ |
| TimeZone z = new SimpleTimeZone(0, kGMT_ID); |
| z.setID(kGMT_ID); |
| return z; |
| } |
| |
| // Maximum value of valid custom time zone hour/min |
| private static final int kMAX_CUSTOM_HOUR = 23; |
| private static final int kMAX_CUSTOM_MIN = 59; |
| private static final int kMAX_CUSTOM_SEC = 59; |
| |
| /** |
| * Parse a custom time zone identifier and return a corresponding zone. |
| * @param id a string of the form GMT[+-]hh:mm, GMT[+-]hhmm, or |
| * GMT[+-]hh. |
| * @return a newly created SimpleTimeZone with the given offset and |
| * no Daylight Savings Time, or null if the id cannot be parsed. |
| */ |
| public static TimeZone getCustomTimeZone(String id){ |
| int[] fields = new int[4]; |
| if (parseCustomID(id, fields)) { |
| String zid = formatCustomID(fields[1], fields[2], fields[3], fields[0] < 0); |
| int offset = fields[0] * ((fields[1] * 60 + fields[2]) * 60 + fields[3]) * 1000; |
| return new SimpleTimeZone(offset, zid); |
| } |
| return null; |
| } |
| |
| /** |
| * Parse a custom time zone identifier and return the normalized |
| * custom time zone identifier for the given custom id string. |
| * @param id a string of the form GMT[+-]hh:mm, GMT[+-]hhmm, or |
| * GMT[+-]hh. |
| * @return The normalized custom id string. |
| */ |
| public static String getCustomID(String id) { |
| int[] fields = new int[4]; |
| if (parseCustomID(id, fields)) { |
| return formatCustomID(fields[1], fields[2], fields[3], fields[0] < 0); |
| } |
| return null; |
| } |
| |
| /* |
| * Parses the given custom time zone identifier |
| * @param id id A string of the form GMT[+-]hh:mm, GMT[+-]hhmm, or |
| * GMT[+-]hh. |
| * @param fields An array of int (length = 4) to receive the parsed |
| * offset time fields. The sign is set to fields[0] (-1 or 1), |
| * hour is set to fields[1], minute is set to fields[2] and second is |
| * set to fields[3]. |
| * @return Returns true when the given custom id is valid. |
| */ |
| static boolean parseCustomID(String id, int[] fields) { |
| NumberFormat numberFormat = null; |
| String idUppercase = id.toUpperCase(); |
| |
| if (id != null && id.length() > kGMT_ID.length() && |
| idUppercase.startsWith(kGMT_ID)) { |
| ParsePosition pos = new ParsePosition(kGMT_ID.length()); |
| int sign = 1; |
| int hour = 0; |
| int min = 0; |
| int sec = 0; |
| |
| if (id.charAt(pos.getIndex()) == 0x002D /*'-'*/) { |
| sign = -1; |
| } else if (id.charAt(pos.getIndex()) != 0x002B /*'+'*/) { |
| return false; |
| } |
| pos.setIndex(pos.getIndex() + 1); |
| |
| numberFormat = NumberFormat.getInstance(); |
| numberFormat.setParseIntegerOnly(true); |
| |
| // Look for either hh:mm, hhmm, or hh |
| int start = pos.getIndex(); |
| |
| Number n = numberFormat.parse(id, pos); |
| if (pos.getIndex() == start) { |
| return false; |
| } |
| hour = n.intValue(); |
| |
| if (pos.getIndex() < id.length()){ |
| if (pos.getIndex() - start > 2 |
| || id.charAt(pos.getIndex()) != 0x003A /*':'*/) { |
| return false; |
| } |
| // hh:mm |
| pos.setIndex(pos.getIndex() + 1); |
| int oldPos = pos.getIndex(); |
| n = numberFormat.parse(id, pos); |
| if ((pos.getIndex() - oldPos) != 2) { |
| // must be 2 digits |
| return false; |
| } |
| min = n.intValue(); |
| if (pos.getIndex() < id.length()) { |
| if (id.charAt(pos.getIndex()) != 0x003A /*':'*/) { |
| return false; |
| } |
| // [:ss] |
| pos.setIndex(pos.getIndex() + 1); |
| oldPos = pos.getIndex(); |
| n = numberFormat.parse(id, pos); |
| if (pos.getIndex() != id.length() |
| || (pos.getIndex() - oldPos) != 2) { |
| return false; |
| } |
| sec = n.intValue(); |
| } |
| } else { |
| // Supported formats are below - |
| // |
| // HHmmss |
| // Hmmss |
| // HHmm |
| // Hmm |
| // HH |
| // H |
| |
| int length = pos.getIndex() - start; |
| if (length <= 0 || 6 < length) { |
| // invalid length |
| return false; |
| } |
| switch (length) { |
| case 1: |
| case 2: |
| // already set to hour |
| break; |
| case 3: |
| case 4: |
| min = hour % 100; |
| hour /= 100; |
| break; |
| case 5: |
| case 6: |
| sec = hour % 100; |
| min = (hour/100) % 100; |
| hour /= 10000; |
| break; |
| } |
| } |
| |
| if (hour <= kMAX_CUSTOM_HOUR && min <= kMAX_CUSTOM_MIN && sec <= kMAX_CUSTOM_SEC) { |
| if (fields != null) { |
| if (fields.length >= 1) { |
| fields[0] = sign; |
| } |
| if (fields.length >= 2) { |
| fields[1] = hour; |
| } |
| if (fields.length >= 3) { |
| fields[2] = min; |
| } |
| if (fields.length >= 4) { |
| fields[3] = sec; |
| } |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Creates a custom zone for the offset |
| * @param offset GMT offset in milliseconds |
| * @return A custom TimeZone for the offset with normalized time zone id |
| */ |
| public static TimeZone getCustomTimeZone(int offset) { |
| boolean negative = false; |
| int tmp = offset; |
| if (offset < 0) { |
| negative = true; |
| tmp = -offset; |
| } |
| |
| int hour, min, sec, millis; |
| |
| millis = tmp % 1000; |
| if (ASSERT) { |
| Assert.assrt("millis!=0", millis != 0); |
| } |
| tmp /= 1000; |
| sec = tmp % 60; |
| tmp /= 60; |
| min = tmp % 60; |
| hour = tmp / 60; |
| |
| // Note: No millisecond part included in TZID for now |
| String zid = formatCustomID(hour, min, sec, negative); |
| |
| return new SimpleTimeZone(offset, zid); |
| } |
| |
| /* |
| * Returns the normalized custom TimeZone ID |
| */ |
| static String formatCustomID(int hour, int min, int sec, boolean negative) { |
| // Create normalized time zone ID - GMT[+|-]hh:mm[:ss] |
| StringBuffer zid = new StringBuffer(kCUSTOM_TZ_PREFIX); |
| if (hour != 0 || min != 0) { |
| if(negative) { |
| zid.append('-'); |
| } else { |
| zid.append('+'); |
| } |
| // Always use US-ASCII digits |
| if (hour < 10) { |
| zid.append('0'); |
| } |
| zid.append(hour); |
| zid.append(':'); |
| if (min < 10) { |
| zid.append('0'); |
| } |
| zid.append(min); |
| |
| if (sec != 0) { |
| // Optional second field |
| zid.append(':'); |
| if (sec < 10) { |
| zid.append('0'); |
| } |
| zid.append(sec); |
| } |
| } |
| return zid.toString(); |
| } |
| |
| private static SoftReference OLSON_TO_META_REF; |
| private static SoftReference META_TO_OLSON_REF; |
| |
| static class OlsonToMetaMappingEntry { |
| String mzid; |
| long from; |
| long to; |
| } |
| |
| private static class MetaToOlsonMappingEntry { |
| String id; |
| String territory; |
| } |
| |
| static Map getOlsonToMetaMap() { |
| Map olsonToMeta = null; |
| synchronized(ZoneMeta.class) { |
| if (OLSON_TO_META_REF != null) { |
| olsonToMeta = (HashMap)OLSON_TO_META_REF.get(); |
| } |
| if (olsonToMeta == null) { |
| olsonToMeta = createOlsonToMetaMap(); |
| if (olsonToMeta == null) { |
| // We need to return non-null Map to avoid disaster |
| olsonToMeta = new HashMap(); |
| } |
| OLSON_TO_META_REF = new SoftReference(olsonToMeta); |
| } |
| } |
| return olsonToMeta; |
| } |
| |
| /* |
| * Create olson tzid to metazone mappings from metazoneInfo.res (3.8.1 or later) |
| */ |
| private static Map createOlsonToMetaMap() { |
| // Create olson id to metazone mapping table |
| HashMap olsonToMeta = null; |
| UResourceBundle metazoneMappingsBundle = null; |
| try { |
| UResourceBundle bundle = UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, "metazoneInfo"); |
| metazoneMappingsBundle = bundle.get("metazoneMappings"); |
| } catch (MissingResourceException mre) { |
| // do nothing |
| } |
| if (metazoneMappingsBundle != null) { |
| String[] tzids = getAvailableIDs(); |
| for (int i = 0; i < tzids.length; i++) { |
| // Skip aliases |
| String canonicalID = TimeZone.getCanonicalID(tzids[i]); |
| if (canonicalID == null || !tzids[i].equals(canonicalID)) { |
| continue; |
| } |
| String tzkey = tzids[i].replace('/', ':'); |
| try { |
| UResourceBundle zoneBundle = metazoneMappingsBundle.get(tzkey); |
| LinkedList mzMappings = new LinkedList(); |
| for (int idx = 0; ; idx++) { |
| try { |
| UResourceBundle mz = zoneBundle.get("mz" + idx); |
| String[] mzstr = mz.getStringArray(); |
| if (mzstr == null || mzstr.length != 3) { |
| continue; |
| } |
| OlsonToMetaMappingEntry mzmap = new OlsonToMetaMappingEntry(); |
| mzmap.mzid = mzstr[0].intern(); |
| mzmap.from = parseDate(mzstr[1]); |
| mzmap.to = parseDate(mzstr[2]); |
| |
| // Add this mapping to the list |
| mzMappings.add(mzmap); |
| } catch (MissingResourceException nomz) { |
| // we're done |
| break; |
| } catch (IllegalArgumentException baddate) { |
| // skip this |
| } |
| } |
| if (mzMappings.size() != 0) { |
| // Add to the olson-to-meta map |
| if (olsonToMeta == null) { |
| olsonToMeta = new HashMap(); |
| } |
| olsonToMeta.put(tzids[i], mzMappings); |
| } |
| } catch (MissingResourceException noum) { |
| // Does not use metazone, just skip this. |
| } |
| } |
| } |
| return olsonToMeta; |
| } |
| |
| /** |
| * Returns a CLDR metazone ID for the given Olson tzid and time. |
| */ |
| public static String getMetazoneID(String olsonID, long date) { |
| String mzid = null; |
| Map olsonToMeta = getOlsonToMetaMap(); |
| List mappings = (List)olsonToMeta.get(olsonID); |
| if (mappings == null) { |
| // The given ID might be an alias - try its canonical id |
| String canonicalID = getCanonicalSystemID(olsonID); |
| if (canonicalID != null && !canonicalID.equals(olsonID)) { |
| mappings = (List)olsonToMeta.get(canonicalID); |
| } |
| } |
| if (mappings != null) { |
| for (int i = 0; i < mappings.size(); i++) { |
| OlsonToMetaMappingEntry mzm = (OlsonToMetaMappingEntry)mappings.get(i); |
| if (date >= mzm.from && date < mzm.to) { |
| mzid = mzm.mzid; |
| break; |
| } |
| } |
| } |
| return mzid; |
| } |
| |
| private static Map getMetaToOlsonMap() { |
| HashMap metaToOlson = null; |
| synchronized(ZoneMeta.class) { |
| if (META_TO_OLSON_REF != null) { |
| metaToOlson = (HashMap)META_TO_OLSON_REF.get(); |
| } |
| if (metaToOlson == null) { |
| metaToOlson = new HashMap(); |
| UResourceBundle metazonesBundle = null; |
| try { |
| UResourceBundle supplementalBundle = UResourceBundle.getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, |
| "supplementalData"); |
| UResourceBundle mapTimezonesBundle = supplementalBundle.get("mapTimezones"); |
| metazonesBundle = mapTimezonesBundle.get("metazones"); |
| } catch (MissingResourceException mre) { |
| // do nothing |
| } |
| if (metazonesBundle != null) { |
| Enumeration mzenum = metazonesBundle.getKeys(); |
| while (mzenum.hasMoreElements()) { |
| String mzkey = (String)mzenum.nextElement(); |
| if (!mzkey.startsWith("meta:")) { |
| continue; |
| } |
| String tzid = null; |
| try { |
| tzid = metazonesBundle.getString(mzkey); |
| } catch (MissingResourceException mre) { |
| // It should not happen.. |
| } |
| if (tzid != null) { |
| int territoryIdx = mzkey.lastIndexOf('_'); |
| if (territoryIdx > 0) { |
| String mzid = mzkey.substring(5 /* "meta:".length() */, territoryIdx); |
| String territory = mzkey.substring(territoryIdx + 1); |
| List mappings = (List)metaToOlson.get(mzid); |
| if (mappings == null) { |
| mappings = new LinkedList(); |
| metaToOlson.put(mzid, mappings); |
| } |
| MetaToOlsonMappingEntry olsonmap = new MetaToOlsonMappingEntry(); |
| olsonmap.id = tzid; |
| olsonmap.territory = territory; |
| mappings.add(olsonmap); |
| } |
| } |
| } |
| } |
| META_TO_OLSON_REF = new SoftReference(metaToOlson); |
| } |
| } |
| return metaToOlson; |
| } |
| |
| /** |
| * Returns an Olson ID for the ginve metazone and region |
| */ |
| public static String getZoneIdByMetazone(String metazoneID, String region) { |
| String tzid = null; |
| Map metaToOlson = getMetaToOlsonMap(); |
| List mappings = (List)metaToOlson.get(metazoneID); |
| if (mappings != null) { |
| for (int i = 0; i < mappings.size(); i++) { |
| MetaToOlsonMappingEntry olsonmap = (MetaToOlsonMappingEntry)mappings.get(i); |
| if (olsonmap.territory.equals(region)) { |
| tzid = olsonmap.id; |
| break; |
| } else if (olsonmap.territory.equals("001")) { |
| tzid = olsonmap.id; |
| } |
| } |
| } |
| return tzid; |
| } |
| |
| // /** |
| // * Returns an Olson ID for the given metazone and locale |
| // */ |
| // public static String getZoneIdByMetazone(String metazoneID, ULocale loc) { |
| // String region = loc.getCountry(); |
| // if (region.length() == 0) { |
| // // Get likely region |
| // ULocale tmp = ULocale.addLikelySubtag(loc); |
| // region = tmp.getCountry(); |
| // } |
| // return getZoneIdByMetazone(metazoneID, region); |
| // } |
| |
| /* |
| * Convert a date string used by metazone mappings to long. |
| * The format used by CLDR metazone mapping is "yyyy-MM-dd HH:mm". |
| * We do not want to use SimpleDateFormat to parse the metazone |
| * mapping range strings in createOlsonToMeta, because it might be |
| * called from SimpleDateFormat initialization code. |
| */ |
| static long parseDate (String text) throws IllegalArgumentException { |
| int year = 0, month = 0, day = 0, hour = 0, min = 0; |
| int idx; |
| int n; |
| |
| // "yyyy" (0 - 3) |
| for (idx = 0; idx <= 3; idx++) { |
| n = text.charAt(idx) - '0'; |
| if (n >= 0 && n < 10) { |
| year = 10*year + n; |
| } else { |
| throw new IllegalArgumentException("Bad year"); |
| } |
| } |
| // "MM" (5 - 6) |
| for (idx = 5; idx <= 6; idx++) { |
| n = text.charAt(idx) - '0'; |
| if (n >= 0 && n < 10) { |
| month = 10*month + n; |
| } else { |
| throw new IllegalArgumentException("Bad month"); |
| } |
| } |
| // "dd" (8 - 9) |
| for (idx = 8; idx <= 9; idx++) { |
| n = text.charAt(idx) - '0'; |
| if (n >= 0 && n < 10) { |
| day = 10*day + n; |
| } else { |
| throw new IllegalArgumentException("Bad day"); |
| } |
| } |
| // "HH" (11 - 12) |
| for (idx = 11; idx <= 12; idx++) { |
| n = text.charAt(idx) - '0'; |
| if (n >= 0 && n < 10) { |
| hour = 10*hour + n; |
| } else { |
| throw new IllegalArgumentException("Bad hour"); |
| } |
| } |
| // "mm" (14 - 15) |
| for (idx = 14; idx <= 15; idx++) { |
| n = text.charAt(idx) - '0'; |
| if (n >= 0 && n < 10) { |
| min = 10*min + n; |
| } else { |
| throw new IllegalArgumentException("Bad minute"); |
| } |
| } |
| |
| long date = Grego.fieldsToDay(year, month - 1, day) * Grego.MILLIS_PER_DAY |
| + hour * Grego.MILLIS_PER_HOUR + min * Grego.MILLIS_PER_MINUTE; |
| return date; |
| } |
| } |
