declare namespace java { namespace util { /** * Resource bundles contain locale-specific objects. When your program needs a * locale-specific resource, a String for example, your program can * load it from the resource bundle that is appropriate for the current user's * locale. In this way, you can write program code that is largely independent * of the user's locale isolating most, if not all, of the locale-specific * information in resource bundles. *

* This allows you to write programs that can: *

*

* Resource bundles belong to families whose members share a common base * name, but whose names also have additional components that identify * their locales. For example, the base name of a family of resource * bundles might be "MyResources". The family should have a default * resource bundle which simply has the same name as its family - * "MyResources" - and will be used as the bundle of last resort if a * specific locale is not supported. The family can then provide as * many locale-specific members as needed, for example a German one * named "MyResources_de". *

* Each resource bundle in a family contains the same items, but the items have * been translated for the locale represented by that resource bundle. * For example, both "MyResources" and "MyResources_de" may have a * String that's used on a button for canceling operations. * In "MyResources" the String may contain "Cancel" and in * "MyResources_de" it may contain "Abbrechen". *

* If there are different resources for different countries, you * can make specializations: for example, "MyResources_de_CH" contains objects for * the German language (de) in Switzerland (CH). If you want to only * modify some of the resources * in the specialization, you can do so. *

* When your program needs a locale-specific object, it loads * the ResourceBundle class using the * {@link #getBundle(java.lang.String, java.util.Locale) getBundle} * method: *

* 
         * ResourceBundle myResources =
         * ResourceBundle.getBundle("MyResources", currentLocale);
         *
*
*

* Resource bundles contain key/value pairs. The keys uniquely * identify a locale-specific object in the bundle. Here's an * example of a ListResourceBundle that contains * two key/value pairs: *

* 
         * public class MyResources extends ListResourceBundle {
         * protected Object[][] getContents() {
         * return new Object[][] {
         * // LOCALIZE THE SECOND STRING OF EACH ARRAY (e.g., "OK")
         * {"OkKey", "OK"},
         * {"CancelKey", "Cancel"},
         * // END OF MATERIAL TO LOCALIZE
         * };
         * }
         * }
         *
*
* Keys are always Strings. * In this example, the keys are "OkKey" and "CancelKey". * In the above example, the values * are also Strings--"OK" and "Cancel"--but * they don't have to be. The values can be any type of object. *

* You retrieve an object from resource bundle using the appropriate * getter method. Because "OkKey" and "CancelKey" * are both strings, you would use getString to retrieve them: *

* 
         * button1 = new Button(myResources.getString("OkKey"));
         * button2 = new Button(myResources.getString("CancelKey"));
         *
*
* The getter methods all require the key as an argument and return * the object if found. If the object is not found, the getter method * throws a MissingResourceException. *

* Besides getString, ResourceBundle also provides * a method for getting string arrays, getStringArray, * as well as a generic getObject method for any other * type of object. When using getObject, you'll * have to cast the result to the appropriate type. For example: *

* 
         * int[] myIntegers = (int[]) myResources.getObject("intList");
         *
*
*

* The Java Platform provides two subclasses of ResourceBundle, * ListResourceBundle and PropertyResourceBundle, * that provide a fairly simple way to create resources. * As you saw briefly in a previous example, ListResourceBundle * manages its resource as a list of key/value pairs. * PropertyResourceBundle uses a properties file to manage * its resources. *

* If ListResourceBundle or PropertyResourceBundle * do not suit your needs, you can write your own ResourceBundle * subclass. Your subclasses must override two methods: handleGetObject * and getKeys(). *

* The implementation of a {@code ResourceBundle} subclass must be thread-safe * if it's simultaneously used by multiple threads. The default implementations * of the non-abstract methods in this class, and the methods in the direct * known concrete subclasses {@code ListResourceBundle} and * {@code PropertyResourceBundle} are thread-safe. *

ResourceBundle.Control

* The {@link ResourceBundle.Control} class provides information necessary * to perform the bundle loading process by the getBundle * factory methods that take a ResourceBundle.Control * instance. You can implement your own subclass in order to enable * non-standard resource bundle formats, change the search strategy, or * define caching parameters. Refer to the descriptions of the class and the * {@link #getBundle(String, Locale, ClassLoader, Control) getBundle} * factory method for details. *

For the {@code getBundle} factory * methods that take no {@link Control} instance, their default behavior of resource bundle loading * can be modified with installed {@link * ResourceBundleControlProvider} implementations. Any installed providers are * detected at the {@code ResourceBundle} class loading time. If any of the * providers provides a {@link Control} for the given base name, that {@link * Control} will be used instead of the default {@link Control}. If there is * more than one service provider installed for supporting the same base name, * the first one returned from {@link ServiceLoader} will be used. *

Cache Management

* Resource bundle instances created by the getBundle factory * methods are cached by default, and the factory methods return the same * resource bundle instance multiple times if it has been * cached. getBundle clients may clear the cache, manage the * lifetime of cached resource bundle instances using time-to-live values, * or specify not to cache resource bundle instances. Refer to the * descriptions of the {@linkplain #getBundle(String, Locale, ClassLoader, * Control) getBundle factory method}, {@link * #clearCache(ClassLoader) clearCache}, {@link * Control#getTimeToLive(String, Locale) * ResourceBundle.Control.getTimeToLive}, and {@link * Control#needsReload(String, Locale, String, ClassLoader, ResourceBundle, * long) ResourceBundle.Control.needsReload} for details. *

Example

* The following is a very simple example of a ResourceBundle * subclass, MyResources, that manages two resources (for a larger number of * resources you would probably use a Map). * Notice that you don't need to supply a value if * a "parent-level" ResourceBundle handles the same * key with the same value (as for the okKey below). *
* 
         * // default (English language, United States)
         * public class MyResources extends ResourceBundle {
         * public Object handleGetObject(String key) {
         * if (key.equals("okKey")) return "Ok";
         * if (key.equals("cancelKey")) return "Cancel";
         * return null;
         * }
         * public Enumeration<String> getKeys() {
         * return Collections.enumeration(keySet());
         * }
         * // Overrides handleKeySet() so that the getKeys() implementation
         * // can rely on the keySet() value.
         * protected Set<String> handleKeySet() {
         * return new HashSet<String>(Arrays.asList("okKey", "cancelKey"));
         * }
         * }
         * // German language
         * public class MyResources_de extends MyResources {
         * public Object handleGetObject(String key) {
         * // don't need okKey, since parent level handles it.
         * if (key.equals("cancelKey")) return "Abbrechen";
         * return null;
         * }
         * protected Set<String> handleKeySet() {
         * return new HashSet<String>(Arrays.asList("cancelKey"));
         * }
         * }
         *
*
* You do not have to restrict yourself to using a single family of * ResourceBundles. For example, you could have a set of bundles for * exception messages, ExceptionResources * (ExceptionResources_fr, ExceptionResources_de, ...), * and one for widgets, WidgetResource (WidgetResources_fr, * WidgetResources_de, ...); breaking up the resources however you like. * @see ListResourceBundle * @see PropertyResourceBundle * @see MissingResourceException * @since JDK1.1 */ // @ts-ignore abstract class ResourceBundle extends java.lang.Object { /** * Sole constructor. (For invocation by subclass constructors, typically * implicit.) */ // @ts-ignore constructor() /** * The parent bundle of this bundle. * The parent bundle is searched by {@link #getObject getObject} * when this bundle does not contain a particular resource. */ // @ts-ignore parent: java.util.ResourceBundle /** * Returns the base name of this bundle, if known, or {@code null} if unknown. * If not null, then this is the value of the {@code baseName} parameter * that was passed to the {@code ResourceBundle.getBundle(...)} method * when the resource bundle was loaded. * @return The base name of the resource bundle, as provided to and expected * by the {#code ResourceBundle.getBundle(...)} methods. * @see #getBundle(java.lang.String, java.util.Locale, java.lang.ClassLoader) * @since 1.8 */ // @ts-ignore public getBaseBundleName(): string /** * Gets a string for the given key from this resource bundle or one of its parents. * Calling this method is equivalent to calling *
* (String) {@link #getObject(java.lang.String) getObject}(key). *
* @param key the key for the desired string * @exception NullPointerException if key is null * @exception MissingResourceException if no object for the given key can be found * @exception ClassCastException if the object found for the given key is not a string * @return the string for the given key */ // @ts-ignore public getString(key: java.lang.String | string): string /** * Gets a string array for the given key from this resource bundle or one of its parents. * Calling this method is equivalent to calling *
* (String[]) {@link #getObject(java.lang.String) getObject}(key). *
* @param key the key for the desired string array * @exception NullPointerException if key is null * @exception MissingResourceException if no object for the given key can be found * @exception ClassCastException if the object found for the given key is not a string array * @return the string array for the given key */ // @ts-ignore public getStringArray(key: java.lang.String | string): string[] /** * Gets an object for the given key from this resource bundle or one of its parents. * This method first tries to obtain the object from this resource bundle using * {@link #handleGetObject(java.lang.String) handleGetObject}. * If not successful, and the parent resource bundle is not null, * it calls the parent's getObject method. * If still not successful, it throws a MissingResourceException. * @param key the key for the desired object * @exception NullPointerException if key is null * @exception MissingResourceException if no object for the given key can be found * @return the object for the given key */ // @ts-ignore public getObject(key: java.lang.String | string): any /** * Returns the locale of this resource bundle. This method can be used after a * call to getBundle() to determine whether the resource bundle returned really * corresponds to the requested locale or is a fallback. * @return the locale of this resource bundle */ // @ts-ignore public getLocale(): java.util.Locale /** * Sets the parent bundle of this bundle. * The parent bundle is searched by {@link #getObject getObject} * when this bundle does not contain a particular resource. * @param parent this bundle's parent bundle. */ // @ts-ignore setParent(parent: java.util.ResourceBundle): void /** * Gets a resource bundle using the specified base name, the default locale, * and the caller's class loader. Calling this method is equivalent to calling *
* getBundle(baseName, Locale.getDefault(), this.getClass().getClassLoader()), *
* except that getClassLoader() is run with the security * privileges of ResourceBundle. * See {@link #getBundle(String, Locale, ClassLoader) getBundle} * for a complete description of the search and instantiation strategy. * @param baseName the base name of the resource bundle, a fully qualified class name * @exception java.lang.NullPointerException * if baseName is null * @exception MissingResourceException * if no resource bundle for the specified base name can be found * @return a resource bundle for the given base name and the default locale */ // @ts-ignore public static getBundle(baseName: java.lang.String | string): java.util.ResourceBundle /** * Returns a resource bundle using the specified base name, the * default locale and the specified control. Calling this method * is equivalent to calling * 
             * getBundle(baseName, Locale.getDefault(),
             * this.getClass().getClassLoader(), control),
             *
* except that getClassLoader() is run with the security * privileges of ResourceBundle. See {@link * #getBundle(String, Locale, ClassLoader, Control) getBundle} for the * complete description of the resource bundle loading process with a * ResourceBundle.Control. * @param baseName * the base name of the resource bundle, a fully qualified class * name * @param control * the control which gives information for the resource bundle * loading process * @return a resource bundle for the given base name and the default * locale * @exception NullPointerException * if baseName or control is * null * @exception MissingResourceException * if no resource bundle for the specified base name can be found * @exception IllegalArgumentException * if the given control doesn't perform properly * (e.g., control.getCandidateLocales returns null.) * Note that validation of control is performed as * needed. * @since 1.6 */ // @ts-ignore public static getBundle(baseName: java.lang.String | string, control: java.util.ResourceBundle.Control): java.util.ResourceBundle /** * Gets a resource bundle using the specified base name and locale, * and the caller's class loader. Calling this method is equivalent to calling *
* getBundle(baseName, locale, this.getClass().getClassLoader()), *
* except that getClassLoader() is run with the security * privileges of ResourceBundle. * See {@link #getBundle(String, Locale, ClassLoader) getBundle} * for a complete description of the search and instantiation strategy. * @param baseName * the base name of the resource bundle, a fully qualified class name * @param locale * the locale for which a resource bundle is desired * @exception NullPointerException * if baseName or locale is null * @exception MissingResourceException * if no resource bundle for the specified base name can be found * @return a resource bundle for the given base name and locale */ // @ts-ignore public static getBundle(baseName: java.lang.String | string, locale: java.util.Locale): java.util.ResourceBundle /** * Returns a resource bundle using the specified base name, target * locale and control, and the caller's class loader. Calling this * method is equivalent to calling * 
             * getBundle(baseName, targetLocale, this.getClass().getClassLoader(),
             * control),
             *
* except that getClassLoader() is run with the security * privileges of ResourceBundle. See {@link * #getBundle(String, Locale, ClassLoader, Control) getBundle} for the * complete description of the resource bundle loading process with a * ResourceBundle.Control. * @param baseName * the base name of the resource bundle, a fully qualified * class name * @param targetLocale * the locale for which a resource bundle is desired * @param control * the control which gives information for the resource * bundle loading process * @return a resource bundle for the given base name and a * Locale in locales * @exception NullPointerException * if baseName, locales or * control is null * @exception MissingResourceException * if no resource bundle for the specified base name in any * of the locales can be found. * @exception IllegalArgumentException * if the given control doesn't perform properly * (e.g., control.getCandidateLocales returns null.) * Note that validation of control is performed as * needed. * @since 1.6 */ // @ts-ignore public static getBundle(baseName: java.lang.String | string, targetLocale: java.util.Locale, control: java.util.ResourceBundle.Control): java.util.ResourceBundle /** * Gets a resource bundle using the specified base name, locale, and class * loader. *

This method behaves the same as calling * {@link #getBundle(String, Locale, ClassLoader, Control)} passing a * default instance of {@link Control} unless another {@link Control} is * provided with the {@link ResourceBundleControlProvider} SPI. Refer to the * description of modifying the default * behavior. *

The following describes the default * behavior. *

getBundle uses the base name, the specified locale, and * the default locale (obtained from {@link java.util.Locale#getDefault() * Locale.getDefault}) to generate a sequence of candidate bundle names. If the specified * locale's language, script, country, and variant are all empty strings, * then the base name is the only candidate bundle name. Otherwise, a list * of candidate locales is generated from the attribute values of the * specified locale (language, script, country and variant) and appended to * the base name. Typically, this will look like the following: * 

             * baseName + "_" + language + "_" + script + "_" + country + "_" + variant
             * baseName + "_" + language + "_" + script + "_" + country
             * baseName + "_" + language + "_" + script
             * baseName + "_" + language + "_" + country + "_" + variant
             * baseName + "_" + language + "_" + country
             * baseName + "_" + language
             *
*

Candidate bundle names where the final component is an empty string * are omitted, along with the underscore. For example, if country is an * empty string, the second and the fifth candidate bundle names above * would be omitted. Also, if script is an empty string, the candidate names * including script are omitted. For example, a locale with language "de" * and variant "JAVA" will produce candidate names with base name * "MyResource" below. * 

             * MyResource_de__JAVA
             * MyResource_de
             *
* In the case that the variant contains one or more underscores ('_'), a * sequence of bundle names generated by truncating the last underscore and * the part following it is inserted after a candidate bundle name with the * original variant. For example, for a locale with language "en", script * "Latn, country "US" and variant "WINDOWS_VISTA", and bundle base name * "MyResource", the list of candidate bundle names below is generated: * 
             * MyResource_en_Latn_US_WINDOWS_VISTA
             * MyResource_en_Latn_US_WINDOWS
             * MyResource_en_Latn_US
             * MyResource_en_Latn
             * MyResource_en_US_WINDOWS_VISTA
             * MyResource_en_US_WINDOWS
             * MyResource_en_US
             * MyResource_en
             *
*
Note: For some Locales, the list of * candidate bundle names contains extra names, or the order of bundle names * is slightly modified. See the description of the default implementation * of {@link Control#getCandidateLocales(String, Locale) * getCandidateLocales} for details.
*

getBundle then iterates over the candidate bundle names * to find the first one for which it can instantiate an actual * resource bundle. It uses the default controls' {@link Control#getFormats * getFormats} method, which generates two bundle names for each generated * name, the first a class name and the second a properties file name. For * each candidate bundle name, it attempts to create a resource bundle: *

*

This continues until a result resource bundle is instantiated or the * list of candidate bundle names is exhausted. If no matching resource * bundle is found, the default control's {@link Control#getFallbackLocale * getFallbackLocale} method is called, which returns the current default * locale. A new sequence of candidate locale names is generated using this * locale and and searched again, as above. *

If still no result bundle is found, the base name alone is looked up. If * this still fails, a MissingResourceException is thrown. *

Once a result resource bundle has been found, * its parent chain is instantiated. If the result bundle already * has a parent (perhaps because it was returned from a cache) the chain is * complete. *

Otherwise, getBundle examines the remainder of the * candidate locale list that was used during the pass that generated the * result resource bundle. (As before, candidate bundle names where the * final component is an empty string are omitted.) When it comes to the * end of the candidate list, it tries the plain bundle name. With each of the * candidate bundle names it attempts to instantiate a resource bundle (first * looking for a class and then a properties file, as described above). *

Whenever it succeeds, it calls the previously instantiated resource * bundle's {@link #setParent(java.util.ResourceBundle) setParent} method * with the new resource bundle. This continues until the list of names * is exhausted or the current bundle already has a non-null parent. *

Once the parent chain is complete, the bundle is returned. *

Note: getBundle caches instantiated resource * bundles and might return the same resource bundle instance multiple times. *

Note:The baseName argument should be a fully * qualified class name. However, for compatibility with earlier versions, * Sun's Java SE Runtime Environments do not verify this, and so it is * possible to access PropertyResourceBundles by specifying a * path name (using "/") instead of a fully qualified class name (using * "."). *

* Example: *

* The following class and property files are provided: * 

             * MyResources.class
             * MyResources.properties
             * MyResources_fr.properties
             * MyResources_fr_CH.class
             * MyResources_fr_CH.properties
             * MyResources_en.properties
             * MyResources_es_ES.class
             *
* The contents of all files are valid (that is, public non-abstract * subclasses of ResourceBundle for the ".class" files, * syntactically correct ".properties" files). The default locale is * Locale("en", "GB"). *

Calling getBundle with the locale arguments below will * instantiate resource bundles as follows: * * * * * * *
Locale("fr", "CH")MyResources_fr_CH.class, parent MyResources_fr.properties, parent MyResources.class
Locale("fr", "FR")MyResources_fr.properties, parent MyResources.class
Locale("de", "DE")MyResources_en.properties, parent MyResources.class
Locale("en", "US")MyResources_en.properties, parent MyResources.class
Locale("es", "ES")MyResources_es_ES.class, parent MyResources.class
*

The file MyResources_fr_CH.properties is never used because it is * hidden by the MyResources_fr_CH.class. Likewise, MyResources.properties * is also hidden by MyResources.class. * @param baseName the base name of the resource bundle, a fully qualified class name * @param locale the locale for which a resource bundle is desired * @param loader the class loader from which to load the resource bundle * @return a resource bundle for the given base name and locale * @exception java.lang.NullPointerException * if baseName, locale, or loader is null * @exception MissingResourceException * if no resource bundle for the specified base name can be found * @since 1.2 */ // @ts-ignore public static getBundle(baseName: java.lang.String | string, locale: java.util.Locale, loader: java.lang.ClassLoader): java.util.ResourceBundle /** * Returns a resource bundle using the specified base name, target * locale, class loader and control. Unlike the {@linkplain * #getBundle(String, Locale, ClassLoader) getBundle * factory methods with no control argument}, the given * control specifies how to locate and instantiate resource * bundles. Conceptually, the bundle loading process with the given * control is performed in the following steps. *

    *
  1. This factory method looks up the resource bundle in the cache for * the specified baseName, targetLocale and * loader. If the requested resource bundle instance is * found in the cache and the time-to-live periods of the instance and * all of its parent instances have not expired, the instance is returned * to the caller. Otherwise, this factory method proceeds with the * loading process below.
    2. *
  2. The {@link ResourceBundle.Control#getFormats(String) * control.getFormats} method is called to get resource bundle formats * to produce bundle or resource names. The strings * "java.class" and "java.properties" * designate class-based and {@linkplain PropertyResourceBundle * property}-based resource bundles, respectively. Other strings * starting with "java." are reserved for future extensions * and must not be used for application-defined formats. Other strings * designate application-defined formats.
    3. *
  3. The {@link ResourceBundle.Control#getCandidateLocales(String, * Locale) control.getCandidateLocales} method is called with the target * locale to get a list of candidate Locales for * which resource bundles are searched.
    4. *
  4. The {@link ResourceBundle.Control#newBundle(String, Locale, * String, ClassLoader, boolean) control.newBundle} method is called to * instantiate a ResourceBundle for the base bundle name, a * candidate locale, and a format. (Refer to the note on the cache * lookup below.) This step is iterated over all combinations of the * candidate locales and formats until the newBundle method * returns a ResourceBundle instance or the iteration has * used up all the combinations. For example, if the candidate locales * are Locale("de", "DE"), Locale("de") and * Locale("") and the formats are "java.class" * and "java.properties", then the following is the * sequence of locale-format combinations to be used to call * control.newBundle. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
    Locale
    *     		format
    *
    Locale("de", "DE")
    *     		java.class
    *
    Locale("de", "DE")java.properties
    *
    Locale("de")java.class
    Locale("de")java.properties
    Locale("")
    *     		java.class
    Locale("")java.properties
    *
    5. *
  5. If the previous step has found no resource bundle, proceed to * Step 6. If a bundle has been found that is a base bundle (a bundle * for Locale("")), and the candidate locale list only contained * Locale(""), return the bundle to the caller. If a bundle * has been found that is a base bundle, but the candidate locale list * contained locales other than Locale(""), put the bundle on hold and * proceed to Step 6. If a bundle has been found that is not a base * bundle, proceed to Step 7.
    6. *
  6. The {@link ResourceBundle.Control#getFallbackLocale(String, * Locale) control.getFallbackLocale} method is called to get a fallback * locale (alternative to the current target locale) to try further * finding a resource bundle. If the method returns a non-null locale, * it becomes the next target locale and the loading process starts over * from Step 3. Otherwise, if a base bundle was found and put on hold in * a previous Step 5, it is returned to the caller now. Otherwise, a * MissingResourceException is thrown.
    7. *
  7. At this point, we have found a resource bundle that's not the * base bundle. If this bundle set its parent during its instantiation, * it is returned to the caller. Otherwise, its parent chain is * instantiated based on the list of candidate locales from which it was * found. Finally, the bundle is returned to the caller.
    8. *
*

During the resource bundle loading process above, this factory * method looks up the cache before calling the {@link * Control#newBundle(String, Locale, String, ClassLoader, boolean) * control.newBundle} method. If the time-to-live period of the * resource bundle found in the cache has expired, the factory method * calls the {@link ResourceBundle.Control#needsReload(String, Locale, * String, ClassLoader, ResourceBundle, long) control.needsReload} * method to determine whether the resource bundle needs to be reloaded. * If reloading is required, the factory method calls * control.newBundle to reload the resource bundle. If * control.newBundle returns null, the factory * method puts a dummy resource bundle in the cache as a mark of * nonexistent resource bundles in order to avoid lookup overhead for * subsequent requests. Such dummy resource bundles are under the same * expiration control as specified by control. *

All resource bundles loaded are cached by default. Refer to * {@link Control#getTimeToLive(String,Locale) * control.getTimeToLive} for details. *

The following is an example of the bundle loading process with the * default ResourceBundle.Control implementation. *

Conditions: *

*

First, getBundle tries loading a resource bundle in * the following sequence. *

*

At this point, getBundle finds * foo/bar/Messages.properties, which is put on hold * because it's the base bundle. getBundle calls {@link * Control#getFallbackLocale(String, Locale) * control.getFallbackLocale("foo.bar.Messages", Locale.ITALY)} which * returns Locale.FRENCH. Next, getBundle * tries loading a bundle in the following sequence. *

*

getBundle finds * foo/bar/Messages_fr.properties and creates a * ResourceBundle instance. Then, getBundle * sets up its parent chain from the list of the candidate locales. Only * foo/bar/Messages.properties is found in the list and * getBundle creates a ResourceBundle instance * that becomes the parent of the instance for * foo/bar/Messages_fr.properties. * @param baseName * the base name of the resource bundle, a fully qualified * class name * @param targetLocale * the locale for which a resource bundle is desired * @param loader * the class loader from which to load the resource bundle * @param control * the control which gives information for the resource * bundle loading process * @return a resource bundle for the given base name and locale * @exception NullPointerException * if baseName, targetLocale, * loader, or control is * null * @exception MissingResourceException * if no resource bundle for the specified base name can be found * @exception IllegalArgumentException * if the given control doesn't perform properly * (e.g., control.getCandidateLocales returns null.) * Note that validation of control is performed as * needed. * @since 1.6 */ // @ts-ignore public static getBundle(baseName: java.lang.String | string, targetLocale: java.util.Locale, loader: java.lang.ClassLoader, control: java.util.ResourceBundle.Control): java.util.ResourceBundle /** * Removes all resource bundles from the cache that have been loaded * using the caller's class loader. * @since 1.6 * @see ResourceBundle.Control#getTimeToLive(String,Locale) */ // @ts-ignore public static clearCache(): void /** * Removes all resource bundles from the cache that have been loaded * using the given class loader. * @param loader the class loader * @exception NullPointerException if loader is null * @since 1.6 * @see ResourceBundle.Control#getTimeToLive(String,Locale) */ // @ts-ignore public static clearCache(loader: java.lang.ClassLoader): void /** * Gets an object for the given key from this resource bundle. * Returns null if this resource bundle does not contain an * object for the given key. * @param key the key for the desired object * @exception NullPointerException if key is null * @return the object for the given key, or null */ // @ts-ignore abstract handleGetObject(key: java.lang.String | string): any /** * Returns an enumeration of the keys. * @return an Enumeration of the keys contained in * this ResourceBundle and its parent bundles. */ // @ts-ignore public abstract getKeys(): java.util.Enumeration /** * Determines whether the given key is contained in * this ResourceBundle or its parent bundles. * @param key * the resource key * @return true if the given key is * contained in this ResourceBundle or its * parent bundles; false otherwise. * @exception NullPointerException * if key is null * @since 1.6 */ // @ts-ignore public containsKey(key: java.lang.String | string): boolean /** * Returns a Set of all keys contained in this * ResourceBundle and its parent bundles. * @return a Set of all keys contained in this * ResourceBundle and its parent bundles. * @since 1.6 */ // @ts-ignore public keySet(): Array /** * Returns a Set of the keys contained only * in this ResourceBundle. *

The default implementation returns a Set of the * keys returned by the {@link #getKeys() getKeys} method except * for the ones for which the {@link #handleGetObject(String) * handleGetObject} method returns null. Once the * Set has been created, the value is kept in this * ResourceBundle in order to avoid producing the * same Set in subsequent calls. Subclasses can * override this method for faster handling. * @return a Set of the keys contained only in this * ResourceBundle * @since 1.6 */ // @ts-ignore handleKeySet(): Array } } }