/// <summary> /// Sets the current iteration position to the first boundary position after /// the specified position. /// </summary> /// /// <param name="offset">The position to begin searching forward from</param> /// <returns>The position of the first boundary after "offset"</returns> /// @stable ICU 2.0 public override int Following(int offset) { ICharacterIterator text = GetText(); IBM.ICU.Text.RuleBasedBreakIterator.CheckOffset(offset, text); // if we have no cached break positions, or if "offset" is outside the // range covered by the cache, then dump the cache and call our // inherited following() method. This will call other methods in this // class that may refresh the cache. if (cachedBreakPositions == null || offset < cachedBreakPositions[0] || offset >= cachedBreakPositions[cachedBreakPositions.Length - 1]) { cachedBreakPositions = null; return(base.Following(offset)); } // on the other hand, if "offset" is within the range covered by the // cache, then just search the cache for the first break position // after "offset" else { positionInCache = 0; while (positionInCache < cachedBreakPositions.Length && offset >= cachedBreakPositions[positionInCache]) { ++positionInCache; } text.SetIndex(cachedBreakPositions[positionInCache]); return(text.GetIndex()); } }
/// <exclude/> /// <summary> /// This is the implementation function for next(). /// </summary> /// internal override int HandleNext() { ICharacterIterator text = GetText(); // if there are no cached break positions, or if we've just moved // off the end of the range covered by the cache, we have to dump // and possibly regenerate the cache if (cachedBreakPositions == null || positionInCache == cachedBreakPositions.Length - 1) { // start by using the inherited handleNext() to find a tentative // return // value. dictionaryCharCount tells us how many dictionary // characters // we passed over on our way to the tentative return value int startPos = text.GetIndex(); fDictionaryCharCount = 0; int result = base.HandleNext(); // if we passed over more than one dictionary character, then we use // divideUpDictionaryRange() to regenerate the cached break // positions // for the new range if (fDictionaryCharCount > 1 && result - startPos > 1) { DivideUpDictionaryRange(startPos, result); } // otherwise, the value we got back from the inherited fuction // is our return value, and we can dump the cache else { cachedBreakPositions = null; return(result); } } // if the cache of break positions has been regenerated (or existed all // along), then just advance to the next break position in the cache // and return it if (cachedBreakPositions != null) { ++positionInCache; text.SetIndex(cachedBreakPositions[positionInCache]); return(cachedBreakPositions[positionInCache]); } IBM.ICU.Impl.Assert.Assrt(false); return(-9999); // SHOULD NEVER GET HERE! }
/// <summary> /// Set the target text to be searched. Text iteration will then begin at the /// start of the text string. This method is useful if you want to reuse an /// iterator to search within a different body of text. /// </summary> /// /// <param name="text">new text iterator to look for match,</param> /// <exception cref="IllegalArgumentException">thrown when text is null or has 0 length</exception> /// <seealso cref="M:IBM.ICU.Text.SearchIterator.GetTarget"/> /// @stable ICU 2.4 public virtual void SetTarget(ICharacterIterator text) { if (text == null || text.GetEndIndex() == text.GetIndex()) { throw new ArgumentException("Illegal null or empty text"); } targetText = text; targetText.SetIndex(targetText.GetBeginIndex()); matchLength = 0; m_reset_ = true; m_isForwardSearching_ = true; if (breakIterator != null) { breakIterator.SetText(targetText); } }
/// <summary> /// Sets the current iteration position to the last boundary position before /// the specified position. /// </summary> /// /// <param name="offset">The position to begin searching from</param> /// <returns>The position of the last boundary before "offset"</returns> /// @stable ICU 2.0 public override int Preceding(int offset) { ICharacterIterator text = GetText(); IBM.ICU.Text.RuleBasedBreakIterator.CheckOffset(offset, text); // if we have no cached break positions, or "offset" is outside the // range covered by the cache, we can just call the inherited routine // (which will eventually call other routines in this class that may // refresh the cache) if (cachedBreakPositions == null || offset <= cachedBreakPositions[0] || offset > cachedBreakPositions[cachedBreakPositions.Length - 1]) { cachedBreakPositions = null; return(base.Preceding(offset)); } // on the other hand, if "offset" is within the range covered by the // cache, // then all we have to do is search the cache for the last break // position // before "offset" else { positionInCache = 0; while (positionInCache < cachedBreakPositions.Length && offset > cachedBreakPositions[positionInCache]) { ++positionInCache; } --positionInCache; text.SetIndex(cachedBreakPositions[positionInCache]); return(text.GetIndex()); } }
/// <seealso cref="null"/> public override int GetIndex() { return(iterator.GetIndex()); }
/// <summary> /// This is the function that actually implements the dictionary-based /// algorithm. Given the endpoints of a range of text, it uses the dictionary /// to determine the positions of any boundaries in this range. It stores all /// the boundary positions it discovers in cachedBreakPositions so that we /// only have to do this work once for each time we enter the range. /// </summary> /// private void DivideUpDictionaryRange(int startPos, int endPos) { ICharacterIterator text = GetText(); // the range we're dividing may begin or end with non-dictionary // characters // (i.e., for line breaking, we may have leading or trailing punctuation // that needs to be kept with the word). Seek from the beginning of the // range to the first dictionary character text.SetIndex(startPos); int c = IBM.ICU.Text.RuleBasedBreakIterator.CICurrent32(text); while (IsDictionaryChar(c) == false) { c = IBM.ICU.Text.RuleBasedBreakIterator.CINext32(text); } // System.out.println("\nDividing up range from " + (text.getIndex() + // 1) + " to " + endPos); // initialize. We maintain two stacks: currentBreakPositions contains // the list of break positions that will be returned if we successfully // finish traversing the whole range now. possibleBreakPositions lists // all other possible word ends we've passed along the way. (Whenever // we reach an error [a sequence of characters that can't begin any word // in the dictionary], we back up, possibly delete some breaks from // currentBreakPositions, move a break from possibleBreakPositions // to currentBreakPositions, and start over from there. This process // continues in this way until we either successfully make it all the // way // across the range, or exhaust all of our combinations of break // positions.) Stack currentBreakPositions = new Stack(); Stack possibleBreakPositions = new Stack(); ArrayList wrongBreakPositions = new ArrayList(); // the dictionary is implemented as a trie, which is treated as a state // machine. -1 represents the end of a legal word. Every word in the // dictionary is represented by a path from the root node to -1. A path // that ends in state 0 is an illegal combination of characters. int state = 0; // these two variables are used for error handling. We keep track of the // farthest we've gotten through the range being divided, and the // combination // of breaks that got us that far. If we use up all possible break // combinations, the text contains an error or a word that's not in the // dictionary. In this case, we "bless" the break positions that got us // the // farthest as real break positions, and then start over from scratch // with // the character where the error occurred. int farthestEndPoint = text.GetIndex(); Stack bestBreakPositions = null; // initialize (we always exit the loop with a break statement) c = IBM.ICU.Text.RuleBasedBreakIterator.CICurrent32(text); while (true) { // System.out.print("c = " + Integer.toString(c, 16) + ", pos = " + // text.getIndex()); // if we can transition to state "-1" from our current state, we're // on the last character of a legal word. Push that position onto // the possible-break-positions stack if (dictionary.At(state, 0) == -1) { possibleBreakPositions.Push(((int)(text.GetIndex()))); } // look up the new state to transition to in the dictionary // There will be no supplementaries here because the Thai dictionary // does not include any. This code is going away soon, not worth // fixing. state = (dictionary.At(state, (char)c)) & 0xFFFF; // TODO: fix // supplementaries // System.out.print(", state = " + state); // if the character we're sitting on causes us to transition to // the "end of word" state, then it was a non-dictionary character // and we've successfully traversed the whole range. Drop out // of the loop. if (state == /*-1*/ 0xFFFF) { currentBreakPositions.Push(((int)(text.GetIndex()))); break; } // if the character we're sitting on causes us to transition to // the error state, or if we've gone off the end of the range // without transitioning to the "end of word" state, we've hit // an error... else if (state == 0 || text.GetIndex() >= endPos) { // if this is the farthest we've gotten, take note of it in // case there's an error in the text if (text.GetIndex() > farthestEndPoint) { farthestEndPoint = text.GetIndex(); bestBreakPositions = (Stack)(currentBreakPositions.Clone()); } // wrongBreakPositions is a list of all break positions we've // tried starting // that didn't allow us to traverse all the way through the // text. Every time // we pop a break position off of currentBreakPositions, we put // it into // wrongBreakPositions to avoid trying it again later. If we // make it to this // spot, we're either going to back up to a break in // possibleBreakPositions // and try starting over from there, or we've exhausted all // possible break // positions and are going to do the fallback procedure. This // loop prevents // us from messing with anything in possibleBreakPositions that // didn't work as // a starting point the last time we tried it (this is to // prevent a bunch of // repetitive checks from slowing down some extreme cases) // variable not used Integer newStartingSpot = null; while (!(possibleBreakPositions.Count == 0) && wrongBreakPositions.Contains(possibleBreakPositions .Peek())) { possibleBreakPositions.Pop(); } // if we've used up all possible break-position combinations, // there's // an error or an unknown word in the text. In this case, we // start // over, treating the farthest character we've reached as the // beginning // of the range, and "blessing" the break positions that got us // that // far as real break positions if ((possibleBreakPositions.Count == 0)) { if (bestBreakPositions != null) { currentBreakPositions = bestBreakPositions; if (farthestEndPoint < endPos) { text.SetIndex(farthestEndPoint + 1); } else { break; } } else { if ((currentBreakPositions.Count == 0 || ((Int32)(currentBreakPositions .Peek())) != text.GetIndex()) && text.GetIndex() != startPos) { currentBreakPositions.Push(((int)(text .GetIndex()))); } IBM.ICU.Text.RuleBasedBreakIterator.CINext32(text); currentBreakPositions .Push(((int)(text.GetIndex()))); } } // if we still have more break positions we can try, then // promote the // last break in possibleBreakPositions into // currentBreakPositions, // and get rid of all entries in currentBreakPositions that come // after // it. Then back up to that position and start over from there // (i.e., // treat that position as the beginning of a new word) else { Int32 temp = (Int32)possibleBreakPositions.Pop(); Object temp2 = null; while (!(currentBreakPositions.Count == 0) && temp < ((Int32)currentBreakPositions .Peek())) { temp2 = currentBreakPositions.Pop(); wrongBreakPositions.Add(temp2); } currentBreakPositions.Push(temp); text.SetIndex(((Int32)currentBreakPositions.Peek())); } // re-sync "c" for the next go-round, and drop out of the loop // if // we've made it off the end of the range c = IBM.ICU.Text.RuleBasedBreakIterator.CICurrent32(text); state = 0; if (text.GetIndex() >= endPos) { break; } } // if we didn't hit any exceptional conditions on this last // iteration, // just advance to the next character and loop else { c = IBM.ICU.Text.RuleBasedBreakIterator.CINext32(text); } // System.out.print(", possibleBreakPositions = { "); for (int i = // 0; i < possibleBreakPositions.size(); i++) // System.out.print(possibleBreakPositions.elementAt(i) + " "); // System.out.print("}"); // System.out.print(", currentBreakPositions = { "); for (int i = 0; // i < currentBreakPositions.size(); i++) // System.out.print(currentBreakPositions.elementAt(i) + " "); // System.out.println("}"); } // dump the last break position in the list, and replace it with the // actual // end of the range (which may be the same character, or may be further // on // because the range actually ended with non-dictionary characters we // want to // keep with the word) if (!(currentBreakPositions.Count == 0)) { currentBreakPositions.Pop(); } currentBreakPositions.Push(((int)(endPos))); // create a regular array to hold the break positions and copy // the break positions from the stack to the array (in addition, // our starting position goes into this array as a break position). // This array becomes the cache of break positions used by next() // and previous(), so this is where we actually refresh the cache. cachedBreakPositions = new int[currentBreakPositions.Count + 1]; cachedBreakPositions[0] = startPos; for (int i = 0; i < currentBreakPositions.Count; i++) { cachedBreakPositions[i + 1] = ((Int32)currentBreakPositions.ToArray()[i]); } positionInCache = 0; }