Also see:

getFormats(String)

Also see:

getFormats(String)

Also see:

getFormats(String)

Also see:

getTimeToLive(String, Locale)

Also see:

getTimeToLive(String, Locale)

 protected Control() 
{

}

Sole constructor. (For invocation by subclass constructors, typically implicit.)

 public List getCandidateLocales(String baseName,
    Locale locale) 
{
            if (baseName == null) {
                throw new NullPointerException();
            }
            String language = locale.getLanguage();
            String country = locale.getCountry();
            String variant = locale.getVariant();
            List< Locale > locales = new ArrayList< Locale >(4);
            if (variant.length()  > 0) {
                locales.add(locale);
            }
            if (country.length()  > 0) {
                locales.add((locales.size() == 0) ?
                            locale : Locale.getInstance(language, country, ""));
            }
            if (language.length()  > 0) {
                locales.add((locales.size() == 0) ?
                            locale : Locale.getInstance(language, "", ""));
            }
            locales.add(Locale.ROOT);
            return locales;
}

Returns a List of Locales as candidate locales for baseName and locale. This method is called by the ResourceBundle.getBundle factory method each time the factory method tries finding a resource bundle for a target Locale.

The sequence of the candidate locales also corresponds to the runtime resource lookup path (also known as the parent chain), if the corresponding resource bundles for the candidate locales exist and their parents are not defined by loaded resource bundles themselves. The last element of the list must be a {@linkplain Locale#ROOT root locale} if it is desired to have the base bundle as the terminal of the parent chain.

If the given locale is equal to Locale.ROOT (the root locale), a List containing only the root Locale must be returned. In this case, the ResourceBundle.getBundle factory method loads only the base bundle as the resulting resource bundle.

It is not a requirement to return an immutable (unmodifiable) List. However, the returned List must not be mutated after it has been returned by getCandidateLocales.

The default implementation returns a List containing Locales in the following sequence:

Locale(language, country, variant)
Locale(language, country)
Locale(language)
Locale.ROOT

where language, country and variant are the language, country and variant values of the given locale, respectively. Locales where the final component values are empty strings are omitted.

The default implementation uses an ArrayList that overriding implementations may modify before returning it to the caller. However, a subclass must not modify it after it has been returned by getCandidateLocales.

For example, if the given baseName is "Messages" and the given locale is Locale("ja", "", "XX"), then a List of Locales:

Locale("ja", "", "XX")
Locale("ja")
Locale.ROOT

is returned. And if the resource bundles for the "ja" and "" Locales are found, then the runtime resource lookup path (parent chain) is:

Messages_ja -> Messages

 public static final ResourceBundle.Control getControl(List formats) 
{
            if (formats.equals(Control.FORMAT_PROPERTIES)) {
                return SingleFormatControl.PROPERTIES_ONLY;
            }
            if (formats.equals(Control.FORMAT_CLASS)) {
                return SingleFormatControl.CLASS_ONLY;
            }
            if (formats.equals(Control.FORMAT_DEFAULT)) {
                return Control.INSTANCE;
            }
            throw new IllegalArgumentException();
}

Returns a ResourceBundle.Control in which the getFormats method returns the specified formats. The formats must be equal to one of Control#FORMAT_PROPERTIES , Control#FORMAT_CLASS or Control#FORMAT_DEFAULT . ResourceBundle.Control instances returned by this method are singletons and thread-safe.

Specifying Control#FORMAT_DEFAULT is equivalent to instantiating the ResourceBundle.Control class, except that this method returns a singleton.

 public Locale getFallbackLocale(String baseName,
    Locale locale) 
{
            if (baseName == null) {
                throw new NullPointerException();
            }
            Locale defaultLocale = Locale.getDefault();
            return locale.equals(defaultLocale) ? null : defaultLocale;
}

Returns a Locale to be used as a fallback locale for further resource bundle searches by the ResourceBundle.getBundle factory method. This method is called from the factory method every time when no resulting resource bundle has been found for baseName and locale, where locale is either the parameter for ResourceBundle.getBundle or the previous fallback locale returned by this method.

The method returns null if no further fallback search is desired.

The default implementation returns the {@linkplain Locale#getDefault() default Locale} if the given locale isn't the default one. Otherwise, null is returned.

 public List getFormats(String baseName) 
{
            if (baseName == null) {
                throw new NullPointerException();
            }
            return FORMAT_DEFAULT;
}

Returns a List of Strings containing formats to be used to load resource bundles for the given baseName. The ResourceBundle.getBundle factory method tries to load resource bundles with formats in the order specified by the list. The list returned by this method must have at least one String. The predefined formats are "java.class" for class-based resource bundles and "java.properties" for {@linkplain PropertyResourceBundle properties-based} ones. Strings starting with "java." are reserved for future extensions and must not be used by application-defined formats.

It is not a requirement to return an immutable (unmodifiable) List. However, the returned List must not be mutated after it has been returned by getFormats.

The default implementation returns #FORMAT_DEFAULT so that the ResourceBundle.getBundle factory method looks up first class-based resource bundles, then properties-based ones.

 public static final ResourceBundle.Control getNoFallbackControl(List formats) 
{
            if (formats.equals(Control.FORMAT_DEFAULT)) {
                return NoFallbackControl.NO_FALLBACK;
            }
            if (formats.equals(Control.FORMAT_PROPERTIES)) {
                return NoFallbackControl.PROPERTIES_ONLY_NO_FALLBACK;
            }
            if (formats.equals(Control.FORMAT_CLASS)) {
                return NoFallbackControl.CLASS_ONLY_NO_FALLBACK;
            }
            throw new IllegalArgumentException();
}

Returns a ResourceBundle.Control in which the getFormats method returns the specified formats and the getFallbackLocale method returns null. The formats must be equal to one of Control#FORMAT_PROPERTIES , Control#FORMAT_CLASS or Control#FORMAT_DEFAULT . ResourceBundle.Control instances returned by this method are singletons and thread-safe.

 public long getTimeToLive(String baseName,
    Locale locale) 
{
            if (baseName == null || locale == null) {
                throw new NullPointerException();
            }
            return TTL_NO_EXPIRATION_CONTROL;
}

Returns the time-to-live (TTL) value for resource bundles that are loaded under this ResourceBundle.Control. Positive time-to-live values specify the number of milliseconds a bundle can remain in the cache without being validated against the source data from which it was constructed. The value 0 indicates that a bundle must be validated each time it is retrieved from the cache. #TTL_DONT_CACHE specifies that loaded resource bundles are not put in the cache. #TTL_NO_EXPIRATION_CONTROL specifies that loaded resource bundles are put in the cache with no expiration control.

The expiration affects only the bundle loading process by the ResourceBundle.getBundle factory method. That is, if the factory method finds a resource bundle in the cache that has expired, the factory method calls the needsReload method to determine whether the resource bundle needs to be reloaded. If needsReload returns true, the cached resource bundle instance is removed from the cache. Otherwise, the instance stays in the cache, updated with the new TTL value returned by this method.

All cached resource bundles are subject to removal from the cache due to memory constraints of the runtime environment. Returning a large positive value doesn't mean to lock loaded resource bundles in the cache.

The default implementation returns #TTL_NO_EXPIRATION_CONTROL .

 public boolean needsReload(String baseName,
    Locale locale,
    String format,
    ClassLoader loader,
    ResourceBundle bundle,
    long loadTime) 
{
            if (bundle == null) {
                throw new NullPointerException();
            }
            if (format.equals("java.class") || format.equals("java.properties")) {
                format = format.substring(5);
            }
            boolean result = false;
            try {
                String resourceName = toResourceName(toBundleName(baseName, locale), format);
                URL url = loader.getResource(resourceName);
                if (url != null) {
                    long lastModified = 0;
                    URLConnection connection = url.openConnection();
                    if (connection != null) {
                        // disable caches to get the correct data
                        connection.setUseCaches(false);
                        if (connection instanceof JarURLConnection) {
                            JarEntry ent = ((JarURLConnection)connection).getJarEntry();
                            if (ent != null) {
                                lastModified = ent.getTime();
                                if (lastModified == -1) {
                                    lastModified = 0;
                                }
                            }
                        } else {
                            lastModified = connection.getLastModified();
                        }
                    }
                    result = lastModified  >= loadTime;
                }
            } catch (NullPointerException npe) {
                throw npe;
            } catch (Exception e) {
                // ignore other exceptions
            }
            return result;
}

Determines if the expired bundle in the cache needs to be reloaded based on the loading time given by loadTime or some other criteria. The method returns true if reloading is required; false otherwise. loadTime is a millisecond offset since the Calendar Epoch. The calling ResourceBundle.getBundle factory method calls this method on the ResourceBundle.Control instance used for its current invocation, not on the instance used in the invocation that originally loaded the resource bundle.

The default implementation compares loadTime and the last modified time of the source data of the resource bundle. If it's determined that the source data has been modified since loadTime, true is returned. Otherwise, false is returned. This implementation assumes that the given format is the same string as its file suffix if it's not one of the default formats, "java.class" or "java.properties".

 public ResourceBundle newBundle(String baseName,
    Locale locale,
    String format,
    ClassLoader loader,
    boolean reload) throws IOException, InstantiationException, IllegalAccessException 
{
            String bundleName = toBundleName(baseName, locale);
            ResourceBundle bundle = null;
            if (format.equals("java.class")) {
                try {
                    Class< ? extends ResourceBundle > bundleClass
                        = (Class< ? extends ResourceBundle >)loader.loadClass(bundleName);
                    // If the class isn't a ResourceBundle subclass, throw a
                    // ClassCastException.
                    if (ResourceBundle.class.isAssignableFrom(bundleClass)) {
                        bundle = bundleClass.newInstance();
                    } else {
                        throw new ClassCastException(bundleClass.getName()
                                     + " cannot be cast to ResourceBundle");
                    }
                } catch (ClassNotFoundException e) {
                }
            } else if (format.equals("java.properties")) {
                final String resourceName = toResourceName(bundleName, "properties");
                final ClassLoader classLoader = loader;
                final boolean reloadFlag = reload;
                InputStream stream = null;
                try {
                    stream = AccessController.doPrivileged(
                        new PrivilegedExceptionAction< InputStream >() {
                            public InputStream run() throws IOException {
                                InputStream is = null;
                                if (reloadFlag) {
                                    URL url = classLoader.getResource(resourceName);
                                    if (url != null) {
                                        URLConnection connection = url.openConnection();
                                        if (connection != null) {
                                            // Disable caches to get fresh data for
                                            // reloading.
                                            connection.setUseCaches(false);
                                            is = connection.getInputStream();
                                        }
                                    }
                                } else {
                                    is = classLoader.getResourceAsStream(resourceName);
                                }
                                return is;
                            }
                        });
                } catch (PrivilegedActionException e) {
                    throw (IOException) e.getException();
                }
                if (stream != null) {
                    try {
                        bundle = new PropertyResourceBundle(stream);
                    } finally {
                        stream.close();
                    }
                }
            } else {
                throw new IllegalArgumentException("unknown format: " + format);
            }
            return bundle;
}

Instantiates a resource bundle for the given bundle name of the given format and locale, using the given class loader if necessary. This method returns null if there is no resource bundle available for the given parameters. If a resource bundle can't be instantiated due to an unexpected error, the error must be reported by throwing an Error or Exception rather than simply returning null.

If the reload flag is true, it indicates that this method is being called because the previously loaded resource bundle has expired.

The default implementation instantiates a ResourceBundle as follows.

• The bundle name is obtained by calling Locale) toBundleName(baseName, locale) .
• If format is "java.class", the Class specified by the bundle name is loaded by calling ClassLoader#loadClass(String) . Then, a ResourceBundle is instantiated by calling Class#newInstance() . Note that the reload flag is ignored for loading class-based resource bundles in this default implementation.
• If format is "java.properties", String) toResourceName(bundlename, "properties") is called to get the resource name. If reload is true, load.getResource is called to get a URL for creating a URLConnection . This URLConnection is used to {@linkplain URLConnection#setUseCaches(boolean) disable the caches} of the underlying resource loading layers, and to {@linkplain URLConnection#getInputStream() get an InputStream}. Otherwise, loader.getResourceAsStream is called to get an InputStream . Then, a PropertyResourceBundle is constructed with the InputStream.
• If format is neither "java.class" nor "java.properties", an IllegalArgumentException is thrown.

 public String toBundleName(String baseName,
    Locale locale) 
{
            if (locale == Locale.ROOT) {
                return baseName;
            }
            String language = locale.getLanguage();
            String country = locale.getCountry();
            String variant = locale.getVariant();
            if (language == "" && country == "" && variant == "") {
                return baseName;
            }
            StringBuilder sb = new StringBuilder(baseName);
            sb.append('_");
            if (variant != "") {
                sb.append(language).append('_").append(country).append('_").append(variant);
            } else if (country != "") {
                sb.append(language).append('_").append(country);
            } else {
                sb.append(language);
            }
            return sb.toString();
}

Converts the given baseName and locale to the bundle name. This method is called from the default implementation of the newBundle and needsReload methods.

This implementation returns the following value:

baseName + "_" + language + "_" + country + "_" + variant

where language, country and variant are the language, country and variant values of locale, respectively. Final component values that are empty Strings are omitted along with the preceding '_'. If all of the values are empty strings, then baseName is returned.

For example, if baseName is "baseName" and locale is Locale("ja", "", "XX"), then "baseName_ja_ _XX" is returned. If the given locale is Locale("en"), then "baseName_en" is returned.

Overriding this method allows applications to use different conventions in the organization and packaging of localized resources.

 public final String toResourceName(String bundleName,
    String suffix) 
{
            StringBuilder sb = new StringBuilder(bundleName.length() + 1 + suffix.length());
            sb.append(bundleName.replace('.", '/")).append('.").append(suffix);
            return sb.toString();
}

Converts the given bundleName to the form required by the ClassLoader.getResource method by replacing all occurrences of '.' in bundleName with '/' and appending a '.' and the given file suffix. For example, if bundleName is "foo.bar.MyResources_ja_JP" and suffix is "properties", then "foo/bar/MyResources_ja_JP.properties" is returned.