/// <summary> /// Get the ordering priority of the previous contracting character in the /// string. </summary> /// <param name="ch"> the starting character of a contracting character token </param> /// <returns> the next contracting character's ordering. Returns NULLORDER /// if the end of string is reached. </returns> 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. List <EntryPair> list = Ordering.GetContractValues(ch); EntryPair pair = list[0]; int order = pair.Value; pair = list[list.Count - 1]; int maxLength = pair.EntryName.Length(); NormalizerBase tempText = (NormalizerBase)Text_Renamed.clone(); tempText.next(); Key.Length = 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.Count - 1; i > 0; i--) { pair = list[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_Renamed.previous(); maxLength -= Character.CharCount(c); } return(order); }
/// <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> /// Get the ordering priority of the next contracting character in the /// string. </summary> /// <param name="ch"> the starting character of a contracting character token </param> /// <returns> the next contracting character's ordering. Returns NULLORDER /// if the end of string is reached. </returns> private int NextContractChar(int ch) { // First get the ordering of this single character, // which is always the first element in the list List <EntryPair> list = Ordering.GetContractValues(ch); EntryPair pair = list[0]; 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[list.Count - 1]; 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_Renamed.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.Length = 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.Count - 1; i > 0; i--) { pair = list[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_Renamed.next(); maxLength -= Character.CharCount(c); } return(order); }