Back to index...

	/*
	* 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.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 static final CaseInsensitiveChar PRIVATEUSE_KEY
	= new CaseInsensitiveChar(LanguageTag.PRIVATEUSE);

	private String language = "";
	private String script = "";
	private String region = "";
	private String variant = "";

	private Map<CaseInsensitiveChar, String> extensions;
	private Set<CaseInsensitiveString> uattributes;
	private Map<CaseInsensitiveString, String> ukeywords;


	public InternalLocaleBuilder() {
	}

	public InternalLocaleBuilder setLanguage(String language) throws LocaleSyntaxException {
	if (LocaleUtils.isEmpty(language)) {
	this.language = "";
	} else {
	if (!LanguageTag.isLanguage(language)) {
	throw new LocaleSyntaxException("Ill-formed language: " + language, 0);
	}
	this.language = language;
	}
	return this;
	}

	public InternalLocaleBuilder setScript(String script) throws LocaleSyntaxException {
	if (LocaleUtils.isEmpty(script)) {
	this.script = "";
	} else {
	if (!LanguageTag.isScript(script)) {
	throw new LocaleSyntaxException("Ill-formed script: " + script, 0);
	}
	this.script = script;
	}
	return this;
	}

	public InternalLocaleBuilder setRegion(String region) throws LocaleSyntaxException {
	if (LocaleUtils.isEmpty(region)) {
	this.region = "";
	} else {
	if (!LanguageTag.isRegion(region)) {
	throw new LocaleSyntaxException("Ill-formed region: " + region, 0);
	}
	this.region = region;
	}
	return this;
	}

	public InternalLocaleBuilder setVariant(String variant) throws LocaleSyntaxException {
	if (LocaleUtils.isEmpty(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);
	}
	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) {
	uattributes = new HashSet<>(4);
	}
	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) {
	uattributes.remove(new CaseInsensitiveString(attribute));
	}
	return this;
	}

	public InternalLocaleBuilder setUnicodeLocaleKeyword(String key, String type) throws LocaleSyntaxException {
	if (!UnicodeLocaleExtension.isKey(key)) {
	throw new LocaleSyntaxException("Ill-formed Unicode locale keyword key: " + key);
	}

	CaseInsensitiveString cikey = new CaseInsensitiveString(key);
	if (type == null) {
	if (ukeywords != null) {
	// null type is used for remove the key
	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());
	}
	itr.next();
	}
	}
	if (ukeywords == null) {
	ukeywords = new HashMap<>(4);
	}
	ukeywords.put(cikey, type);
	}
	return this;
	}

	public InternalLocaleBuilder setExtension(char singleton, String value) throws LocaleSyntaxException {
	// validate key
	boolean isBcpPrivateuse = LanguageTag.isPrivateusePrefixChar(singleton);
	if (!isBcpPrivateuse && !LanguageTag.isExtensionSingletonChar(singleton)) {
	throw new LocaleSyntaxException("Ill-formed extension key: " + singleton);
	}

	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) {
	uattributes.clear();
	}
	if (ukeywords != null) {
	ukeywords.clear();
	}
	} else {
	if (extensions != null && extensions.containsKey(key)) {
	extensions.remove(key);
	}
	}
	} else {
	// validate value
	String val = value.replaceAll(BaseLocale.SEP, LanguageTag.SEP);
	StringTokenIterator itr = new StringTokenIterator(val, LanguageTag.SEP);
	while (!itr.isDone()) {
	String s = itr.current();
	boolean validSubtag;
	if (isBcpPrivateuse) {
	validSubtag = LanguageTag.isPrivateuseSubtag(s);
	} else {
	validSubtag = LanguageTag.isExtensionSubtag(s);
	}
	if (!validSubtag) {
	throw new LocaleSyntaxException("Ill-formed extension value: " + s,
	itr.currentStart());
	}
	itr.next();
	}

	if (UnicodeLocaleExtension.isSingletonChar(key.value())) {
	setUnicodeLocaleExtension(val);
	} else {
	if (extensions == null) {
	extensions = new HashMap<>(4);
	}
	extensions.put(key, val);
	}
	}
	return this;
	}

	/*
	* Set extension/private subtags in a single string representation
	*/
	public InternalLocaleBuilder setExtensions(String subtags) throws LocaleSyntaxException {
	if (LocaleUtils.isEmpty(subtags)) {
	clearExtensions();
	return this;
	}
	subtags = subtags.replaceAll(BaseLocale.SEP, LanguageTag.SEP);
	StringTokenIterator itr = new StringTokenIterator(subtags, LanguageTag.SEP);

	List<String> extensions = null;
	String privateuse = null;

	int parsed = 0;
	int start;

	// Make a list of extension subtags
	while (!itr.isDone()) {
	String s = itr.current();
	if (LanguageTag.isExtensionSingleton(s)) {
	start = itr.currentStart();
	String singleton = s;
	StringBuilder sb = new StringBuilder(singleton);

	itr.next();
	while (!itr.isDone()) {
	s = itr.current();
	if (LanguageTag.isExtensionSubtag(s)) {
	sb.append(LanguageTag.SEP).append(s);
	parsed = itr.currentEnd();
	} else {
	break;
	}
	itr.next();
	}

	if (parsed < start) {
	throw new LocaleSyntaxException("Incomplete extension '" + singleton + "'",
	start);
	}

	if (extensions == null) {
	extensions = new ArrayList<>(4);
	}
	extensions.add(sb.toString());
	} else {
	break;
	}
	}
	if (!itr.isDone()) {
	String s = itr.current();
	if (LanguageTag.isPrivateusePrefix(s)) {
	start = itr.currentStart();
	StringBuilder sb = new StringBuilder(s);

	itr.next();
	while (!itr.isDone()) {
	s = itr.current();
	if (!LanguageTag.isPrivateuseSubtag(s)) {
	break;
	}
	sb.append(LanguageTag.SEP).append(s);
	parsed = itr.currentEnd();

	itr.next();
	}
	if (parsed <= 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());
	}

	return setExtensions(extensions, privateuse);
	}

	/*
	* Set a list of BCP47 extensions and private use subtags
	* BCP47 extensions are already validated and well-formed, but may contain duplicates
	*/
	private InternalLocaleBuilder setExtensions(List<String> bcpExtensions, String privateuse) {
	clearExtensions();

	if (!LocaleUtils.isEmpty(bcpExtensions)) {
	Set<CaseInsensitiveChar> done = new HashSet<>(bcpExtensions.size());
	for (String bcpExt : bcpExtensions) {
	CaseInsensitiveChar key = new CaseInsensitiveChar(bcpExt);
	// ignore duplicates
	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) {
	extensions = new HashMap<>(4);
	}
	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) {
	extensions = new HashMap<>(1);
	}
	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().isEmpty()) {
	language = langtag.getExtlangs().get(0);
	} else {
	String lang = langtag.getLanguage();
	if (!lang.equals(LanguageTag.UNDETERMINED)) {
	language = lang;
	}
	}
	script = langtag.getScript();
	region = langtag.getRegion();

	List<String> bcpVariants = langtag.getVariants();
	if (!bcpVariants.isEmpty()) {
	StringBuilder var = new StringBuilder(bcpVariants.get(0));
	int size = bcpVariants.size();
	for (int i = 1; i < size; i++) {
	var.append(BaseLocale.SEP).append(bcpVariants.get(i));
	}
	variant = var.toString();
	}

	setExtensions(langtag.getExtensions(), langtag.getPrivateuse());

	return this;
	}

	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();

	// Special backward compatibility support

	// 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(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(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 build ignores the variant "NY" and change the language to "nn".
	language = "nn";
	variant = "";
	}

	// Validate base locale fields before updating internal state.
	// LocaleExtensions always store validated/canonicalized values,
	// so no checks are necessary.
	if (language.length() > 0 && !LanguageTag.isLanguage(language)) {
	throw new LocaleSyntaxException("Ill-formed language: " + language);
	}

	if (script.length() > 0 && !LanguageTag.isScript(script)) {
	throw new LocaleSyntaxException("Ill-formed script: " + script);
	}

	if (region.length() > 0 && !LanguageTag.isRegion(region)) {
	throw new LocaleSyntaxException("Ill-formed region: " + region);
	}

	if (variant.length() > 0) {
	int errIdx = checkVariants(variant, BaseLocale.SEP);
	if (errIdx != -1) {
	throw new LocaleSyntaxException("Ill-formed variant: " + variant, errIdx);
	}
	}

	// The input locale is validated at this point.
	// Now, updating builder's internal fields.
	this.language = language;
	this.script = script;
	this.region = region;
	this.variant = variant;
	clearExtensions();

	Set<Character> extKeys = (localeExtensions == null) ? null : localeExtensions.getKeys();
	if (extKeys != null) {
	// map localeExtensions back to builder's internal format
	for (Character key : extKeys) {
	Extension e = localeExtensions.getExtension(key);
	if (e instanceof UnicodeLocaleExtension) {
	UnicodeLocaleExtension ue = (UnicodeLocaleExtension)e;
	for (String uatr : ue.getUnicodeLocaleAttributes()) {
	if (uattributes == null) {
	uattributes = new HashSet<>(4);
	}
	uattributes.add(new CaseInsensitiveString(uatr));
	}
	for (String ukey : ue.getUnicodeLocaleKeys()) {
	if (ukeywords == null) {
	ukeywords = new HashMap<>(4);
	}
	ukeywords.put(new CaseInsensitiveString(ukey), ue.getUnicodeLocaleType(ukey));
	}
	} else {
	if (extensions == null) {
	extensions = new HashMap<>(4);
	}
	extensions.put(new CaseInsensitiveChar(key), e.getValue());
	}
	}
	}
	return this;
	}

	public InternalLocaleBuilder clear() {
	language = "";
	script = "";
	region = "";
	variant = "";
	clearExtensions();
	return this;
	}

	public InternalLocaleBuilder clearExtensions() {
	if (extensions != null) {
	extensions.clear();
	}
	if (uattributes != null) {
	uattributes.clear();
	}
	if (ukeywords != null) {
	ukeywords.clear();
	}
	return this;
	}

	public BaseLocale getBaseLocale() {
	String language = this.language;
	String script = this.script;
	String region = this.region;
	String variant = this.variant;

	// Special private use subtag sequence identified by "lvariant" will be
	// interpreted as Java variant.
	if (extensions != null) {
	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 (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));
	variant = sb.toString();
	}
	}
	}

	return BaseLocale.getInstance(language, script, region, variant);
	}

	public LocaleExtensions getLocaleExtensions() {
	if (LocaleUtils.isEmpty(extensions) && LocaleUtils.isEmpty(uattributes)
	&& LocaleUtils.isEmpty(ukeywords)) {
	return null;
	}

	LocaleExtensions lext = 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
	*/
	static String removePrivateuseVariant(String privuseVal) {
	StringTokenIterator itr = new StringTokenIterator(privuseVal, LanguageTag.SEP);

	// Note: privateuse value "abc-lvariant" is unchanged
	// because no subtags after "lvariant".

	int prefixStart = -1;
	boolean sawPrivuseVar = false;
	while (!itr.isDone()) {
	if (prefixStart != -1) {
	// Note: privateuse value "abc-lvariant" is unchanged
	// because no subtags after "lvariant".
	sawPrivuseVar = true;
	break;
	}
	if (LocaleUtils.caseIgnoreMatch(itr.current(), LanguageTag.PRIVUSE_VARIANT_PREFIX)) {
	prefixStart = itr.currentStart();
	}
	itr.next();
	}
	if (!sawPrivuseVar) {
	return privuseVal;
	}

	assert(prefixStart == 0 \|\| prefixStart > 1);
	return (prefixStart == 0) ? null : privuseVal.substring(0, prefixStart -1);
	}

	/*
	* Check if the given variant subtags separated by the given
	* separator(s) are valid
	*/
	private int checkVariants(String variants, String sep) {
	StringTokenIterator itr = new StringTokenIterator(variants, sep);
	while (!itr.isDone()) {
	String s = itr.current();
	if (!LanguageTag.isVariant(s)) {
	return itr.currentStart();
	}
	itr.next();
	}
	return -1;
	}

	/*
	* Private methods parsing Unicode Locale Extension subtags.
	* 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) {
	uattributes.clear();
	}
	if (ukeywords != null) {
	ukeywords.clear();
	}

	StringTokenIterator itr = new StringTokenIterator(subtags, LanguageTag.SEP);

	// parse attributes
	while (!itr.isDone()) {
	if (!UnicodeLocaleExtension.isAttribute(itr.current())) {
	break;
	}
	if (uattributes == null) {
	uattributes = new HashSet<>(4);
	}
	uattributes.add(new CaseInsensitiveString(itr.current()));
	itr.next();
	}

	// parse keywords
	CaseInsensitiveString key = null;
	String type;
	int typeStart = -1;
	int typeEnd = -1;
	while (!itr.isDone()) {
	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) {
	ukeywords = new HashMap<>(4);
	}
	ukeywords.put(key, type);

	// reset keyword info
	CaseInsensitiveString tmpKey = new CaseInsensitiveString(itr.current());
	key = ukeywords.containsKey(tmpKey) ? null : tmpKey;
	typeStart = typeEnd = -1;
	} else {
	if (typeStart == -1) {
	typeStart = itr.currentStart();
	}
	typeEnd = itr.currentEnd();
	}
	} 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)) {
	// 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) {
	ukeywords = new HashMap<>(4);
	}
	ukeywords.put(key, type);
	}
	break;
	}

	itr.next();
	}
	}

	static final class CaseInsensitiveString {
	private final String str, lowerStr;

	CaseInsensitiveString(String s) {
	str = s;
	lowerStr = LocaleUtils.toLowerString(s);
	}

	public String value() {
	return str;
	}

	@Override
	public int hashCode() {
	return lowerStr.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
	if (this == obj) {
	return true;
	}
	if (!(obj instanceof CaseInsensitiveString)) {
	return false;
	}
	return lowerStr.equals(((CaseInsensitiveString)obj).lowerStr);
	}
	}

	static final class CaseInsensitiveChar {
	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) {
	ch = c;
	lowerCh = LocaleUtils.toLower(ch);
	}

	public char value() {
	return ch;
	}

	@Override
	public int hashCode() {
	return lowerCh;
	}

	@Override
	public boolean equals(Object obj) {
	if (this == obj) {
	return true;
	}
	if (!(obj instanceof CaseInsensitiveChar)) {
	return false;
	}
	return lowerCh == ((CaseInsensitiveChar)obj).lowerCh;
	}
	}
	}

Back to index...