243 lines
8.4 KiB
Java
243 lines
8.4 KiB
Java
/*
|
|
* 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
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 2009-2010, International Business Machines Corporation and *
|
|
* others. All Rights Reserved. *
|
|
*******************************************************************************
|
|
*/
|
|
package sun.util.locale;
|
|
|
|
import java.util.Collections;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Set;
|
|
import java.util.SortedMap;
|
|
import java.util.SortedSet;
|
|
import java.util.TreeMap;
|
|
import java.util.TreeSet;
|
|
|
|
import sun.util.locale.InternalLocaleBuilder.CaseInsensitiveChar;
|
|
import sun.util.locale.InternalLocaleBuilder.CaseInsensitiveString;
|
|
|
|
|
|
public class LocaleExtensions {
|
|
|
|
private final Map<Character, Extension> extensionMap;
|
|
private final String id;
|
|
|
|
public static final LocaleExtensions CALENDAR_JAPANESE
|
|
= new LocaleExtensions("u-ca-japanese",
|
|
UnicodeLocaleExtension.SINGLETON,
|
|
UnicodeLocaleExtension.CA_JAPANESE);
|
|
|
|
public static final LocaleExtensions NUMBER_THAI
|
|
= new LocaleExtensions("u-nu-thai",
|
|
UnicodeLocaleExtension.SINGLETON,
|
|
UnicodeLocaleExtension.NU_THAI);
|
|
|
|
private LocaleExtensions(String id, Character key, Extension value) {
|
|
this.id = id;
|
|
this.extensionMap = Collections.singletonMap(key, value);
|
|
}
|
|
|
|
/*
|
|
* Package private constructor, only used by InternalLocaleBuilder.
|
|
*/
|
|
LocaleExtensions(Map<CaseInsensitiveChar, String> extensions,
|
|
Set<CaseInsensitiveString> uattributes,
|
|
Map<CaseInsensitiveString, String> ukeywords) {
|
|
boolean hasExtension = !LocaleUtils.isEmpty(extensions);
|
|
boolean hasUAttributes = !LocaleUtils.isEmpty(uattributes);
|
|
boolean hasUKeywords = !LocaleUtils.isEmpty(ukeywords);
|
|
|
|
if (!hasExtension && !hasUAttributes && !hasUKeywords) {
|
|
id = "";
|
|
extensionMap = Collections.emptyMap();
|
|
return;
|
|
}
|
|
|
|
// Build extension map
|
|
SortedMap<Character, Extension> map = new TreeMap<>();
|
|
if (hasExtension) {
|
|
for (Entry<CaseInsensitiveChar, String> ext : extensions.entrySet()) {
|
|
char key = LocaleUtils.toLower(ext.getKey().value());
|
|
String value = ext.getValue();
|
|
|
|
if (LanguageTag.isPrivateusePrefixChar(key)) {
|
|
// we need to exclude special variant in privuateuse, e.g. "x-abc-lvariant-DEF"
|
|
value = InternalLocaleBuilder.removePrivateuseVariant(value);
|
|
if (value == null) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
map.put(key, new Extension(key, LocaleUtils.toLowerString(value)));
|
|
}
|
|
}
|
|
|
|
if (hasUAttributes || hasUKeywords) {
|
|
SortedSet<String> uaset = null;
|
|
SortedMap<String, String> ukmap = null;
|
|
|
|
if (hasUAttributes) {
|
|
uaset = new TreeSet<>();
|
|
for (CaseInsensitiveString cis : uattributes) {
|
|
uaset.add(LocaleUtils.toLowerString(cis.value()));
|
|
}
|
|
}
|
|
|
|
if (hasUKeywords) {
|
|
ukmap = new TreeMap<>();
|
|
for (Entry<CaseInsensitiveString, String> kwd : ukeywords.entrySet()) {
|
|
String key = LocaleUtils.toLowerString(kwd.getKey().value());
|
|
String type = LocaleUtils.toLowerString(kwd.getValue());
|
|
ukmap.put(key, type);
|
|
}
|
|
}
|
|
|
|
UnicodeLocaleExtension ule = new UnicodeLocaleExtension(uaset, ukmap);
|
|
map.put(UnicodeLocaleExtension.SINGLETON, ule);
|
|
}
|
|
|
|
if (map.isEmpty()) {
|
|
// this could happen when only privuateuse with special variant
|
|
id = "";
|
|
extensionMap = Collections.emptyMap();
|
|
} else {
|
|
id = toID(map);
|
|
extensionMap = map;
|
|
}
|
|
}
|
|
|
|
public Set<Character> getKeys() {
|
|
if (extensionMap.isEmpty()) {
|
|
return Collections.emptySet();
|
|
}
|
|
return Collections.unmodifiableSet(extensionMap.keySet());
|
|
}
|
|
|
|
public Extension getExtension(Character key) {
|
|
return extensionMap.get(LocaleUtils.toLower(key));
|
|
}
|
|
|
|
public String getExtensionValue(Character key) {
|
|
Extension ext = extensionMap.get(LocaleUtils.toLower(key));
|
|
if (ext == null) {
|
|
return null;
|
|
}
|
|
return ext.getValue();
|
|
}
|
|
|
|
public Set<String> getUnicodeLocaleAttributes() {
|
|
Extension ext = extensionMap.get(UnicodeLocaleExtension.SINGLETON);
|
|
if (ext == null) {
|
|
return Collections.emptySet();
|
|
}
|
|
assert (ext instanceof UnicodeLocaleExtension);
|
|
return ((UnicodeLocaleExtension)ext).getUnicodeLocaleAttributes();
|
|
}
|
|
|
|
public Set<String> getUnicodeLocaleKeys() {
|
|
Extension ext = extensionMap.get(UnicodeLocaleExtension.SINGLETON);
|
|
if (ext == null) {
|
|
return Collections.emptySet();
|
|
}
|
|
assert (ext instanceof UnicodeLocaleExtension);
|
|
return ((UnicodeLocaleExtension)ext).getUnicodeLocaleKeys();
|
|
}
|
|
|
|
public String getUnicodeLocaleType(String unicodeLocaleKey) {
|
|
Extension ext = extensionMap.get(UnicodeLocaleExtension.SINGLETON);
|
|
if (ext == null) {
|
|
return null;
|
|
}
|
|
assert (ext instanceof UnicodeLocaleExtension);
|
|
return ((UnicodeLocaleExtension)ext).getUnicodeLocaleType(LocaleUtils.toLowerString(unicodeLocaleKey));
|
|
}
|
|
|
|
public boolean isEmpty() {
|
|
return extensionMap.isEmpty();
|
|
}
|
|
|
|
public static boolean isValidKey(char c) {
|
|
return LanguageTag.isExtensionSingletonChar(c) || LanguageTag.isPrivateusePrefixChar(c);
|
|
}
|
|
|
|
public static boolean isValidUnicodeLocaleKey(String ukey) {
|
|
return UnicodeLocaleExtension.isKey(ukey);
|
|
}
|
|
|
|
private static String toID(SortedMap<Character, Extension> map) {
|
|
StringBuilder buf = new StringBuilder();
|
|
Extension privuse = null;
|
|
for (Entry<Character, Extension> entry : map.entrySet()) {
|
|
char singleton = entry.getKey();
|
|
Extension extension = entry.getValue();
|
|
if (LanguageTag.isPrivateusePrefixChar(singleton)) {
|
|
privuse = extension;
|
|
} else {
|
|
if (buf.length() > 0) {
|
|
buf.append(LanguageTag.SEP);
|
|
}
|
|
buf.append(extension);
|
|
}
|
|
}
|
|
if (privuse != null) {
|
|
if (buf.length() > 0) {
|
|
buf.append(LanguageTag.SEP);
|
|
}
|
|
buf.append(privuse);
|
|
}
|
|
return buf.toString();
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return id;
|
|
}
|
|
|
|
public String getID() {
|
|
return id;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return id.hashCode();
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object other) {
|
|
if (this == other) {
|
|
return true;
|
|
}
|
|
if (!(other instanceof LocaleExtensions)) {
|
|
return false;
|
|
}
|
|
return id.equals(((LocaleExtensions)other).id);
|
|
}
|
|
}
|