feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/sun/util/locale/provider/LocaleProviderAdapter.java

@@ -0,0 +1,456 @@
+/*
+ * Copyright (c) 2012, 2015, 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<? extends LocaleServiceProvider>, ConcurrentMap<Locale, LocaleProviderAdapter>>
+        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.
+     */
+    public 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<P> 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();
+}