1 /*
   2  * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.util.cldr;
  27 
  28 import static sun.util.locale.provider.LocaleProviderAdapter.Type;
  29 
  30 import java.text.MessageFormat;
  31 import java.util.Arrays;
  32 import java.util.Locale;
  33 import java.util.Objects;
  34 import java.util.ResourceBundle;
  35 import java.util.Set;
  36 import java.util.TimeZone;
  37 import java.util.stream.Collectors;
  38 import sun.util.calendar.ZoneInfoFile;
  39 import sun.util.locale.provider.LocaleProviderAdapter;
  40 import sun.util.locale.provider.LocaleResources;
  41 import sun.util.locale.provider.TimeZoneNameProviderImpl;
  42 import sun.util.locale.provider.TimeZoneNameUtility;
  43 
  44 /**
  45  * Concrete implementation of the
  46  * {@link java.util.spi.TimeZoneNameProvider TimeZoneNameProvider} class
  47  * for the CLDR LocaleProviderAdapter.
  48  *
  49  * @author Naoto Sato
  50  */
  51 public class CLDRTimeZoneNameProviderImpl extends TimeZoneNameProviderImpl {
  52 
  53     private static final String NO_INHERITANCE_MARKER = "\u2205\u2205\u2205";
  54     private static class AVAILABLE_IDS {
  55         static final String[] INSTANCE =
  56             Arrays.stream(ZoneInfoFile.getZoneIds())
  57                 .sorted()
  58                 .toArray(String[]::new);
  59     }
  60 
  61     // display name array indexes
  62     private static final int INDEX_TZID         = 0;
  63     private static final int INDEX_STD_LONG     = 1;
  64     private static final int INDEX_STD_SHORT    = 2;
  65     private static final int INDEX_DST_LONG     = 3;
  66     private static final int INDEX_DST_SHORT    = 4;
  67     private static final int INDEX_GEN_LONG     = 5;
  68     private static final int INDEX_GEN_SHORT    = 6;
  69 
  70     public CLDRTimeZoneNameProviderImpl(Type type, Set<String> langtags) {
  71         super(type, langtags);
  72     }
  73 
  74     @Override
  75     protected String[] getDisplayNameArray(String id, Locale locale) {
  76         // Use English for the ROOT locale
  77         locale = locale.equals(Locale.ROOT) ? Locale.ENGLISH : locale;
  78         String[] namesSuper = super.getDisplayNameArray(id, locale);
  79 
  80         if (namesSuper == null) {
  81             // try canonical id instead
  82             namesSuper = super.getDisplayNameArray(
  83                 TimeZoneNameUtility.canonicalTZID(id).orElse(id),
  84                 locale);
  85         }
  86 
  87         if (namesSuper != null) {
  88             // CLDR's resource bundle has an translated entry for this id.
  89             // Fix up names if needed, either missing or no-inheritance
  90             namesSuper[INDEX_TZID] = id;
  91 
  92             for(int i = INDEX_STD_LONG; i < namesSuper.length; i++) { // index 0 is the 'id' itself
  93                 switch (namesSuper[i]) {
  94                 case "":
  95                     // Fill in empty elements
  96                     deriveFallbackName(namesSuper, i, locale,
  97                                        !exists(namesSuper, INDEX_DST_LONG));
  98                     break;
  99                 case NO_INHERITANCE_MARKER:
 100                     // CLDR's "no inheritance marker"
 101                     namesSuper[i] = toGMTFormat(id, i == INDEX_DST_LONG || i == INDEX_DST_SHORT,
 102                                                 i % 2 != 0, locale);
 103                     break;
 104                 default:
 105                     break;
 106                 }
 107             }
 108             return namesSuper;
 109         } else {
 110             // Derive the names for this id. Validate the id first.
 111             if (Arrays.binarySearch(AVAILABLE_IDS.INSTANCE, id) >= 0) {
 112                 String[] names = new String[INDEX_GEN_SHORT + 1];
 113                 names[INDEX_TZID] = id;
 114                 deriveFallbackNames(names, locale);
 115                 return names;
 116             }
 117         }
 118 
 119         return null;
 120     }
 121 
 122     @Override
 123     protected String[][] getZoneStrings(Locale locale) {
 124         // Use English for the ROOT locale
 125         locale = locale.equals(Locale.ROOT) ? Locale.ENGLISH : locale;
 126         String[][] ret = super.getZoneStrings(locale);
 127 
 128         // Fill in for the empty names.
 129         // English names are prefilled for performance.
 130         if (!locale.equals(Locale.ENGLISH) &&
 131             !locale.equals(Locale.US)) {
 132             for (int zoneIndex = 0; zoneIndex < ret.length; zoneIndex++) {
 133                 deriveFallbackNames(ret[zoneIndex], locale);
 134             }
 135         }
 136         return ret;
 137     }
 138 
 139     // Derive fallback time zone name according to LDML's logic
 140     private void deriveFallbackNames(String[] names, Locale locale) {
 141         boolean noDST = !exists(names, INDEX_DST_LONG);
 142         for (int i = INDEX_STD_LONG; i <= INDEX_GEN_SHORT; i++) {
 143             deriveFallbackName(names, i, locale, noDST);
 144         }
 145     }
 146 
 147     private void deriveFallbackName(String[] names, int index, Locale locale, boolean noDST) {
 148         String id = names[INDEX_TZID];
 149 
 150         if (exists(names, index)) {
 151             if (names[index].equals(NO_INHERITANCE_MARKER)) {
 152                 // CLDR's "no inheritance marker"
 153                 names[index] = toGMTFormat(id,
 154                                     index == INDEX_DST_LONG || index == INDEX_DST_SHORT,
 155                                     index % 2 != 0, locale);
 156             }
 157             return;
 158         }
 159 
 160         // Check if COMPAT can substitute the name
 161         if (LocaleProviderAdapter.getAdapterPreference().contains(Type.JRE)) {
 162             String[] compatNames = (String[])LocaleProviderAdapter.forJRE()
 163                 .getLocaleResources(mapChineseLocale(locale))
 164                 .getTimeZoneNames(id);
 165             if (compatNames != null) {
 166                 for (int i = INDEX_STD_LONG; i <= INDEX_GEN_SHORT; i++) {
 167                     // Assumes COMPAT has no empty slots
 168                     if (i == index || !exists(names, i)) {
 169                         names[i] = compatNames[i];
 170                     }
 171                 }
 172                 return;
 173             }
 174         }
 175 
 176         // Type Fallback
 177         if (noDST && typeFallback(names, index)) {
 178             return;
 179         }
 180 
 181         // Region Fallback
 182         if (regionFormatFallback(names, index, locale)) {
 183             return;
 184         }
 185 
 186         // last resort
 187         if (!id.toUpperCase(Locale.ROOT).startsWith("UT")) {
 188             names[index] = toGMTFormat(id,
 189                                        index == INDEX_DST_LONG || index == INDEX_DST_SHORT,
 190                                        index % 2 != 0,
 191                                        locale);
 192             // aliases of "GMT" timezone.
 193             if ((exists(names, INDEX_STD_LONG)) && (id.startsWith("Etc/")
 194                     || id.startsWith("GMT") || id.startsWith("Greenwich"))) {
 195                 switch (id) {
 196                 case "Etc/GMT":
 197                 case "Etc/GMT-0":
 198                 case "Etc/GMT+0":
 199                 case "Etc/GMT0":
 200                 case "GMT+0":
 201                 case "GMT-0":
 202                 case "GMT0":
 203                 case "Greenwich":
 204                     names[INDEX_DST_LONG] = names[INDEX_GEN_LONG] = names[INDEX_STD_LONG];
 205                     break;
 206                 }
 207             }
 208         }
 209     }
 210 
 211     private boolean exists(String[] names, int index) {
 212         return Objects.nonNull(names)
 213                 && Objects.nonNull(names[index])
 214                 && !names[index].isEmpty();
 215     }
 216 
 217     private boolean typeFallback(String[] names, int index) {
 218         // check generic
 219         int genIndex = INDEX_GEN_SHORT - index % 2;
 220         if (!exists(names, index) && exists(names, genIndex)) {
 221             names[index] = names[genIndex];
 222         } else {
 223             // check standard
 224             int stdIndex = INDEX_STD_SHORT - index % 2;
 225             if (!exists(names, index) && exists(names, stdIndex)) {
 226                 names[index] = names[stdIndex];
 227             }
 228         }
 229 
 230         return exists(names, index);
 231     }
 232 
 233     private boolean regionFormatFallback(String[] names, int index, Locale l) {
 234         String id = names[INDEX_TZID];
 235         LocaleResources lr = LocaleProviderAdapter.forType(Type.CLDR).getLocaleResources(l);
 236         ResourceBundle fd = lr.getJavaTimeFormatData();
 237 
 238         String rgn = (String) lr.getTimeZoneNames("timezone.excity." + id);
 239         if (rgn == null && !id.startsWith("Etc") && !id.startsWith("SystemV")) {
 240             int slash = id.lastIndexOf('/');
 241             if (slash > 0) {
 242                 rgn = id.substring(slash + 1).replaceAll("_", " ");
 243             }
 244         }
 245 
 246         if (rgn != null) {
 247             String fmt = "";
 248             switch (index) {
 249             case INDEX_STD_LONG:
 250                 fmt = fd.getString("timezone.regionFormat.standard");
 251                 break;
 252             case INDEX_DST_LONG:
 253                 fmt = fd.getString("timezone.regionFormat.daylight");
 254                 break;
 255             case INDEX_GEN_LONG:
 256                 fmt = fd.getString("timezone.regionFormat");
 257                 break;
 258             }
 259             if (!fmt.isEmpty()) {
 260                 names[index] = MessageFormat.format(fmt, rgn);
 261             }
 262         }
 263 
 264         return exists(names, index);
 265     }
 266 
 267     private String toGMTFormat(String id, boolean daylight, boolean isShort, Locale l) {
 268         TimeZone tz = ZoneInfoFile.getZoneInfo(id);
 269         int offset = (tz.getRawOffset() + (daylight ? tz.getDSTSavings() : 0)) / 60000;
 270         LocaleResources lr = LocaleProviderAdapter.forType(Type.CLDR).getLocaleResources(l);
 271         ResourceBundle fd = lr.getJavaTimeFormatData();
 272 
 273         if (offset == 0) {
 274             return fd.getString("timezone.gmtZeroFormat");
 275         } else {
 276             String gmtFormat = fd.getString("timezone.gmtFormat");
 277             String hourFormat = fd.getString("timezone.hourFormat");
 278 
 279             if (offset > 0) {
 280                 hourFormat = hourFormat.substring(0, hourFormat.indexOf(";"));
 281             } else {
 282                 hourFormat = hourFormat.substring(hourFormat.indexOf(";") + 1);
 283                 offset = -offset;
 284             }
 285             hourFormat = hourFormat
 286                 .replaceFirst("H+", (isShort ? "\\%1\\$d" : "\\%1\\$02d"))
 287                 .replaceFirst("m+", "\\%2\\$02d");
 288             return MessageFormat.format(gmtFormat,
 289                     String.format(l, hourFormat, offset / 60, offset % 60));
 290         }
 291     }
 292 
 293     // Mapping CLDR's Simplified/Traditional Chinese resources
 294     // to COMPAT's zh-CN/TW
 295     private Locale mapChineseLocale(Locale locale) {
 296         if (locale.getLanguage() == "zh") {
 297             switch (locale.getScript()) {
 298                 case "Hans":
 299                     return Locale.CHINA;
 300                 case "Hant":
 301                     return Locale.TAIWAN;
 302                 case "":
 303                     // no script, guess from country code.
 304                     switch (locale.getCountry()) {
 305                         case "":
 306                         case "CN":
 307                         case "SG":
 308                             return Locale.CHINA;
 309                         case "HK":
 310                         case "MO":
 311                         case "TW":
 312                             return Locale.TAIWAN;
 313                     }
 314                     break;
 315             }
 316         }
 317 
 318         // no need to map
 319         return locale;
 320     }
 321 }