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