jdk-sandbox: comparison jdk/src/share/classes/java/util/Locale.java

equal deleted inserted replaced

-:d331b7996fc3
+:75c0420badef
 /*
-* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1996, 2011, 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
 import java.text.MessageFormat;
 import java.util.spi.LocaleNameProvider;
 import sun.security.action.GetPropertyAction;
 import sun.util.LocaleServiceProviderPool;
-import sun.util.locale.AsciiUtil;
 import sun.util.locale.BaseLocale;
 import sun.util.locale.InternalLocaleBuilder;
 import sun.util.locale.LanguageTag;
 import sun.util.locale.LocaleExtensions;
 import sun.util.locale.LocaleObjectCache;
 import sun.util.locale.LocaleSyntaxException;
+import sun.util.locale.LocaleUtils;
 import sun.util.locale.ParseStatus;
 import sun.util.locale.UnicodeLocaleExtension;
 import sun.util.resources.LocaleData;
 import sun.util.resources.OpenListResourceBundle;
 static private final  Cache LOCALECACHE = new Cache();
 /** Useful constant for language.
 */
-static public final Locale ENGLISH = getInstance("en", "", "");
+static public final Locale ENGLISH = createConstant("en", "");
 /** Useful constant for language.
 */
-static public final Locale FRENCH = getInstance("fr", "", "");
+static public final Locale FRENCH = createConstant("fr", "");
 /** Useful constant for language.
 */
-static public final Locale GERMAN = getInstance("de", "", "");
+static public final Locale GERMAN = createConstant("de", "");
 /** Useful constant for language.
 */
-static public final Locale ITALIAN = getInstance("it", "", "");
+static public final Locale ITALIAN = createConstant("it", "");
 /** Useful constant for language.
 */
-static public final Locale JAPANESE = getInstance("ja", "", "");
+static public final Locale JAPANESE = createConstant("ja", "");
 /** Useful constant for language.
 */
-static public final Locale KOREAN = getInstance("ko", "", "");
+static public final Locale KOREAN = createConstant("ko", "");
 /** Useful constant for language.
 */
-static public final Locale CHINESE = getInstance("zh", "", "");
+static public final Locale CHINESE = createConstant("zh", "");
 /** Useful constant for language.
 */
-static public final Locale SIMPLIFIED_CHINESE = getInstance("zh", "CN", "");
+static public final Locale SIMPLIFIED_CHINESE = createConstant("zh", "CN");
 /** Useful constant for language.
 */
-static public final Locale TRADITIONAL_CHINESE = getInstance("zh", "TW", "");
+static public final Locale TRADITIONAL_CHINESE = createConstant("zh", "TW");
 /** Useful constant for country.
 */
-static public final Locale FRANCE = getInstance("fr", "FR", "");
+static public final Locale FRANCE = createConstant("fr", "FR");
 /** Useful constant for country.
 */
-static public final Locale GERMANY = getInstance("de", "DE", "");
+static public final Locale GERMANY = createConstant("de", "DE");
 /** Useful constant for country.
 */
-static public final Locale ITALY = getInstance("it", "IT", "");
+static public final Locale ITALY = createConstant("it", "IT");
 /** Useful constant for country.
 */
-static public final Locale JAPAN = getInstance("ja", "JP", "");
+static public final Locale JAPAN = createConstant("ja", "JP");
 /** Useful constant for country.
 */
-static public final Locale KOREA = getInstance("ko", "KR", "");
+static public final Locale KOREA = createConstant("ko", "KR");
 /** Useful constant for country.
 */
 static public final Locale CHINA = SIMPLIFIED_CHINESE;
 */
 static public final Locale TAIWAN = TRADITIONAL_CHINESE;
 /** Useful constant for country.
 */
-static public final Locale UK = getInstance("en", "GB", "");
+static public final Locale UK = createConstant("en", "GB");
 /** Useful constant for country.
 */
-static public final Locale US = getInstance("en", "US", "");
+static public final Locale US = createConstant("en", "US");
 /** Useful constant for country.
 */
-static public final Locale CANADA = getInstance("en", "CA", "");
+static public final Locale CANADA = createConstant("en", "CA");
 /** Useful constant for country.
 */
