Back to index...

	/*
	* Copyright (c) 2012, 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.
	*/

	package sun.util.locale;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Locale;
	import java.util.Locale.*;
	import static java.util.Locale.FilteringMode.*;
	import static java.util.Locale.LanguageRange.*;
	import java.util.Map;
	import java.util.Set;

	/**
	* Implementation for BCP47 Locale matching
	*
	*/
	public final class LocaleMatcher {

	public static List<Locale> filter(List<LanguageRange> priorityList,
	Collection<Locale> locales,
	FilteringMode mode) {
	if (priorityList.isEmpty() \|\| locales.isEmpty()) {
	return new ArrayList<>(); // need to return a empty mutable List
	}

	// Create a list of language tags to be matched.
	List<String> tags = new ArrayList<>();
	for (Locale locale : locales) {
	tags.add(locale.toLanguageTag());
	}

	// Filter language tags.
	List<String> filteredTags = filterTags(priorityList, tags, mode);

	// Create a list of matching locales.
	List<Locale> filteredLocales = new ArrayList<>(filteredTags.size());
	for (String tag : filteredTags) {
	filteredLocales.add(Locale.forLanguageTag(tag));
	}

	return filteredLocales;
	}

	public static List<String> filterTags(List<LanguageRange> priorityList,
	Collection<String> tags,
	FilteringMode mode) {
	if (priorityList.isEmpty() \|\| tags.isEmpty()) {
	return new ArrayList<>(); // need to return a empty mutable List
	}

	ArrayList<LanguageRange> list;
	if (mode == EXTENDED_FILTERING) {
	return filterExtended(priorityList, tags);
	} else {
	list = new ArrayList<>();
	for (LanguageRange lr : priorityList) {
	String range = lr.getRange();
	if (range.startsWith("*-")
	\|\| range.indexOf("-*") != -1) { // Extended range
	if (mode == AUTOSELECT_FILTERING) {
	return filterExtended(priorityList, tags);
	} else if (mode == MAP_EXTENDED_RANGES) {
	if (range.charAt(0) == '*') {
	range = "*";
	} else {
	range = range.replaceAll("-[*]", "");
	}
	list.add(new LanguageRange(range, lr.getWeight()));
	} else if (mode == REJECT_EXTENDED_RANGES) {
	throw new IllegalArgumentException("An extended range \""
	+ range
	+ "\" found in REJECT_EXTENDED_RANGES mode.");
	}
	} else { // Basic range
	list.add(lr);
	}
	}

	return filterBasic(list, tags);
	}
	}

	private static List<String> filterBasic(List<LanguageRange> priorityList,
	Collection<String> tags) {
	List<String> list = new ArrayList<>();
	for (LanguageRange lr : priorityList) {
	String range = lr.getRange();
	if (range.equals("*")) {
	return new ArrayList<String>(tags);
	} else {
	for (String tag : tags) {
	tag = tag.toLowerCase();
	if (tag.startsWith(range)) {
	int len = range.length();
	if ((tag.length() == len \|\| tag.charAt(len) == '-')
	&& !list.contains(tag)) {
	list.add(tag);
	}
	}
	}
	}
	}

	return list;
	}

	private static List<String> filterExtended(List<LanguageRange> priorityList,
	Collection<String> tags) {
	List<String> list = new ArrayList<>();
	for (LanguageRange lr : priorityList) {
	String range = lr.getRange();
	if (range.equals("*")) {
	return new ArrayList<String>(tags);
	}
	String[] rangeSubtags = range.split("-");
	for (String tag : tags) {
	tag = tag.toLowerCase();
	String[] tagSubtags = tag.split("-");
	if (!rangeSubtags[0].equals(tagSubtags[0])
	&& !rangeSubtags[0].equals("*")) {
	continue;
	}

	int rangeIndex = 1;
	int tagIndex = 1;

	while (rangeIndex < rangeSubtags.length
	&& tagIndex < tagSubtags.length) {
	if (rangeSubtags[rangeIndex].equals("*")) {
	rangeIndex++;
	} else if (rangeSubtags[rangeIndex].equals(tagSubtags[tagIndex])) {
	rangeIndex++;
	tagIndex++;
	} else if (tagSubtags[tagIndex].length() == 1
	&& !tagSubtags[tagIndex].equals("*")) {
	break;
	} else {
	tagIndex++;
	}
	}

	if (rangeSubtags.length == rangeIndex && !list.contains(tag)) {
	list.add(tag);
	}
	}
	}

	return list;
	}

	public static Locale lookup(List<LanguageRange> priorityList,
	Collection<Locale> locales) {
	if (priorityList.isEmpty() \|\| locales.isEmpty()) {
	return null;
	}

	// Create a list of language tags to be matched.
	List<String> tags = new ArrayList<>();
	for (Locale locale : locales) {
	tags.add(locale.toLanguageTag());
	}

	// Look up a language tags.
	String lookedUpTag = lookupTag(priorityList, tags);

	if (lookedUpTag == null) {
	return null;
	} else {
	return Locale.forLanguageTag(lookedUpTag);
	}
	}

	public static String lookupTag(List<LanguageRange> priorityList,
	Collection<String> tags) {
	if (priorityList.isEmpty() \|\| tags.isEmpty()) {
	return null;
	}

	for (LanguageRange lr : priorityList) {
	String range = lr.getRange();

	// Special language range ("*") is ignored in lookup.
	if (range.equals("*")) {
	continue;
	}

	String rangeForRegex = range.replaceAll("\\x2A", "\\\\p{Alnum}*");
	while (rangeForRegex.length() > 0) {
	for (String tag : tags) {
	tag = tag.toLowerCase();
	if (tag.matches(rangeForRegex)) {
	return tag;
	}
	}

	// Truncate from the end....
	int index = rangeForRegex.lastIndexOf('-');
	if (index >= 0) {
	rangeForRegex = rangeForRegex.substring(0, index);

	// if range ends with an extension key, truncate it.
	if (rangeForRegex.lastIndexOf('-') == rangeForRegex.length()-2) {
	rangeForRegex =
	rangeForRegex.substring(0, rangeForRegex.length()-2);
	}
	} else {
	rangeForRegex = "";
	}
	}
	}

	return null;
	}

	public static List<LanguageRange> parse(String ranges) {
	ranges = ranges.replaceAll(" ", "").toLowerCase();
	if (ranges.startsWith("accept-language:")) {
	ranges = ranges.substring(16); // delete unnecessary prefix
	}

	String[] langRanges = ranges.split(",");
	List<LanguageRange> list = new ArrayList<>(langRanges.length);
	List<String> tempList = new ArrayList<>();
	int numOfRanges = 0;

	for (String range : langRanges) {
	int index;
	String r;
	double w;

	if ((index = range.indexOf(";q=")) == -1) {
	r = range;
	w = MAX_WEIGHT;
	} else {
	r = range.substring(0, index);
	index += 3;
	try {
	w = Double.parseDouble(range.substring(index));
	}
	catch (Exception e) {
	throw new IllegalArgumentException("weight=\""
	+ range.substring(index)
	+ "\" for language range \"" + r + "\"");
	}

	if (w < MIN_WEIGHT \|\| w > MAX_WEIGHT) {
	throw new IllegalArgumentException("weight=" + w
	+ " for language range \"" + r
	+ "\". It must be between " + MIN_WEIGHT
	+ " and " + MAX_WEIGHT + ".");
	}
	}

	if (!tempList.contains(r)) {
	LanguageRange lr = new LanguageRange(r, w);
	index = numOfRanges;
	for (int j = 0; j < numOfRanges; j++) {
	if (list.get(j).getWeight() < w) {
	index = j;
	break;
	}
	}
	list.add(index, lr);
	numOfRanges++;
	tempList.add(r);

	// Check if the range has an equivalent using IANA LSR data.
	// If yes, add it to the User's Language Priority List as well.

	// aa-XX -> aa-YY
	String equivalent;
	if ((equivalent = getEquivalentForRegionAndVariant(r)) != null
	&& !tempList.contains(equivalent)) {
	list.add(index+1, new LanguageRange(equivalent, w));
	numOfRanges++;
	tempList.add(equivalent);
	}

	String[] equivalents;
	if ((equivalents = getEquivalentsForLanguage(r)) != null) {
	for (String equiv: equivalents) {
	// aa-XX -> bb-XX(, cc-XX)
	if (!tempList.contains(equiv)) {
	list.add(index+1, new LanguageRange(equiv, w));
	numOfRanges++;
	tempList.add(equiv);
	}

	// bb-XX -> bb-YY(, cc-YY)
	equivalent = getEquivalentForRegionAndVariant(equiv);
	if (equivalent != null
	&& !tempList.contains(equivalent)) {
	list.add(index+1, new LanguageRange(equivalent, w));
	numOfRanges++;
	tempList.add(equivalent);
	}
	}
	}
	}
	}

	return list;
	}

	private static String[] getEquivalentsForLanguage(String range) {
	String r = range;

	while (r.length() > 0) {
	if (LocaleEquivalentMaps.singleEquivMap.containsKey(r)) {
	String equiv = LocaleEquivalentMaps.singleEquivMap.get(r);
	// Return immediately for performance if the first matching
	// subtag is found.
	return new String[] {range.replaceFirst(r, equiv)};
	} else if (LocaleEquivalentMaps.multiEquivsMap.containsKey(r)) {
	String[] equivs = LocaleEquivalentMaps.multiEquivsMap.get(r);
	for (int i = 0; i < equivs.length; i++) {
	equivs[i] = range.replaceFirst(r, equivs[i]);
	}
	return equivs;
	}

	// Truncate the last subtag simply.
	int index = r.lastIndexOf('-');
	if (index == -1) {
	break;
	}
	r = r.substring(0, index);
	}

	return null;
	}

	private static String getEquivalentForRegionAndVariant(String range) {
	int extensionKeyIndex = getExtentionKeyIndex(range);

	for (String subtag : LocaleEquivalentMaps.regionVariantEquivMap.keySet()) {
	int index;
	if ((index = range.indexOf(subtag)) != -1) {
	// Check if the matching text is a valid region or variant.
	if (extensionKeyIndex != Integer.MIN_VALUE
	&& index > extensionKeyIndex) {
	continue;
	}

	int len = index + subtag.length();
	if (range.length() == len \|\| range.charAt(len) == '-') {
	return range.replaceFirst(subtag, LocaleEquivalentMaps.regionVariantEquivMap.get(subtag));
	}
	}
	}

	return null;
	}

	private static int getExtentionKeyIndex(String s) {
	char[] c = s.toCharArray();
	int index = Integer.MIN_VALUE;
	for (int i = 1; i < c.length; i++) {
	if (c[i] == '-') {
	if (i - index == 2) {
	return index;
	} else {
	index = i;
	}
	}
	}
	return Integer.MIN_VALUE;
	}

	public static List<LanguageRange> mapEquivalents(
	List<LanguageRange>priorityList,
	Map<String, List<String>> map) {
	if (priorityList.isEmpty()) {
	return new ArrayList<>(); // need to return a empty mutable List
	}
	if (map == null \|\| map.isEmpty()) {
	return new ArrayList<LanguageRange>(priorityList);
	}

	// Create a map, key=originalKey.toLowerCaes(), value=originalKey
	Map<String, String> keyMap = new HashMap<>();
	for (String key : map.keySet()) {
	keyMap.put(key.toLowerCase(), key);
	}

	List<LanguageRange> list = new ArrayList<>();
	for (LanguageRange lr : priorityList) {
	String range = lr.getRange();
	String r = range;
	boolean hasEquivalent = false;

	while (r.length() > 0) {
	if (keyMap.containsKey(r)) {
	hasEquivalent = true;
	List<String> equivalents = map.get(keyMap.get(r));
	if (equivalents != null) {
	int len = r.length();
	for (String equivalent : equivalents) {
	list.add(new LanguageRange(equivalent.toLowerCase()
	+ range.substring(len),
	lr.getWeight()));
	}
	}
	// Return immediately if the first matching subtag is found.
	break;
	}

	// Truncate the last subtag simply.
	int index = r.lastIndexOf('-');
	if (index == -1) {
	break;
	}
	r = r.substring(0, index);
	}

	if (!hasEquivalent) {
	list.add(lr);
	}
	}

	return list;
	}

	private LocaleMatcher() {}

	}

Back to index...