Java example source code file (LocaleProviderAdapter.java)

This example Java source code file (LocaleProviderAdapter.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

cldr, concurrenthashmap, concurrentmap, fallback, host, jre, list, locale, localeprovideradapter, localeserviceprovider, security, string, text_resources_package, threading, threads, type, util, util_resources_package

The LocaleProviderAdapter.java Java example source code

/*
 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.util.locale.provider;

import java.security.AccessController;
import java.text.spi.BreakIteratorProvider;
import java.text.spi.CollatorProvider;
import java.text.spi.DateFormatProvider;
import java.text.spi.DateFormatSymbolsProvider;
import java.text.spi.DecimalFormatSymbolsProvider;
import java.text.spi.NumberFormatProvider;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.spi.CalendarDataProvider;
import java.util.spi.CalendarNameProvider;
import java.util.spi.CurrencyNameProvider;
import java.util.spi.LocaleNameProvider;
import java.util.spi.LocaleServiceProvider;
import java.util.spi.TimeZoneNameProvider;
import sun.util.cldr.CLDRLocaleProviderAdapter;
import sun.util.spi.CalendarProvider;

/**
 * The LocaleProviderAdapter abstract class.
 *
 * @author Naoto Sato
 * @author Masayoshi Okutsu
 */
public abstract class LocaleProviderAdapter {
    /**
     * Adapter type.
     */
    public static enum Type {
        JRE("sun.util.resources", "sun.text.resources"),
        CLDR("sun.util.resources.cldr", "sun.text.resources.cldr"),
        SPI,
        HOST,
        FALLBACK("sun.util.resources", "sun.text.resources");

        private final String UTIL_RESOURCES_PACKAGE;
        private final String TEXT_RESOURCES_PACKAGE;

        private Type() {
            this(null, null);
        }

        private Type(String util, String text) {
            UTIL_RESOURCES_PACKAGE = util;
            TEXT_RESOURCES_PACKAGE = text;
        }

        public String getUtilResourcesPackage() {
            return UTIL_RESOURCES_PACKAGE;
        }

        public String getTextResourcesPackage() {
            return TEXT_RESOURCES_PACKAGE;
        }
    }

    /**
     * LocaleProviderAdapter preference list. The default list is intended
     * to behave the same manner in JDK7.
     */
    private static final List<Type> adapterPreference;

    /**
     * JRE Locale Data Adapter instance
     */
    private static LocaleProviderAdapter jreLocaleProviderAdapter = new JRELocaleProviderAdapter();

    /**
     * SPI Locale Data Adapter instance
     */
    private static LocaleProviderAdapter spiLocaleProviderAdapter = new SPILocaleProviderAdapter();

    /**
     * CLDR Locale Data Adapter instance, if any.
     */
    private static LocaleProviderAdapter cldrLocaleProviderAdapter = null;

    /**
     * HOST Locale Data Adapter instance, if any.
     */
    private static LocaleProviderAdapter hostLocaleProviderAdapter = null;

    /**
     * FALLBACK Locale Data Adapter instance. It's basically the same with JRE, but only kicks
     * in for the root locale.
     */
    private static LocaleProviderAdapter fallbackLocaleProviderAdapter = null;

    /**
     * Default fallback adapter type, which should return something meaningful in any case.
     * This is either JRE or FALLBACK.
     */
    static LocaleProviderAdapter.Type defaultLocaleProviderAdapter = null;

    /**
     * Adapter lookup cache.
     */
    private static ConcurrentMap<Class>
        adapterCache = new ConcurrentHashMap<>();

    static {
        String order = AccessController.doPrivileged(
                           new sun.security.action.GetPropertyAction("java.locale.providers"));
        List<Type> typeList = new ArrayList<>();

        // Check user specified adapter preference
        if (order != null && order.length() != 0) {
            String[] types = order.split(",");
            for (String type : types) {
                try {
                    Type aType = Type.valueOf(type.trim().toUpperCase(Locale.ROOT));

                    // load adapter if necessary
                    switch (aType) {
                        case CLDR:
                            if (cldrLocaleProviderAdapter == null) {
                                cldrLocaleProviderAdapter = new CLDRLocaleProviderAdapter();
                            }
                            break;
                        case HOST:
                            if (hostLocaleProviderAdapter == null) {
                                hostLocaleProviderAdapter = new HostLocaleProviderAdapter();
                            }
                            break;
                    }
                    if (!typeList.contains(aType)) {
                        typeList.add(aType);
                    }
                } catch (IllegalArgumentException | UnsupportedOperationException e) {
                    // could be caused by the user specifying wrong
                    // provider name or format in the system property
                    LocaleServiceProviderPool.config(LocaleProviderAdapter.class, e.toString());
                }
            }
        }

        if (!typeList.isEmpty()) {
            if (!typeList.contains(Type.JRE)) {
                // Append FALLBACK as the last resort.
                fallbackLocaleProviderAdapter = new FallbackLocaleProviderAdapter();
                typeList.add(Type.FALLBACK);
                defaultLocaleProviderAdapter = Type.FALLBACK;
            } else {
                defaultLocaleProviderAdapter = Type.JRE;
            }
        } else {
            // Default preference list
            typeList.add(Type.JRE);
            typeList.add(Type.SPI);
            defaultLocaleProviderAdapter = Type.JRE;
        }

        adapterPreference = Collections.unmodifiableList(typeList);
    }

    /**
     * Returns the singleton instance for each adapter type
     */
    public static LocaleProviderAdapter forType(Type type) {
        switch (type) {
        case JRE:
            return jreLocaleProviderAdapter;
        case CLDR:
            return cldrLocaleProviderAdapter;
        case SPI:
            return spiLocaleProviderAdapter;
        case HOST:
            return hostLocaleProviderAdapter;
        case FALLBACK:
            return fallbackLocaleProviderAdapter;
        default:
            throw new InternalError("unknown locale data adapter type");
        }
    }

    public static LocaleProviderAdapter forJRE() {
        return jreLocaleProviderAdapter;
    }

    public static LocaleProviderAdapter getResourceBundleBased() {
        for (Type type : getAdapterPreference()) {
            if (type == Type.JRE || type == Type.CLDR || type == Type.FALLBACK) {
                return forType(type);
            }
        }
        // Shouldn't happen.
        throw new InternalError();
    }
    /**
     * Returns the preference order of LocaleProviderAdapter.Type
     */
    public static List<Type> getAdapterPreference() {
        return adapterPreference;
    }

    /**
     * Returns a LocaleProviderAdapter for the given locale service provider that
     * best matches the given locale. This method returns the LocaleProviderAdapter
     * for JRE if none is found for the given locale.
     *
     * @param providerClass the class for the locale service provider
     * @param locale the desired locale.
     * @return a LocaleProviderAdapter
     */
    public static LocaleProviderAdapter getAdapter(Class<? extends LocaleServiceProvider> providerClass,
                                               Locale locale) {
        LocaleProviderAdapter adapter;

        // cache lookup
        ConcurrentMap<Locale, LocaleProviderAdapter> adapterMap = adapterCache.get(providerClass);
        if (adapterMap != null) {
            if ((adapter = adapterMap.get(locale)) != null) {
                return adapter;
            }
        } else {
            adapterMap = new ConcurrentHashMap<>();
            adapterCache.putIfAbsent(providerClass, adapterMap);
        }

        // Fast look-up for the given locale
        adapter = findAdapter(providerClass, locale);
        if (adapter != null) {
            adapterMap.putIfAbsent(locale, adapter);
            return adapter;
        }

        // Try finding an adapter in the normal candidate locales path of the given locale.
        List<Locale> lookupLocales = ResourceBundle.Control.getControl(ResourceBundle.Control.FORMAT_DEFAULT)
                                        .getCandidateLocales("", locale);
        for (Locale loc : lookupLocales) {
            if (loc.equals(locale)) {
                // We've already done with this loc.
                continue;
            }
            adapter = findAdapter(providerClass, loc);
            if (adapter != null) {
                adapterMap.putIfAbsent(locale, adapter);
                return adapter;
            }
        }

        // returns the adapter for FALLBACK as the last resort
        adapterMap.putIfAbsent(locale, fallbackLocaleProviderAdapter);
        return fallbackLocaleProviderAdapter;
    }

    private static LocaleProviderAdapter findAdapter(Class<? extends LocaleServiceProvider> providerClass,
                                                 Locale locale) {
        for (Type type : getAdapterPreference()) {
            LocaleProviderAdapter adapter = forType(type);
            LocaleServiceProvider provider = adapter.getLocaleServiceProvider(providerClass);
            if (provider != null) {
                if (provider.isSupportedLocale(locale)) {
                    return adapter;
                }
            }
        }
        return null;
    }

    /**
     * A utility method for implementing the default LocaleServiceProvider.isSupportedLocale
     * for the JRE, CLDR, and FALLBACK adapters.
     */
    static boolean isSupportedLocale(Locale locale, LocaleProviderAdapter.Type type, Set<String> langtags) {
        assert type == Type.JRE || type == Type.CLDR || type == Type.FALLBACK;
        if (Locale.ROOT.equals(locale)) {
            return true;
        }

        if (type == Type.FALLBACK) {
            // no other locales except ROOT are supported for FALLBACK
            return false;
        }

        locale = locale.stripExtensions();
        if (langtags.contains(locale.toLanguageTag())) {
            return true;
        }
        if (type == Type.JRE) {
            String oldname = locale.toString().replace('_', '-');
            return langtags.contains(oldname) ||
                   "ja-JP-JP".equals(oldname) ||
                   "th-TH-TH".equals(oldname) ||
                   "no-NO-NY".equals(oldname);
        }
        return false;
    }

    public static Locale[] toLocaleArray(Set<String> tags) {
        Locale[] locs = new Locale[tags.size() + 1];
        int index = 0;
        locs[index++] = Locale.ROOT;
        for (String tag : tags) {
            switch (tag) {
            case "ja-JP-JP":
                locs[index++] = JRELocaleConstants.JA_JP_JP;
                break;
            case "th-TH-TH":
                locs[index++] = JRELocaleConstants.TH_TH_TH;
                break;
            default:
                locs[index++] = Locale.forLanguageTag(tag);
                break;
            }
        }
        return locs;
    }

    /**
     * Returns the type of this LocaleProviderAdapter
     */
    public abstract LocaleProviderAdapter.Type getAdapterType();

    /**
     * Getter method for Locale Service Providers.
     */
    public abstract <P extends LocaleServiceProvider> P getLocaleServiceProvider(Class
 c);

    /**
     * Returns a BreakIteratorProvider for this LocaleProviderAdapter, or null if no
     * BreakIteratorProvider is available.
     *
     * @return a BreakIteratorProvider
     */
    public abstract BreakIteratorProvider getBreakIteratorProvider();

    /**
     * Returns a ollatorProvider for this LocaleProviderAdapter, or null if no
     * ollatorProvider is available.
     *
     * @return a ollatorProvider
     */
    public abstract CollatorProvider getCollatorProvider();

    /**
     * Returns a DateFormatProvider for this LocaleProviderAdapter, or null if no
     * DateFormatProvider is available.
     *
     * @return a DateFormatProvider
     */
    public abstract DateFormatProvider getDateFormatProvider();

    /**
     * Returns a DateFormatSymbolsProvider for this LocaleProviderAdapter, or null if no
     * DateFormatSymbolsProvider is available.
     *
     * @return a DateFormatSymbolsProvider
     */
    public abstract DateFormatSymbolsProvider getDateFormatSymbolsProvider();

    /**
     * Returns a DecimalFormatSymbolsProvider for this LocaleProviderAdapter, or null if no
     * DecimalFormatSymbolsProvider is available.
     *
     * @return a DecimalFormatSymbolsProvider
     */
    public abstract DecimalFormatSymbolsProvider getDecimalFormatSymbolsProvider();

    /**
     * Returns a NumberFormatProvider for this LocaleProviderAdapter, or null if no
     * NumberFormatProvider is available.
     *
     * @return a NumberFormatProvider
     */
    public abstract NumberFormatProvider getNumberFormatProvider();

    /*
     * Getter methods for java.util.spi.* providers
     */

    /**
     * Returns a CurrencyNameProvider for this LocaleProviderAdapter, or null if no
     * CurrencyNameProvider is available.
     *
     * @return a CurrencyNameProvider
     */
    public abstract CurrencyNameProvider getCurrencyNameProvider();

    /**
     * Returns a LocaleNameProvider for this LocaleProviderAdapter, or null if no
     * LocaleNameProvider is available.
     *
     * @return a LocaleNameProvider
     */
    public abstract LocaleNameProvider getLocaleNameProvider();

    /**
     * Returns a TimeZoneNameProvider for this LocaleProviderAdapter, or null if no
     * TimeZoneNameProvider is available.
     *
     * @return a TimeZoneNameProvider
     */
    public abstract TimeZoneNameProvider getTimeZoneNameProvider();

    /**
     * Returns a CalendarDataProvider for this LocaleProviderAdapter, or null if no
     * CalendarDataProvider is available.
     *
     * @return a CalendarDataProvider
     */
    public abstract CalendarDataProvider getCalendarDataProvider();

    /**
     * Returns a CalendarNameProvider for this LocaleProviderAdapter, or null if no
     * CalendarNameProvider is available.
     *
     * @return a CalendarNameProvider
     */
    public abstract CalendarNameProvider getCalendarNameProvider();

    /**
     * Returns a CalendarProvider for this LocaleProviderAdapter, or null if no
     * CalendarProvider is available.
     *
     * @return a CalendarProvider
     */
    public abstract CalendarProvider getCalendarProvider();

    public abstract LocaleResources getLocaleResources(Locale locale);

    public abstract Locale[] getAvailableLocales();
}