Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright 2005-2006 Sun Microsystems, Inc.  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.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package sun.util;
27
 
35
 import java.util.List;
37
 import java.util.Map;
40
 import java.util.Set;
An instance of this class holds a set of the third party implementations of a particular locale sensitive service, such as java.util.spi.LocaleNameProvider. 
51
 
52
 public final class LocaleServiceProviderPool {

    
A Map that holds singleton instances of this class. Each instance holds a set of provider implementations of a particular locale sensitive service. 
57
 
58
     private static Map<Class, LocaleServiceProviderPool> poolOfPools =
59
         new ConcurrentHashMap<Class, LocaleServiceProviderPool>();

    
A Set containing locale service providers that implement the specified provider SPI 
64
 
65
     private Set<LocaleServiceProvider> providers =
66
         new LinkedHashSet<LocaleServiceProvider>();

    
A Map that retains Locale->provider mapping 
70
 
72
         new ConcurrentHashMap<Locale, LocaleServiceProvider>();

    
Available locales for this locale sensitive service. This also contains JRE's available locales 
77
 
78
     private Set<Locale> availableLocales = null;

    
Available locales within this JRE. Currently this is declared as static. This could be non-static later, so that they could have different sets for each locale sensitive services. 
84
 
85
     private static List<Locale> availableJRELocales = null;

    
Provider locales for this locale sensitive service. 
89
 
90
     private Set<Locale> providerLocales = null;

    
A factory method that returns a singleton instance 
94
 
95
     public static LocaleServiceProviderPool getPool(Class<? extends LocaleServiceProvider> providerClass) {
96
         LocaleServiceProviderPool pool = .get(providerClass);
97
         if (pool == null) {
98
             LocaleServiceProviderPool newPool =
99
                 new LocaleServiceProviderPool(providerClass);
100
            pool = .put(providerClass, newPool);
101
            if (pool == null) {
102
                pool = newPool;
103
            }
104
        }
106
        return pool;
107
    }

    
The sole constructor.

Parameters:
c class of the locale sensitive service
114
    private LocaleServiceProviderPool (final Class<? extends LocaleServiceProvider> c) {
115
        try {
116
            AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
117
                public Object run() {
118
                    for (LocaleServiceProvider provider : ServiceLoader.loadInstalled(c)) {
119
                        .add(provider);
120
                    }
121
                    return null;
122
                }
123
            });
124
        }  catch (PrivilegedActionException e) {
125
            Logger.getLogger("sun.util.LocaleServiceProviderPool").config(e.toString());
126
        }
127
    }

    
Lazy loaded set of available locales. Loading all locales is a very long operation. 
133
    private static class AllAvailableLocales {
        
Available locales for all locale sensitive services. This also contains JRE's available locales 
138
        static final Locale[] allAvailableLocales;
140
        static {
141
            Class[] providerClasses = {
142
                java.text.spi.BreakIteratorProvider.class,
143
                java.text.spi.CollatorProvider.class,
144
                java.text.spi.DateFormatProvider.class,
145
                java.text.spi.DateFormatSymbolsProvider.class,
146
                java.text.spi.DecimalFormatSymbolsProvider.class,
147
                java.text.spi.NumberFormatProvider.class,
148
                java.util.spi.CurrencyNameProvider.class,
149
                java.util.spi.LocaleNameProvider.class,
150
                java.util.spi.TimeZoneNameProvider.class };
151
            Set<Locale> all = new HashSet<Locale>(Arrays.asList(
152
                    LocaleData.getAvailableLocales())
153
            );
154
            for (Class providerClass : providerClasses) {
155
                LocaleServiceProviderPool pool =
156
                    LocaleServiceProviderPool.getPool(providerClass);
157
                all.addAll(pool.getProviderLocales());
158
            }
159
             = all.toArray(new Locale[0]);
160
        }
161
    }

    
Returns an array of available locales for all the provider classes. This array is a merged array of all the locales that are provided by each provider, including the JRE.

Returns:
an array of the available locales for all provider classes
170
    public static Locale[] getAllAvailableLocales() {
172
    }

    
Returns an array of available locales. This array is a merged array of all the locales that are provided by each provider, including the JRE.

Returns:
an array of the available locales
181
    public synchronized Locale[] getAvailableLocales() {
182
        if ( == null) {
183
             = new HashSet<Locale>(getJRELocales());
184
            if (hasProviders()) {
185
                .addAll(getProviderLocales());
186
            }
187
        }
188
        Locale[] tmp = new Locale[.size()];
189
        .toArray(tmp);
190
        return tmp;
191
    }

    
