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