Back to index...

	/*
	* Copyright (c) 2003, 2013, 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 java.lang;

	import java.text.BreakIterator;
	import java.util.HashSet;
	import java.util.Hashtable;
	import java.util.Iterator;
	import java.util.Locale;
	import sun.text.Normalizer;


	/**
	* This is a utility class for <code>String.toLowerCase()</code> and
	* <code>String.toUpperCase()</code>, that handles special casing with
	* conditions. In other words, it handles the mappings with conditions
	* that are defined in
	* <a href="http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt">Special
	* Casing Properties</a> file.
	* <p>
	* Note that the unconditional case mappings (including 1:M mappings)
	* are handled in <code>Character.toLower/UpperCase()</code>.
	*/
	final class ConditionalSpecialCasing {

	// context conditions.
	static final int FINAL_CASED = 1;
	static final int AFTER_SOFT_DOTTED = 2;
	static final int MORE_ABOVE = 3;
	static final int AFTER_I = 4;
	static final int NOT_BEFORE_DOT = 5;

	// combining class definitions
	static final int COMBINING_CLASS_ABOVE = 230;

	// Special case mapping entries
	static Entry[] entry = {
	//# ================================================================================
	//# Conditional mappings
	//# ================================================================================
	new Entry(0x03A3, new char[]{0x03C2}, new char[]{0x03A3}, null, FINAL_CASED), // # GREEK CAPITAL LETTER SIGMA
	new Entry(0x0130, new char[]{0x0069, 0x0307}, new char[]{0x0130}, null, 0), // # LATIN CAPITAL LETTER I WITH DOT ABOVE

	//# ================================================================================
	//# Locale-sensitive mappings
	//# ================================================================================
	//# Lithuanian
	new Entry(0x0307, new char[]{0x0307}, new char[]{}, "lt", AFTER_SOFT_DOTTED), // # COMBINING DOT ABOVE
	new Entry(0x0049, new char[]{0x0069, 0x0307}, new char[]{0x0049}, "lt", MORE_ABOVE), // # LATIN CAPITAL LETTER I
	new Entry(0x004A, new char[]{0x006A, 0x0307}, new char[]{0x004A}, "lt", MORE_ABOVE), // # LATIN CAPITAL LETTER J
	new Entry(0x012E, new char[]{0x012F, 0x0307}, new char[]{0x012E}, "lt", MORE_ABOVE), // # LATIN CAPITAL LETTER I WITH OGONEK
	new Entry(0x00CC, new char[]{0x0069, 0x0307, 0x0300}, new char[]{0x00CC}, "lt", 0), // # LATIN CAPITAL LETTER I WITH GRAVE
	new Entry(0x00CD, new char[]{0x0069, 0x0307, 0x0301}, new char[]{0x00CD}, "lt", 0), // # LATIN CAPITAL LETTER I WITH ACUTE
	new Entry(0x0128, new char[]{0x0069, 0x0307, 0x0303}, new char[]{0x0128}, "lt", 0), // # LATIN CAPITAL LETTER I WITH TILDE

	//# ================================================================================
	//# Turkish and Azeri
	new Entry(0x0130, new char[]{0x0069}, new char[]{0x0130}, "tr", 0), // # LATIN CAPITAL LETTER I WITH DOT ABOVE
	new Entry(0x0130, new char[]{0x0069}, new char[]{0x0130}, "az", 0), // # LATIN CAPITAL LETTER I WITH DOT ABOVE
	new Entry(0x0307, new char[]{}, new char[]{0x0307}, "tr", AFTER_I), // # COMBINING DOT ABOVE
	new Entry(0x0307, new char[]{}, new char[]{0x0307}, "az", AFTER_I), // # COMBINING DOT ABOVE
	new Entry(0x0049, new char[]{0x0131}, new char[]{0x0049}, "tr", NOT_BEFORE_DOT), // # LATIN CAPITAL LETTER I
	new Entry(0x0049, new char[]{0x0131}, new char[]{0x0049}, "az", NOT_BEFORE_DOT), // # LATIN CAPITAL LETTER I
	new Entry(0x0069, new char[]{0x0069}, new char[]{0x0130}, "tr", 0), // # LATIN SMALL LETTER I
	new Entry(0x0069, new char[]{0x0069}, new char[]{0x0130}, "az", 0) // # LATIN SMALL LETTER I
	};

	// A hash table that contains the above entries
	static Hashtable<Integer, HashSet<Entry>> entryTable = new Hashtable<>();
	static {
	// create hashtable from the entry
	for (Entry cur : entry) {
	Integer cp = cur.getCodePoint();
	HashSet<Entry> set = entryTable.get(cp);
	if (set == null) {
	set = new HashSet<>();
	entryTable.put(cp, set);
	}
	set.add(cur);
	}
	}

	static int toLowerCaseEx(String src, int index, Locale locale) {
	char[] result = lookUpTable(src, index, locale, true);

	if (result != null) {
	if (result.length == 1) {
	return result[0];
	} else {
	return Character.ERROR;
	}
	} else {
	// default to Character class' one
	return Character.toLowerCase(src.codePointAt(index));
	}
	}

	static int toUpperCaseEx(String src, int index, Locale locale) {
	char[] result = lookUpTable(src, index, locale, false);

	if (result != null) {
	if (result.length == 1) {
	return result[0];
	} else {
	return Character.ERROR;
	}
	} else {
	// default to Character class' one
	return Character.toUpperCaseEx(src.codePointAt(index));
	}
	}

	static char[] toLowerCaseCharArray(String src, int index, Locale locale) {
	return lookUpTable(src, index, locale, true);
	}

	static char[] toUpperCaseCharArray(String src, int index, Locale locale) {
	char[] result = lookUpTable(src, index, locale, false);
	if (result != null) {
	return result;
	} else {
	return Character.toUpperCaseCharArray(src.codePointAt(index));
	}
	}

	private static char[] lookUpTable(String src, int index, Locale locale, boolean bLowerCasing) {
	HashSet<Entry> set = entryTable.get(src.codePointAt(index));
	char[] ret = null;

	if (set != null) {
	Iterator<Entry> iter = set.iterator();
	String currentLang = locale.getLanguage();
	while (iter.hasNext()) {
	Entry entry = iter.next();
	String conditionLang = entry.getLanguage();
	if (((conditionLang == null) \|\| (conditionLang.equals(currentLang))) &&
	isConditionMet(src, index, locale, entry.getCondition())) {
	ret = bLowerCasing ? entry.getLowerCase() : entry.getUpperCase();
	if (conditionLang != null) {
	break;
	}
	}
	}
	}

	return ret;
	}

	private static boolean isConditionMet(String src, int index, Locale locale, int condition) {
	switch (condition) {
	case FINAL_CASED:
	return isFinalCased(src, index, locale);

	case AFTER_SOFT_DOTTED:
	return isAfterSoftDotted(src, index);

	case MORE_ABOVE:
	return isMoreAbove(src, index);

	case AFTER_I:
	return isAfterI(src, index);

	case NOT_BEFORE_DOT:
	return !isBeforeDot(src, index);

	default:
	return true;
	}
	}

	/**
	* Implements the "Final_Cased" condition
	*
	* Specification: Within the closest word boundaries containing C, there is a cased
	* letter before C, and there is no cased letter after C.
	*
	* Regular Expression:
	* Before C: [{cased==true}][{wordBoundary!=true}]*
	* After C: !([{wordBoundary!=true}]*[{cased}])
	*/
	private static boolean isFinalCased(String src, int index, Locale locale) {
	BreakIterator wordBoundary = BreakIterator.getWordInstance(locale);
	wordBoundary.setText(src);
	int ch;

	// Look for a preceding 'cased' letter
	for (int i = index; (i >= 0) && !wordBoundary.isBoundary(i);
	i -= Character.charCount(ch)) {

	ch = src.codePointBefore(i);
	if (isCased(ch)) {

	int len = src.length();
	// Check that there is no 'cased' letter after the index
	for (i = index + Character.charCount(src.codePointAt(index));
	(i < len) && !wordBoundary.isBoundary(i);
	i += Character.charCount(ch)) {

	ch = src.codePointAt(i);
	if (isCased(ch)) {
	return false;
	}
	}

	return true;
	}
	}

	return false;
	}

	/**
	* Implements the "After_I" condition
	*
	* Specification: The last preceding base character was an uppercase I,
	* and there is no intervening combining character class 230 (ABOVE).
	*
	* Regular Expression:
	* Before C: [I]([{cc!=230}&{cc!=0}])*
	*/
	private static boolean isAfterI(String src, int index) {
	int ch;
	int cc;

	// Look for the last preceding base character
	for (int i = index; i > 0; i -= Character.charCount(ch)) {

	ch = src.codePointBefore(i);

	if (ch == 'I') {
	return true;
	} else {
	cc = Normalizer.getCombiningClass(ch);
	if ((cc == 0) \|\| (cc == COMBINING_CLASS_ABOVE)) {
	return false;
	}
	}
	}

	return false;
	}

	/**
	* Implements the "After_Soft_Dotted" condition
	*
	* Specification: The last preceding character with combining class
	* of zero before C was Soft_Dotted, and there is no intervening
	* combining character class 230 (ABOVE).
	*
	* Regular Expression:
	* Before C: [{Soft_Dotted==true}]([{cc!=230}&{cc!=0}])*
	*/
	private static boolean isAfterSoftDotted(String src, int index) {
	int ch;
	int cc;

	// Look for the last preceding character
	for (int i = index; i > 0; i -= Character.charCount(ch)) {

	ch = src.codePointBefore(i);

	if (isSoftDotted(ch)) {
	return true;
	} else {
	cc = Normalizer.getCombiningClass(ch);
	if ((cc == 0) \|\| (cc == COMBINING_CLASS_ABOVE)) {
	return false;
	}
	}
	}

	return false;
	}

	/**
	* Implements the "More_Above" condition
	*
	* Specification: C is followed by one or more characters of combining
	* class 230 (ABOVE) in the combining character sequence.
	*
	* Regular Expression:
	* After C: [{cc!=0}]*[{cc==230}]
	*/
	private static boolean isMoreAbove(String src, int index) {
	int ch;
	int cc;
	int len = src.length();

	// Look for a following ABOVE combining class character
	for (int i = index + Character.charCount(src.codePointAt(index));
	i < len; i += Character.charCount(ch)) {

	ch = src.codePointAt(i);
	cc = Normalizer.getCombiningClass(ch);

	if (cc == COMBINING_CLASS_ABOVE) {
	return true;
	} else if (cc == 0) {
	return false;
	}
	}

	return false;
	}

	/**
	* Implements the "Before_Dot" condition
	*
	* Specification: C is followed by <code>U+0307 COMBINING DOT ABOVE</code>.
	* Any sequence of characters with a combining class that is
	* neither 0 nor 230 may intervene between the current character
	* and the combining dot above.
	*
	* Regular Expression:
	* After C: ([{cc!=230}&{cc!=0}])*[\u0307]
	*/
	private static boolean isBeforeDot(String src, int index) {
	int ch;
	int cc;
	int len = src.length();

	// Look for a following COMBINING DOT ABOVE
	for (int i = index + Character.charCount(src.codePointAt(index));
	i < len; i += Character.charCount(ch)) {

	ch = src.codePointAt(i);

	if (ch == '\u0307') {
	return true;
	} else {
	cc = Normalizer.getCombiningClass(ch);
	if ((cc == 0) \|\| (cc == COMBINING_CLASS_ABOVE)) {
	return false;
	}
	}
	}

	return false;
	}

	/**
	* Examines whether a character is 'cased'.
	*
	* A character C is defined to be 'cased' if and only if at least one of
	* following are true for C: uppercase==true, or lowercase==true, or
	* general_category==titlecase_letter.
	*
	* The uppercase and lowercase property values are specified in the data
	* file DerivedCoreProperties.txt in the Unicode Character Database.
	*/
	private static boolean isCased(int ch) {
	int type = Character.getType(ch);
	if (type == Character.LOWERCASE_LETTER \|\|
	type == Character.UPPERCASE_LETTER \|\|
	type == Character.TITLECASE_LETTER) {
	return true;
	} else {
	// Check for Other_Lowercase and Other_Uppercase
	//
	if ((ch >= 0x02B0) && (ch <= 0x02B8)) {
	// MODIFIER LETTER SMALL H..MODIFIER LETTER SMALL Y
	return true;
	} else if ((ch >= 0x02C0) && (ch <= 0x02C1)) {
	// MODIFIER LETTER GLOTTAL STOP..MODIFIER LETTER REVERSED GLOTTAL STOP
	return true;
	} else if ((ch >= 0x02E0) && (ch <= 0x02E4)) {
	// MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP
	return true;
	} else if (ch == 0x0345) {
	// COMBINING GREEK YPOGEGRAMMENI
	return true;
	} else if (ch == 0x037A) {
	// GREEK YPOGEGRAMMENI
	return true;
	} else if ((ch >= 0x1D2C) && (ch <= 0x1D61)) {
	// MODIFIER LETTER CAPITAL A..MODIFIER LETTER SMALL CHI
	return true;
	} else if ((ch >= 0x2160) && (ch <= 0x217F)) {
	// ROMAN NUMERAL ONE..ROMAN NUMERAL ONE THOUSAND
	// SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL ONE THOUSAND
	return true;
	} else if ((ch >= 0x24B6) && (ch <= 0x24E9)) {
	// CIRCLED LATIN CAPITAL LETTER A..CIRCLED LATIN CAPITAL LETTER Z
	// CIRCLED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z
	return true;
	} else {
	return false;
	}
	}
	}

	private static boolean isSoftDotted(int ch) {
	switch (ch) {
	case 0x0069: // Soft_Dotted # L& LATIN SMALL LETTER I
	case 0x006A: // Soft_Dotted # L& LATIN SMALL LETTER J
	case 0x012F: // Soft_Dotted # L& LATIN SMALL LETTER I WITH OGONEK
	case 0x0268: // Soft_Dotted # L& LATIN SMALL LETTER I WITH STROKE
	case 0x0456: // Soft_Dotted # L& CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
	case 0x0458: // Soft_Dotted # L& CYRILLIC SMALL LETTER JE
	case 0x1D62: // Soft_Dotted # L& LATIN SUBSCRIPT SMALL LETTER I
	case 0x1E2D: // Soft_Dotted # L& LATIN SMALL LETTER I WITH TILDE BELOW
	case 0x1ECB: // Soft_Dotted # L& LATIN SMALL LETTER I WITH DOT BELOW
	case 0x2071: // Soft_Dotted # L& SUPERSCRIPT LATIN SMALL LETTER I
	return true;
	default:
	return false;
	}
	}

	/**
	* An internal class that represents an entry in the Special Casing Properties.
	*/
	static class Entry {
	int ch;
	char [] lower;
	char [] upper;
	String lang;
	int condition;

	Entry(int ch, char[] lower, char[] upper, String lang, int condition) {
	this.ch = ch;
	this.lower = lower;
	this.upper = upper;
	this.lang = lang;
	this.condition = condition;
	}

	int getCodePoint() {
	return ch;
	}

	char[] getLowerCase() {
	return lower;
	}

	char[] getUpperCase() {
	return upper;
	}

	String getLanguage() {
	return lang;
	}

	int getCondition() {
	return condition;
	}
	}
	}

Back to index...