Returns an array of available locales from providers. Note that this method does not return a defensive copy.

Returns:
list of the provider locales
199
    private synchronized Set<Locale> getProviderLocales() {
200
        if ( == null) {
201
             = new HashSet<Locale>();
202
            if (hasProviders()) {
203
                for (LocaleServiceProvider lsp : ) {
204
                    Locale[] locales = lsp.getAvailableLocales();
205
                    for (Locale locale: locales) {
206
                        .add(locale);
207
                    }
208
                }
209
            }
210
        }
211
        return ;
212
    }

    
Returns whether any provider for this locale sensitive service is available or not.

Returns:
true if any provider is available
220
    public boolean hasProviders() {
221
        return !.isEmpty();
222
    }

    
Returns an array of available locales supported by the JRE. Note that this method does not return a defensive copy.

Returns:
list of the available JRE locales
230
    private synchronized List<Locale> getJRELocales() {
231
        if ( == null) {
232
             =
233
                Arrays.asList(LocaleData.getAvailableLocales());
234
        }
235
        return ;
236
    }

    
Returns whether the given locale is supported by the JRE.

Parameters:
locale the locale to test.
Returns:
true, if the locale is supported by the JRE. false otherwise.
245
    private boolean isJRESupported(Locale locale) {
246
        List<Locale> locales = getJRELocales();
247
        return locales.contains(locale);
248
    }

    
Returns the provider's localized object for the specified locale.

Parameters:
getter an object on which getObject() method is called to obtain the provider's instance.
locale the given locale that is used as the starting one
params provider specific parameters
Returns:
provider's instance, or null.
260
    public <P, S> S getLocalizedObject(LocalizedObjectGetter<P, S> getter,
261
                                     Locale locale,
262
                                     Object... params) {
263
        return getLocalizedObjectImpl(getter, locale, true, null, null, null, params);
264
    }

    
Returns the provider's localized name for the specified locale.

Parameters:
getter an object on which getObject() method is called to obtain the provider's instance.
locale the given locale that is used as the starting one
bundle JRE resource bundle that contains the localized names, or null for localized objects.
key the key string if bundle is supplied, otherwise null.
params provider specific parameters
Returns:
provider's instance, or null.
279
    public <P, S> S getLocalizedObject(LocalizedObjectGetter<P, S> getter,
280
                                     Locale locale,
281
                                     OpenListResourceBundle bundle,
282
                                     String key,
283
                                     Object... params) {
284
        return getLocalizedObjectImpl(getter, locale, false, null, bundle, key, params);
285
    }

    
Returns the provider's localized name for the specified locale.

Parameters:
getter an object on which getObject() method is called to obtain the provider's instance.
locale the given locale that is used as the starting one
bundleKey JRE specific bundle key. e.g., "USD" is for currency symbol and "usd" is for currency display name in the JRE bundle.
bundle JRE resource bundle that contains the localized names, or null for localized objects.
key the key string if bundle is supplied, otherwise null.
params provider specific parameters
Returns:
provider's instance, or null.
302
    public <P, S> S getLocalizedObject(LocalizedObjectGetter<P, S> getter,
303
                                     Locale locale,
304
                                     String bundleKey,
305
                                     OpenListResourceBundle bundle,
306
                                     String key,
307
                                     Object... params) {
308
        return getLocalizedObjectImpl(getter, locale, false, bundleKey, bundle, key, params);
309
    }
