jdk-sandbox: comparison src/java.base/share/classes/sun/util/locale/BaseLocale.java

equal deleted inserted replaced

-:85c27aabf312
+:3d17a524da95
 /*
-* Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2010, 2018, 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
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 */
 package sun.util.locale;
 import java.lang.ref.SoftReference;
 import java.util.StringJoiner;
 public final class BaseLocale {
 public static final String SEP = "_";
 private final String region;
 private final String variant;
 private volatile int hash;
-// This method must be called only when creating the Locale.* constants.
+// This method must be called with normalize = false only when creating the
-private BaseLocale(String language, String region) {
+// Locale.* constants and non-normalized BaseLocale$Keys used for lookup.
-this.language = language;
+private BaseLocale(String language, String script, String region, String variant,
-this.script = "";
+boolean normalize) {
-this.region = region;
+if (normalize) {
-this.variant = "";
+this.language = LocaleUtils.toLowerString(language).intern();
-}
+this.script = LocaleUtils.toTitleString(script).intern();
+this.region = LocaleUtils.toUpperString(region).intern();
-private BaseLocale(String language, String script, String region, String variant) {
+this.variant = variant.intern();
-this.language = (language != null) ? LocaleUtils.toLowerString(language).intern() : "";
+} else {
-this.script = (script != null) ? LocaleUtils.toTitleString(script).intern() : "";
+this.language = language;
-this.region = (region != null) ? LocaleUtils.toUpperString(region).intern() : "";
+this.script = script;
-this.variant = (variant != null) ? variant.intern() : "";
+this.region = region;
+this.variant = variant;
+}
 }
 // Called for creating the Locale.* constants. No argument
 // validation is performed.
 public static BaseLocale createInstance(String language, String region) {
-BaseLocale base = new BaseLocale(language, region);
+BaseLocale base = new BaseLocale(language, "", region, "", false);
-CACHE.put(new Key(language, region), base);
+CACHE.put(new Key(base), base);
 return base;
 }
 public static BaseLocale getInstance(String language, String script,
 String region, String variant) {
 } else if (LocaleUtils.caseIgnoreMatch(language, "id")) {
 language = "in";
 }
 }
-Key key = new Key(language, script, region, variant);
+Key key = new Key(language, script, region, variant, false);
 BaseLocale baseLocale = CACHE.get(key);
 return baseLocale;
 }
 public String getLanguage() {
 }
 @Override
 public String toString() {
 StringJoiner sj = new StringJoiner(", ");
-if (language.length() > 0) {
+if (!language.isEmpty()) {
 sj.add("language=" + language);
 }
-if (script.length() > 0) {
+if (!script.isEmpty()) {
 sj.add("script=" + script);
 }
-if (region.length() > 0) {
+if (!region.isEmpty()) {
 sj.add("region=" + region);
 }
-if (variant.length() > 0) {
+if (!variant.isEmpty()) {
 sj.add("variant=" + variant);
 }
 return sj.toString();
 }
 }
 return h;
 }
 private static final class Key {
-private final SoftReference<String> lang;
+/**
-private final SoftReference<String> scrt;
+* Keep a SoftReference to the Key data if normalized (actually used
-private final SoftReference<String> regn;
+* as a cache key) and not initialized via the constant creation path.
-private final SoftReference<String> vart;
+*
+* This allows us to avoid creating SoftReferences on lookup Keys
+* (which are short-lived) and for Locales created via
+* Locale#createConstant.
+*/
+private final SoftReference<BaseLocale> holderRef;
+private final BaseLocale holder;
 private final boolean normalized;
 private final int hash;
 /**
 * Creates a Key. language and region must be normalized
 * (intern'ed in the proper case).
 */
-private Key(String language, String region) {
+private Key(BaseLocale locale) {
-assert language.intern() == language
+this.holder = locale;
-&& region.intern() == region;
+this.holderRef = null;
-lang = new SoftReference<>(language);
-scrt = new SoftReference<>("");
-regn = new SoftReference<>(region);
-vart = new SoftReference<>("");
 this.normalized = true;
+String language = locale.getLanguage();
+String region = locale.getRegion();
+assert LocaleUtils.toLowerString(language).intern() == language
+&& LocaleUtils.toUpperString(region).intern() == region
+&& locale.getVariant() == ""
+&& locale.getScript() == "";
 int h = language.hashCode();
 if (region != "") {
 int len = region.length();
 for (int i = 0; i < len; i++) {
 }
 }
 hash = h;
 }
-public Key(String language, String script, String region, String variant) {
-this(language, script, region, variant, false);
-}
 private Key(String language, String script, String region,
-String variant, boolean normalized) {
+String variant, boolean normalize) {
+if (language == null) {
+language = "";
+}
+if (script == null) {
+script = "";
+}
+if (region == null) {
+region = "";
+}
+if (variant == null) {
+variant = "";
+}
+BaseLocale locale = new BaseLocale(language, script, region, variant, normalize);
+this.normalized = normalize;
+if (normalized) {
+this.holderRef = new SoftReference<>(locale);
+this.holder = null;
+} else {
+this.holderRef = null;
+this.holder = locale;
+}
+this.hash = hashCode(locale);
+}
+public int hashCode() {
+return hash;
+}
+private int hashCode(BaseLocale locale) {
 int h = 0;
-if (language != null) {
+String lang = locale.getLanguage();
-lang = new SoftReference<>(language);
+int len = lang.length();
-int len = language.length();
+for (int i = 0; i < len; i++) {
-for (int i = 0; i < len; i++) {
+h = 31*h + LocaleUtils.toLower(lang.charAt(i));
-h = 31*h + LocaleUtils.toLower(language.charAt(i));
+}
-}
+String scrt = locale.getScript();
-} else {
+len = scrt.length();
-lang = new SoftReference<>("");
+for (int i = 0; i < len; i++) {
-}
+h = 31*h + LocaleUtils.toLower(scrt.charAt(i));
-if (script != null) {
+}
-scrt = new SoftReference<>(script);
+String regn = locale.getRegion();
-int len = script.length();
+len = regn.length();
 for (int i = 0; i < len; i++) {
-h = 31*h + LocaleUtils.toLower(script.charAt(i));
+h = 31*h + LocaleUtils.toLower(regn.charAt(i));
 }
-} else {
+String vart = locale.getVariant();
-scrt = new SoftReference<>("");
+len = vart.length();
-}
+for (int i = 0; i < len; i++) {
-if (region != null) {
+h = 31*h + vart.charAt(i);
-regn = new SoftReference<>(region);
+}
-int len = region.length();
+return h;
-for (int i = 0; i < len; i++) {
+}
-h = 31*h + LocaleUtils.toLower(region.charAt(i));
-}
+private BaseLocale getBaseLocale() {
-} else {
+return (holder == null) ? holderRef.get() : holder;
-regn = new SoftReference<>("");
-}
-if (variant != null) {
-vart = new SoftReference<>(variant);
-int len = variant.length();
-for (int i = 0; i < len; i++) {
-h = 31*h + variant.charAt(i);
-}
-} else {
-vart = new SoftReference<>("");
-}
-hash = h;
-this.normalized = normalized;
 }
 @Override
 public boolean equals(Object obj) {
 if (this == obj) {
 return true;
 }
 if (obj instanceof Key && this.hash == ((Key)obj).hash) {
-String tl = this.lang.get();
+BaseLocale other = ((Key) obj).getBaseLocale();
-String ol = ((Key)obj).lang.get();
+BaseLocale locale = this.getBaseLocale();
-if (tl != null && ol != null &&
+if (other != null && locale != null
-LocaleUtils.caseIgnoreMatch(ol, tl)) {
+&& LocaleUtils.caseIgnoreMatch(other.getLanguage(), locale.getLanguage())
-String ts = this.scrt.get();
+&& LocaleUtils.caseIgnoreMatch(other.getScript(), locale.getScript())
-String os = ((Key)obj).scrt.get();
+&& LocaleUtils.caseIgnoreMatch(other.getRegion(), locale.getRegion())
-if (ts != null && os != null &&
+// variant is case sensitive in JDK!
-LocaleUtils.caseIgnoreMatch(os, ts)) {
+&& other.getVariant().equals(locale.getVariant())) {
-String tr = this.regn.get();
+return true;
-String or = ((Key)obj).regn.get();
-if (tr != null && or != null &&
-LocaleUtils.caseIgnoreMatch(or, tr)) {
-String tv = this.vart.get();
-String ov = ((Key)obj).vart.get();
-return (ov != null && ov.equals(tv));
-}
-}
 }
 }
 return false;
-}
-@Override
-public int hashCode() {
-return hash;
 }
 public static Key normalize(Key key) {
 if (key.normalized) {
 return key;
 }
-String lang = LocaleUtils.toLowerString(key.lang.get()).intern();
+// Only normalized keys may be softly referencing the data holder
-String scrt = LocaleUtils.toTitleString(key.scrt.get()).intern();
+assert (key.holder != null && key.holderRef == null);
-String regn = LocaleUtils.toUpperString(key.regn.get()).intern();
+BaseLocale locale = key.holder;
-String vart = key.vart.get().intern(); // preserve upper/lower cases
+return new Key(locale.getLanguage(), locale.getScript(),
+locale.getRegion(), locale.getVariant(), true);
-return new Key(lang, scrt, regn, vart, true);
 }
 }
 private static class Cache extends LocaleObjectCache<Key, BaseLocale> {
 public Cache() {
 }
 @Override
 protected Key normalizeKey(Key key) {
-assert key.lang.get() != null &&
-key.scrt.get() != null &&
-key.regn.get() != null &&
-key.vart.get() != null;
 return Key.normalize(key);
 }
 @Override
 protected BaseLocale createObject(Key key) {
-return new BaseLocale(key.lang.get(), key.scrt.get(),
+return Key.normalize(key).getBaseLocale();
-key.regn.get(), key.vart.get());
 }
 }
 }

changeset 48763	3d17a524da95
parent 47216	71c04702a3d5
child 54412	41356f083e93