/// <summary> /// 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(). </summary> /// <param name="sourceText"> the source string. </param> /// <param name="owner"> the collation object. </param> internal CollationElementIterator(CharacterIterator sourceText, RuleBasedCollator owner) { this.Owner = owner; Ordering = owner.Tables; NormalizerBase.Mode mode = CollatorUtilities.toNormalizerMode(owner.Decomposition); Text_Renamed = new NormalizerBase(sourceText, mode); }
/// <summary> /// 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(). </summary> /// <param name="sourceText"> the source string. </param> /// <param name="owner"> the collation object. </param> internal CollationElementIterator(String sourceText, RuleBasedCollator owner) { this.Owner = owner; Ordering = owner.Tables; if (sourceText.Length() != 0) { NormalizerBase.Mode mode = CollatorUtilities.toNormalizerMode(owner.Decomposition); Text_Renamed = new NormalizerBase(sourceText, mode); } }
/// <summary> /// Resets the cursor to the beginning of the string. The next call /// to next() will return the first collation element in the string. /// </summary> public void Reset() { if (Text_Renamed != null) { Text_Renamed.reset(); NormalizerBase.Mode mode = CollatorUtilities.toNormalizerMode(Owner.Decomposition); Text_Renamed.Mode = mode; } Buffer = null; ExpIndex = 0; SwapOrder = 0; }
/// <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)); }