1 /*
   2  * Copyright (c) 2012, 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.locale.provider;
  27 
  28 import java.security.AccessController;
  29 import java.text.spi.BreakIteratorProvider;
  30 import java.text.spi.CollatorProvider;
  31 import java.text.spi.DateFormatProvider;
  32 import java.text.spi.DateFormatSymbolsProvider;
  33 import java.text.spi.DecimalFormatSymbolsProvider;
  34 import java.text.spi.NumberFormatProvider;
  35 import java.util.ArrayList;
  36 import java.util.List;
  37 import java.util.Locale;
  38 import java.util.ResourceBundle;
  39 import java.util.Set;
  40 import java.util.spi.CalendarDataProvider;
  41 import java.util.spi.CurrencyNameProvider;
  42 import java.util.spi.LocaleNameProvider;
  43 import java.util.spi.LocaleServiceProvider;
  44 import java.util.spi.TimeZoneNameProvider;
  45 import sun.util.cldr.CLDRLocaleProviderAdapter;
  46 import sun.util.resources.LocaleData;
  47 
  48 /**
  49  * The LocaleProviderAdapter abstract class.
  50  *
  51  * @author Naoto Sato
  52  * @author Masayoshi Okutsu
  53  */
  54 public abstract class LocaleProviderAdapter {
  55     /**
  56      * Adapter type.
  57      */
  58     public static enum Type {
  59         JRE("sun.util.resources", "sun.text.resources"),
  60         CLDR("sun.util.resources.cldr", "sun.text.resources.cldr"),
  61         SPI,
  62         HOST;
  63 
  64         private final String UTIL_RESOURCES_PACKAGE;
  65         private final String TEXT_RESOURCES_PACKAGE;
  66 
  67         private Type() {
  68             this(null, null);
  69         }
  70 
  71         private Type(String util, String text) {
  72             UTIL_RESOURCES_PACKAGE = util;
  73             TEXT_RESOURCES_PACKAGE = text;
  74         }
  75 
  76         public String getUtilResourcesPackage() {
  77             return UTIL_RESOURCES_PACKAGE;
  78         }
  79 
  80         public String getTextResourcesPackage() {
  81             return TEXT_RESOURCES_PACKAGE;
  82         }
  83     }
  84 
  85     /**
  86      * LocaleProviderAdapter preference list. The default list is intended
  87      * to behave the same manner in JDK7.
  88      */
  89     private static Type[] adapterPreference = {
  90         Type.JRE,
  91         Type.SPI,
  92     };
  93 
  94     /**
  95      * JRE Locale Data Adapter instance
  96      */
  97     private static LocaleProviderAdapter jreLocaleProviderAdapter = new JRELocaleProviderAdapter();
  98 
  99     /**
 100      * SPI Locale Data Adapter instance
 101      */
 102     private static LocaleProviderAdapter spiLocaleProviderAdapter = new SPILocaleProviderAdapter();
 103 
 104     /**
 105      * CLDR Locale Data Adapter instance, if any.
 106      */
 107     private static LocaleProviderAdapter cldrLocaleProviderAdapter = null;
 108 
 109     /**
 110      * HOST Locale Data Adapter instance, if any.
 111      */
 112     private static LocaleProviderAdapter hostLocaleProviderAdapter = null;
 113 
 114     static {
 115         String order = AccessController.doPrivileged(
 116                            new sun.security.action.GetPropertyAction("java.locale.providers"));
 117                     // Override adapterPreference with the properties one
 118                     if (order != null && order.length() != 0) {
 119                         String[] types = order.split(",");
 120                         List<Type> typeList = new ArrayList<>();
 121                         for (String type : types) {
 122                             try {
 123                             Type aType = Type.valueOf(type.trim().toUpperCase(Locale.ROOT));
 124 
 125                                 // load adapter if necessary
 126                                 switch (aType) {
 127                                 case CLDR:
 128                         cldrLocaleProviderAdapter = new CLDRLocaleProviderAdapter();
 129                                     break;
 130                                 case HOST:
 131                         hostLocaleProviderAdapter = new HostLocaleProviderAdapter();
 132                                     break;
 133                                 }
 134                                 typeList.add(aType);
 135                 } catch (// could be caused by the user specifying wrong
 136                                      // provider name or format in the system property
 137                                      IllegalArgumentException |
 138                                      UnsupportedOperationException e) {
 139                                 LocaleServiceProviderPool.config(LocaleProviderAdapter.class, e.toString());
 140                             }
 141                         }
 142 
 143                         if (!typeList.contains(Type.JRE)) {
 144                             // Append JRE as the last resort.
 145                             typeList.add(Type.JRE);
 146                         }
 147                         adapterPreference = typeList.toArray(new Type[0]);
 148                     }
 149     }
 150 
 151 
 152     /**
 153      * Returns the singleton instance for each adapter type
 154      */
 155     public static LocaleProviderAdapter forType(Type type) {
 156         switch (type) {
 157         case JRE:
 158             return jreLocaleProviderAdapter;
 159         case CLDR:
 160             return cldrLocaleProviderAdapter;
 161         case SPI:
 162             return spiLocaleProviderAdapter;
 163         case HOST:
 164             return hostLocaleProviderAdapter;
 165         default:
 166             throw new InternalError("unknown locale data adapter type");
 167         }
 168     }
 169 
 170     public static LocaleProviderAdapter forJRE() {
 171         return jreLocaleProviderAdapter;
 172     }
 173 
 174     public static LocaleProviderAdapter getResourceBundleBased() {
 175         for (Type type : getAdapterPreference()) {
 176             if (type == Type.JRE || type == Type.CLDR) {
 177                 return forType(type);
 178             }
 179         }
 180         // Shouldn't happen.
 181         throw new InternalError();
 182     }
 183     /**
 184      * Returns the preference order of LocaleProviderAdapter.Type
 185      */
 186     public static Type[] getAdapterPreference() {
 187         return adapterPreference;
 188     }
 189 
 190     /**
 191      * Returns a LocaleProviderAdapter for the given locale service provider that
 192      * best matches the given locale. This method returns the LocaleProviderAdapter
 193      * for JRE if none is found for the given locale.
 194      *
 195      * @param providerClass the class for the locale service provider
 196      * @param locale the desired locale.
 197      * @return a LocaleProviderAdapter
 198      */
 199     public static LocaleProviderAdapter getAdapter(Class<? extends LocaleServiceProvider> providerClass,
 200                                                Locale locale) {
 201         // Fast look-up for the given locale
 202         LocaleProviderAdapter adapter = findAdapter(providerClass, locale);
 203         if (adapter != null) {
 204             return adapter;
 205         }
 206 
 207         // Try finding an adapter in the normal candidate locales path of the given locale.
 208         List<Locale> lookupLocales = ResourceBundle.Control.getControl(ResourceBundle.Control.FORMAT_DEFAULT)
 209                                         .getCandidateLocales("", locale);
 210         for (Locale loc : lookupLocales) {
 211             if (loc.equals(locale)) {
 212                 // We've already done with this loc.
 213                 continue;
 214             }
 215             adapter = findAdapter(providerClass, loc);
 216             if (adapter != null) {
 217                 return adapter;
 218             }
 219         }
 220 
 221         // returns the adapter for JRE as the last resort
 222         return jreLocaleProviderAdapter;
 223     }
 224 
 225     private static LocaleProviderAdapter findAdapter(Class<? extends LocaleServiceProvider> providerClass,
 226                                                  Locale locale) {
 227         for (Type type : getAdapterPreference()) {
 228             LocaleProviderAdapter adapter = forType(type);
 229             LocaleServiceProvider provider = adapter.getLocaleServiceProvider(providerClass);
 230             if (provider != null) {
 231                 if (provider.isSupportedLocale(locale)) {
 232                     return adapter;
 233                 }
 234             }
 235         }
 236         return null;
 237     }
 238 
 239     /**
 240      * A utility method for implementing the default LocaleServiceProvider.isSupportedLocale
 241      * for the JRE and CLDR adapters.
 242      */
 243     static boolean isSupportedLocale(Locale locale, LocaleProviderAdapter.Type type, Set<String> langtags) {
 244         assert type == Type.JRE || type == Type.CLDR;
 245         if (locale == Locale.ROOT) {
 246             return true;
 247         }
 248         locale = locale.stripExtensions();
 249         if (langtags.contains(locale.toLanguageTag())) {
 250             return true;
 251         }
 252         if (type == LocaleProviderAdapter.Type.JRE) {
 253             String oldname = locale.toString().replace('_', '-');
 254             return langtags.contains(oldname);
 255         }
 256         return false;
 257     }
 258 
 259     public static Locale[] toLocaleArray(Set<String> tags) {
 260         Locale[] locs = new Locale[tags.size() + 1];
 261         int index = 0;
 262         locs[index++] = Locale.ROOT;
 263         for (String tag : tags) {
 264             switch (tag) {
 265             case "ja-JP-JP":
 266                 locs[index++] = JRELocaleConstants.JA_JP_JP;
 267                 break;
 268             case "th-TH-TH":
 269                 locs[index++] = JRELocaleConstants.TH_TH_TH;
 270                 break;
 271             default:
 272                 locs[index++] = Locale.forLanguageTag(tag);
 273                 break;
 274             }
 275         }
 276         return locs;
 277     }
 278 
 279     /**
 280      * Returns the type of this LocaleProviderAdapter
 281      */
 282     public abstract LocaleProviderAdapter.Type getAdapterType();
 283 
 284     /**
 285      * Getter method for Locale Service Providers.
 286      */
 287     public abstract <P extends LocaleServiceProvider> P getLocaleServiceProvider(Class<P> c);
 288 
 289     /**
 290      * Returns a BreakIteratorProvider for this LocaleProviderAdapter, or null if no
 291      * BreakIteratorProvider is available.
 292      *
 293      * @return a BreakIteratorProvider
 294      */
 295     public abstract BreakIteratorProvider getBreakIteratorProvider();
 296 
 297     /**
 298      * Returns a ollatorProvider for this LocaleProviderAdapter, or null if no
 299      * ollatorProvider is available.
 300      *
 301      * @return a ollatorProvider
 302      */
 303     public abstract CollatorProvider getCollatorProvider();
 304 
 305     /**
 306      * Returns a DateFormatProvider for this LocaleProviderAdapter, or null if no
 307      * DateFormatProvider is available.
 308      *
 309      * @return a DateFormatProvider
 310      */
 311     public abstract DateFormatProvider getDateFormatProvider();
 312 
 313     /**
 314      * Returns a DateFormatSymbolsProvider for this LocaleProviderAdapter, or null if no
 315      * DateFormatSymbolsProvider is available.
 316      *
 317      * @return a DateFormatSymbolsProvider
 318      */
 319     public abstract DateFormatSymbolsProvider getDateFormatSymbolsProvider();
 320 
 321     /**
 322      * Returns a DecimalFormatSymbolsProvider for this LocaleProviderAdapter, or null if no
 323      * DecimalFormatSymbolsProvider is available.
 324      *
 325      * @return a DecimalFormatSymbolsProvider
 326      */
 327     public abstract DecimalFormatSymbolsProvider getDecimalFormatSymbolsProvider();
 328 
 329     /**
 330      * Returns a NumberFormatProvider for this LocaleProviderAdapter, or null if no
 331      * NumberFormatProvider is available.
 332      *
 333      * @return a NumberFormatProvider
 334      */
 335     public abstract NumberFormatProvider getNumberFormatProvider();
 336 
 337     /*
 338      * Getter methods for java.util.spi.* providers
 339      */
 340 
 341     /**
 342      * Returns a CurrencyNameProvider for this LocaleProviderAdapter, or null if no
 343      * CurrencyNameProvider is available.
 344      *
 345      * @return a CurrencyNameProvider
 346      */
 347     public abstract CurrencyNameProvider getCurrencyNameProvider();
 348 
 349     /**
 350      * Returns a LocaleNameProvider for this LocaleProviderAdapter, or null if no
 351      * LocaleNameProvider is available.
 352      *
 353      * @return a LocaleNameProvider
 354      */
 355     public abstract LocaleNameProvider getLocaleNameProvider();
 356 
 357     /**
 358      * Returns a TimeZoneNameProvider for this LocaleProviderAdapter, or null if no
 359      * TimeZoneNameProvider is available.
 360      *
 361      * @return a TimeZoneNameProvider
 362      */
 363     public abstract TimeZoneNameProvider getTimeZoneNameProvider();
 364 
 365     /**
 366      * Returns a CalendarDataProvider for this LocaleProviderAdapter, or null if no
 367      * CalendarDataProvider is available.
 368      *
 369      * @return a CalendarDataProvider
 370      */
 371     public abstract CalendarDataProvider getCalendarDataProvider();
 372 
 373     public abstract LocaleResources getLocaleResources(Locale locale);
 374 
 375     public abstract LocaleData getLocaleData();
 376 
 377     public abstract Locale[] getAvailableLocales();
 378 }