-static public final Locale CANADA_FRENCH = getInstance("fr", "CA", "");
+static public final Locale CANADA_FRENCH = createConstant("fr", "CA");
 /**
 * Useful constant for the root locale.  The root locale is the locale whose
 * language, country, and variant are empty ("") strings.  This is regarded
 * as the base locale of all locales, and is used as the language/country
 * neutral locale for the locale sensitive operations.
 *
 * @since 1.6
 */
-static public final Locale ROOT = getInstance("", "", "");
+static public final Locale ROOT = createConstant("", "");
 /**
 * The key for the private use extension ('x').
 *
 * @see #getExtension(char)
 * Display types for retrieving localized names from the name providers.
 */
 private static final int DISPLAY_LANGUAGE = 0;
 private static final int DISPLAY_COUNTRY  = 1;
 private static final int DISPLAY_VARIANT  = 2;
-private static final int DISPLAY_SCRIPT = 3;
+private static final int DISPLAY_SCRIPT   = 3;
 /**
 * Private constructor used by getInstance method
 */
 private Locale(BaseLocale baseLocale, LocaleExtensions extensions) {
-_baseLocale = baseLocale;
+this.baseLocale = baseLocale;
-_extensions = extensions;
+this.localeExtensions = extensions;
 }
 /**
 * Construct a locale from language, country and variant.
 * This constructor normalizes the language value to lowercase and
 */
 public Locale(String language, String country, String variant) {
 if (language== null || country == null || variant == null) {
 throw new NullPointerException();
 }
-_baseLocale = BaseLocale.getInstance(convertOldISOCodes(language), "", country, variant);
+baseLocale = BaseLocale.getInstance(convertOldISOCodes(language), "", country, variant);
-_extensions = getCompatibilityExtensions(language, "", country, variant);
+localeExtensions = getCompatibilityExtensions(language, "", country, variant);
 }
 /**
 * Construct a locale from language and country.
 * This constructor normalizes the language value to lowercase and
 public Locale(String language) {
 this(language, "", "");
 }
 /**
+* This method must be called only for creating the Locale.*
+* constants due to making shortcuts.
+*/
+private static Locale createConstant(String lang, String country) {
+BaseLocale base = BaseLocale.createInstance(lang, country);
+return getInstance(base, null);
+}
+/**
 * Returns a <code>Locale</code> constructed from the given
 * <code>language</code>, <code>country</code> and
 * <code>variant</code>. If the same <code>Locale</code> instance
 * is available in the cache, then that instance is
 * returned. Otherwise, a new <code>Locale</code> instance is
 * @param variant vendor and browser specific code. See class description.
 * @return the <code>Locale</code> instance requested
 * @exception NullPointerException if any argument is null.
 */
 static Locale getInstance(String language, String country, String variant) {
-return getInstance(language, "", country, variant, LocaleExtensions.EMPTY_EXTENSIONS);
+return getInstance(language, "", country, variant, null);
 }
 static Locale getInstance(String language, String script, String country,
 String variant, LocaleExtensions extensions) {
 if (language== null || script == null || country == null || variant == null) {
 throw new NullPointerException();
 }
 if (extensions == null) {
-extensions = LocaleExtensions.EMPTY_EXTENSIONS;
-}
-if (extensions.equals(LocaleExtensions.EMPTY_EXTENSIONS)) {
 extensions = getCompatibilityExtensions(language, script, country, variant);
 }
 BaseLocale baseloc = BaseLocale.getInstance(language, script, country, variant);
 return getInstance(baseloc, extensions);
 LocaleKey key = new LocaleKey(baseloc, extensions);
 return LOCALECACHE.get(key);
 }
 private static class Cache extends LocaleObjectCache<LocaleKey, Locale> {
-public Cache() {
+private Cache() {
 }
+@Override
 protected Locale createObject(LocaleKey key) {
-return new Locale(key._base, key._exts);
+return new Locale(key.base, key.exts);
 }
 }
-private static class LocaleKey {
+private static final class LocaleKey {
-private BaseLocale _base;
+private final BaseLocale base;
-private LocaleExtensions _exts;
+private final LocaleExtensions exts;
+private final int hash;
 private LocaleKey(BaseLocale baseLocale, LocaleExtensions extensions) {
-_base = baseLocale;
+base = baseLocale;
-_exts = extensions;
+exts = extensions;
-}
+// Calculate the hash value here because it's always used.
+int h = base.hashCode();
+if (exts != null) {
+h ^= exts.hashCode();
+}
+hash = h;
+}
+@Override
 public boolean equals(Object obj) {
 if (this == obj) {
 return true;
 }
 if (!(obj instanceof LocaleKey)) {
 return false;
 }
 LocaleKey other = (LocaleKey)obj;
-return _base.equals(other._base) && _exts.equals(other._exts);
+if (hash != other.hash || !base.equals(other.base)) {
-}
+return false;
+}
+if (exts == null) {
+return other.exts == null;
+}
+return exts.equals(other.exts);
+}
+@Override
 public int hashCode() {
-return _base.hashCode() ^ _exts.hashCode();
+return hash;
 }
 }
 /**
 * Gets the current value of the default locale for this instance
 * </pre>
 * @return The language code, or the empty string if none is defined.
 * @see #getDisplayLanguage
 */
 public String getLanguage() {
-return _baseLocale.getLanguage();
+return baseLocale.getLanguage();
 }
 /**
 * Returns the script for this locale, which should
 * either be the empty string or an ISO 15924 4-letter script
 * @return The script code, or the empty string if none is defined.
 * @see #getDisplayScript
 * @since 1.7
 */
 public String getScript() {
-return _baseLocale.getScript();
+return baseLocale.getScript();
 }
 /**
 * Returns the country/region code for this locale, which should
 * either be the empty string, an uppercase ISO 3166 2-letter code,
 *
 * @return The country/region code, or the empty string if none is defined.
 * @see #getDisplayCountry
 */
 public String getCountry() {
-return _baseLocale.getRegion();
+return baseLocale.getRegion();
 }
 /**
 * Returns the variant code for this locale.
 *
 * @return The variant code, or the empty string if none is defined.
 * @see #getDisplayVariant
 */
 public String getVariant() {
-return _baseLocale.getVariant();
+return baseLocale.getVariant();
 }
 /**
 * Returns the extension (or private use) value associated with
 * the specified key, or null if there is no extension
 */
 public String getExtension(char key) {
 if (!LocaleExtensions.isValidKey(key)) {
 throw new IllegalArgumentException("Ill-formed extension key: " + key);
 }
-return _extensions.getExtensionValue(key);
+return (localeExtensions == null) ? null : localeExtensions.getExtensionValue(key);
 }
 /**
 * Returns the set of extension keys associated with this locale, or the
 * empty set if it has no extensions. The returned set is unmodifiable.
 * @return The set of extension keys, or the empty set if this locale has
 * no extensions.
 * @since 1.7
 */
 public Set<Character> getExtensionKeys() {
-return _extensions.getKeys();
+if (localeExtensions == null) {
+return Collections.emptySet();
+}
+return localeExtensions.getKeys();
 }
 /**
 * Returns the set of unicode locale attributes associated with
 * this locale, or the empty set if it has no attributes. The
 *
 * @return The set of attributes.
 * @since 1.7
 */
 public Set<String> getUnicodeLocaleAttributes() {
-return _extensions.getUnicodeLocaleAttributes();
+if (localeExtensions == null) {
+return Collections.emptySet();
+}
+return localeExtensions.getUnicodeLocaleAttributes();
 }
 /**
 * Returns the Unicode locale type associated with the specified Unicode locale key
 * for this locale. Returns the empty string for keys that are defined with no type.
 */
 public String getUnicodeLocaleType(String key) {
 if (!UnicodeLocaleExtension.isKey(key)) {
 throw new IllegalArgumentException("Ill-formed Unicode locale key: " + key);
 }
-return _extensions.getUnicodeLocaleType(key);
+return (localeExtensions == null) ? null : localeExtensions.getUnicodeLocaleType(key);
 }
 /**
 * Returns the set of Unicode locale keys defined by this locale, or the empty set if
 * this locale has none.  The returned set is immutable.  Keys are all lower case.
 * @return The set of Unicode locale keys, or the empty set if this locale has
 * no Unicode locale keywords.
 * @since 1.7
 */
 public Set<String> getUnicodeLocaleKeys() {
-return _extensions.getUnicodeLocaleKeys();
+if (localeExtensions == null) {
+return Collections.emptySet();
+}
+return localeExtensions.getUnicodeLocaleKeys();
 }
 /**
 * Package locale method returning the Locale's BaseLocale,
 * used by ResourceBundle
 * @return base locale of this Locale
 */
 BaseLocale getBaseLocale() {
-return _baseLocale;
+return baseLocale;
 }
 /**
-* Package local method returning the Locale's LocaleExtensions,
+* Package private method returning the Locale's LocaleExtensions,
-* used by ResourceBundle
+* used by ResourceBundle.
-* @return locale exnteions of this Locale
+* @return locale exnteions of this Locale,
+*         or {@code null} if no extensions are defined
 */
 LocaleExtensions getLocaleExtensions() {
-return _extensions;
+return localeExtensions;
 }
 /**
 * Returns a string representation of this <code>Locale</code>
 * object, consisting of language, country, variant, script,
 *
 * @return A string representation of the Locale, for debugging.
 * @see #getDisplayName
 * @see #toLanguageTag
 */
