/// <summary>
/// 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.
/// </summary>
private int[] MakeReorderedBuffer(int colFirst, int lastValue, int[] lastExpansion, bool forward)
{
int[] result;
int firstValue = Ordering.GetUnicodeOrder(colFirst);
if (firstValue >= RuleBasedCollator.CONTRACTCHARINDEX)
{
firstValue = forward? NextContractChar(colFirst) : PrevContractChar(colFirst);
}
int[] firstExpansion = null;
if (firstValue >= RuleBasedCollator.EXPANDCHARINDEX)
{
firstExpansion = Ordering.GetExpandValueList(firstValue);
}
if (!forward)
{
int temp1 = firstValue;
firstValue = lastValue;
lastValue = temp1;
int[] temp2 = firstExpansion;
firstExpansion = lastExpansion;
lastExpansion = temp2;
}
if (firstExpansion == null && lastExpansion == null)
{
result = new int [2];
result[0] = firstValue;
result[1] = lastValue;
}
else
{
int firstLength = firstExpansion == null? 1 : firstExpansion.Length;
int lastLength = lastExpansion == null? 1 : lastExpansion.Length;
result = new int[firstLength + lastLength];
if (firstExpansion == null)
{
result[0] = firstValue;
}
else
{
System.Array.Copy(firstExpansion, 0, result, 0, firstLength);
}
if (lastExpansion == null)
{
result[firstLength] = lastValue;
}
else
{
System.Array.Copy(lastExpansion, 0, result, firstLength, lastLength);
}
}
return(result);
}
/// <summary>
/// Get the previous collation element in the string. <para>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>
/// </para>
/// <para>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.</para>
/// </summary>
/// <returns> the previous collation element
/// @since 1.2 </returns>
public int Previous()
{
if (Text_Renamed == null)
{
return(NULLORDER);
}
NormalizerBase.Mode textMode = Text_Renamed.Mode;
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode = CollatorUtilities.toNormalizerMode(Owner.Decomposition);
if (textMode != ownerMode)
{
Text_Renamed.Mode = 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_Renamed.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.SEAsianSwapping)
{
int vowel;
if (IsThaiBaseConsonant(ch))
{
vowel = Text_Renamed.previous();
if (IsThaiPreVowel(vowel))
{
Buffer = MakeReorderedBuffer(vowel, value, Buffer, false);
ExpIndex = Buffer.Length - 1;
value = Buffer[ExpIndex];
}
else
{
Text_Renamed.next();
}
}
if (IsLaoBaseConsonant(ch))
{
vowel = Text_Renamed.previous();
if (IsLaoPreVowel(vowel))
{
Buffer = MakeReorderedBuffer(vowel, value, Buffer, false);
ExpIndex = Buffer.Length - 1;
value = Buffer[ExpIndex];
}
else
{
Text_Renamed.next();
}
}
}
return(StrengthOrder(value));
}
/// <summary>
/// Get the next collation element in the string. <para>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>
/// </para>
/// <para>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.</para>
/// </summary>
/// <returns> the next collation element </returns>
public int Next()
{
if (Text_Renamed == null)
{
return(NULLORDER);
}
NormalizerBase.Mode textMode = Text_Renamed.Mode;
// convert the owner's mode to something the Normalizer understands
NormalizerBase.Mode ownerMode = CollatorUtilities.toNormalizerMode(Owner.Decomposition);
if (textMode != ownerMode)
{
Text_Renamed.Mode = 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_Renamed.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.SEAsianSwapping)
{
int consonant;
if (IsThaiPreVowel(ch))
{
consonant = Text_Renamed.next();
if (IsThaiBaseConsonant(consonant))
{
Buffer = MakeReorderedBuffer(consonant, value, Buffer, true);
value = Buffer[0];
ExpIndex = 1;
}
else if (consonant != NormalizerBase.DONE)
{
Text_Renamed.previous();
}
}
if (IsLaoPreVowel(ch))
{
consonant = Text_Renamed.next();
if (IsLaoBaseConsonant(consonant))
{
Buffer = MakeReorderedBuffer(consonant, value, Buffer, true);
value = Buffer[0];
ExpIndex = 1;
}
else if (consonant != NormalizerBase.DONE)
{
Text_Renamed.previous();
}
}
}
return(StrengthOrder(value));
}
