/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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.
*/
/*
* (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
* (C) Copyright IBM Corp. 1996-1998 - All Rights Reserved
*
* The original version of this source code and documentation is copyrighted
* and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
* materials are provided under terms of a License Agreement between Taligent
* and Sun. This technology is protected by multiple US and International
* patents. This notice and attribution to Taligent may not be removed.
* Taligent is a registered trademark of Taligent, Inc.
*
*/
/**
* The <code>CollationElementIterator</code> class is used as an iterator
* to walk through each character of an international string. Use the iterator
* to return the ordering priority of the positioned character. The ordering
* priority of a character, which we refer to as a key, defines how a character
* is collated in the given collation object.
*
* <p>
* For example, consider the following in Spanish:
* <blockquote>
* <pre>
* "ca" -> the first key is key('c') and second key is key('a').
* "cha" -> the first key is key('ch') and second key is key('a').
* </pre>
* </blockquote>
* And in German,
* <blockquote>
* <pre>
* "\u00e4b"-> the first key is key('a'), the second key is key('e'), and
* the third key is key('b').
* </pre>
* </blockquote>
* The key of a character is an integer composed of primary order(short),
* secondary order(byte), and tertiary order(byte). Java strictly defines
* the size and signedness of its primitive data types. Therefore, the static
* functions <code>primaryOrder</code>, <code>secondaryOrder</code>, and
* <code>tertiaryOrder</code> return <code>int</code>, <code>short</code>,
* and <code>short</code> respectively to ensure the correctness of the key
* value.
*
* <p>
* Example of the iterator usage,
* <blockquote>
* <pre>
*
* String testString = "This is a test";
* Collator col = Collator.getInstance();
* if (col instanceof RuleBasedCollator) {
* RuleBasedCollator ruleBasedCollator = (RuleBasedCollator)col;
* CollationElementIterator collationElementIterator = ruleBasedCollator.getCollationElementIterator(testString);
* int primaryOrder = CollationElementIterator.primaryOrder(collationElementIterator.next());
* :
* }
* </pre>
* </blockquote>
*
* <p>
* <code>CollationElementIterator.next</code> returns the collation order
* of the next character. A collation order consists of primary order,
* secondary order and tertiary order. The data type of the collation
* order is <strong>int</strong>. The first 16 bits of a collation order
* is its primary order; the next 8 bits is the secondary order and the
* last 8 bits is the tertiary order.
*
* <p><b>Note:</b> <code>CollationElementIterator</code> is a part of
* <code>RuleBasedCollator</code> implementation. It is only usable
* with <code>RuleBasedCollator</code> instances.
*
* @see Collator
* @see RuleBasedCollator
* @author Helena Shih, Laura Werner, Richard Gillam
*/
public final class CollationElementIterator
{
/**
* Null order which indicates the end of string is reached by the
* cursor.
*/
/**
* CollationElementIterator constructor. This takes the source string and
* the collation object. The cursor will walk thru the source string based
* on the predefined collation rules. If the source string is empty,
* NULLORDER will be returned on the calls to next().
* @param sourceText the source string.
* @param order the collation object.
*/
}
}
/**
* CollationElementIterator constructor. This takes the source string and
* the collation object. The cursor will walk thru the source string based
* on the predefined collation rules. If the source string is empty,
* NULLORDER will be returned on the calls to next().
* @param sourceText the source string.
* @param order the collation object.
*/
}
/**
* Resets the cursor to the beginning of the string. The next call
* to next() will return the first collation element in the string.
*/
public void reset()
{
}
expIndex = 0;
swapOrder = 0;
}
/**
* 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()
{
return NULLORDER;
}
// convert the owner's mode to something the Normalizer understands
}
// if buffer contains any decomposed char values
// return their strength orders before continuing in
// the Normalizer's CharacterIterator.
} else {
expIndex = 0;
}
} else if (swapOrder != 0) {
}
swapOrder = 0;
return order;
}
// are we at the end of Normalizer's text?
return NULLORDER;
}
return UNMAPPEDCHARVALUE;
}
}
expIndex = 0;
}
if (ordering.isSEAsianSwapping()) {
int consonant;
if (isThaiPreVowel(ch)) {
if (isThaiBaseConsonant(consonant)) {
expIndex = 1;
}
}
if (isLaoPreVowel(ch)) {
if (isLaoBaseConsonant(consonant)) {
expIndex = 1;
}
}
}
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>
* @since 1.2
*/
public int previous()
{
return NULLORDER;
}
// convert the owner's mode to something the Normalizer understands
}
if (expIndex > 0) {
} else {
expIndex = 0;
}
} else if (swapOrder != 0) {
}
swapOrder = 0;
return order;
}
return NULLORDER;
}
return ch;
}
}
if (ordering.isSEAsianSwapping()) {
int vowel;
if (isThaiBaseConsonant(ch)) {
if (isThaiPreVowel(vowel)) {
} else {
}
}
if (isLaoBaseConsonant(ch)) {
if (isLaoPreVowel(vowel)) {
} else {
}
}
}
return strengthOrder(value);
}
/**
* Return the primary component of a collation element.
* @param order the collation element
* @return the element's primary component
*/
{
}
/**
* Return the secondary component of a collation element.
* @param order the collation element
* @return the element's secondary component
*/
{
}
/**
* Return the tertiary component of a collation element.
* @param order the collation element
* @return the element's tertiary component
*/
{
}
/**
* Get the comparison order in the desired strength. Ignore the other
* differences.
* @param order The order value
*/
{
int s = owner.getStrength();
{
{
}
return order;
}
/**
* Sets the iterator to point to the collation element corresponding to
* the specified character (the parameter is a CHARACTER offset in the
* original string, not an offset into its corresponding sequence of
* collation elements). The value returned by the next call to next()
* will be the collation element corresponding to the specified position
* in the text. If that position is in the middle of a contracting
* character sequence, the result of the next call to next() is the
* collation element for that sequence. This means that getOffset()
* is not guaranteed to return the same value as was passed to a preceding
* call to setOffset().
*
* @param newOffset The new character offset into the original text.
* @since 1.2
*/
{
} else {
// if the desired character isn't used in a contracting character
// sequence, bypass all the backing-up logic-- we're sitting on
// the right character already
if (ordering.usedInContractSeq(c)) {
// walk backwards through the string until we see a character
// that DOESN'T participate in a contracting character sequence
while (ordering.usedInContractSeq(c)) {
}
// now walk forward using this object's next() method until
// we pass the starting point and set our current position
// to the beginning of the last "character" before or at
// our starting position
next();
}
// we don't need this, since last is the last index
// that is the starting of the contraction which encompass
// newOffset
// text.previous();
}
}
}
expIndex = 0;
swapOrder = 0;
}
/**
* Returns the character offset in the original text corresponding to the next
* collation element. (That is, getOffset() returns the position in the text
* corresponding to the collation element that will be returned by the next
* call to next().) This value will always be the index of the FIRST character
* corresponding to the collation element (a contracting character sequence is
* when two or more characters all correspond to the same collation element).
* This means if you do setOffset(x) followed immediately by getOffset(), getOffset()
* won't necessarily return x.
*
* @return The character offset in the original text corresponding to the collation
* element that will be returned by the next call to next().
* @since 1.2
*/
public int getOffset()
{
}
/**
* Return the maximum length of any expansion sequences that end
* with the specified comparison order.
* @param order a collation order returned by previous or next.
* @return the maximum length of any expansion sequences ending
* with the specified order.
* @since 1.2
*/
{
}
/**
* Set a new string over which to iterate.
*
* @param source the new source text
* @since 1.2
*/
{
swapOrder = 0;
expIndex = 0;
} else {
}
}
/**
* Set a new string over which to iterate.
*
* @param source the new source text.
* @since 1.2
*/
{
swapOrder = 0;
expIndex = 0;
} else {
}
}
//============================================================
// privates
//============================================================
/**
* Determine if a character is a Thai vowel (which sorts after
* its base consonant).
*/
}
/**
* Determine if a character is a Thai base consonant
*/
}
/**
* Determine if a character is a Lao vowel (which sorts after
* its base consonant).
*/
}
/**
* Determine if a character is a Lao base consonant
*/
}
/**
* This method produces a buffer which contains the collation
* elements for the two characters, with colFirst's values preceding
* another character's. Presumably, the other character precedes colFirst
* in logical order (otherwise you wouldn't need this method would you?).
* The assumption is that the other char's value(s) have already been
* computed. If this char has a single element it is passed to this
* method as lastValue, and lastExpansion is null. If it has an
* expansion it is passed in lastExpansion, and colLastValue is ignored.
*/
int lastValue,
int[] lastExpansion,
boolean forward) {
int[] result;
}
int[] firstExpansion = null;
}
if (!forward) {
int temp1 = firstValue;
int[] temp2 = firstExpansion;
}
result = new int [2];
}
else {
if (firstExpansion == null) {
}
else {
}
if (lastExpansion == null) {
}
else {
}
}
return result;
}
/**
* Check if a comparison order is ignorable.
* @return true if a character is ignorable, false otherwise.
*/
{
}
/**
* 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.
*/
{
// First get the ordering of this single character,
// which is always the first element in the list
// 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.
// (the Normalizer is cloned here so that the seeking we do in the next loop
// won't affect our real position in the text)
// 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".
if (Character.isSupplementaryCodePoint(c)) {
maxLength -= 2;
} else {
--maxLength;
}
}
// 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;
continue;
> maxLength) {
}
}
// 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) {
}
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.
*/
{
// 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.
if (Character.isSupplementaryCodePoint(c)) {
maxLength -= 2;
} else {
--maxLength;
}
}
maxLength = 1;
continue;
> maxLength) {
}
}
while (maxLength > 1) {
}
return order;
}
}