/** initial size of the bundle cache */

private static final int INITIAL_CACHE_SIZE = 32;

/** constant indicating that no resource bundle exists */

private static final ResourceBundle NONEXISTENT_BUNDLE = new ResourceBundle() {

public Enumeration<String> getKeys() { return null; }

protected Object handleGetObject(String key) { return null; }

public String toString() { return "NONEXISTENT_BUNDLE"; }

};

/**

private static final ConcurrentMap<CacheKey, BundleReference> cacheList

= new ConcurrentHashMap<>(INITIAL_CACHE_SIZE);

/**

private static final ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();

/**

public String getBaseBundleName() {

return name;

}

/**

protected ResourceBundle parent = null;

/**

private Locale locale = null;

/**

private String name;

/**

private volatile boolean expired;

/**

private volatile CacheKey cacheKey;

/**

private volatile Set<String> keySet;

private static final List<ResourceBundleControlProvider> providers;

static {

List<ResourceBundleControlProvider> list = null;

ServiceLoader<ResourceBundleControlProvider> serviceLoaders

= ServiceLoader.loadInstalled(ResourceBundleControlProvider.class);

for (ResourceBundleControlProvider provider : serviceLoaders) {

if (list == null) {

list = new ArrayList<>();

}

list.add(provider);

}

providers = list;

}

/**

public ResourceBundle() {

}

/**

public final String getString(String key) {

return (String) getObject(key);

}

/**

public final String[] getStringArray(String key) {

return (String[]) getObject(key);

}

/**

public final Object getObject(String key) {

Object obj = handleGetObject(key);

if (obj == null) {

if (parent != null) {

obj = parent.getObject(key);

}

if (obj == null) {

throw new MissingResourceException("Can't find resource for bundle "

+this.getClass().getName()

+", key "+key,

this.getClass().getName(),

key);

}

}

return obj;

}

/**

public Locale getLocale() {

return locale;

}

/*

private static ClassLoader getLoader(Class<?> caller) {

ClassLoader cl = caller == null ? null : caller.getClassLoader();

if (cl == null) {

// When the caller's loader is the boot class loader, cl is null

// here. In that case, ClassLoader.getSystemClassLoader() may

// return the same class loader that the application is

// using. We therefore use a wrapper ClassLoader to create a

// separate scope for bundles loaded on behalf of the Java

// runtime so that these bundles cannot be returned from the

// cache to the application (5048280).

cl = RBClassLoader.INSTANCE;

}

return cl;

}

/**

private static class RBClassLoader extends ClassLoader {

private static final RBClassLoader INSTANCE = AccessController.doPrivileged(

new PrivilegedAction<RBClassLoader>() {

public RBClassLoader run() {

return new RBClassLoader();

}

});

private static final ClassLoader loader = ClassLoader.getSystemClassLoader();

private RBClassLoader() {

}

public Class<?> loadClass(String name) throws ClassNotFoundException {

if (loader != null) {

return loader.loadClass(name);

}

return Class.forName(name);

}

public URL getResource(String name) {

if (loader != null) {

return loader.getResource(name);

}

return ClassLoader.getSystemResource(name);

}

public InputStream getResourceAsStream(String name) {

if (loader != null) {

return loader.getResourceAsStream(name);

}

return ClassLoader.getSystemResourceAsStream(name);

}

}

/**

protected void setParent(ResourceBundle parent) {

assert parent != NONEXISTENT_BUNDLE;

this.parent = parent;

}

/**

private static class CacheKey implements Cloneable {

// These three are the actual keys for lookup in Map.

private String name;

private Locale locale;

private LoaderReference loaderRef;

// bundle format which is necessary for calling

// Control.needsReload().

private String format;

// These time values are in CacheKey so that NONEXISTENT_BUNDLE

// doesn't need to be cloned for caching.

// The time when the bundle has been loaded

private volatile long loadTime;

// The time when the bundle expires in the cache, or either

// Control.TTL_DONT_CACHE or Control.TTL_NO_EXPIRATION_CONTROL.

private volatile long expirationTime;

// Placeholder for an error report by a Throwable

private Throwable cause;

// Hash code value cache to avoid recalculating the hash code

// of this instance.

private int hashCodeCache;

CacheKey(String baseName, Locale locale, ClassLoader loader) {

this.name = baseName;

this.locale = locale;

if (loader == null) {

this.loaderRef = null;

} else {

loaderRef = new LoaderReference(loader, referenceQueue, this);

}

calculateHashCode();

}

String getName() {

return name;

}

CacheKey setName(String baseName) {

if (!this.name.equals(baseName)) {

this.name = baseName;

calculateHashCode();

}

return this;

}

Locale getLocale() {

return locale;

}

CacheKey setLocale(Locale locale) {

if (!this.locale.equals(locale)) {

this.locale = locale;

calculateHashCode();

}

return this;

}

ClassLoader getLoader() {

return (loaderRef != null) ? loaderRef.get() : null;

}

public boolean equals(Object other) {

if (this == other) {

return true;

}

try {

final CacheKey otherEntry = (CacheKey)other;

//quick check to see if they are not equal

if (hashCodeCache != otherEntry.hashCodeCache) {

return false;

}

//are the names the same?

if (!name.equals(otherEntry.name)) {

return false;

}

// are the locales the same?

if (!locale.equals(otherEntry.locale)) {

return false;

}

//are refs (both non-null) or (both null)?

if (loaderRef == null) {

return otherEntry.loaderRef == null;

}

ClassLoader loader = loaderRef.get();

return (otherEntry.loaderRef != null)

// with a null reference we can no longer find

// out which class loader was referenced; so

// treat it as unequal

&& (loader != null)

&& (loader == otherEntry.loaderRef.get());

} catch ( NullPointerException | ClassCastException e) {

}

return false;

}

public int hashCode() {

return hashCodeCache;

}

private void calculateHashCode() {

hashCodeCache = name.hashCode() << 3;

hashCodeCache ^= locale.hashCode();

ClassLoader loader = getLoader();

if (loader != null) {

hashCodeCache ^= loader.hashCode();

}

}

public Object clone() {

try {

CacheKey clone = (CacheKey) super.clone();

if (loaderRef != null) {

clone.loaderRef = new LoaderReference(loaderRef.get(),

referenceQueue, clone);

}

// Clear the reference to a Throwable

clone.cause = null;

return clone;

} catch (CloneNotSupportedException e) {

//this should never happen

throw new InternalError(e);

}

}

String getFormat() {

return format;

}

void setFormat(String format) {

this.format = format;

}

private void setCause(Throwable cause) {

if (this.cause == null) {

this.cause = cause;

} else {

// Override the cause if the previous one is

// ClassNotFoundException.

if (this.cause instanceof ClassNotFoundException) {

this.cause = cause;

}

}

}

private Throwable getCause() {

return cause;

}

public String toString() {

String l = locale.toString();

if (l.length() == 0) {

if (locale.getVariant().length() != 0) {

l = "__" + locale.getVariant();

} else {

l = "\"\"";

}

}

return "CacheKey[" + name + ", lc=" + l + ", ldr=" + getLoader()

+ "(format=" + format + ")]";

}

}

/**

private static interface CacheKeyReference {

public CacheKey getCacheKey();

}

/**

private static class LoaderReference extends WeakReference<ClassLoader>

implements CacheKeyReference {

private CacheKey cacheKey;

LoaderReference(ClassLoader referent, ReferenceQueue<Object> q, CacheKey key) {

super(referent, q);

cacheKey = key;

}

public CacheKey getCacheKey() {

return cacheKey;

}

}

/**

private static class BundleReference extends SoftReference<ResourceBundle>

implements CacheKeyReference {

private CacheKey cacheKey;

BundleReference(ResourceBundle referent, ReferenceQueue<Object> q, CacheKey key) {

super(referent, q);

cacheKey = key;

}

public CacheKey getCacheKey() {

return cacheKey;

}

}

/**

@CallerSensitive

public static final ResourceBundle getBundle(String baseName)

{

return getBundleImpl(baseName, Locale.getDefault(),

getLoader(Reflection.getCallerClass()),

getDefaultControl(baseName));

}

/**

@CallerSensitive

public static final ResourceBundle getBundle(String baseName,

Control control) {

return getBundleImpl(baseName, Locale.getDefault(),

getLoader(Reflection.getCallerClass()),

control);

}

/**

@CallerSensitive

public static final ResourceBundle getBundle(String baseName,

Locale locale)

{

return getBundleImpl(baseName, locale,

getLoader(Reflection.getCallerClass()),

getDefaultControl(baseName));

}

/**

@CallerSensitive

public static final ResourceBundle getBundle(String baseName, Locale targetLocale,

Control control) {

return getBundleImpl(baseName, targetLocale,

getLoader(Reflection.getCallerClass()),

control);

}

/**