+@Override
 public final String toString() {
-boolean l = (_baseLocale.getLanguage().length() != 0);
+boolean l = (baseLocale.getLanguage().length() != 0);
-boolean s = (_baseLocale.getScript().length() != 0);
+boolean s = (baseLocale.getScript().length() != 0);
-boolean r = (_baseLocale.getRegion().length() != 0);
+boolean r = (baseLocale.getRegion().length() != 0);
-boolean v = (_baseLocale.getVariant().length() != 0);
+boolean v = (baseLocale.getVariant().length() != 0);
-boolean e = (_extensions.getID().length() != 0);
+boolean e = (localeExtensions != null && localeExtensions.getID().length() != 0);
-StringBuilder result = new StringBuilder(_baseLocale.getLanguage());
+StringBuilder result = new StringBuilder(baseLocale.getLanguage());
 if (r || (l && (v || s || e))) {
 result.append('_')
-.append(_baseLocale.getRegion()); // This may just append '_'
+.append(baseLocale.getRegion()); // This may just append '_'
 }
 if (v && (l || r)) {
 result.append('_')
-.append(_baseLocale.getVariant());
+.append(baseLocale.getVariant());
 }
 if (s && (l || r)) {
 result.append("_#")
-.append(_baseLocale.getScript());
+.append(baseLocale.getScript());
 }
 if (e && (l || r)) {
 result.append('_');
 if (!s) {
 result.append('#');
 }
-result.append(_extensions.getID());
+result.append(localeExtensions.getID());
 }
 return result.toString();
 }
 * @return a BCP47 language tag representing the locale
 * @see #forLanguageTag(String)
 * @since 1.7
 */
 public String toLanguageTag() {
-LanguageTag tag = LanguageTag.parseLocale(_baseLocale, _extensions);
+LanguageTag tag = LanguageTag.parseLocale(baseLocale, localeExtensions);
 StringBuilder buf = new StringBuilder();
 String subtag = tag.getLanguage();
 if (subtag.length() > 0) {
 buf.append(LanguageTag.canonicalizeLanguage(subtag));
 LanguageTag tag = LanguageTag.parse(languageTag, null);
 InternalLocaleBuilder bldr = new InternalLocaleBuilder();
 bldr.setLanguageTag(tag);
 BaseLocale base = bldr.getBaseLocale();
 LocaleExtensions exts = bldr.getLocaleExtensions();
-if (exts.isEmpty() && base.getVariant().length() > 0) {
+if (exts == null && base.getVariant().length() > 0) {
-exts = getCompatibilityExtensions(base.getLanguage(), base.getScript(), base.getRegion(), base.getVariant());
+exts = getCompatibilityExtensions(base.getLanguage(), base.getScript(),
+base.getRegion(), base.getVariant());
 }
 return getInstance(base, exts);
 }
 /**
 * @return A three-letter abbreviation of this locale's language.
 * @exception MissingResourceException Throws MissingResourceException if
 * three-letter language abbreviation is not available for this locale.
 */
 public String getISO3Language() throws MissingResourceException {
-String lang = _baseLocale.getLanguage();
+String lang = baseLocale.getLanguage();
 if (lang.length() == 3) {
 return lang;
 }
 String language3 = getISO3Code(lang, LocaleISOData.isoLanguageTable);
 * @return A three-letter abbreviation of this locale's country.
 * @exception MissingResourceException Throws MissingResourceException if the
 * three-letter country abbreviation is not available for this locale.
 */
 public String getISO3Country() throws MissingResourceException {
-String country3 = getISO3Code(_baseLocale.getRegion(), LocaleISOData.isoCountryTable);
+String country3 = getISO3Code(baseLocale.getRegion(), LocaleISOData.isoCountryTable);
 if (country3 == null) {
 throw new MissingResourceException("Couldn't find 3-letter country code for "
-+ _baseLocale.getRegion(), "FormatData_" + toString(), "ShortCountry");
++ baseLocale.getRegion(), "FormatData_" + toString(), "ShortCountry");
 }
 return country3;
 }
 private static final String getISO3Code(String iso2Code, String table) {
 * this function returns the empty string.
 *
 * @exception NullPointerException if <code>inLocale</code> is <code>null</code>
 */
 public String getDisplayLanguage(Locale inLocale) {
-return getDisplayString(_baseLocale.getLanguage(), inLocale, DISPLAY_LANGUAGE);
+return getDisplayString(baseLocale.getLanguage(), inLocale, DISPLAY_LANGUAGE);
 }
 /**
 * Returns a name for the the locale's script that is appropriate for display to
 * the user. If possible, the name will be localized for the default locale.  Returns
 * @return the display name of the script code for the current default locale
 * @throws NullPointerException if <code>inLocale</code> is <code>null</code>
 * @since 1.7
 */
 public String getDisplayScript(Locale inLocale) {
-return getDisplayString(_baseLocale.getScript(), inLocale, DISPLAY_SCRIPT);
+return getDisplayString(baseLocale.getScript(), inLocale, DISPLAY_SCRIPT);
 }
 /**
 * Returns a name for the locale's country that is appropriate for display to the
 * user.
 * this function returns the empty string.
 *
 * @exception NullPointerException if <code>inLocale</code> is <code>null</code>
 */
 public String getDisplayCountry(Locale inLocale) {
-return getDisplayString(_baseLocale.getRegion(), inLocale, DISPLAY_COUNTRY);
+return getDisplayString(baseLocale.getRegion(), inLocale, DISPLAY_COUNTRY);
 }
 private String getDisplayString(String code, Locale inLocale, int type) {
 if (code.length() == 0) {
 return "";
 * doesn't specify a variant code, this function returns the empty string.
 *
 * @exception NullPointerException if <code>inLocale</code> is <code>null</code>
 */
 public String getDisplayVariant(Locale inLocale) {
-if (_baseLocale.getVariant().length() == 0)
+if (baseLocale.getVariant().length() == 0)
 return "";
 OpenListResourceBundle bundle = LocaleData.getLocaleNames(inLocale);
 String names[] = getDisplayVariantArray(bundle, inLocale);
 return "";
 } else {
 return formatList(variantNames, listPattern, listCompositionPattern);
 }
 }
-ArrayList<String> names = new ArrayList<String>(4);
+ArrayList<String> names = new ArrayList<>(4);
 if (languageName.length() != 0) {
 names.add(languageName);
 }
 if (scriptName.length() != 0) {
 names.add(scriptName);
 /**
 * Override hashCode.
 * Since Locales are often used in hashtables, caches the value
 * for speed.
 */
+@Override
 public int hashCode() {
 int hc = hashCodeValue;
 if (hc == 0) {
-hc = _baseLocale.hashCode() ^ _extensions.hashCode();
+hc = baseLocale.hashCode();
+if (localeExtensions != null) {
+hc ^= localeExtensions.hashCode();
+}
 hashCodeValue = hc;
 }
 return hc;
 }
 * deemed equal to another Locale with identical language, script, country,
 * variant and extensions, and unequal to all other objects.
 *
 * @return true if this Locale is equal to the specified object.
 */
+@Override
 public boolean equals(Object obj) {
 if (this == obj)                      // quick check
 return true;
 if (!(obj instanceof Locale))
 return false;
-BaseLocale otherBase = ((Locale)obj)._baseLocale;
+BaseLocale otherBase = ((Locale)obj).baseLocale;
-LocaleExtensions otherExt = ((Locale)obj)._extensions;
+if (!baseLocale.equals(otherBase)) {
-return _baseLocale.equals(otherBase) && _extensions.equals(otherExt);
+return false;
+}
+if (localeExtensions == null) {
+return ((Locale)obj).localeExtensions == null;
+}
+return localeExtensions.equals(((Locale)obj).localeExtensions);
 }
 // ================= privates =====================================
-private transient BaseLocale _baseLocale;
+private transient BaseLocale baseLocale;
-private transient LocaleExtensions _extensions;
+private transient LocaleExtensions localeExtensions;
 /**
 * Calculated hashcode
 */
 private transient volatile int hashCodeValue = 0;
 * @param bundle the ResourceBundle to use to get the display names
 * @return an array of display names, possible of zero length.
 */
 private String[] getDisplayVariantArray(OpenListResourceBundle bundle, Locale inLocale) {
 // Split the variant name into tokens separated by '_'.
-StringTokenizer tokenizer = new StringTokenizer(_baseLocale.getVariant(), "_");
+StringTokenizer tokenizer = new StringTokenizer(baseLocale.getVariant(), "_");
 String[] names = new String[tokenizer.countTokens()];
 // For each variant token, lookup the display name.  If
 // not found, use the variant name itself.
 for (int i=0; i<names.length; ++i) {
 * @throws IOException
 * @since 1.7
 */
 private void writeObject(ObjectOutputStream out) throws IOException {
 ObjectOutputStream.PutField fields = out.putFields();
-fields.put("language", _baseLocale.getLanguage());
+fields.put("language", baseLocale.getLanguage());
-fields.put("script", _baseLocale.getScript());
+fields.put("script", baseLocale.getScript());
-fields.put("country", _baseLocale.getRegion());
+fields.put("country", baseLocale.getRegion());
-fields.put("variant", _baseLocale.getVariant());
+fields.put("variant", baseLocale.getVariant());
-fields.put("extensions", _extensions.getID());
+fields.put("extensions", localeExtensions == null ? "" : localeExtensions.getID());
 fields.put("hashcode", -1); // place holder just for backward support
 out.writeFields();
 }
 /**
 String language = (String)fields.get("language", "");
 String script = (String)fields.get("script", "");
 String country = (String)fields.get("country", "");
 String variant = (String)fields.get("variant", "");
 String extStr = (String)fields.get("extensions", "");
-_baseLocale = BaseLocale.getInstance(convertOldISOCodes(language), script, country, variant);
+baseLocale = BaseLocale.getInstance(convertOldISOCodes(language), script, country, variant);
-try {
+if (extStr.length() > 0) {
-InternalLocaleBuilder bldr = new InternalLocaleBuilder();
+try {
-bldr.setExtensions(extStr);
+InternalLocaleBuilder bldr = new InternalLocaleBuilder();
-_extensions = bldr.getLocaleExtensions();
+bldr.setExtensions(extStr);
-} catch (LocaleSyntaxException e) {
+localeExtensions = bldr.getLocaleExtensions();
-throw new IllformedLocaleException(e.getMessage());
+} catch (LocaleSyntaxException e) {
+throw new IllformedLocaleException(e.getMessage());
+}
+} else {
+localeExtensions = null;
 }
 }
 /**
 * Returns a cached <code>Locale</code> instance equivalent to
 * @return an instance of <code>Locale</code> equivalent to
 * the deserialized <code>Locale</code>.
 * @throws java.io.ObjectStreamException
 */
 private Object readResolve() throws java.io.ObjectStreamException {
-return getInstance(_baseLocale.getLanguage(), _baseLocale.getScript(),
+return getInstance(baseLocale.getLanguage(), baseLocale.getScript(),
-_baseLocale.getRegion(), _baseLocale.getVariant(), _extensions);
+baseLocale.getRegion(), baseLocale.getVariant(), localeExtensions);
 }
 private static volatile String[] isoLanguages = null;
 private static volatile String[] isoCountries = null;
 private static String convertOldISOCodes(String language) {
 // we accept both the old and the new ISO codes for the languages whose ISO
 // codes have changed, but we always store the OLD code, for backward compatibility
-language = AsciiUtil.toLowerString(language).intern();
+language = LocaleUtils.toLowerString(language).intern();
 if (language == "he") {
 return "iw";
 } else if (language == "yi") {
 return "ji";
 } else if (language == "id") {
 } else {
 return language;
 }
 }
-private static LocaleExtensions getCompatibilityExtensions(String language, String script, String country, String variant) {
+private static LocaleExtensions getCompatibilityExtensions(String language,
-LocaleExtensions extensions = LocaleExtensions.EMPTY_EXTENSIONS;
+String script,
+String country,
+String variant) {
+LocaleExtensions extensions = null;
 // Special cases for backward compatibility support
-if (AsciiUtil.caseIgnoreMatch(language, "ja")
+if (LocaleUtils.caseIgnoreMatch(language, "ja")
 && script.length() == 0
-&& AsciiUtil.caseIgnoreMatch(country, "JP")
+&& LocaleUtils.caseIgnoreMatch(country, "jp")
-&& AsciiUtil.caseIgnoreMatch(variant, "JP")) {
+&& "JP".equals(variant)) {
 // ja_JP_JP -> u-ca-japanese (calendar = japanese)
 extensions = LocaleExtensions.CALENDAR_JAPANESE;
-} else if (AsciiUtil.caseIgnoreMatch(language, "th")
+} else if (LocaleUtils.caseIgnoreMatch(language, "th")
 && script.length() == 0
-&& AsciiUtil.caseIgnoreMatch(country, "TH")
+&& LocaleUtils.caseIgnoreMatch(country, "th")
-&& AsciiUtil.caseIgnoreMatch(variant, "TH")) {
+&& "TH".equals(variant)) {
 // th_TH_TH -> u-nu-thai (numbersystem = thai)
 extensions = LocaleExtensions.NUMBER_THAI;
 }
 return extensions;
 }
 *
 * @see Locale#forLanguageTag
 * @since 1.7
 */
 public static final class Builder {
-private InternalLocaleBuilder _locbld;
+private final InternalLocaleBuilder localeBuilder;
 /**
 * Constructs an empty Builder. The default value of all
 * fields, extensions, and private use information is the
 * empty string.
 */
 public Builder() {
-_locbld = new InternalLocaleBuilder();
+localeBuilder = new InternalLocaleBuilder();
 }
 /**
 * Resets the <code>Builder</code> to match the provided
 * <code>locale</code>.  Existing state is discarded.
 * any ill-formed fields.
 * @throws NullPointerException if <code>locale</code> is null.
 */
 public Builder setLocale(Locale locale) {
 try {
-_locbld.setLocale(locale._baseLocale, locale._extensions);
+localeBuilder.setLocale(locale.baseLocale, locale.localeExtensions);
 } catch (LocaleSyntaxException e) {
 throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
 }
 return this;
 }
 ParseStatus sts = new ParseStatus();
 LanguageTag tag = LanguageTag.parse(languageTag, sts);
 if (sts.isError()) {
 throw new IllformedLocaleException(sts.getErrorMessage(), sts.getErrorIndex());
 }
-_locbld.setLanguageTag(tag);
+localeBuilder.setLanguageTag(tag);
 return this;
 }
 /**
 * Sets the language.  If <code>language</code> is the empty string or
 * @return This builder.
 * @throws IllformedLocaleException if <code>language</code> is ill-formed
 */
 public Builder setLanguage(String language) {
 try {
-_locbld.setLanguage(language);
+localeBuilder.setLanguage(language);
 } catch (LocaleSyntaxException e) {
 throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
 }
 return this;
 }
 * @return This builder.
 * @throws IllformedLocaleException if <code>script</code> is ill-formed
 */
 public Builder setScript(String script) {
 try {
-_locbld.setScript(script);
+localeBuilder.setScript(script);
 } catch (LocaleSyntaxException e) {
 throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
 }
 return this;
 }
 * @return This builder.
 * @throws IllformedLocaleException if <code>region</code> is ill-formed
 */
 public Builder setRegion(String region) {
 try {
-_locbld.setRegion(region);
+localeBuilder.setRegion(region);
 } catch (LocaleSyntaxException e) {
 throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
 }
 return this;
 }
 * @return This builder.
 * @throws IllformedLocaleException if <code>variant</code> is ill-formed
 */
 public Builder setVariant(String variant) {
 try {
-_locbld.setVariant(variant);
+localeBuilder.setVariant(variant);
 } catch (LocaleSyntaxException e) {
 throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
 }
 return this;
 }
 * or <code>value</code> is ill-formed
 * @see #setUnicodeLocaleKeyword(String, String)
 */
 public Builder setExtension(char key, String value) {
 try {
-_locbld.setExtension(key, value);
+localeBuilder.setExtension(key, value);
 } catch (LocaleSyntaxException e) {
 throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
 }
 return this;
 }
 * @throws NullPointerException if <code>key</code> is null
 * @see #setExtension(char, String)
 */
 public Builder setUnicodeLocaleKeyword(String key, String type) {
 try {
-_locbld.setUnicodeLocaleKeyword(key, type);
+localeBuilder.setUnicodeLocaleKeyword(key, type);
 } catch (LocaleSyntaxException e) {
 throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
 }
 return this;
 }
 * @throws IllformedLocaleException if <code>attribute</code> is ill-formed
 * @see #setExtension(char, String)
 */
 public Builder addUnicodeLocaleAttribute(String attribute) {
 try {
-_locbld.addUnicodeLocaleAttribute(attribute);
+localeBuilder.addUnicodeLocaleAttribute(attribute);
 } catch (LocaleSyntaxException e) {
 throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
 }
 return this;
 }
 * @throws IllformedLocaleException if <code>attribute</code> is ill-formed
 * @see #setExtension(char, String)
 */
 public Builder removeUnicodeLocaleAttribute(String attribute) {
 try {
-_locbld.removeUnicodeLocaleAttribute(attribute);
+localeBuilder.removeUnicodeLocaleAttribute(attribute);
 } catch (LocaleSyntaxException e) {
 throw new IllformedLocaleException(e.getMessage(), e.getErrorIndex());
 }
 return this;
 }
 * Resets the builder to its initial, empty state.
 *
 * @return This builder.
 */
 public Builder clear() {
-_locbld.clear();
+localeBuilder.clear();
 return this;
 }
 /**
 * Resets the extensions to their initial, empty state.
 *
 * @return This builder.
 * @see #setExtension(char, String)
 */
 public Builder clearExtensions() {
-_locbld.clearExtensions();
+localeBuilder.clearExtensions();
 return this;
 }
 /**
 * Returns an instance of <code>Locale</code> created from the fields set
 * {@link #setLanguageTag}.)
 *
 * @return A Locale.
 */
 public Locale build() {
-BaseLocale baseloc = _locbld.getBaseLocale();
+BaseLocale baseloc = localeBuilder.getBaseLocale();
-LocaleExtensions extensions = _locbld.getLocaleExtensions();
+LocaleExtensions extensions = localeBuilder.getLocaleExtensions();
-if (extensions.isEmpty() && baseloc.getVariant().length() > 0) {
+if (extensions == null && baseloc.getVariant().length() > 0) {
 extensions = getCompatibilityExtensions(baseloc.getLanguage(), baseloc.getScript(),
 baseloc.getRegion(), baseloc.getVariant());
 }
 return Locale.getInstance(baseloc, extensions);
 }

changeset 9224	75c0420badef
parent 8780	c88e159a3e5c
child 9232	9e29d6359705