Print this page
| Split |
Close |
| Expand all |
| Collapse all |
--- old/src/share/classes/sun/util/locale/provider/LocaleProviderAdapter.java
+++ new/src/share/classes/sun/util/locale/provider/LocaleProviderAdapter.java
1 1 /*
2 2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
3 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 4 *
5 5 * This code is free software; you can redistribute it and/or modify it
6 6 * under the terms of the GNU General Public License version 2 only, as
7 7 * published by the Free Software Foundation. Oracle designates this
8 8 * particular file as subject to the "Classpath" exception as provided
9 9 * by Oracle in the LICENSE file that accompanied this code.
10 10 *
11 11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 14 * version 2 for more details (a copy is included in the LICENSE file that
15 15 * accompanied this code).
16 16 *
17 17 * You should have received a copy of the GNU General Public License version
18 18 * 2 along with this work; if not, write to the Free Software Foundation,
19 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 20 *
21 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 22 * or visit www.oracle.com if you need additional information or have any
23 23 * questions.
24 24 */
25 25
26 26 package sun.util.locale.provider;
27 27
28 28 import java.security.AccessController;
29 29 import java.text.spi.BreakIteratorProvider;
30 30 import java.text.spi.CollatorProvider;
31 31 import java.text.spi.DateFormatProvider;
32 32 import java.text.spi.DateFormatSymbolsProvider;
33 33 import java.text.spi.DecimalFormatSymbolsProvider;
34 34 import java.text.spi.NumberFormatProvider;
35 35 import java.util.ArrayList;
36 36 import java.util.List;
37 37 import java.util.Locale;
38 38 import java.util.ResourceBundle;
39 39 import java.util.Set;
40 40 import java.util.spi.CalendarDataProvider;
41 41 import java.util.spi.CurrencyNameProvider;
42 42 import java.util.spi.LocaleNameProvider;
43 43 import java.util.spi.LocaleServiceProvider;
44 44 import java.util.spi.TimeZoneNameProvider;
45 45 import sun.util.cldr.CLDRLocaleProviderAdapter;
46 46 import sun.util.resources.LocaleData;
47 47
48 48 /**
49 49 * The LocaleProviderAdapter abstract class.
50 50 *
51 51 * @author Naoto Sato
52 52 * @author Masayoshi Okutsu
53 53 */
54 54 public abstract class LocaleProviderAdapter {
55 55 /**
56 56 * Adapter type.
57 57 */
58 58 public static enum Type {
59 59 JRE("sun.util.resources", "sun.text.resources"),
60 60 CLDR("sun.util.resources.cldr", "sun.text.resources.cldr"),
61 61 SPI,
62 62 HOST;
63 63
64 64 private final String UTIL_RESOURCES_PACKAGE;
65 65 private final String TEXT_RESOURCES_PACKAGE;
66 66
67 67 private Type() {
68 68 this(null, null);
69 69 }
70 70
71 71 private Type(String util, String text) {
72 72 UTIL_RESOURCES_PACKAGE = util;
73 73 TEXT_RESOURCES_PACKAGE = text;
74 74 }
75 75
76 76 public String getUtilResourcesPackage() {
77 77 return UTIL_RESOURCES_PACKAGE;
78 78 }
79 79
80 80 public String getTextResourcesPackage() {
81 81 return TEXT_RESOURCES_PACKAGE;
82 82 }
83 83 }
84 84
85 85 /**
86 86 * LocaleProviderAdapter preference list. The default list is intended
87 87 * to behave the same manner in JDK7.
88 88 */
89 89 private static Type[] adapterPreference = {
90 90 Type.JRE,
91 91 Type.SPI,
92 92 };
93 93
94 94 /**
95 95 * JRE Locale Data Adapter instance
96 96 */
97 97 private static LocaleProviderAdapter jreLocaleProviderAdapter = new JRELocaleProviderAdapter();
98 98
99 99 /**
100 100 * SPI Locale Data Adapter instance
101 101 */
102 102 private static LocaleProviderAdapter spiLocaleProviderAdapter = new SPILocaleProviderAdapter();
103 103
104 104 /**
105 105 * CLDR Locale Data Adapter instance, if any.
106 106 */
|
↓ open down ↓ |
106 lines elided |
↑ open up ↑ |
107 107 private static LocaleProviderAdapter cldrLocaleProviderAdapter = null;
108 108
109 109 /**
110 110 * HOST Locale Data Adapter instance, if any.
111 111 */
112 112 private static LocaleProviderAdapter hostLocaleProviderAdapter = null;
113 113
114 114 static {
115 115 String order = AccessController.doPrivileged(
116 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));
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 124
125 - // load adapter if necessary
126 - switch (aType) {
127 - case CLDR:
125 + // load adapter if necessary
126 + switch (aType) {
127 + case CLDR:
128 128 cldrLocaleProviderAdapter = new CLDRLocaleProviderAdapter();
129 - break;
130 - case HOST:
129 + break;
130 + case HOST:
131 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]);
132 + break;
148 133 }
134 + typeList.add(aType);
135 + } catch (IllegalArgumentException |
136 + UnsupportedOperationException e) {
137 + // could be caused by the user specifying wrong
138 + // provider name or format in the system property
139 + LocaleServiceProviderPool.config(LocaleProviderAdapter.class, e.toString());
140 + }
141 + }
142 + adapterPreference = typeList.toArray(new Type[0]);
143 + }
149 144 }
150 145
151 146
152 147 /**
153 148 * Returns the singleton instance for each adapter type
154 149 */
155 150 public static LocaleProviderAdapter forType(Type type) {
156 151 switch (type) {
157 152 case JRE:
158 153 return jreLocaleProviderAdapter;
159 154 case CLDR:
160 155 return cldrLocaleProviderAdapter;
161 156 case SPI:
162 157 return spiLocaleProviderAdapter;
163 158 case HOST:
164 159 return hostLocaleProviderAdapter;
165 160 default:
166 161 throw new InternalError("unknown locale data adapter type");
167 162 }
168 163 }
169 164
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
170 165 public static LocaleProviderAdapter forJRE() {
171 166 return jreLocaleProviderAdapter;
172 167 }
173 168
174 169 public static LocaleProviderAdapter getResourceBundleBased() {
175 170 for (Type type : getAdapterPreference()) {
176 171 if (type == Type.JRE || type == Type.CLDR) {
177 172 return forType(type);
178 173 }
179 174 }
180 - // Shouldn't happen.
181 - throw new InternalError();
175 +
176 + // for the last resort JRE adapter
177 + return forType(Type.JRE);
182 178 }
183 179 /**
184 180 * Returns the preference order of LocaleProviderAdapter.Type
185 181 */
186 182 public static Type[] getAdapterPreference() {
187 183 return adapterPreference;
188 184 }
189 185
190 186 /**
191 187 * Returns a LocaleProviderAdapter for the given locale service provider that
192 188 * best matches the given locale. This method returns the LocaleProviderAdapter
193 - * for JRE if none is found for the given locale.
189 + * for JRE if none is found for the ROOT locale.
194 190 *
195 191 * @param providerClass the class for the locale service provider
196 192 * @param locale the desired locale.
197 193 * @return a LocaleProviderAdapter
198 194 */
199 195 public static LocaleProviderAdapter getAdapter(Class<? extends LocaleServiceProvider> providerClass,
200 196 Locale locale) {
201 197 // Fast look-up for the given locale
202 198 LocaleProviderAdapter adapter = findAdapter(providerClass, locale);
203 199 if (adapter != null) {
204 200 return adapter;
205 201 }
206 202
207 203 // Try finding an adapter in the normal candidate locales path of the given locale.
208 204 List<Locale> lookupLocales = ResourceBundle.Control.getControl(ResourceBundle.Control.FORMAT_DEFAULT)
209 205 .getCandidateLocales("", locale);
210 206 for (Locale loc : lookupLocales) {
211 207 if (loc.equals(locale)) {
212 208 // We've already done with this loc.
213 209 continue;
214 210 }
215 211 adapter = findAdapter(providerClass, loc);
216 212 if (adapter != null) {
217 213 return adapter;
218 214 }
219 215 }
220 216
221 217 // returns the adapter for JRE as the last resort
222 218 return jreLocaleProviderAdapter;
223 219 }
224 220
225 221 private static LocaleProviderAdapter findAdapter(Class<? extends LocaleServiceProvider> providerClass,
226 222 Locale locale) {
227 223 for (Type type : getAdapterPreference()) {
228 224 LocaleProviderAdapter adapter = forType(type);
229 225 LocaleServiceProvider provider = adapter.getLocaleServiceProvider(providerClass);
230 226 if (provider != null) {
231 227 if (provider.isSupportedLocale(locale)) {
232 228 return adapter;
233 229 }
234 230 }
235 231 }
236 232 return null;
237 233 }
238 234
239 235 /**
240 236 * A utility method for implementing the default LocaleServiceProvider.isSupportedLocale
241 237 * for the JRE and CLDR adapters.
242 238 */
243 239 static boolean isSupportedLocale(Locale locale, LocaleProviderAdapter.Type type, Set<String> langtags) {
244 240 assert type == Type.JRE || type == Type.CLDR;
245 241 if (locale == Locale.ROOT) {
246 242 return true;
247 243 }
248 244 locale = locale.stripExtensions();
249 245 if (langtags.contains(locale.toLanguageTag())) {
250 246 return true;
251 247 }
252 248 if (type == LocaleProviderAdapter.Type.JRE) {
253 249 String oldname = locale.toString().replace('_', '-');
254 250 return langtags.contains(oldname);
255 251 }
256 252 return false;
257 253 }
258 254
259 255 public static Locale[] toLocaleArray(Set<String> tags) {
260 256 Locale[] locs = new Locale[tags.size() + 1];
261 257 int index = 0;
262 258 locs[index++] = Locale.ROOT;
263 259 for (String tag : tags) {
264 260 switch (tag) {
265 261 case "ja-JP-JP":
266 262 locs[index++] = JRELocaleConstants.JA_JP_JP;
267 263 break;
268 264 case "th-TH-TH":
269 265 locs[index++] = JRELocaleConstants.TH_TH_TH;
270 266 break;
271 267 default:
272 268 locs[index++] = Locale.forLanguageTag(tag);
273 269 break;
274 270 }
275 271 }
276 272 return locs;
277 273 }
278 274
279 275 /**
280 276 * Returns the type of this LocaleProviderAdapter
281 277 */
282 278 public abstract LocaleProviderAdapter.Type getAdapterType();
283 279
284 280 /**
285 281 * Getter method for Locale Service Providers.
286 282 */
287 283 public abstract <P extends LocaleServiceProvider> P getLocaleServiceProvider(Class<P> c);
288 284
289 285 /**
290 286 * Returns a BreakIteratorProvider for this LocaleProviderAdapter, or null if no
291 287 * BreakIteratorProvider is available.
292 288 *
293 289 * @return a BreakIteratorProvider
294 290 */
295 291 public abstract BreakIteratorProvider getBreakIteratorProvider();
296 292
297 293 /**
298 294 * Returns a ollatorProvider for this LocaleProviderAdapter, or null if no
299 295 * ollatorProvider is available.
300 296 *
301 297 * @return a ollatorProvider
302 298 */
303 299 public abstract CollatorProvider getCollatorProvider();
304 300
305 301 /**
306 302 * Returns a DateFormatProvider for this LocaleProviderAdapter, or null if no
307 303 * DateFormatProvider is available.
308 304 *
309 305 * @return a DateFormatProvider
310 306 */
311 307 public abstract DateFormatProvider getDateFormatProvider();
312 308
313 309 /**
314 310 * Returns a DateFormatSymbolsProvider for this LocaleProviderAdapter, or null if no
315 311 * DateFormatSymbolsProvider is available.
316 312 *
317 313 * @return a DateFormatSymbolsProvider
318 314 */
319 315 public abstract DateFormatSymbolsProvider getDateFormatSymbolsProvider();
320 316
321 317 /**
322 318 * Returns a DecimalFormatSymbolsProvider for this LocaleProviderAdapter, or null if no
323 319 * DecimalFormatSymbolsProvider is available.
324 320 *
325 321 * @return a DecimalFormatSymbolsProvider
326 322 */
327 323 public abstract DecimalFormatSymbolsProvider getDecimalFormatSymbolsProvider();
328 324
329 325 /**
330 326 * Returns a NumberFormatProvider for this LocaleProviderAdapter, or null if no
331 327 * NumberFormatProvider is available.
332 328 *
333 329 * @return a NumberFormatProvider
334 330 */
335 331 public abstract NumberFormatProvider getNumberFormatProvider();
336 332
337 333 /*
338 334 * Getter methods for java.util.spi.* providers
339 335 */
340 336
341 337 /**
342 338 * Returns a CurrencyNameProvider for this LocaleProviderAdapter, or null if no
343 339 * CurrencyNameProvider is available.
344 340 *
345 341 * @return a CurrencyNameProvider
346 342 */
347 343 public abstract CurrencyNameProvider getCurrencyNameProvider();
348 344
349 345 /**
350 346 * Returns a LocaleNameProvider for this LocaleProviderAdapter, or null if no
351 347 * LocaleNameProvider is available.
352 348 *
353 349 * @return a LocaleNameProvider
354 350 */
355 351 public abstract LocaleNameProvider getLocaleNameProvider();
356 352
357 353 /**
358 354 * Returns a TimeZoneNameProvider for this LocaleProviderAdapter, or null if no
359 355 * TimeZoneNameProvider is available.
360 356 *
361 357 * @return a TimeZoneNameProvider
362 358 */
363 359 public abstract TimeZoneNameProvider getTimeZoneNameProvider();
364 360
365 361 /**
366 362 * Returns a CalendarDataProvider for this LocaleProviderAdapter, or null if no
367 363 * CalendarDataProvider is available.
368 364 *
369 365 * @return a CalendarDataProvider
370 366 */
371 367 public abstract CalendarDataProvider getCalendarDataProvider();
372 368
373 369 public abstract LocaleResources getLocaleResources(Locale locale);
374 370
375 371 public abstract LocaleData getLocaleData();
376 372
377 373 public abstract Locale[] getAvailableLocales();
378 374 }
|
↓ open down ↓ |
175 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX