| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.ide.common.generate.locale; |
| |
| import com.google.common.base.Charsets; |
| import com.google.common.base.Joiner; |
| import com.google.common.base.Splitter; |
| import com.google.common.collect.ArrayListMultimap; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Maps; |
| import com.google.common.collect.Multimap; |
| import com.google.common.collect.Sets; |
| import com.google.common.io.ByteStreams; |
| import com.google.common.io.Files; |
| |
| import com.android.ide.common.resources.LocaleManager; |
| import com.ibm.icu.util.ULocale; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.HttpURLConnection; |
| import java.net.URL; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.SimpleTimeZone; |
| import java.util.TimeZone; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| /** |
| * Code which generates the lookup tables in {@link LocaleManager}. |
| */ |
| public class LocaleTableGenerator { |
| private static final boolean DEBUG = true; |
| private static final boolean INCLUDE_TIMEZONE_COMMENTS = false; |
| private static final int PADDING = 16; |
| |
| private Map<String, String> mLanguage3to2; |
| private Map<String, String> mRegion3to2; |
| private Map<String, String> mLanguage2to3; |
| private Map<String, String> mRegion2to3; |
| private Map<String, String> mRegionName; |
| private Map<String, String> mLanguageName; |
| private Multimap<String, String> mAssociatedRegions; |
| private final List<String> mLanguage2Codes; |
| private final List<String> mLanguage3Codes; |
| private final List<String> mRegion2Codes; |
| private final List<String> mRegion3Codes; |
| private final Map<String, Integer> mLanguage2Index; |
| private final Map<String, Integer> mLanguage3Index; |
| private final Map<String, Integer> mRegion2Index; |
| private final Map<String, Integer> mRegion3Index; |
| private Map<String, List<String>> mRegionLists; |
| @SuppressWarnings("StringBufferField") private StringBuilder mOutput; |
| private Map<TimeZone, String> mZoneToRegion; |
| private List<TimeZone> mZoneCandidates; |
| |
| public static void main(String[] args) { |
| new LocaleTableGenerator().generate(); |
| } |
| |
| private void importLanguageSpec() { |
| // Read in contents of http://www.loc.gov/standards/iso639-2/ISO-639-2_utf-8.txt |
| byte[] bytes = new byte[0]; |
| try { |
| HttpURLConnection connection = null; |
| InputStream stream = LocaleTableGenerator.class.getResourceAsStream("ISO-639-2_utf-8.txt"); |
| if (stream == null) { |
| // Try to fetch it remotely |
| URL url = new URL("http://www.loc.gov/standards/iso639-2/ISO-639-2_utf-8.txt"); |
| connection = (HttpURLConnection) url.openConnection(); |
| stream = connection.getInputStream(); |
| if (stream == null) { |
| System.err.println("Couldn't find 639-2 spec; download from " |
| + "http://www.loc.gov/standards/iso639-2/ISO-639-2_utf-8.txt and place " |
| + "in source folder"); |
| System.exit(-1); |
| } |
| } |
| bytes = ByteStreams.toByteArray(stream); |
| stream.close(); |
| if (connection != null) { |
| connection.disconnect(); |
| } |
| } catch (IOException e) { |
| assert false; |
| } |
| String spec = new String(bytes, Charsets.UTF_8); |
| if (spec.charAt(0) == '\ufeff') { // Strip off UTF-8 BOM |
| spec = spec.substring(1); |
| } |
| int count3 = 0; |
| int count2 = 0; |
| int matched = 0; |
| for (String line : Splitter.on('\n').trimResults().omitEmptyStrings().split(spec)) { |
| String[] components = line.split("\\|"); |
| assert components.length == 5 : line; |
| String iso2 = components[2]; |
| String iso3 = components[0]; |
| String languageName = components[3]; |
| assert iso3 != null : line; |
| assert iso2 != null : line; |
| assert languageName != null : line; |
| if (iso3.contains("-") || languageName.contains("Reserved")) { |
| // e.g. "qaa-qtz|||Reserved for local use|" |
| continue; |
| } |
| assert iso3.length() == 3 : iso3; |
| |
| // 3 languages in that spec have deprecated codes which will not work right; |
| // see LocaleFolderDetector#DEPRECATED_CODE for details |
| if (iso2.equals("he")) { |
| iso2 = "iw"; |
| } else if (iso2.equals("id")) { |
| iso2 = "in"; |
| } else if (iso2.equals("yi")) { |
| iso2 = "ji"; |
| } |
| |
| if (!iso2.isEmpty() && mLanguage2to3.containsKey(iso2)) { |
| // We already know about this one |
| matched++; |
| continue; |
| } else if ("zxx".equals(iso3)) { |
| // "No linguistic content |
| continue; |
| } |
| if (!iso2.isEmpty()) { |
| assert iso2.length() == 2 : iso2; |
| mLanguage2to3.put(iso2, iso3); |
| count2++; |
| } |
| count3++; |
| mLanguageName.put(iso3, languageName); |
| } |
| |
| if (DEBUG) { |
| System.out.println("Added in " + count3 + " extra codes, " + count2 |
| + " of them for 2-letter codes, and " + matched |
| + " were ignored because we had ICU data."); |
| } |
| } |
| |
| private void importRegionSpec() { |
| // Read in text contents of the table from http://en.wikipedia.org/wiki/ISO_3166-1_alpha-3 |
| byte[] bytes = new byte[0]; |
| try { |
| HttpURLConnection connection; |
| InputStream stream = LocaleTableGenerator.class.getResourceAsStream("ISO_3166-1_alpha-3.txt"); |
| if (stream == null) { |
| // Try to fetch it remotely |
| URL url = new URL("http://en.wikipedia.org/wiki/ISO_3166-1_alpha-3"); |
| connection = (HttpURLConnection) url.openConnection(); |
| stream = connection.getInputStream(); |
| if (stream == null) { |
| System.err.println("Couldn't find 639-2 spec; download from " |
| + "http://en.wikipedia.org/wiki/ISO_3166-1_alpha-3 and place " |
| + "in source folder as ISO_3166-1_alpha-3.txt"); |
| System.exit(-1); |
| } |
| |
| bytes = ByteStreams.toByteArray(stream); |
| String spec = new String(bytes, Charsets.UTF_8); |
| StringBuilder recreated = new StringBuilder(1000); |
| String prev = null; |
| Pattern CODE_PATTERN = Pattern.compile("<td.*><tt>(...)</tt></td>"); |
| // or <tt>ABW</tt></td> |
| Pattern NAME_PATTERN = Pattern.compile("<td><a href=\"/wiki/(.+)\" title=\"(.+)\">(.+)</a></td>"); |
| for (String line : spec.split("\n")) { |
| if (prev != null && line.startsWith("<td><a href=")) { |
| Matcher matcher = NAME_PATTERN.matcher(line); |
| if (matcher.matches()) { |
| Matcher matcherPrev = CODE_PATTERN.matcher(prev); |
| if (matcherPrev.matches()) { |
| recreated.append(matcherPrev.group(1)).append("\t").append(matcher.group(3)).append("\n"); |
| } |
| } |
| } |
| prev = line; |
| } |
| |
| stream.close(); |
| connection.disconnect(); |
| bytes = recreated.toString().getBytes(Charsets.UTF_8); |
| } else { |
| bytes = ByteStreams.toByteArray(stream); |
| stream.close(); |
| } |
| } catch (IOException e) { |
| assert false; |
| } |
| String spec = new String(bytes, Charsets.UTF_8); |
| if (spec.charAt(0) == '\ufeff') { // Strip off UTF-8 BOM |
| spec = spec.substring(1); |
| } |
| int count3 = 0; |
| int matched = 0; |
| |
| Map<String,String> regionNameToCode = Maps.newHashMap(); |
| for (Map.Entry<String,String> entry : mRegionName.entrySet()) { |
| regionNameToCode.put(entry.getValue(), entry.getKey()); |
| } |
| |
| // Look at existing entries |
| Map<String,String> regionNameToCode2 = Maps.newHashMap(); |
| for (String code : LocaleManager.getRegionCodes(true)) { |
| regionNameToCode2.put(LocaleManager.getRegionName(code), code); |
| } |
| |
| for (String line : Splitter.on('\n').trimResults().omitEmptyStrings().split(spec)) { |
| String[] components = line.split("\\t"); |
| assert components.length == 2 : line; |
| String iso3 = components[0]; |
| if (mRegionName.containsKey(iso3)) { |
| matched++; |
| continue; |
| } |
| String name = components[1]; |
| if (regionNameToCode.get(name) != null) { |
| if (DEBUG) { |
| System.out.println("Found region " + name + " as " |
| + regionNameToCode.get(name)); |
| } |
| } else { |
| String iso2 = regionNameToCode2.get(name); |
| if (iso2 != null) { |
| mRegionName.put(iso3, name); |
| mRegion2to3.put(iso2, iso3); |
| count3++; |
| } else { |
| if (DEBUG) { |
| System.out.println("Unexpected name=" + name + ", code=" + iso3 |
| + ", line=" + line); |
| } |
| } |
| } |
| } |
| |
| if (DEBUG) { |
| System.out.println("Added in " + count3 + " extra codes, and " + matched |
| + " were ignored because we had ICU data."); |
| } |
| } |
| |
| public LocaleTableGenerator() { |
| mLanguage2to3 = Maps.newHashMap(); |
| mRegion2to3 = Maps.newHashMap(); |
| mLanguageName = Maps.newHashMap(); |
| mRegionName = Maps.newHashMap(); |
| mAssociatedRegions = ArrayListMultimap.create(); |
| |
| importFromIcu4j(); |
| |
| // We've pulled data out of ICU, but still missing languages and regions; merge |
| // in from the specs |
| importLanguageSpec(); |
| importRegionSpec(); |
| |
| // There are some macro-languages missing here! |
| |
| |
| // UMN.49: http://en.wikipedia.org/wiki/UN_M.49 |
| populateUNM49(); |
| |
| mLanguage3to2 = Maps.newHashMap(); |
| for (Map.Entry<String,String> entry : mLanguage2to3.entrySet()) { |
| mLanguage3to2.put(entry.getValue(), entry.getKey()); |
| } |
| mRegion3to2 = Maps.newHashMap(); |
| for (Map.Entry<String,String> entry : mRegion2to3.entrySet()) { |
| mRegion3to2.put(entry.getValue(), entry.getKey()); |
| } |
| |
| // Register deprecated codes manually. This is done *after* we produce the |
| // reverse map above, such that we make sure we don't accidentally have |
| // the 3-letter new code map back and override the proper 3-letter code |
| // with the deprecated code |
| if (!mLanguageName.containsKey("ind")) { |
| mLanguageName.put("ind", "Indonesian"); |
| } |
| if (!mLanguageName.containsKey("yid")) { |
| mLanguageName.put("ji", "Yiddish"); |
| } |
| if (!mLanguageName.containsKey("heb")) { |
| mLanguageName.put("iw", "Hebrew"); |
| } |
| mLanguage2to3.put("in", "ind"); // proper 3-letter code, but NOT mapping back: should be id |
| mLanguage2to3.put("ji", "yid"); // proper 3-letter code, but NOT mapping back: should be yi |
| mLanguage2to3.put("iw", "heb"); // proper 3-letter code, but NOT mapping back: should be he |
| // Make sure the forward map (from 3 to 2) is also using the primary (new) code |
| mLanguage3to2.put("ind", "in"); |
| mLanguage3to2.put("heb", "iw"); |
| mLanguage3to2.put("yid", "ji"); |
| |
| |
| mLanguage2Codes = sorted(mLanguage2to3.keySet()); |
| mLanguage3Codes = sorted(mLanguageName.keySet()); |
| mRegion2Codes = sorted(mRegion2to3.keySet()); |
| mRegion3Codes = sorted(mRegionName.keySet()); |
| |
| mLanguage2Index = Maps.newHashMap(); |
| for (int i = 0, n = mLanguage2Codes.size(); i < n; i++) { |
| mLanguage2Index.put(mLanguage2Codes.get(i), i); |
| } |
| mLanguage3Index = Maps.newHashMap(); |
| for (int i = 0, n = mLanguage3Codes.size(); i < n; i++) { |
| mLanguage3Index.put(mLanguage3Codes.get(i), i); |
| } |
| mRegion2Index = Maps.newHashMap(); |
| for (int i = 0, n = mRegion2Codes.size(); i < n; i++) { |
| mRegion2Index.put(mRegion2Codes.get(i), i); |
| } |
| mRegion3Index = Maps.newHashMap(); |
| for (int i = 0, n = mRegion3Codes.size(); i < n; i++) { |
| mRegion3Index.put(mRegion3Codes.get(i), i); |
| } |
| |
| Set<String> known = Sets.newHashSet(LocaleManager.getLanguageCodes()); |
| known.removeAll(mLanguage2to3.keySet()); |
| if (!known.isEmpty()) { |
| List<String> sorted = Lists.newArrayList(known); |
| Collections.sort(sorted); |
| System.out.println("Missing language registrations for " + sorted); |
| assert false; |
| } |
| |
| known = Sets.newHashSet(LocaleManager.getRegionCodes()); |
| known.removeAll(mRegion2to3.keySet()); |
| if (!known.isEmpty()) { |
| List<String> sorted = Lists.newArrayList(known); |
| Collections.sort(sorted); |
| System.out.println("Missing region registrations for " + sorted); |
| assert false; |
| } |
| |
| // Compute list of ordered regions |
| mRegionLists = Maps.newHashMap(); |
| for (String code : mLanguage3Codes) { |
| Collection<String> regions = mAssociatedRegions.get(code); |
| final String defaultRegion = getDefaultRegionFor(code); |
| if (regions == null || regions.size() < 2) { |
| if (regions != null && regions.size() == 1 && defaultRegion != null) { |
| assert regions.iterator().next().equals(defaultRegion); |
| } |
| if (regions != null && regions.size() == 1) { |
| mRegionLists.put(code, Collections.singletonList(regions.iterator().next())); |
| } else if (defaultRegion != null) { |
| mRegionLists.put(code, Collections.singletonList(defaultRegion)); |
| } |
| } else { |
| final List<String> sorted = Lists.newArrayList(regions); |
| Collections.sort(sorted, new Comparator<String>() { |
| @Override |
| public int compare(String o1, String o2) { |
| int rank1 = o1.equals(defaultRegion) ? 0 : 1; |
| int rank2 = o2.equals(defaultRegion) ? 0 : 1; |
| int delta = rank1 - rank2; |
| if (delta == 0) { |
| delta = o1.compareTo(o2); |
| assert delta != 0 : |
| "Found more than one occurrence of " + o1 + " in " + sorted; |
| } |
| return delta; |
| } |
| }); |
| mRegionLists.put(code, sorted); |
| } |
| } |
| } |
| |
| private void importFromIcu4j() { |
| for (ULocale locale : ULocale.getAvailableLocales()) { |
| String language2 = locale.getLanguage(); |
| String language3 = locale.getISO3Language(); |
| if (language3.isEmpty()) { |
| // suspicious; skip this one. Misconfigured ICU? |
| continue; |
| } |
| if (!language2.equals(language3)) { |
| mLanguage2to3.put(language2, language3); |
| } |
| mLanguageName.put(language3, locale.getDisplayLanguage()); |
| |
| String region3 = locale.getISO3Country(); |
| if (region3 != null && !region3.isEmpty()) { |
| mRegionName.put(region3, locale.getDisplayCountry()); |
| String region2 = locale.getCountry(); |
| if (!region3.equals(region2)) { |
| mRegion2to3.put(region2, region3); |
| } |
| |
| if (!mAssociatedRegions.containsEntry(language3, region3)) { |
| mAssociatedRegions.put(language3, region3); |
| } |
| } |
| |
| if (locale.getFallback() != null && !locale.getFallback().toString().isEmpty() && |
| !locale.toString().startsWith(locale.getFallback().toString())) { |
| System.out.println("Fallback for " + locale + " is " + locale.getFallback()); |
| } |
| |
| // TODO: Include this |
| //locale.isRightToLeft() |
| |
| |
| |
| //System.out.println("Locale " + locale.toString() + "; " + locale.getISO3Language() + " : " + locale.getISO3Country() + " : " + locale.getDisplayLanguage() + ", " + locale.getDisplayCountry()); |
| } |
| } |
| |
| @SuppressWarnings("UnusedDeclaration") |
| private void registerMacroLanguage(String iso2, String iso3) { |
| if (!mLanguage2to3.containsKey(iso2)) { |
| assert mLanguageName.containsKey(iso3) : iso2; |
| mLanguage2to3.put(iso2, iso3); |
| } |
| } |
| |
| private void populateUNM49() { |
| // TODO: Populate region names from http://en.wikipedia.org/wiki/UN_M.49, e.g. |
| // via something like the following (but we're not doing this, since ICU4J |
| // can't provide actual region names: |
| // for (Region region : Region.getAvailable(Region.RegionType.CONTINENT)) { |
| // mRegionName.put(String.valueOf(region.getNumericCode()), region.toString()); |
| // } |
| // What we want here are codes like |
| // 001 World |
| // 002 Africa |
| // 015 Northern Africa |
| // 014 Eastern Africa |
| // etc |
| } |
| |
| private void generate() { |
| String code1 = generateTimeZoneLookup(); |
| String code2 = generateLocaleTables(); |
| |
| String code = |
| " // The remainder of this class is generated by generate-locale-data\n" + |
| " // DO NOT EDIT MANUALLY\n\n" + |
| code1 + "\n" + code2; |
| if (DEBUG) { |
| int lines = 0; |
| for (int i = 0, n = code.length(); i < n; i++) { |
| if (code.charAt(i) == '\n') { |
| lines++; |
| } |
| } |
| System.out.println("Generated " + lines + " lines."); |
| } |
| try { |
| File tempFile = File.createTempFile("LocaleData", ".java"); |
| Files.write(code, tempFile, Charsets.UTF_8); |
| System.out.println("Wrote updated locale data code fragment to " + tempFile); |
| } catch (IOException ioe) { |
| ioe.printStackTrace(); |
| assert false; |
| } |
| } |
| |
| private String generateLocaleTables() { |
| StringBuilder sb = new StringBuilder(5000); |
| |
| int level = 1; |
| generateLanguageTables(sb, level); |
| generateRegionTables(sb, level); |
| generateRegionMappingTables(sb, level); |
| generateAssertions(sb, level); |
| |
| if (DEBUG) { |
| System.out.println("Number of languages=" + mLanguageName.size()); |
| System.out.println("Number of regions=" + mRegionName.size()); |
| } |
| |
| return sb.toString(); |
| } |
| |
| private void generateRegionMappingTables(StringBuilder sb, int level) { |
| for (String code : mLanguage3Codes) { |
| List<String> sorted = mRegionLists.get(code); |
| if (sorted != null && sorted.size() > 1) { |
| indent(sb, level); |
| sb.append("// Language ").append(code).append(": ") |
| .append(Joiner.on(",").join(sorted)).append("\n"); |
| |
| indent(sb, level); |
| sb.append("private static final int[] ").append(getLanguageRegionFieldName(code)) |
| .append(" = new int[] { "); |
| boolean first = true; |
| for (String region : sorted) { |
| Integer integer = mRegion3Index.get(region); |
| assert integer != null : region; |
| if (first) { |
| first = false; |
| } else { |
| sb.append(","); |
| } |
| sb.append(integer); |
| } |
| sb.append(" };\n"); |
| } |
| } |
| |
| // Format preferred regions (multiple) |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("private static final int[][] LANGUAGE_REGIONS = new int[][] {\n"); |
| int column = 0; |
| indent(sb, level + 1); |
| int lineBegin = sb.length(); |
| for (int i = 0, n = mLanguage3Codes.size(); i < n; i++) { |
| String code = mLanguage3Codes.get(i); |
| List<String> sorted = mRegionLists.get(code); |
| if (sorted != null && sorted.size() > 1) { |
| sb.append(getLanguageRegionFieldName(code)); |
| } else { |
| sb.append("null"); |
| } |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (sb.length() - lineBegin > 60) { |
| sb.append("\n"); |
| lineBegin = sb.length(); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| |
| sb.append("\n"); |
| |
| |
| // Format preferred region (just one) |
| indent(sb, level); |
| sb.append("private static final int[] LANGUAGE_REGION = new int[] {\n"); |
| column = 0; |
| indent(sb, level + 1); |
| for (int i = 0, n = mLanguage3Codes.size(); i < n; i++) { |
| String iso3 = mLanguage3Codes.get(i); |
| List<String> sorted = mRegionLists.get(iso3); |
| Integer index = -1; |
| if (sorted != null && !sorted.isEmpty()) { |
| index = mRegion3Index.get(sorted.get(0)); |
| } |
| append(sb, String.valueOf(index), 3, true); |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (column == 8) { |
| column = 0; |
| sb.append("\n"); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| sb.append("\n"); |
| } |
| |
| private static String getLanguageRegionFieldName(String languageCode) { |
| assert languageCode.length() == 3 : languageCode; |
| return "REGIONS_" + languageCode.toUpperCase(Locale.US); |
| } |
| |
| private String getDefaultRegionFor(String languageCode) { |
| assert languageCode.length() == 3 : languageCode; |
| |
| String iso2Language = getIso2Language(languageCode); |
| String hardcoded = iso2Language != null ? LocaleManager.getDefaultLanguageRegion( |
| iso2Language) : null; |
| if (hardcoded != null) { |
| if (getIso3Region(hardcoded) == null) { |
| assert false : "Couldn't find an ISO 3 region for " + hardcoded + " with language code " + languageCode + " (region-2 is " + LocaleManager.getRegionName(hardcoded); |
| } |
| hardcoded = getIso3Region(hardcoded); |
| assert hardcoded != null : languageCode; |
| } |
| |
| Collection<String> regions = mAssociatedRegions.get(languageCode); |
| if (regions != null && !regions.isEmpty()) { |
| // Violated for example for gsw (Swiss German, with regions CHE, FRA, LIE) |
| //assert iso2Language != null : languageCode + " didn't have an iso 2 code but does have regions " + regions; // We only have |
| if (regions.size() == 1) { |
| // Make |
| String region = regions.iterator().next(); |
| assert hardcoded == null || region.equals(hardcoded) : region + " vs " + hardcoded; |
| return region; |
| } |
| |
| if (hardcoded == null || regions.contains(hardcoded)) { |
| return hardcoded; |
| } else { |
| assert false : "Didn't find region " + hardcoded + " in expected regions " + regions + " for " + languageCode; |
| } |
| } |
| |
| return hardcoded; |
| } |
| |
| private void generateAssertions(StringBuilder sb, int level) { |
| indent(sb, level); |
| sb.append("static {\n"); |
| level++; |
| |
| |
| indent(sb, level); |
| sb.append( |
| "// These maps should have been generated programmatically; look for accidental edits\n"); |
| indent(sb, level); |
| sb.append("assert ISO_639_2_CODES.length == ").append(mLanguage3Codes.size()).append(";\n"); |
| indent(sb, level); |
| sb.append("assert ISO_639_2_NAMES.length == ").append(mLanguage3Codes.size()).append(";\n"); |
| indent(sb, level); |
| sb.append("assert ISO_639_2_TO_1.length == ").append(mLanguage3Codes.size()).append(";\n"); |
| indent(sb, level); |
| sb.append("assert ISO_639_1_CODES.length == ").append(mLanguage2Codes.size()).append(";\n"); |
| indent(sb, level); |
| sb.append("assert ISO_639_1_TO_2.length == ").append(mLanguage2Codes.size()).append(";\n"); |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("assert ISO_3166_2_CODES.length == ").append(mRegion3Codes.size()).append(";\n"); |
| indent(sb, level); |
| sb.append("assert ISO_3166_2_NAMES.length == ").append(mRegion3Codes.size()).append(";\n"); |
| indent(sb, level); |
| sb.append("assert ISO_3166_2_TO_1.length == ").append(mRegion3Codes.size()).append(";\n"); |
| indent(sb, level); |
| sb.append("assert ISO_3166_1_CODES.length == ").append(mRegion2Codes.size()).append(";\n"); |
| indent(sb, level); |
| sb.append("assert ISO_3166_1_TO_2.length == ").append(mRegion2Codes.size()).append(";\n"); |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("assert LANGUAGE_REGION.length == ").append(mLanguage3Codes.size()).append(";\n"); |
| indent(sb, level); |
| sb.append("assert LANGUAGE_REGIONS.length == ").append(mLanguage3Codes.size()).append(";\n"); |
| |
| level--; |
| indent(sb, level); |
| sb.append("}\n"); |
| } |
| |
| @SuppressWarnings("UnusedDeclaration") |
| private String getIso3Language(String iso2Code) { |
| assert iso2Code.length() == 3 : iso2Code; |
| return mLanguage2to3.get(iso2Code); |
| } |
| |
| private String getIso2Language(String iso3Code) { |
| assert iso3Code.length() == 3 : iso3Code + " was " + iso3Code.length() + " chars"; |
| return mLanguage3to2.get(iso3Code); |
| } |
| |
| private String getIso3Region(String iso2Code) { |
| assert iso2Code.length() == 2 : iso2Code; |
| return mRegion2to3.get(iso2Code); |
| } |
| |
| private String getIso2Region(String iso3Code) { |
| assert iso3Code.length() == 3 : iso3Code; |
| return mRegion3to2.get(iso3Code); |
| } |
| |
| private void generateLanguageTables(StringBuilder sb, int level) { |
| |
| // Format ISO 3 code table |
| indent(sb, level); |
| sb.append("private static final String[] ISO_639_2_CODES = new String[] {\n"); |
| int column = 0; |
| indent(sb, level + 1); |
| for (int i = 0, n = mLanguage3Codes.size(); i < n; i++) { |
| String code = mLanguage3Codes.get(i); |
| sb.append('"').append(code).append('"'); |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (column == 9) { |
| column = 0; |
| sb.append("\n"); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| |
| sb.append("\n"); |
| |
| // ISO 3 language names |
| indent(sb, level); |
| sb.append("private static final String[] ISO_639_2_NAMES = new String[] {\n"); |
| for (int i = 0, n = mLanguage3Codes.size(); i < n; i++) { |
| String code = mLanguage3Codes.get(i); |
| String name = mLanguageName.get(code); |
| assert name != null : code; |
| indent(sb, level + 1); |
| String literal = '"' + escape(name) + '"' + (i < n -1 ? "," : ""); |
| append(sb, literal, 40, false); |
| sb.append("// Code ").append(code); |
| String iso2 = getIso2Language(code); |
| if (iso2 != null) { |
| sb.append("/").append(iso2); |
| } |
| sb.append("\n"); |
| } |
| indent(sb, level); |
| sb.append("};\n"); |
| |
| sb.append("\n"); |
| |
| // Format ISO 2 code table |
| indent(sb, level); |
| sb.append("private static final String[] ISO_639_1_CODES = new String[] {\n"); |
| column = 0; |
| indent(sb, level + 1); |
| |
| for (int i = 0, n = mLanguage2Codes.size(); i < n; i++) { |
| String code = mLanguage2Codes.get(i); |
| sb.append('"').append(code).append('"'); |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (column == 11) { |
| column = 0; |
| sb.append("\n"); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| sb.append("\n"); |
| |
| // Format iso2 to iso3 mapping table |
| indent(sb, level); |
| sb.append("// Each element corresponds to an ISO 639-1 code, and contains the index\n"); |
| indent(sb, level); |
| sb.append("// for the corresponding ISO 639-2 code\n"); |
| indent(sb, level); |
| sb.append("private static final int[] ISO_639_1_TO_2 = new int[] {\n"); |
| column = 0; |
| indent(sb, level + 1); |
| for (int i = 0, n = mLanguage2Codes.size(); i < n; i++) { |
| String iso2 = mLanguage2Codes.get(i); |
| String iso3 = mLanguage2to3.get(iso2); |
| int index = mLanguage3Index.get(iso3); |
| append(sb, String.valueOf(index), 3, true); |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (column == 11) { |
| column = 0; |
| sb.append("\n"); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| |
| sb.append("\n"); |
| |
| // Format iso3 to iso2 mapping table |
| indent(sb, level); |
| sb.append("// Each element corresponds to an ISO 639-2 code, and contains the index\n"); |
| indent(sb, level); |
| sb.append("// for the corresponding ISO 639-1 code, or -1 if not represented\n"); |
| indent(sb, level); |
| sb.append("private static final int[] ISO_639_2_TO_1 = new int[] {\n"); |
| column = 0; |
| indent(sb, level + 1); |
| for (int i = 0, n = mLanguage3Codes.size(); i < n; i++) { |
| String iso3 = mLanguage3Codes.get(i); |
| int index = -1; |
| String iso2 = mLanguage3to2.get(iso3); |
| if (iso2 != null) { |
| index = mLanguage2Index.get(iso2); |
| } |
| append(sb, String.valueOf(index), 3, true); |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (column == 11) { |
| column = 0; |
| sb.append("\n"); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| } |
| |
| private void generateRegionTables(StringBuilder sb, int level) { |
| // Format ISO 3 code table |
| indent(sb, level); |
| sb.append("private static final String[] ISO_3166_2_CODES = new String[] {\n"); |
| int column = 0; |
| indent(sb, level + 1); |
| for (int i = 0, n = mRegion3Codes.size(); i < n; i++) { |
| String code = mRegion3Codes.get(i); |
| sb.append('"').append(code).append('"'); |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (column == 9) { |
| column = 0; |
| sb.append("\n"); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| |
| sb.append("\n"); |
| |
| // ISO 3 language names |
| indent(sb, level); |
| sb.append("private static final String[] ISO_3166_2_NAMES = new String[] {\n"); |
| for (int i = 0, n = mRegion3Codes.size(); i < n; i++) { |
| String code = mRegion3Codes.get(i); |
| String name = mRegionName.get(code); |
| assert name != null : code; |
| indent(sb, level + 1); |
| String literal = '"' + escape(name) + '"' + (i < n -1 ? "," : ""); |
| append(sb, literal, 40, false); |
| sb.append("// Code ").append(code); |
| String iso2 = getIso2Region(code); |
| if (iso2 != null) { |
| sb.append("/").append(iso2); |
| } |
| |
| |
| sb.append("\n"); |
| } |
| indent(sb, level); |
| sb.append("};\n"); |
| |
| sb.append("\n"); |
| |
| // Format ISO 2 code table |
| indent(sb, level); |
| sb.append("private static final String[] ISO_3166_1_CODES = new String[] {\n"); |
| column = 0; |
| indent(sb, level + 1); |
| |
| for (int i = 0, n = mRegion2Codes.size(); i < n; i++) { |
| String code = mRegion2Codes.get(i); |
| sb.append('"').append(code).append('"'); |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (column == 11) { |
| column = 0; |
| sb.append("\n"); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| sb.append("\n"); |
| |
| // Format iso2 to iso3 mapping table |
| indent(sb, level); |
| sb.append("// Each element corresponds to an ISO2 code, and contains the index\n"); |
| indent(sb, level); |
| sb.append("// for the corresponding ISO3 code\n"); |
| indent(sb, level); |
| sb.append("private static final int[] ISO_3166_1_TO_2 = new int[] {\n"); |
| column = 0; |
| indent(sb, level + 1); |
| for (int i = 0, n = mRegion2Codes.size(); i < n; i++) { |
| String iso2 = mRegion2Codes.get(i); |
| String iso3 = mRegion2to3.get(iso2); |
| assert iso3 != null; |
| int index = mRegion3Index.get(iso3); |
| append(sb, String.valueOf(index), 3, true); |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (column == 11) { |
| column = 0; |
| sb.append("\n"); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| |
| sb.append("\n"); |
| |
| // Format iso3 to iso2 mapping table |
| indent(sb, level); |
| sb.append("// Each element corresponds to an ISO3 code, and contains the index\n"); |
| indent(sb, level); |
| sb.append("// for the corresponding ISO2 code, or -1 if not represented\n"); |
| indent(sb, level); |
| sb.append("private static final int[] ISO_3166_2_TO_1 = new int[] {\n"); |
| column = 0; |
| indent(sb, level + 1); |
| for (int i = 0, n = mRegion3Codes.size(); i < n; i++) { |
| String iso3 = mRegion3Codes.get(i); |
| int index = -1; |
| String iso2 = mRegion3to2.get(iso3); |
| if (iso2 != null) { |
| index = mRegion2Index.get(iso2); |
| } |
| append(sb, String.valueOf(index), 3, true); |
| if (i < n - 1) { |
| sb.append(", "); |
| } |
| column++; |
| if (column == 11) { |
| column = 0; |
| sb.append("\n"); |
| if (i < n - 1) { |
| indent(sb, level + 1); |
| } |
| } |
| } |
| sb.append("\n"); |
| indent(sb, level); |
| sb.append("};\n"); |
| } |
| |
| private static void append(StringBuilder sb, String string, int width, boolean rhs) { |
| if (!rhs) { |
| sb.append(string); |
| } |
| for (int i = width - string.length(); i > 0; i--) { |
| sb.append(' '); |
| } |
| if (rhs) { |
| sb.append(string); |
| } |
| } |
| |
| private static void indent(StringBuilder sb, int level) { |
| for (int i = 0; i < level; i++) { |
| sb.append(" "); |
| } |
| } |
| |
| private static String escape(String s) { |
| for (int i = 0, n = s.length(); i < n; i++) { |
| char c = s.charAt(i); |
| if (c >= 128) { |
| StringBuilder sb = new StringBuilder(); |
| for (int j = 0, m = s.length(); j < m; j++) { |
| char d = s.charAt(j); |
| if (d < 128) { |
| sb.append(d); |
| } |
| else { |
| sb.append('\\'); |
| sb.append('u'); |
| sb.append(String.format("%04x", (int) d)); |
| } |
| } |
| return sb.toString(); |
| } |
| } |
| return s; |
| } |
| |
| |
| private static <T extends Comparable> List<T> sorted(Collection<T> list) { |
| List<T> sorted = Lists.newArrayList(list); |
| Collections.sort(sorted); |
| return sorted; |
| } |
| |
| /** Produce a map from a region code to relevant timezones */ |
| private static Map<String, Set<TimeZone>> getRegionToZones() { |
| Map<String, Set<TimeZone>> zones = new HashMap<String, Set<TimeZone>>(); |
| for (Locale locale : Locale.getAvailableLocales()) { |
| String countryCode = locale.getCountry(); |
| if (countryCode.length() != 2) { |
| continue; |
| } |
| Set<TimeZone> timezones = zones.get(countryCode); |
| if (timezones == null) { |
| timezones = Sets.newHashSet(); |
| zones.put(countryCode, timezones); |
| } |
| String[] ids = com.ibm.icu.util.TimeZone.getAvailableIDs(countryCode); |
| for (String id : ids) { |
| timezones.add(TimeZone.getTimeZone(id)); |
| } |
| } |
| return zones; |
| } |
| |
| /** Produces an inverse mapping for the result from {@link #getRegionToZones()} */ |
| private static Map<TimeZone, String> getZoneToRegion( |
| Map<String, Set<TimeZone>> regionToZones) { |
| final Map<TimeZone, String> zoneToRegion = Maps.newHashMap(); |
| for (Map.Entry<String, Set<TimeZone>> entry : regionToZones.entrySet()) { |
| String region = entry.getKey(); |
| for (TimeZone zone : entry.getValue()) { |
| if (zone.getID().equals("GMT")) { |
| continue; |
| } |
| if (zoneToRegion.containsKey(zone) && !zoneToRegion.get(zone).equals(region)) { |
| System.err.println( |
| "Didn't expect multiple regions to have the same time zone: " + |
| zone.getID() + " in both " + zoneToRegion.get(zone) + |
| " and now " + region); |
| System.exit(-1); |
| } |
| zoneToRegion.put(zone, region); |
| } |
| } |
| |
| return zoneToRegion; |
| } |
| |
| /** Removes timezones that reference regions directly in the id */ |
| private static List<TimeZone> filterCountryZones(Collection<TimeZone> zones) { |
| // Generate lookup tree for regions |
| |
| Map<String,String> countryToRegionCode = Maps.newHashMap(); |
| for (String region : LocaleManager.getRegionCodes()) { |
| countryToRegionCode.put(LocaleManager.getRegionName(region), region); |
| } |
| |
| // Remove continent codes that are actually country names; these are |
| // obvious later |
| List<TimeZone> filtered = Lists.newArrayListWithExpectedSize(zones.size()); |
| for (TimeZone zone : zones) { |
| String id = zone.getID(); |
| |
| if (id.equals("GMT")) { |
| // In some ICU database this is mapped to Taiwan; that's not right. |
| continue; |
| } |
| |
| boolean containsCountry = false; |
| // Look in all elements of the timezone, e.g. we can have |
| // Portugal, or Asia/Singapore, or America/Argentina/Mendoza |
| for (String element : Splitter.on('/').trimResults().split(id)) { |
| // Change '_' to ' ' such that we look up e.g. El Salvador, not El_Salvador |
| String name = element.replace('_', ' '); |
| if (countryToRegionCode.get(name) != null) { |
| containsCountry = true; |
| break; |
| } |
| if (element.equals("US")) { |
| // Region name is United States, but this really does map to a country code |
| containsCountry = true; |
| break; |
| } |
| |
| } |
| if (!containsCountry) { |
| filtered.add(zone); |
| } |
| } |
| |
| return filtered; |
| } |
| |
| private static int hashedId(TimeZone zone) { |
| // Instead of String#hashCode, use this to ensure stable across platforms |
| int h = 0; |
| String id = zone.getID(); |
| for (int i = 0, n = id.length(); i < n; i++) { |
| h = 31 * h + id.charAt(i); |
| } |
| return h; |
| } |
| |
| private List<TimeZone> sortByRegion(Collection<TimeZone> zones) { |
| List<TimeZone> sorted = Lists.newArrayList(zones); |
| |
| final Map<String,Integer> regionFrequency = Maps.newHashMap(); |
| for (TimeZone zone : zones) { |
| String region = mZoneToRegion.get(zone); |
| Integer frequency = regionFrequency.get(region); |
| if (frequency == null) { |
| regionFrequency.put(region, 1); |
| } else { |
| regionFrequency.put(region, frequency + 1); |
| } |
| } |
| |
| Collections.sort(sorted, new Comparator<TimeZone>() { |
| // Sort such that the timezones are all sorted (alphabetically) grouped |
| // by the same target region, and the regions in turn are sorted |
| // by frequency |
| @Override |
| public int compare(TimeZone o1, TimeZone o2) { |
| String r1 = mZoneToRegion.get(o1); |
| String r2 = mZoneToRegion.get(o2); |
| assert r1 != null : o1.getID(); |
| assert r2 != null : o2.getID(); |
| int delta = r1.compareTo(r2); |
| if (delta == 0) { // Same region: compare alphabetically by id |
| return o1.getID().compareTo(o2.getID()); |
| } else { |
| // Different regions: compare by frequency |
| int f1 = regionFrequency.get(r1); |
| int f2 = regionFrequency.get(r2); |
| delta = f1 - f2; |
| if (delta == 0) { |
| delta = r1.compareTo(r2); // If same region frequency, alphabetical |
| if (delta != 0) { |
| // But sort empty strings last |
| if (r1.isEmpty()) { |
| return 1; |
| } else if (r2.isEmpty()) { |
| return -1; |
| } |
| } |
| } |
| } |
| |
| return delta; |
| } |
| }); |
| return sorted; |
| } |
| |
| public String generateTimeZoneLookup() { |
| Map<String, Set<TimeZone>> regionToZones = getRegionToZones(); // ICU data |
| Map<TimeZone, String> zoneToRegion = getZoneToRegion(regionToZones); |
| |
| // Make sure this is generated on a recent JDK which has a lot of |
| // the new time zones |
| String property = System.getProperty("java.version"); |
| assert property.startsWith("1.") : property; |
| assert property.charAt(2) >= '8' : "Use a more recent JRE when generating data"; |
| |
| List<TimeZone> candidates = Lists.newArrayList(zoneToRegion.keySet()); |
| |
| mZoneToRegion = zoneToRegion; |
| mZoneCandidates = candidates; |
| mOutput = new StringBuilder(1000); |
| |
| // Generate lookup tree for regions |
| final Multimap<String, TimeZone> mContinentMap = ArrayListMultimap.create(); |
| for (TimeZone zone : mZoneCandidates) { |
| String id = zone.getID(); |
| int index = id.indexOf('/'); |
| String continent = ""; |
| if (index != -1) { |
| continent = id.substring(0, index); |
| } |
| mContinentMap.put(continent, zone); |
| } |
| List<String> sortedContinents = Lists.newArrayList(mContinentMap.keySet()); |
| Collections.sort(sortedContinents, new Comparator<String>() { |
| // Sort by decreasing timezone-per continent count, but put the |
| // no-continent codes at the end |
| @Override |
| public int compare(String o1, String o2) { |
| boolean e1 = o1.isEmpty(); |
| boolean e2 = o2.isEmpty(); |
| if (e1 && e2) { |
| return 0; |
| } else if (e1) { |
| return 1; |
| } else if (e2) { |
| return -1; |
| } else { |
| int delta = mContinentMap.get(o2).size() - mContinentMap.get(o1).size(); |
| if (delta != 0) { |
| return delta; |
| } |
| return o1.compareTo(o2); |
| } |
| } |
| }); |
| |
| int level = 1; |
| |
| if (INCLUDE_TIMEZONE_COMMENTS) { |
| indent(mOutput, level); |
| mOutput.append("@SuppressWarnings(\"SpellCheckingInspection\")\n"); |
| } |
| indent(mOutput, level); |
| mOutput.append("private static int getTimeZoneRegionIndex(@NonNull TimeZone zone) {\n"); |
| level++; |
| |
| indent(mOutput, level); |
| mOutput.append("// Instead of String#hashCode, use this to ensure stable across platforms\n"); |
| indent(mOutput, level); |
| mOutput.append("String id = zone.getID();\n"); |
| indent(mOutput, level); |
| mOutput.append("int hashedId = 0;\n"); |
| indent(mOutput, level); |
| mOutput.append("for (int i = 0, n = id.length(); i < n; i++) {\n"); |
| indent(mOutput, level + 1); |
| mOutput.append("hashedId = 31 * hashedId + id.charAt(i);\n"); |
| indent(mOutput, level); |
| mOutput.append("}\n"); |
| |
| indent(mOutput, level); |
| mOutput.append("switch (zone.getRawOffset()) {\n"); |
| |
| Multimap<Integer,TimeZone> offsetMap = ArrayListMultimap.create(); |
| for (TimeZone zone : mZoneCandidates) { |
| int rawOffset = zone.getRawOffset(); |
| offsetMap.put(rawOffset, zone); |
| } |
| makeJdkTimezoneCorrections(offsetMap); |
| |
| level++; |
| for (Integer offset : sorted(offsetMap.keySet())) { |
| indent(mOutput, level); |
| mOutput.append("case ").append(offset).append(":"); |
| |
| if (INCLUDE_TIMEZONE_COMMENTS) { |
| mOutput.append(" // "); |
| mOutput.append(String.valueOf(offset / 3600000.0)); |
| mOutput.append(" hours"); |
| } |
| mOutput.append("\n"); |
| |
| generateZones(level + 1, offsetMap.get(offset)); |
| } |
| level--; |
| |
| indent(mOutput, level); |
| mOutput.append("}\n"); |
| |
| indent(mOutput, level); |
| mOutput.append("return -1;\n"); |
| level--; |
| indent(mOutput, level); |
| mOutput.append("}\n"); |
| |
| // Check that our lookup method not only always produces a region |
| // (which is checked by testFindRegionByTimeZone), but also check |
| // that it produces the *same* results as the ICU mappings! |
| for (TimeZone zone : mZoneCandidates) { |
| String region = LocaleManager.getTimeZoneRegionAlpha2(zone); |
| String expected = zoneToRegion.get(zone); |
| if (expected.isEmpty()) { |
| continue; |
| } |
| assert expected.equals(region) : expected + " vs " + region; |
| } |
| |
| return mOutput.toString(); |
| } |
| |
| private void makeJdkTimezoneCorrections(Multimap<Integer,TimeZone> offsetMap) { |
| // There have been some timezone corrections; since our switch-based lookup is |
| // based on offsets, we should list these corrected timezones in both switch |
| // blocks. |
| // |
| // For example, in JDK 6, the timezone "America/Rio_Branco" had rawOffset -14400000, |
| // and in JDK 8 it's -18000000. Therefore, we should have switch statements for |
| // both. |
| |
| // JDK 1.6 to JDK 1.7: |
| correctOffset(offsetMap, "Africa/Tripoli", 3600000, 7200000); |
| correctOffset(offsetMap, "Libya", 3600000, 7200000); |
| correctOffset(offsetMap, "America/Argentina/San_Luis", -14400000, -10800000); |
| correctOffset(offsetMap, "America/Eirunepe", -14400000, -10800000); |
| correctOffset(offsetMap, "America/Porto_Acre", -14400000, -10800000); |
| correctOffset(offsetMap, "America/Rio_Branco", -14400000, -10800000); |
| correctOffset(offsetMap, "Brazil/Acre", -14400000, -10800000); |
| //correctOffset(offsetMap, "Pacific/Fakaofo", 50400000, 46800000); |
| |
| // JDK 1.7 to JDK 1.8: |
| correctOffset(offsetMap, "Europe/Simferopol", 7200000, 14400000); |
| //correctId(offsetMap, "Asia/Riyadh87", "Mideast/Riyadh87", 11224000); |
| //correctId(offsetMap, "Asia/Riyadh88", "Mideast/Riyadh88", 11224000); |
| //correctId(offsetMap, "Asia/Riyadh89", "Mideast/Riyadh89", 11224000); |
| |
| // JDK 1.8 to JDK 1. EA: |
| //correctId(offsetMap, null, "Asia/Chita", 28800000); |
| //correctId(offsetMap, null, "Asia/Srednekolymsk", 39600000); |
| //correctId(offsetMap, null, "Pacific/Bougainville", 39600000); |
| correctOffset(offsetMap, "Asia/Irkutsk", 32400000, 28800000); |
| correctOffset(offsetMap, "Asia/Kashgar", 28800000, 21600000); |
| correctOffset(offsetMap, "Asia/Khandyga", 36000000, 32400000); |
| correctOffset(offsetMap, "Asia/Krasnoyarsk", 28800000, 25200000); |
| correctOffset(offsetMap, "Asia/Magadan", 43200000, 36000000); |
| correctOffset(offsetMap, "Asia/Novosibirsk", 25200000, 21600000); |
| correctOffset(offsetMap, "Asia/Omsk", 25200000, 21600000); |
| correctOffset(offsetMap, "Asia/Sakhalin", 39600000, 36000000); |
| correctOffset(offsetMap, "Asia/Urumqi", 28800000, 21600000); |
| correctOffset(offsetMap, "Asia/Ust-Nera", 39600000, 36000000); |
| correctOffset(offsetMap, "Asia/Vladivostok", 39600000, 36000000); |
| correctOffset(offsetMap, "Asia/Yakutsk", 36000000, 32400000); |
| correctOffset(offsetMap, "Asia/Yekaterinburg", 21600000, 18000000); |
| correctOffset(offsetMap, "Europe/Kaliningrad", 10800000, 7200000); |
| correctOffset(offsetMap, "Europe/Moscow", 14400000, 10800000); |
| correctOffset(offsetMap, "Europe/Simferopol", 14400000, 10800000); |
| correctOffset(offsetMap, "Europe/Volgograd", 14400000, 10800000); |
| correctOffset(offsetMap, "W-SU", 14400000, 10800000); |
| |
| correctRegion(offsetMap, "Europe/Simferopol", 7200000, 14400000, 10800000, ""); |
| } |
| |
| private void correctOffset( |
| Multimap<Integer, TimeZone> offsetMap, |
| String id, |
| int rawOffset1, |
| int rawOffset2) { |
| TimeZone old = findZone(id); |
| if (old == null) { |
| // Not relevant for our usage |
| return; |
| } |
| TimeZone zone1 = findZone(offsetMap, id, rawOffset1); |
| if (zone1 == null) { |
| addZone(offsetMap, id, rawOffset1, old); |
| } |
| TimeZone zone2 = findZone(offsetMap, id, rawOffset2); |
| if (zone2 == null) { |
| addZone(offsetMap, id, rawOffset2, old); |
| } |
| } |
| |
| private void correctRegion( |
| Multimap<Integer, TimeZone> offsetMap, |
| String id, |
| int rawOffset1, |
| int rawOffset2, |
| int rawOffset3, |
| String region) { |
| TimeZone zone1 = findZone(offsetMap, id, rawOffset1); |
| if (zone1 != null) { |
| mZoneToRegion.put(zone1, region); |
| } |
| TimeZone zone2 = findZone(offsetMap, id, rawOffset2); |
| if (zone2 != null) { |
| mZoneToRegion.put(zone2, region); |
| } |
| TimeZone zone3 = findZone(offsetMap, id, rawOffset3); |
| if (zone3 != null) { |
| mZoneToRegion.put(zone3, region); |
| } |
| } |
| |
| private void addZone(Multimap<Integer, TimeZone> offsetMap, String id, int rawOffset, |
| TimeZone old) { |
| TimeZone zone = new SimpleTimeZone(rawOffset, id); |
| offsetMap.put(rawOffset, zone); |
| mZoneCandidates.add(zone); |
| mZoneToRegion.put(zone, mZoneToRegion.get(old)); |
| } |
| |
| private void correctId( |
| Multimap<Integer, TimeZone> offsetMap, |
| String id1, |
| String id2, |
| int rawOffset) { |
| if (id1 != null) { |
| TimeZone zone1 = findZone(offsetMap, id1, rawOffset); |
| if (zone1 == null && id2 != null) { |
| TimeZone old = findZone(id2); |
| addZone(offsetMap, id1, rawOffset, old); |
| } |
| } |
| if (id2 != null) { |
| TimeZone zone2 = findZone(offsetMap, id2, rawOffset); |
| if (zone2 == null && id1 != null) { |
| TimeZone old = findZone(id1); |
| addZone(offsetMap, id2, rawOffset, old); |
| } |
| } |
| } |
| |
| private TimeZone findZone(String id) { |
| for (TimeZone zone : mZoneCandidates) { |
| if (zone.getID().equals(id)) { |
| return zone; |
| } |
| } |
| |
| return null; |
| } |
| |
| private static TimeZone findZone(Multimap<Integer, TimeZone> offsetMap, |
| String id, int rawOffset) { |
| Collection<TimeZone> zones = offsetMap.get(rawOffset); |
| if (zones == null) { |
| return null; |
| } |
| |
| for (TimeZone zone : zones) { |
| if (id.equals(zone.getID())) { |
| return zone; |
| } |
| } |
| |
| return null; |
| } |
| |
| private void generateZones(int level, Collection<TimeZone> zones) { |
| assert !zones.isEmpty(); |
| |
| // See if they all map to the same region |
| boolean regionsDiffer = false; |
| String sameRegion = mZoneToRegion.get(zones.iterator().next()); |
| for (TimeZone zone : zones) { |
| String region = mZoneToRegion.get(zone); |
| if (!sameRegion.equals(region)) { |
| regionsDiffer = true; |
| break; |
| } |
| } |
| if (!regionsDiffer) { |
| returnRegion(zones, level); |
| return; |
| } |
| |
| indent(mOutput, level); |
| mOutput.append("switch (hashedId) {\n"); |
| level++; |
| |
| Map<Integer,TimeZone> hashCodes = Maps.newHashMap(); |
| List<TimeZone> sorted = sortByRegion(zones); |
| String lastRegion = mZoneToRegion.get(sorted.get(zones.size() - 1)); |
| for (int i = 0, n = sorted.size(); i < n; i++) { |
| TimeZone zone = sorted.get(i); |
| int hash = hashedId(zone); |
| if (hashCodes.containsKey(hash)) { |
| System.err.println("Timezones clash: same hash " + hash + " for " |
| + zone.getID() + " and " |
| + hashCodes.get(hash)); |
| System.exit(-1); |
| } |
| |
| String region = mZoneToRegion.get(zone); |
| |
| if (i < n - 1 && region.equals(lastRegion)) { |
| // TODO: Combine into a list instead |
| if (INCLUDE_TIMEZONE_COMMENTS) { |
| indent(mOutput, level); |
| pad(7); |
| mOutput.append("// ").append(escape(zone.getID())); |
| mOutput.append("\n"); |
| } |
| continue; |
| } else if (i == n - 1) { |
| indent(mOutput, level); |
| mOutput.append("default:\n"); |
| } else { |
| indent(mOutput, level); |
| mOutput.append("case ").append(hash).append(":"); |
| String text = String.valueOf(hash); |
| pad(text); |
| |
| if (INCLUDE_TIMEZONE_COMMENTS) { |
| mOutput.append(" // ").append(escape(zone.getID())); |
| } |
| mOutput.append("\n"); |
| } |
| if (i < n - 1 && region.equals(mZoneToRegion.get(sorted.get(i + 1)))) { |
| // Don't return each one; share a single body when the regions are the same |
| continue; |
| } |
| returnRegion(zone, level + 1); |
| } |
| |
| level--; |
| indent(mOutput, level); |
| mOutput.append("}\n"); |
| } |
| |
| private void pad(int space) { |
| int padding = PADDING + space; |
| for (int j = 0; j < padding; j++) { |
| mOutput.append(' '); |
| } |
| } |
| |
| private void pad(String text) { |
| int padding = PADDING - text.length(); |
| for (int j = 0; j < padding; j++) { |
| mOutput.append(' '); |
| } |
| } |
| |
| private void returnRegion(Collection<TimeZone> zones, int level) { |
| String region = mZoneToRegion.get(zones.iterator().next()); |
| List<String> ids = Lists.newArrayList(); |
| for (TimeZone zone : zones) { |
| ids.add(zone.getID()); |
| assert region.equals(mZoneToRegion.get(zone)) : zone + " vs " + region; |
| } |
| indent(mOutput, level); |
| if (region.isEmpty()) { |
| mOutput.append("return -1;\n"); |
| return; |
| } |
| int index = mRegion3Index.get(getIso3Region(region)); |
| mOutput.append("return ").append(index).append(";"); |
| if (INCLUDE_TIMEZONE_COMMENTS) { |
| pad(-9); |
| mOutput.append("// ").append(escape(LocaleManager.getRegionName(region))); |
| } |
| mOutput.append("\n"); |
| } |
| |
| private void returnRegion(TimeZone zone, int level) { |
| returnRegion(Collections.singletonList(zone), level); |
| } |
| } |