311
    private <P, S> S getLocalizedObjectImpl(LocalizedObjectGetter<P, S> getter,
312
                                     Locale locale,
313
                                     boolean isObjectProvider,
314
                                     String bundleKey,
315
                                     OpenListResourceBundle bundle,
316
                                     String key,
317
                                     Object... params) {
318
        if (hasProviders()) {
319
            if (bundleKey == null) {
320
                bundleKey = key;
321
            }
322
            Locale bundleLocale = (bundle != null ? bundle.getLocale() : null);
323
            Locale requested = locale;
324
            P lsp;
325
            S providersObj = null;
327
            // check whether a provider has an implementation that's closer
328
            // to the requested locale than the bundle we've found (for
329
            // localized names), or Java runtime's supported locale
330
            // (for localized objects)
331
            while ((locale = findProviderLocale(locale, bundleLocale)) != null) {
333
                lsp = (P)findProvider(locale);
335
                if (lsp != null) {
336
                    providersObj = getter.getObject(lsp, requested, key, params);
337
                    if (providersObj != null) {
338
                        return providersObj;
339
                    } else if (isObjectProvider) {
340
                        Logger.getLogger("sun.util.LocaleServiceProviderPool").config(
341
                            "A locale sensitive service provider returned null for a localized objects,  which should not happen.  provider: " + lsp + " locale: " + requested);
342
                    }
343
                }
345
                locale = getParentLocale(locale);
346
            }
348
            // look up the JRE bundle and its parent chain.  Only
349
            // providers for localized names are checked hereafter.
350
            while (bundle != null) {
351
                bundleLocale = bundle.getLocale();
353
                if (bundle.handleGetKeys().contains(bundleKey)) {
354
                    // JRE has it.
355
                    return null;
356
                } else {
357
                    lsp = (P)findProvider(bundleLocale);
358
                    if (lsp != null) {
359
                        providersObj = getter.getObject(lsp, requested, key, params);
360
                        if (providersObj != null) {
361
                            return providersObj;
362
                        }
363
                    }
364
                }
366
                // try parent bundle
367
                bundle = bundle.getParent();
368
            }
369
        }
371
        // not found.
372
        return null;
373
    }

    
Returns a locale service provider instance that supports the specified locale.

Parameters:
locale the given locale
Returns:
the provider, or null if there is no provider available.
383
    private LocaleServiceProvider findProvider(Locale locale) {
384
        if (!hasProviders()) {
385
            return null;
386
        }
388
        if (.containsKey(locale)) {
389
            LocaleServiceProvider provider = .get(locale);
390
            if (provider != .) {
391
                return provider;
392
            }
393
        } else {
394
            for (LocaleServiceProvider lsp : ) {
395
                Locale[] locales = lsp.getAvailableLocales();
396
                for (Locale available: locales) {
397
                    if (locale.equals(available)) {
398
                        LocaleServiceProvider providerInCache =
399
                            .put(locale, lsp);
400
                        return (providerInCache != null ?
401
                                providerInCache :
402
                                lsp);
403
                    }
404
                }
405
            }
406
            .put(locale, .);
407
        }
408
        return null;
409
    }

    
Returns the provider's locale that is the most appropriate within the range

Parameters:
start the given locale that is used as the starting one
end the given locale that is used as the end one (exclusive), or null if it reaching any of the JRE supported locale should terminate the look up.
Returns:
the most specific locale within the range, or null if no provider locale found in that range.
422
    private Locale findProviderLocale(Locale start, Locale end) {
423
        Set<Locale> provLoc = getProviderLocales();
424
        Locale current = start;
426
        while (current != null) {
427
            if (end != null) {
428
                if (current.equals(end)) {
429
                    current = null;
430
                    break;
431
                }
432
            } else {
433
                if (isJRESupported(current)) {
434
                    current = null;
435
                    break;
436
                }
437
            }
439
            if (provLoc.contains(current)) {
440
                break;
441
            }
443
            current = getParentLocale(current);
444
        }
446
        return current;
447
    }

    
Returns the parent locale.

Parameters:
locale the locale
Returns:
the parent locale
455
    private static Locale getParentLocale(Locale locale) {
456
        String variant = locale.getVariant();
457
        if (variant != "") {
458
            int underscoreIndex = variant.lastIndexOf('_');
459
            if (underscoreIndex != (-1)) {
460
                return new Locale(locale.getLanguage(), locale.getCountry(),
461
                                  variant.substring(0, underscoreIndex));
462
            } else {
463
                return new Locale(locale.getLanguage(), locale.getCountry());
464
            }
465
        } else if (locale.getCountry() != "") {
466
            return new Locale(locale.getLanguage());
467
        } else if (locale.getLanguage() != "") {
468
            return .;
469
        } else {
470
            return null;
471
        }
472
    }

    
A dummy locale service provider that indicates there is no provider available 
478
    private static class NullProvider extends LocaleServiceProvider {
479
        private static final NullProvider INSTANCE = new NullProvider();
481
        public Locale[] getAvailableLocales() {
482
            throw new RuntimeException("Should not get called.");
483
        }
484
    }

    
An interface to get a localized object for each locale sensitve service class. 
490
    public interface LocalizedObjectGetter<P, S> {
        
Returns an object from the provider

Parameters:
lsp the provider
locale the locale
key key string to localize, or null if the provider is not a name provider
params provider specific params
Returns:
localized object from the provider
501
        public S getObject(P lsp,
502
                                Locale locale,
503
                                String key,
504
                                Object... params);
505
    }
New to GrepCode? Check out our FAQ X