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. The default list is intended
92 * to behave the same manner in JDK7.
93 */
94 private static final List<Type> adapterPreference;
95
96 /**
97 * JRE Locale Data Adapter instance
98 */
99 private static LocaleProviderAdapter jreLocaleProviderAdapter = new JRELocaleProviderAdapter();
100
101 /**
102 * SPI Locale Data Adapter instance
103 */
104 private static LocaleProviderAdapter spiLocaleProviderAdapter = new SPILocaleProviderAdapter();
105
106 /**
107 * CLDR Locale Data Adapter instance, if any.
108 */
109 private static LocaleProviderAdapter cldrLocaleProviderAdapter = null;
110
111 /**
112 * HOST Locale Data Adapter instance, if any.
160 typeList.add(aType);
161 }
162 } catch (IllegalArgumentException | UnsupportedOperationException e) {
163 // could be caused by the user specifying wrong
164 // provider name or format in the system property
165 LocaleServiceProviderPool.config(LocaleProviderAdapter.class, e.toString());
166 }
167 }
168 }
169
170 if (!typeList.isEmpty()) {
171 if (!typeList.contains(Type.JRE)) {
172 // Append FALLBACK as the last resort.
173 fallbackLocaleProviderAdapter = new FallbackLocaleProviderAdapter();
174 typeList.add(Type.FALLBACK);
175 defaultLocaleProviderAdapter = Type.FALLBACK;
176 } else {
177 defaultLocaleProviderAdapter = Type.JRE;
178 }
179 } else {
180 // Default preference list
181 typeList.add(Type.JRE);
182 typeList.add(Type.SPI);
183 defaultLocaleProviderAdapter = Type.JRE;
184 }
185
186 adapterPreference = Collections.unmodifiableList(typeList);
187 }
188
189 /**
190 * Returns the singleton instance for each adapter type
191 */
192 public static LocaleProviderAdapter forType(Type type) {
193 switch (type) {
194 case JRE:
195 return jreLocaleProviderAdapter;
196 case CLDR:
197 return cldrLocaleProviderAdapter;
198 case SPI:
199 return spiLocaleProviderAdapter;
200 case HOST:
201 return hostLocaleProviderAdapter;
202 case FALLBACK:
203 return fallbackLocaleProviderAdapter;
204 default:
205 throw new InternalError("unknown locale data adapter type");
206 }
207 }
208
209 public static LocaleProviderAdapter forJRE() {
210 return jreLocaleProviderAdapter;
211 }
212
213 public static LocaleProviderAdapter getResourceBundleBased() {
214 for (Type type : getAdapterPreference()) {
215 if (type == Type.JRE || type == Type.CLDR || type == Type.FALLBACK) {
216 return forType(type);
217 }
218 }
219 // Shouldn't happen.
220 throw new InternalError();
221 }
222 /**
223 * Returns the preference order of LocaleProviderAdapter.Type
224 */
225 public static List<Type> getAdapterPreference() {
226 return adapterPreference;
227 }
228
229 /**
230 * Returns a LocaleProviderAdapter for the given locale service provider that
231 * best matches the given locale. This method returns the LocaleProviderAdapter
232 * for JRE if none is found for the given locale.
233 *
234 * @param providerClass the class for the locale service provider
235 * @param locale the desired locale.
236 * @return a LocaleProviderAdapter
278 }
279
280 private static LocaleProviderAdapter findAdapter(Class<? extends LocaleServiceProvider> providerClass,
281 Locale locale) {
282 for (Type type : getAdapterPreference()) {
283 LocaleProviderAdapter adapter = forType(type);
284 LocaleServiceProvider provider = adapter.getLocaleServiceProvider(providerClass);
285 if (provider != null) {
286 if (provider.isSupportedLocale(locale)) {
287 return adapter;
288 }
289 }
290 }
291 return null;
292 }
293
294 /**
295 * A utility method for implementing the default LocaleServiceProvider.isSupportedLocale
296 * for the JRE, CLDR, and FALLBACK adapters.
297 */
298 public static boolean isSupportedLocale(Locale locale, LocaleProviderAdapter.Type type, Set<String> langtags) {
299 assert type == Type.JRE || type == Type.CLDR || type == Type.FALLBACK;
300 if (Locale.ROOT.equals(locale)) {
301 return true;
302 }
303
304 if (type == Type.FALLBACK) {
305 // no other locales except ROOT are supported for FALLBACK
306 return false;
307 }
308
309 locale = locale.stripExtensions();
310 if (langtags.contains(locale.toLanguageTag())) {
311 return true;
312 }
313 if (type == Type.JRE) {
314 String oldname = locale.toString().replace('_', '-');
315 return langtags.contains(oldname) ||
316 "ja-JP-JP".equals(oldname) ||
317 "th-TH-TH".equals(oldname) ||
318 "no-NO-NY".equals(oldname);
319 }
320 return false;
321 }
322
323 public static Locale[] toLocaleArray(Set<String> tags) {
324 Locale[] locs = new Locale[tags.size() + 1];
325 int index = 0;
326 locs[index++] = Locale.ROOT;
327 for (String tag : tags) {
328 switch (tag) {
329 case "ja-JP-JP":
330 locs[index++] = JRELocaleConstants.JA_JP_JP;
331 break;
332 case "th-TH-TH":
333 locs[index++] = JRELocaleConstants.TH_TH_TH;
334 break;
335 default:
336 locs[index++] = Locale.forLanguageTag(tag);
337 break;
338 }
339 }
|
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.
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
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 }
|