下面列出了java.lang.Character#isSupplementaryCodePoint ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Get the next collation element in the string. <p>This iterator iterates
* over a sequence of collation elements that were built from the string.
* Because there isn't necessarily a one-to-one mapping from characters to
* collation elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the next character in the
* string".</p>
* <p>This function returns the collation element that the iterator is currently
* pointing to and then updates the internal pointer to point to the next element.
* previous() updates the pointer first and then returns the element. This
* means that when you change direction while iterating (i.e., call next() and
* then call previous(), or call previous() and then call next()), you'll get
* back the same element twice.</p>
*
* @return the next collation element
*/
public int next()
{
if (text == null) {
return NULLORDER;
}
NormalizerBase.Mode textMode = text.getMode();
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode =
CollatorUtilities.toNormalizerMode(owner.getDecomposition());
if (textMode != ownerMode) {
text.setMode(ownerMode);
}
// if buffer contains any decomposed char values
// return their strength orders before continuing in
// the Normalizer's CharacterIterator.
if (buffer != null) {
if (expIndex < buffer.length) {
return strengthOrder(buffer[expIndex++]);
} else {
buffer = null;
expIndex = 0;
}
} else if (swapOrder != 0) {
if (Character.isSupplementaryCodePoint(swapOrder)) {
char[] chars = Character.toChars(swapOrder);
swapOrder = chars[1];
return chars[0] << 16;
}
int order = swapOrder << 16;
swapOrder = 0;
return order;
}
int ch = text.next();
// are we at the end of Normalizer's text?
if (ch == NormalizerBase.DONE) {
return NULLORDER;
}
int value = ordering.getUnicodeOrder(ch);
if (value == RuleBasedCollator.UNMAPPED) {
swapOrder = ch;
return UNMAPPEDCHARVALUE;
}
else if (value >= RuleBasedCollator.CONTRACTCHARINDEX) {
value = nextContractChar(ch);
}
if (value >= RuleBasedCollator.EXPANDCHARINDEX) {
buffer = ordering.getExpandValueList(value);
expIndex = 0;
value = buffer[expIndex++];
}
if (ordering.isSEAsianSwapping()) {
int consonant;
if (isThaiPreVowel(ch)) {
consonant = text.next();
if (isThaiBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
if (isLaoPreVowel(ch)) {
consonant = text.next();
if (isLaoBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
}
return strengthOrder(value);
}
/**
* Get the ordering priority of the previous contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int prevContractChar(int ch)
{
// This function is identical to nextContractChar(), except that we've
// switched things so that the next() and previous() calls on the Normalizer
// are switched and so that we skip entry pairs with the fwd flag turned on
// rather than off. Notice that we still use append() and startsWith() when
// working on the fragment. This is because the entry pairs that are used
// in reverse iteration have their names reversed already.
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
pair = list.lastElement();
int maxLength = pair.entryName.length();
NormalizerBase tempText = (NormalizerBase)text.clone();
tempText.next();
key.setLength(0);
int c = tempText.previous();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.previous();
}
String fragment = key.toString();
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
while (maxLength > 1) {
c = text.previous();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the ordering priority of the next contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int nextContractChar(int ch)
{
// First get the ordering of this single character,
// which is always the first element in the list
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
// find out the length of the longest contracting character sequence in the list.
// There's logic in the builder code to make sure the longest sequence is always
// the last.
pair = list.lastElement();
int maxLength = pair.entryName.length();
// (the Normalizer is cloned here so that the seeking we do in the next loop
// won't affect our real position in the text)
NormalizerBase tempText = (NormalizerBase)text.clone();
// extract the next maxLength characters in the string (we have to do this using the
// Normalizer to ensure that our offsets correspond to those the rest of the
// iterator is using) and store it in "fragment".
tempText.previous();
key.setLength(0);
int c = tempText.next();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.next();
}
String fragment = key.toString();
// now that we have that fragment, iterate through this list looking for the
// longest sequence that matches the characters in the actual text. (maxLength
// is used here to keep track of the length of the longest sequence)
// Upon exit from this loop, maxLength will contain the length of the matching
// sequence and order will contain the collation-element value corresponding
// to this sequence
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (!pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
// seek our current iteration position to the end of the matching sequence
// and return the appropriate collation-element value (if there was no matching
// sequence, we're already seeked to the right position and order already contains
// the correct collation-element value for the single character)
while (maxLength > 1) {
c = text.next();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the ordering priority of the next contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int nextContractChar(int ch)
{
// First get the ordering of this single character,
// which is always the first element in the list
Vector list = ordering.getContractValues(ch);
EntryPair pair = (EntryPair)list.firstElement();
int order = pair.value;
// find out the length of the longest contracting character sequence in the list.
// There's logic in the builder code to make sure the longest sequence is always
// the last.
pair = (EntryPair)list.lastElement();
int maxLength = pair.entryName.length();
// (the Normalizer is cloned here so that the seeking we do in the next loop
// won't affect our real position in the text)
NormalizerBase tempText = (NormalizerBase)text.clone();
// extract the next maxLength characters in the string (we have to do this using the
// Normalizer to ensure that our offsets correspond to those the rest of the
// iterator is using) and store it in "fragment".
tempText.previous();
key.setLength(0);
int c = tempText.next();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.next();
}
String fragment = key.toString();
// now that we have that fragment, iterate through this list looking for the
// longest sequence that matches the characters in the actual text. (maxLength
// is used here to keep track of the length of the longest sequence)
// Upon exit from this loop, maxLength will contain the length of the matching
// sequence and order will contain the collation-element value corresponding
// to this sequence
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = (EntryPair)list.elementAt(i);
if (!pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
// seek our current iteration position to the end of the matching sequence
// and return the appropriate collation-element value (if there was no matching
// sequence, we're already seeked to the right position and order already contains
// the correct collation-element value for the single character)
while (maxLength > 1) {
c = text.next();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the ordering priority of the previous contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int prevContractChar(int ch)
{
// This function is identical to nextContractChar(), except that we've
// switched things so that the next() and previous() calls on the Normalizer
// are switched and so that we skip entry pairs with the fwd flag turned on
// rather than off. Notice that we still use append() and startsWith() when
// working on the fragment. This is because the entry pairs that are used
// in reverse iteration have their names reversed already.
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
pair = list.lastElement();
int maxLength = pair.entryName.length();
NormalizerBase tempText = (NormalizerBase)text.clone();
tempText.next();
key.setLength(0);
int c = tempText.previous();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.previous();
}
String fragment = key.toString();
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
while (maxLength > 1) {
c = text.previous();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the ordering priority of the previous contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int prevContractChar(int ch)
{
// This function is identical to nextContractChar(), except that we've
// switched things so that the next() and previous() calls on the Normalizer
// are switched and so that we skip entry pairs with the fwd flag turned on
// rather than off. Notice that we still use append() and startsWith() when
// working on the fragment. This is because the entry pairs that are used
// in reverse iteration have their names reversed already.
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
pair = list.lastElement();
int maxLength = pair.entryName.length();
NormalizerBase tempText = (NormalizerBase)text.clone();
tempText.next();
key.setLength(0);
int c = tempText.previous();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.previous();
}
String fragment = key.toString();
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
while (maxLength > 1) {
c = text.previous();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the ordering priority of the next contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int nextContractChar(int ch)
{
// First get the ordering of this single character,
// which is always the first element in the list
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
// find out the length of the longest contracting character sequence in the list.
// There's logic in the builder code to make sure the longest sequence is always
// the last.
pair = list.lastElement();
int maxLength = pair.entryName.length();
// (the Normalizer is cloned here so that the seeking we do in the next loop
// won't affect our real position in the text)
NormalizerBase tempText = (NormalizerBase)text.clone();
// extract the next maxLength characters in the string (we have to do this using the
// Normalizer to ensure that our offsets correspond to those the rest of the
// iterator is using) and store it in "fragment".
tempText.previous();
key.setLength(0);
int c = tempText.next();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.next();
}
String fragment = key.toString();
// now that we have that fragment, iterate through this list looking for the
// longest sequence that matches the characters in the actual text. (maxLength
// is used here to keep track of the length of the longest sequence)
// Upon exit from this loop, maxLength will contain the length of the matching
// sequence and order will contain the collation-element value corresponding
// to this sequence
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (!pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
// seek our current iteration position to the end of the matching sequence
// and return the appropriate collation-element value (if there was no matching
// sequence, we're already seeked to the right position and order already contains
// the correct collation-element value for the single character)
while (maxLength > 1) {
c = text.next();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the ordering priority of the previous contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int prevContractChar(int ch)
{
// This function is identical to nextContractChar(), except that we've
// switched things so that the next() and previous() calls on the Normalizer
// are switched and so that we skip entry pairs with the fwd flag turned on
// rather than off. Notice that we still use append() and startsWith() when
// working on the fragment. This is because the entry pairs that are used
// in reverse iteration have their names reversed already.
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
pair = list.lastElement();
int maxLength = pair.entryName.length();
NormalizerBase tempText = (NormalizerBase)text.clone();
tempText.next();
key.setLength(0);
int c = tempText.previous();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.previous();
}
String fragment = key.toString();
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
while (maxLength > 1) {
c = text.previous();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the ordering priority of the previous contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int prevContractChar(int ch)
{
// This function is identical to nextContractChar(), except that we've
// switched things so that the next() and previous() calls on the Normalizer
// are switched and so that we skip entry pairs with the fwd flag turned on
// rather than off. Notice that we still use append() and startsWith() when
// working on the fragment. This is because the entry pairs that are used
// in reverse iteration have their names reversed already.
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
pair = list.lastElement();
int maxLength = pair.entryName.length();
NormalizerBase tempText = (NormalizerBase)text.clone();
tempText.next();
key.setLength(0);
int c = tempText.previous();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.previous();
}
String fragment = key.toString();
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
while (maxLength > 1) {
c = text.previous();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the ordering priority of the next contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int nextContractChar(int ch)
{
// First get the ordering of this single character,
// which is always the first element in the list
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
// find out the length of the longest contracting character sequence in the list.
// There's logic in the builder code to make sure the longest sequence is always
// the last.
pair = list.lastElement();
int maxLength = pair.entryName.length();
// (the Normalizer is cloned here so that the seeking we do in the next loop
// won't affect our real position in the text)
NormalizerBase tempText = (NormalizerBase)text.clone();
// extract the next maxLength characters in the string (we have to do this using the
// Normalizer to ensure that our offsets correspond to those the rest of the
// iterator is using) and store it in "fragment".
tempText.previous();
key.setLength(0);
int c = tempText.next();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.next();
}
String fragment = key.toString();
// now that we have that fragment, iterate through this list looking for the
// longest sequence that matches the characters in the actual text. (maxLength
// is used here to keep track of the length of the longest sequence)
// Upon exit from this loop, maxLength will contain the length of the matching
// sequence and order will contain the collation-element value corresponding
// to this sequence
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (!pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
// seek our current iteration position to the end of the matching sequence
// and return the appropriate collation-element value (if there was no matching
// sequence, we're already seeked to the right position and order already contains
// the correct collation-element value for the single character)
while (maxLength > 1) {
c = text.next();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the next collation element in the string. <p>This iterator iterates
* over a sequence of collation elements that were built from the string.
* Because there isn't necessarily a one-to-one mapping from characters to
* collation elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the next character in the
* string".</p>
* <p>This function returns the collation element that the iterator is currently
* pointing to and then updates the internal pointer to point to the next element.
* previous() updates the pointer first and then returns the element. This
* means that when you change direction while iterating (i.e., call next() and
* then call previous(), or call previous() and then call next()), you'll get
* back the same element twice.</p>
*
* @return the next collation element
*/
public int next()
{
if (text == null) {
return NULLORDER;
}
NormalizerBase.Mode textMode = text.getMode();
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode =
CollatorUtilities.toNormalizerMode(owner.getDecomposition());
if (textMode != ownerMode) {
text.setMode(ownerMode);
}
// if buffer contains any decomposed char values
// return their strength orders before continuing in
// the Normalizer's CharacterIterator.
if (buffer != null) {
if (expIndex < buffer.length) {
return strengthOrder(buffer[expIndex++]);
} else {
buffer = null;
expIndex = 0;
}
} else if (swapOrder != 0) {
if (Character.isSupplementaryCodePoint(swapOrder)) {
char[] chars = Character.toChars(swapOrder);
swapOrder = chars[1];
return chars[0] << 16;
}
int order = swapOrder << 16;
swapOrder = 0;
return order;
}
int ch = text.next();
// are we at the end of Normalizer's text?
if (ch == NormalizerBase.DONE) {
return NULLORDER;
}
int value = ordering.getUnicodeOrder(ch);
if (value == RuleBasedCollator.UNMAPPED) {
swapOrder = ch;
return UNMAPPEDCHARVALUE;
}
else if (value >= RuleBasedCollator.CONTRACTCHARINDEX) {
value = nextContractChar(ch);
}
if (value >= RuleBasedCollator.EXPANDCHARINDEX) {
buffer = ordering.getExpandValueList(value);
expIndex = 0;
value = buffer[expIndex++];
}
if (ordering.isSEAsianSwapping()) {
int consonant;
if (isThaiPreVowel(ch)) {
consonant = text.next();
if (isThaiBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
if (isLaoPreVowel(ch)) {
consonant = text.next();
if (isLaoBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
}
return strengthOrder(value);
}
/**
* Get the ordering priority of the previous contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int prevContractChar(int ch)
{
// This function is identical to nextContractChar(), except that we've
// switched things so that the next() and previous() calls on the Normalizer
// are switched and so that we skip entry pairs with the fwd flag turned on
// rather than off. Notice that we still use append() and startsWith() when
// working on the fragment. This is because the entry pairs that are used
// in reverse iteration have their names reversed already.
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
pair = list.lastElement();
int maxLength = pair.entryName.length();
NormalizerBase tempText = (NormalizerBase)text.clone();
tempText.next();
key.setLength(0);
int c = tempText.previous();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.previous();
}
String fragment = key.toString();
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
while (maxLength > 1) {
c = text.previous();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the next collation element in the string. <p>This iterator iterates
* over a sequence of collation elements that were built from the string.
* Because there isn't necessarily a one-to-one mapping from characters to
* collation elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the next character in the
* string".</p>
* <p>This function returns the collation element that the iterator is currently
* pointing to and then updates the internal pointer to point to the next element.
* previous() updates the pointer first and then returns the element. This
* means that when you change direction while iterating (i.e., call next() and
* then call previous(), or call previous() and then call next()), you'll get
* back the same element twice.</p>
*/
public int next()
{
if (text == null) {
return NULLORDER;
}
NormalizerBase.Mode textMode = text.getMode();
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode =
CollatorUtilities.toNormalizerMode(owner.getDecomposition());
if (textMode != ownerMode) {
text.setMode(ownerMode);
}
// if buffer contains any decomposed char values
// return their strength orders before continuing in
// the Normalizer's CharacterIterator.
if (buffer != null) {
if (expIndex < buffer.length) {
return strengthOrder(buffer[expIndex++]);
} else {
buffer = null;
expIndex = 0;
}
} else if (swapOrder != 0) {
if (Character.isSupplementaryCodePoint(swapOrder)) {
char[] chars = Character.toChars(swapOrder);
swapOrder = chars[1];
return chars[0] << 16;
}
int order = swapOrder << 16;
swapOrder = 0;
return order;
}
int ch = text.next();
// are we at the end of Normalizer's text?
if (ch == NormalizerBase.DONE) {
return NULLORDER;
}
int value = ordering.getUnicodeOrder(ch);
if (value == RuleBasedCollator.UNMAPPED) {
swapOrder = ch;
return UNMAPPEDCHARVALUE;
}
else if (value >= RuleBasedCollator.CONTRACTCHARINDEX) {
value = nextContractChar(ch);
}
if (value >= RuleBasedCollator.EXPANDCHARINDEX) {
buffer = ordering.getExpandValueList(value);
expIndex = 0;
value = buffer[expIndex++];
}
if (ordering.isSEAsianSwapping()) {
int consonant;
if (isThaiPreVowel(ch)) {
consonant = text.next();
if (isThaiBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
if (isLaoPreVowel(ch)) {
consonant = text.next();
if (isLaoBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
}
return strengthOrder(value);
}
/**
* Get the previous collation element in the string. <p>This iterator iterates
* over a sequence of collation elements that were built from the string.
* Because there isn't necessarily a one-to-one mapping from characters to
* collation elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the previous character in the
* string".</p>
* <p>This function updates the iterator's internal pointer to point to the
* collation element preceding the one it's currently pointing to and then
* returns that element, while next() returns the current element and then
* updates the pointer. This means that when you change direction while
* iterating (i.e., call next() and then call previous(), or call previous()
* and then call next()), you'll get back the same element twice.</p>
*
* @return the previous collation element
* @since 1.2
*/
public int previous()
{
if (text == null) {
return NULLORDER;
}
NormalizerBase.Mode textMode = text.getMode();
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode =
CollatorUtilities.toNormalizerMode(owner.getDecomposition());
if (textMode != ownerMode) {
text.setMode(ownerMode);
}
if (buffer != null) {
if (expIndex > 0) {
return strengthOrder(buffer[--expIndex]);
} else {
buffer = null;
expIndex = 0;
}
} else if (swapOrder != 0) {
if (Character.isSupplementaryCodePoint(swapOrder)) {
char[] chars = Character.toChars(swapOrder);
swapOrder = chars[1];
return chars[0] << 16;
}
int order = swapOrder << 16;
swapOrder = 0;
return order;
}
int ch = text.previous();
if (ch == NormalizerBase.DONE) {
return NULLORDER;
}
int value = ordering.getUnicodeOrder(ch);
if (value == RuleBasedCollator.UNMAPPED) {
swapOrder = UNMAPPEDCHARVALUE;
return ch;
} else if (value >= RuleBasedCollator.CONTRACTCHARINDEX) {
value = prevContractChar(ch);
}
if (value >= RuleBasedCollator.EXPANDCHARINDEX) {
buffer = ordering.getExpandValueList(value);
expIndex = buffer.length;
value = buffer[--expIndex];
}
if (ordering.isSEAsianSwapping()) {
int vowel;
if (isThaiBaseConsonant(ch)) {
vowel = text.previous();
if (isThaiPreVowel(vowel)) {
buffer = makeReorderedBuffer(vowel, value, buffer, false);
expIndex = buffer.length - 1;
value = buffer[expIndex];
} else {
text.next();
}
}
if (isLaoBaseConsonant(ch)) {
vowel = text.previous();
if (isLaoPreVowel(vowel)) {
buffer = makeReorderedBuffer(vowel, value, buffer, false);
expIndex = buffer.length - 1;
value = buffer[expIndex];
} else {
text.next();
}
}
}
return strengthOrder(value);
}
/**
* Get the ordering priority of the previous contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int prevContractChar(int ch)
{
// This function is identical to nextContractChar(), except that we've
// switched things so that the next() and previous() calls on the Normalizer
// are switched and so that we skip entry pairs with the fwd flag turned on
// rather than off. Notice that we still use append() and startsWith() when
// working on the fragment. This is because the entry pairs that are used
// in reverse iteration have their names reversed already.
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
pair = list.lastElement();
int maxLength = pair.entryName.length();
NormalizerBase tempText = (NormalizerBase)text.clone();
tempText.next();
key.setLength(0);
int c = tempText.previous();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.previous();
}
String fragment = key.toString();
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
while (maxLength > 1) {
c = text.previous();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the ordering priority of the previous contracting character in the
* string.
* @param ch the starting character of a contracting character token
* @return the next contracting character's ordering. Returns NULLORDER
* if the end of string is reached.
*/
private int prevContractChar(int ch)
{
// This function is identical to nextContractChar(), except that we've
// switched things so that the next() and previous() calls on the Normalizer
// are switched and so that we skip entry pairs with the fwd flag turned on
// rather than off. Notice that we still use append() and startsWith() when
// working on the fragment. This is because the entry pairs that are used
// in reverse iteration have their names reversed already.
Vector<EntryPair> list = ordering.getContractValues(ch);
EntryPair pair = list.firstElement();
int order = pair.value;
pair = list.lastElement();
int maxLength = pair.entryName.length();
NormalizerBase tempText = (NormalizerBase)text.clone();
tempText.next();
key.setLength(0);
int c = tempText.previous();
while (maxLength > 0 && c != NormalizerBase.DONE) {
if (Character.isSupplementaryCodePoint(c)) {
key.append(Character.toChars(c));
maxLength -= 2;
} else {
key.append((char)c);
--maxLength;
}
c = tempText.previous();
}
String fragment = key.toString();
maxLength = 1;
for (int i = list.size() - 1; i > 0; i--) {
pair = list.elementAt(i);
if (pair.fwd)
continue;
if (fragment.startsWith(pair.entryName) && pair.entryName.length()
> maxLength) {
maxLength = pair.entryName.length();
order = pair.value;
}
}
while (maxLength > 1) {
c = text.previous();
maxLength -= Character.charCount(c);
}
return order;
}
/**
* Get the previous collation element in the string. <p>This iterator iterates
* over a sequence of collation elements that were built from the string.
* Because there isn't necessarily a one-to-one mapping from characters to
* collation elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the previous character in the
* string".</p>
* <p>This function updates the iterator's internal pointer to point to the
* collation element preceding the one it's currently pointing to and then
* returns that element, while next() returns the current element and then
* updates the pointer. This means that when you change direction while
* iterating (i.e., call next() and then call previous(), or call previous()
* and then call next()), you'll get back the same element twice.</p>
*
* @return the previous collation element
* @since 1.2
*/
public int previous()
{
if (text == null) {
return NULLORDER;
}
NormalizerBase.Mode textMode = text.getMode();
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode =
CollatorUtilities.toNormalizerMode(owner.getDecomposition());
if (textMode != ownerMode) {
text.setMode(ownerMode);
}
if (buffer != null) {
if (expIndex > 0) {
return strengthOrder(buffer[--expIndex]);
} else {
buffer = null;
expIndex = 0;
}
} else if (swapOrder != 0) {
if (Character.isSupplementaryCodePoint(swapOrder)) {
char[] chars = Character.toChars(swapOrder);
swapOrder = chars[1];
return chars[0] << 16;
}
int order = swapOrder << 16;
swapOrder = 0;
return order;
}
int ch = text.previous();
if (ch == NormalizerBase.DONE) {
return NULLORDER;
}
int value = ordering.getUnicodeOrder(ch);
if (value == RuleBasedCollator.UNMAPPED) {
swapOrder = UNMAPPEDCHARVALUE;
return ch;
} else if (value >= RuleBasedCollator.CONTRACTCHARINDEX) {
value = prevContractChar(ch);
}
if (value >= RuleBasedCollator.EXPANDCHARINDEX) {
buffer = ordering.getExpandValueList(value);
expIndex = buffer.length;
value = buffer[--expIndex];
}
if (ordering.isSEAsianSwapping()) {
int vowel;
if (isThaiBaseConsonant(ch)) {
vowel = text.previous();
if (isThaiPreVowel(vowel)) {
buffer = makeReorderedBuffer(vowel, value, buffer, false);
expIndex = buffer.length - 1;
value = buffer[expIndex];
} else {
text.next();
}
}
if (isLaoBaseConsonant(ch)) {
vowel = text.previous();
if (isLaoPreVowel(vowel)) {
buffer = makeReorderedBuffer(vowel, value, buffer, false);
expIndex = buffer.length - 1;
value = buffer[expIndex];
} else {
text.next();
}
}
}
return strengthOrder(value);
}
/**
* Get the next collation element in the string. <p>This iterator iterates
* over a sequence of collation elements that were built from the string.
* Because there isn't necessarily a one-to-one mapping from characters to
* collation elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the next character in the
* string".</p>
* <p>This function returns the collation element that the iterator is currently
* pointing to and then updates the internal pointer to point to the next element.
* previous() updates the pointer first and then returns the element. This
* means that when you change direction while iterating (i.e., call next() and
* then call previous(), or call previous() and then call next()), you'll get
* back the same element twice.</p>
*
* @return the next collation element
*/
public int next()
{
if (text == null) {
return NULLORDER;
}
NormalizerBase.Mode textMode = text.getMode();
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode =
CollatorUtilities.toNormalizerMode(owner.getDecomposition());
if (textMode != ownerMode) {
text.setMode(ownerMode);
}
// if buffer contains any decomposed char values
// return their strength orders before continuing in
// the Normalizer's CharacterIterator.
if (buffer != null) {
if (expIndex < buffer.length) {
return strengthOrder(buffer[expIndex++]);
} else {
buffer = null;
expIndex = 0;
}
} else if (swapOrder != 0) {
if (Character.isSupplementaryCodePoint(swapOrder)) {
char[] chars = Character.toChars(swapOrder);
swapOrder = chars[1];
return chars[0] << 16;
}
int order = swapOrder << 16;
swapOrder = 0;
return order;
}
int ch = text.next();
// are we at the end of Normalizer's text?
if (ch == NormalizerBase.DONE) {
return NULLORDER;
}
int value = ordering.getUnicodeOrder(ch);
if (value == RuleBasedCollator.UNMAPPED) {
swapOrder = ch;
return UNMAPPEDCHARVALUE;
}
else if (value >= RuleBasedCollator.CONTRACTCHARINDEX) {
value = nextContractChar(ch);
}
if (value >= RuleBasedCollator.EXPANDCHARINDEX) {
buffer = ordering.getExpandValueList(value);
expIndex = 0;
value = buffer[expIndex++];
}
if (ordering.isSEAsianSwapping()) {
int consonant;
if (isThaiPreVowel(ch)) {
consonant = text.next();
if (isThaiBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
if (isLaoPreVowel(ch)) {
consonant = text.next();
if (isLaoBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
}
return strengthOrder(value);
}
/**
* Get the previous collation element in the string. <p>This iterator iterates
* over a sequence of collation elements that were built from the string.
* Because there isn't necessarily a one-to-one mapping from characters to
* collation elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the previous character in the
* string".</p>
* <p>This function updates the iterator's internal pointer to point to the
* collation element preceding the one it's currently pointing to and then
* returns that element, while next() returns the current element and then
* updates the pointer. This means that when you change direction while
* iterating (i.e., call next() and then call previous(), or call previous()
* and then call next()), you'll get back the same element twice.</p>
*
* @return the previous collation element
* @since 1.2
*/
public int previous()
{
if (text == null) {
return NULLORDER;
}
NormalizerBase.Mode textMode = text.getMode();
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode =
CollatorUtilities.toNormalizerMode(owner.getDecomposition());
if (textMode != ownerMode) {
text.setMode(ownerMode);
}
if (buffer != null) {
if (expIndex > 0) {
return strengthOrder(buffer[--expIndex]);
} else {
buffer = null;
expIndex = 0;
}
} else if (swapOrder != 0) {
if (Character.isSupplementaryCodePoint(swapOrder)) {
char[] chars = Character.toChars(swapOrder);
swapOrder = chars[1];
return chars[0] << 16;
}
int order = swapOrder << 16;
swapOrder = 0;
return order;
}
int ch = text.previous();
if (ch == NormalizerBase.DONE) {
return NULLORDER;
}
int value = ordering.getUnicodeOrder(ch);
if (value == RuleBasedCollator.UNMAPPED) {
swapOrder = UNMAPPEDCHARVALUE;
return ch;
} else if (value >= RuleBasedCollator.CONTRACTCHARINDEX) {
value = prevContractChar(ch);
}
if (value >= RuleBasedCollator.EXPANDCHARINDEX) {
buffer = ordering.getExpandValueList(value);
expIndex = buffer.length;
value = buffer[--expIndex];
}
if (ordering.isSEAsianSwapping()) {
int vowel;
if (isThaiBaseConsonant(ch)) {
vowel = text.previous();
if (isThaiPreVowel(vowel)) {
buffer = makeReorderedBuffer(vowel, value, buffer, false);
expIndex = buffer.length - 1;
value = buffer[expIndex];
} else {
text.next();
}
}
if (isLaoBaseConsonant(ch)) {
vowel = text.previous();
if (isLaoPreVowel(vowel)) {
buffer = makeReorderedBuffer(vowel, value, buffer, false);
expIndex = buffer.length - 1;
value = buffer[expIndex];
} else {
text.next();
}
}
}
return strengthOrder(value);
}
/**
* Get the next collation element in the string. <p>This iterator iterates
* over a sequence of collation elements that were built from the string.
* Because there isn't necessarily a one-to-one mapping from characters to
* collation elements, this doesn't mean the same thing as "return the
* collation element [or ordering priority] of the next character in the
* string".</p>
* <p>This function returns the collation element that the iterator is currently
* pointing to and then updates the internal pointer to point to the next element.
* previous() updates the pointer first and then returns the element. This
* means that when you change direction while iterating (i.e., call next() and
* then call previous(), or call previous() and then call next()), you'll get
* back the same element twice.</p>
*
* @return the next collation element
*/
public int next()
{
if (text == null) {
return NULLORDER;
}
NormalizerBase.Mode textMode = text.getMode();
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode =
CollatorUtilities.toNormalizerMode(owner.getDecomposition());
if (textMode != ownerMode) {
text.setMode(ownerMode);
}
// if buffer contains any decomposed char values
// return their strength orders before continuing in
// the Normalizer's CharacterIterator.
if (buffer != null) {
if (expIndex < buffer.length) {
return strengthOrder(buffer[expIndex++]);
} else {
buffer = null;
expIndex = 0;
}
} else if (swapOrder != 0) {
if (Character.isSupplementaryCodePoint(swapOrder)) {
char[] chars = Character.toChars(swapOrder);
swapOrder = chars[1];
return chars[0] << 16;
}
int order = swapOrder << 16;
swapOrder = 0;
return order;
}
int ch = text.next();
// are we at the end of Normalizer's text?
if (ch == NormalizerBase.DONE) {
return NULLORDER;
}
int value = ordering.getUnicodeOrder(ch);
if (value == RuleBasedCollator.UNMAPPED) {
swapOrder = ch;
return UNMAPPEDCHARVALUE;
}
else if (value >= RuleBasedCollator.CONTRACTCHARINDEX) {
value = nextContractChar(ch);
}
if (value >= RuleBasedCollator.EXPANDCHARINDEX) {
buffer = ordering.getExpandValueList(value);
expIndex = 0;
value = buffer[expIndex++];
}
if (ordering.isSEAsianSwapping()) {
int consonant;
if (isThaiPreVowel(ch)) {
consonant = text.next();
if (isThaiBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
if (isLaoPreVowel(ch)) {
consonant = text.next();
if (isLaoBaseConsonant(consonant)) {
buffer = makeReorderedBuffer(consonant, value, buffer, true);
value = buffer[0];
expIndex = 1;
} else if (consonant != NormalizerBase.DONE) {
text.previous();
}
}
}
return strengthOrder(value);
}