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

equal deleted inserted replaced

-:d331b7996fc3
+:75c0420badef
 /*
-* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2010, 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.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 public final class InternalLocaleBuilder {
-private String _language = "";
+private static final CaseInsensitiveChar PRIVATEUSE_KEY
-private String _script = "";
+= new CaseInsensitiveChar(LanguageTag.PRIVATEUSE);
-private String _region = "";
-private String _variant = "";
+private String language = "";
+private String script = "";
-private static final CaseInsensitiveChar PRIVUSE_KEY = new CaseInsensitiveChar(LanguageTag.PRIVATEUSE.charAt(0));
+private String region = "";
+private String variant = "";
-private HashMap<CaseInsensitiveChar, String> _extensions;
-private HashSet<CaseInsensitiveString> _uattributes;
+private Map<CaseInsensitiveChar, String> extensions;
-private HashMap<CaseInsensitiveString, String> _ukeywords;
+private Set<CaseInsensitiveString> uattributes;
+private Map<CaseInsensitiveString, String> ukeywords;
 public InternalLocaleBuilder() {
 }
 public InternalLocaleBuilder setLanguage(String language) throws LocaleSyntaxException {
-if (language == null || language.length() == 0) {
+if (LocaleUtils.isEmpty(language)) {
-_language = "";
+this.language = "";
 } else {
 if (!LanguageTag.isLanguage(language)) {
 throw new LocaleSyntaxException("Ill-formed language: " + language, 0);
 }
-_language = language;
+this.language = language;
 }
 return this;
 }
 public InternalLocaleBuilder setScript(String script) throws LocaleSyntaxException {
-if (script == null || script.length() == 0) {
+if (LocaleUtils.isEmpty(script)) {
-_script = "";
+this.script = "";
 } else {
 if (!LanguageTag.isScript(script)) {
 throw new LocaleSyntaxException("Ill-formed script: " + script, 0);
 }
-_script = script;
+this.script = script;
 }
 return this;
 }
 public InternalLocaleBuilder setRegion(String region) throws LocaleSyntaxException {
-if (region == null || region.length() == 0) {
+if (LocaleUtils.isEmpty(region)) {
-_region = "";
+this.region = "";
 } else {
 if (!LanguageTag.isRegion(region)) {
 throw new LocaleSyntaxException("Ill-formed region: " + region, 0);
 }
-_region = region;
+this.region = region;
 }
 return this;
 }
 public InternalLocaleBuilder setVariant(String variant) throws LocaleSyntaxException {
-if (variant == null || variant.length() == 0) {
+if (LocaleUtils.isEmpty(variant)) {
-_variant = "";
+this.variant = "";
 } else {
 // normalize separators to "_"
 String var = variant.replaceAll(LanguageTag.SEP, BaseLocale.SEP);
 int errIdx = checkVariants(var, BaseLocale.SEP);
 if (errIdx != -1) {
 throw new LocaleSyntaxException("Ill-formed variant: " + variant, errIdx);
 }
-_variant = var;
+this.variant = var;
 }
 return this;
 }
 public InternalLocaleBuilder addUnicodeLocaleAttribute(String attribute) throws LocaleSyntaxException {
 if (!UnicodeLocaleExtension.isAttribute(attribute)) {
 throw new LocaleSyntaxException("Ill-formed Unicode locale attribute: " + attribute);
 }
 // Use case insensitive string to prevent duplication
-if (_uattributes == null) {
+if (uattributes == null) {
-_uattributes = new HashSet<CaseInsensitiveString>(4);
+uattributes = new HashSet<>(4);
 }
-_uattributes.add(new CaseInsensitiveString(attribute));
+uattributes.add(new CaseInsensitiveString(attribute));
 return this;
 }
 public InternalLocaleBuilder removeUnicodeLocaleAttribute(String attribute) throws LocaleSyntaxException {
 if (attribute == null || !UnicodeLocaleExtension.isAttribute(attribute)) {
 throw new LocaleSyntaxException("Ill-formed Unicode locale attribute: " + attribute);
 }
-if (_uattributes != null) {
+if (uattributes != null) {
-_uattributes.remove(new CaseInsensitiveString(attribute));
+uattributes.remove(new CaseInsensitiveString(attribute));
 }
 return this;
 }
 public InternalLocaleBuilder setUnicodeLocaleKeyword(String key, String type) throws LocaleSyntaxException {
 throw new LocaleSyntaxException("Ill-formed Unicode locale keyword key: " + key);
 }
 CaseInsensitiveString cikey = new CaseInsensitiveString(key);
 if (type == null) {
-if (_ukeywords != null) {
+if (ukeywords != null) {
 // null type is used for remove the key
-_ukeywords.remove(cikey);
+ukeywords.remove(cikey);
 }
 } else {
 if (type.length() != 0) {
 // normalize separator to "-"
 String tp = type.replaceAll(BaseLocale.SEP, LanguageTag.SEP);
 // validate
 StringTokenIterator itr = new StringTokenIterator(tp, LanguageTag.SEP);
 while (!itr.isDone()) {
 String s = itr.current();
 if (!UnicodeLocaleExtension.isTypeSubtag(s)) {
-throw new LocaleSyntaxException("Ill-formed Unicode locale keyword type: " + type, itr.currentStart());
+throw new LocaleSyntaxException("Ill-formed Unicode locale keyword type: "
++ type,
+itr.currentStart());
 }
 itr.next();
 }
 }
-if (_ukeywords == null) {
+if (ukeywords == null) {
-_ukeywords = new HashMap<CaseInsensitiveString, String>(4);
+ukeywords = new HashMap<>(4);
 }
-_ukeywords.put(cikey, type);
+ukeywords.put(cikey, type);
 }
 return this;
 }
 public InternalLocaleBuilder setExtension(char singleton, String value) throws LocaleSyntaxException {
 boolean isBcpPrivateuse = LanguageTag.isPrivateusePrefixChar(singleton);
 if (!isBcpPrivateuse && !LanguageTag.isExtensionSingletonChar(singleton)) {
 throw new LocaleSyntaxException("Ill-formed extension key: " + singleton);
 }
-boolean remove = (value == null || value.length() == 0);
+boolean remove = LocaleUtils.isEmpty(value);
 CaseInsensitiveChar key = new CaseInsensitiveChar(singleton);
 if (remove) {
 if (UnicodeLocaleExtension.isSingletonChar(key.value())) {
 // clear entire Unicode locale extension
-if (_uattributes != null) {
+if (uattributes != null) {
-_uattributes.clear();
+uattributes.clear();
 }
-if (_ukeywords != null) {
+if (ukeywords != null) {
-_ukeywords.clear();
+ukeywords.clear();
 }
 } else {
-if (_extensions != null && _extensions.containsKey(key)) {
+if (extensions != null && extensions.containsKey(key)) {
-_extensions.remove(key);
+extensions.remove(key);
 }
 }
 } else {
 // validate value
 String val = value.replaceAll(BaseLocale.SEP, LanguageTag.SEP);
 validSubtag = LanguageTag.isPrivateuseSubtag(s);
 } else {
 validSubtag = LanguageTag.isExtensionSubtag(s);
 }
 if (!validSubtag) {
-throw new LocaleSyntaxException("Ill-formed extension value: " + s, itr.currentStart());
+throw new LocaleSyntaxException("Ill-formed extension value: " + s,
+itr.currentStart());
 }
 itr.next();
 }
 if (UnicodeLocaleExtension.isSingletonChar(key.value())) {
 setUnicodeLocaleExtension(val);
 } else {
-if (_extensions == null) {
+if (extensions == null) {
-_extensions = new HashMap<CaseInsensitiveChar, String>(4);
+extensions = new HashMap<>(4);
 }
-_extensions.put(key, val);
+extensions.put(key, val);
 }
 }
 return this;
 }
 /*
 * Set extension/private subtags in a single string representation
 */
 public InternalLocaleBuilder setExtensions(String subtags) throws LocaleSyntaxException {
-if (subtags == null || subtags.length() == 0) {
+if (LocaleUtils.isEmpty(subtags)) {
 clearExtensions();
 return this;
 }
 subtags = subtags.replaceAll(BaseLocale.SEP, LanguageTag.SEP);
 StringTokenIterator itr = new StringTokenIterator(subtags, LanguageTag.SEP);
 }
 itr.next();
 }
 if (parsed < start) {
-throw new LocaleSyntaxException("Incomplete extension '" + singleton + "'", start);
+throw new LocaleSyntaxException("Incomplete extension '" + singleton + "'",
+start);
 }
 if (extensions == null) {
-extensions = new ArrayList<String>(4);
+extensions = new ArrayList<>(4);
 }
 extensions.add(sb.toString());
 } else {
 break;
 }
 parsed = itr.currentEnd();
 itr.next();
 }
 if (parsed <= start) {
-throw new LocaleSyntaxException("Incomplete privateuse:" + subtags.substring(start), start);
+throw new LocaleSyntaxException("Incomplete privateuse:"
++ subtags.substring(start),
+start);
 } else {
 privateuse = sb.toString();
 }
 }
 }
 if (!itr.isDone()) {
-throw new LocaleSyntaxException("Ill-formed extension subtags:" + subtags.substring(itr.currentStart()), itr.currentStart());
+throw new LocaleSyntaxException("Ill-formed extension subtags:"
++ subtags.substring(itr.currentStart()),
+itr.currentStart());
 }
 return setExtensions(extensions, privateuse);
 }
 * BCP47 extensions are already validated and well-formed, but may contain duplicates
 */
 private InternalLocaleBuilder setExtensions(List<String> bcpExtensions, String privateuse) {
 clearExtensions();
-if (bcpExtensions != null && bcpExtensions.size() > 0) {
+if (!LocaleUtils.isEmpty(bcpExtensions)) {
-HashSet<CaseInsensitiveChar> processedExntensions = new HashSet<CaseInsensitiveChar>(bcpExtensions.size());
+Set<CaseInsensitiveChar> done = new HashSet<>(bcpExtensions.size());
 for (String bcpExt : bcpExtensions) {
-CaseInsensitiveChar key = new CaseInsensitiveChar(bcpExt.charAt(0));
+CaseInsensitiveChar key = new CaseInsensitiveChar(bcpExt);
 // ignore duplicates
-if (!processedExntensions.contains(key)) {
+if (!done.contains(key)) {
 // each extension string contains singleton, e.g. "a-abc-def"
 if (UnicodeLocaleExtension.isSingletonChar(key.value())) {
 setUnicodeLocaleExtension(bcpExt.substring(2));
 } else {
-if (_extensions == null) {
+if (extensions == null) {
-_extensions = new HashMap<CaseInsensitiveChar, String>(4);
+extensions = new HashMap<>(4);
 }
-_extensions.put(key, bcpExt.substring(2));
+extensions.put(key, bcpExt.substring(2));
 }
 }
+done.add(key);
 }
 }
 if (privateuse != null && privateuse.length() > 0) {
 // privateuse string contains prefix, e.g. "x-abc-def"
-if (_extensions == null) {
+if (extensions == null) {
-_extensions = new HashMap<CaseInsensitiveChar, String>(1);
+extensions = new HashMap<>(1);
 }
-_extensions.put(new CaseInsensitiveChar(privateuse.charAt(0)), privateuse.substring(2));
+extensions.put(new CaseInsensitiveChar(privateuse), privateuse.substring(2));
 }
 return this;
 }
 /*
 * Reset Builder's internal state with the given language tag
 */
 public InternalLocaleBuilder setLanguageTag(LanguageTag langtag) {
 clear();
-if (langtag.getExtlangs().size() > 0) {
+if (!langtag.getExtlangs().isEmpty()) {
-_language = langtag.getExtlangs().get(0);
+language = langtag.getExtlangs().get(0);
 } else {
-String language = langtag.getLanguage();
+String lang = langtag.getLanguage();
-if (!language.equals(LanguageTag.UNDETERMINED)) {
+if (!lang.equals(LanguageTag.UNDETERMINED)) {
-_language = language;
+language = lang;
 }
 }
-_script = langtag.getScript();
+script = langtag.getScript();
-_region = langtag.getRegion();
+region = langtag.getRegion();
 List<String> bcpVariants = langtag.getVariants();
-if (bcpVariants.size() > 0) {
+if (!bcpVariants.isEmpty()) {
 StringBuilder var = new StringBuilder(bcpVariants.get(0));
-for (int i = 1; i < bcpVariants.size(); i++) {
+int size = bcpVariants.size();
+for (int i = 1; i < size; i++) {
 var.append(BaseLocale.SEP).append(bcpVariants.get(i));
 }
-_variant = var.toString();
+variant = var.toString();
 }
 setExtensions(langtag.getExtensions(), langtag.getPrivateuse());
 return this;
 }
-public InternalLocaleBuilder setLocale(BaseLocale base, LocaleExtensions extensions) throws LocaleSyntaxException {
+public InternalLocaleBuilder setLocale(BaseLocale base, LocaleExtensions localeExtensions) throws LocaleSyntaxException {
 String language = base.getLanguage();
 String script = base.getScript();
 String region = base.getRegion();
 String variant = base.getVariant();
 // Exception 1 - ja_JP_JP
 if (language.equals("ja") && region.equals("JP") && variant.equals("JP")) {
 // When locale ja_JP_JP is created, ca-japanese is always there.
 // The builder ignores the variant "JP"
-assert("japanese".equals(extensions.getUnicodeLocaleType("ca")));
+assert("japanese".equals(localeExtensions.getUnicodeLocaleType("ca")));
 variant = "";
 }
 // Exception 2 - th_TH_TH
 else if (language.equals("th") && region.equals("TH") && variant.equals("TH")) {
 // When locale th_TH_TH is created, nu-thai is always there.
 // The builder ignores the variant "TH"
-assert("thai".equals(extensions.getUnicodeLocaleType("nu")));
+assert("thai".equals(localeExtensions.getUnicodeLocaleType("nu")));
 variant = "";
 }
 // Exception 3 - no_NO_NY
 else if (language.equals("no") && region.equals("NO") && variant.equals("NY")) {
 // no_NO_NY is a valid locale and used by Java 6 or older versions.
 }
 }
 // The input locale is validated at this point.
 // Now, updating builder's internal fields.
-_language = language;
+this.language = language;
-_script = script;
+this.script = script;
-_region = region;
+this.region = region;
-_variant = variant;
+this.variant = variant;
 clearExtensions();
-Set<Character> extKeys = (extensions == null) ? null : extensions.getKeys();
+Set<Character> extKeys = (localeExtensions == null) ? null : localeExtensions.getKeys();
 if (extKeys != null) {
-// map extensions back to builder's internal format
+// map localeExtensions back to builder's internal format
 for (Character key : extKeys) {
-Extension e = extensions.getExtension(key);
+Extension e = localeExtensions.getExtension(key);
 if (e instanceof UnicodeLocaleExtension) {
 UnicodeLocaleExtension ue = (UnicodeLocaleExtension)e;
 for (String uatr : ue.getUnicodeLocaleAttributes()) {
-if (_uattributes == null) {
+if (uattributes == null) {
-_uattributes = new HashSet<CaseInsensitiveString>(4);
+uattributes = new HashSet<>(4);
 }
-_uattributes.add(new CaseInsensitiveString(uatr));
+uattributes.add(new CaseInsensitiveString(uatr));
 }
 for (String ukey : ue.getUnicodeLocaleKeys()) {
-if (_ukeywords == null) {
+if (ukeywords == null) {
-_ukeywords = new HashMap<CaseInsensitiveString, String>(4);
+ukeywords = new HashMap<>(4);
 }
-_ukeywords.put(new CaseInsensitiveString(ukey), ue.getUnicodeLocaleType(ukey));
+ukeywords.put(new CaseInsensitiveString(ukey), ue.getUnicodeLocaleType(ukey));
 }
 } else {
-if (_extensions == null) {
+if (extensions == null) {
-_extensions = new HashMap<CaseInsensitiveChar, String>(4);
+extensions = new HashMap<>(4);
 }
-_extensions.put(new CaseInsensitiveChar(key.charValue()), e.getValue());
+extensions.put(new CaseInsensitiveChar(key), e.getValue());
 }
 }
 }
 return this;
 }
 public InternalLocaleBuilder clear() {
-_language = "";
+language = "";
-_script = "";
+script = "";
-_region = "";
+region = "";
-_variant = "";
+variant = "";
 clearExtensions();
 return this;
 }
 public InternalLocaleBuilder clearExtensions() {
-if (_extensions != null) {
+if (extensions != null) {
-_extensions.clear();
+extensions.clear();
 }
-if (_uattributes != null) {
+if (uattributes != null) {
-_uattributes.clear();
+uattributes.clear();
 }
-if (_ukeywords != null) {
+if (ukeywords != null) {
-_ukeywords.clear();
+ukeywords.clear();
 }
 return this;
 }
 public BaseLocale getBaseLocale() {
-String language = _language;
+String language = this.language;
-String script = _script;
+String script = this.script;
-String region = _region;
+String region = this.region;
-String variant = _variant;
+String variant = this.variant;
 // Special private use subtag sequence identified by "lvariant" will be
 // interpreted as Java variant.
-if (_extensions != null) {
+if (extensions != null) {
-String privuse = _extensions.get(PRIVUSE_KEY);
+String privuse = extensions.get(PRIVATEUSE_KEY);
 if (privuse != null) {
 StringTokenIterator itr = new StringTokenIterator(privuse, LanguageTag.SEP);
 boolean sawPrefix = false;
 int privVarStart = -1;
 while (!itr.isDone()) {
 if (sawPrefix) {
 privVarStart = itr.currentStart();
 break;
 }
-if (AsciiUtil.caseIgnoreMatch(itr.current(), LanguageTag.PRIVUSE_VARIANT_PREFIX)) {
+if (LocaleUtils.caseIgnoreMatch(itr.current(), LanguageTag.PRIVUSE_VARIANT_PREFIX)) {
 sawPrefix = true;
 }
 itr.next();
 }
 if (privVarStart != -1) {
 StringBuilder sb = new StringBuilder(variant);
 if (sb.length() != 0) {
 sb.append(BaseLocale.SEP);
 }
-sb.append(privuse.substring(privVarStart).replaceAll(LanguageTag.SEP, BaseLocale.SEP));
+sb.append(privuse.substring(privVarStart).replaceAll(LanguageTag.SEP,
+BaseLocale.SEP));
 variant = sb.toString();
 }
 }
 }
 return BaseLocale.getInstance(language, script, region, variant);
 }
 public LocaleExtensions getLocaleExtensions() {
-if ((_extensions == null || _extensions.size() == 0)
+if (LocaleUtils.isEmpty(extensions) && LocaleUtils.isEmpty(uattributes)
-&& (_uattributes == null || _uattributes.size() == 0)
+&& LocaleUtils.isEmpty(ukeywords)) {
-&& (_ukeywords == null || _ukeywords.size() == 0)) {
+return null;
-return LocaleExtensions.EMPTY_EXTENSIONS;
+}
-}
+LocaleExtensions lext = new LocaleExtensions(extensions, uattributes, ukeywords);
-return new LocaleExtensions(_extensions, _uattributes, _ukeywords);
+return lext.isEmpty() ? null : lext;
 }
 /*
 * Remove special private use subtag sequence identified by "lvariant"
 * and return the rest. Only used by LocaleExtensions
 // Note: privateuse value "abc-lvariant" is unchanged
 // because no subtags after "lvariant".
 sawPrivuseVar = true;
 break;
 }
-if (AsciiUtil.caseIgnoreMatch(itr.current(), LanguageTag.PRIVUSE_VARIANT_PREFIX)) {
+if (LocaleUtils.caseIgnoreMatch(itr.current(), LanguageTag.PRIVUSE_VARIANT_PREFIX)) {
 prefixStart = itr.currentStart();
 }
 itr.next();
 }
 if (!sawPrivuseVar) {
 * Duplicated attributes/keywords will be ignored.
 * The input must be a valid extension subtags (excluding singleton).
 */
 private void setUnicodeLocaleExtension(String subtags) {
 // wipe out existing attributes/keywords
-if (_uattributes != null) {
+if (uattributes != null) {
-_uattributes.clear();
+uattributes.clear();
 }
-if (_ukeywords != null) {
+if (ukeywords != null) {
-_ukeywords.clear();
+ukeywords.clear();
 }
 StringTokenIterator itr = new StringTokenIterator(subtags, LanguageTag.SEP);
 // parse attributes
 while (!itr.isDone()) {
 if (!UnicodeLocaleExtension.isAttribute(itr.current())) {
 break;
 }
-if (_uattributes == null) {
+if (uattributes == null) {
-_uattributes = new HashSet<CaseInsensitiveString>(4);
+uattributes = new HashSet<>(4);
 }
-_uattributes.add(new CaseInsensitiveString(itr.current()));
+uattributes.add(new CaseInsensitiveString(itr.current()));
 itr.next();
 }
 // parse keywords
 CaseInsensitiveString key = null;
 if (key != null) {
 if (UnicodeLocaleExtension.isKey(itr.current())) {
 // next keyword - emit previous one
 assert(typeStart == -1 || typeEnd != -1);
 type = (typeStart == -1) ? "" : subtags.substring(typeStart, typeEnd);
-if (_ukeywords == null) {
+if (ukeywords == null) {
-_ukeywords = new HashMap<CaseInsensitiveString, String>(4);
+ukeywords = new HashMap<>(4);
 }
-_ukeywords.put(key, type);
+ukeywords.put(key, type);
 // reset keyword info
 CaseInsensitiveString tmpKey = new CaseInsensitiveString(itr.current());
-key = _ukeywords.containsKey(tmpKey) ? null : tmpKey;
+key = ukeywords.containsKey(tmpKey) ? null : tmpKey;
 typeStart = typeEnd = -1;
 } else {
 if (typeStart == -1) {
 typeStart = itr.currentStart();
 }
 }
 } else if (UnicodeLocaleExtension.isKey(itr.current())) {
 // 1. first keyword or
 // 2. next keyword, but previous one was duplicate
 key = new CaseInsensitiveString(itr.current());
-if (_ukeywords != null && _ukeywords.containsKey(key)) {
+if (ukeywords != null && ukeywords.containsKey(key)) {
 // duplicate
 key = null;
 }
 }
 if (!itr.hasNext()) {
 if (key != null) {
 // last keyword
 assert(typeStart == -1 || typeEnd != -1);
 type = (typeStart == -1) ? "" : subtags.substring(typeStart, typeEnd);
-if (_ukeywords == null) {
+if (ukeywords == null) {
-_ukeywords = new HashMap<CaseInsensitiveString, String>(4);
+ukeywords = new HashMap<>(4);
 }
-_ukeywords.put(key, type);
+ukeywords.put(key, type);
 }
 break;
 }
 itr.next();
 }
 }
-static class CaseInsensitiveString {
+static final class CaseInsensitiveString {
-private String _s;
+private final String str, lowerStr;
 CaseInsensitiveString(String s) {
-_s = s;
+str = s;
+lowerStr = LocaleUtils.toLowerString(s);
 }
 public String value() {
-return _s;
+return str;
 }
+@Override
 public int hashCode() {
-return AsciiUtil.toLowerString(_s).hashCode();
+return lowerStr.hashCode();
 }
+@Override
 public boolean equals(Object obj) {
 if (this == obj) {
 return true;
 }
 if (!(obj instanceof CaseInsensitiveString)) {
 return false;
 }
-return AsciiUtil.caseIgnoreMatch(_s, ((CaseInsensitiveString)obj).value());
+return lowerStr.equals(((CaseInsensitiveString)obj).lowerStr);
 }
 }
-static class CaseInsensitiveChar {
+static final class CaseInsensitiveChar {
-private char _c;
+private final char ch, lowerCh;
+/**
+* Constructs a CaseInsensitiveChar with the first char of the
+* given s.
+*/
+private CaseInsensitiveChar(String s) {
+this(s.charAt(0));
+}
 CaseInsensitiveChar(char c) {
-_c = c;
+ch = c;
+lowerCh = LocaleUtils.toLower(ch);
 }
 public char value() {
-return _c;
+return ch;
 }
+@Override
 public int hashCode() {
-return AsciiUtil.toLower(_c);
+return lowerCh;
 }
+@Override
 public boolean equals(Object obj) {
 if (this == obj) {
 return true;
 }
 if (!(obj instanceof CaseInsensitiveChar)) {
 return false;
 }
-return _c ==  AsciiUtil.toLower(((CaseInsensitiveChar)obj).value());
+return lowerCh == ((CaseInsensitiveChar)obj).lowerCh;
 }
 }
 }

changeset 9224	75c0420badef
parent 6501	684810d882b3