// protected constructor ---------------------------------------------- /** * Protected constructor for use by subclasses. * Initializes the iterator with the argument target text for searching * and sets the BreakIterator. * See class documentation for more details on the use of the target text * and {@link BreakIterator}. * * @param target The target text to be searched. * @param breaker A {@link BreakIterator} that is used to determine the * boundaries of a logical match. This argument can be null. * @exception IllegalArgumentException thrown when argument target is null, * or of length 0 * @see BreakIterator * @stable ICU 2.0 */ protected SearchIterator(CharacterIterator target, BreakIterator breaker) { this.search_ = new Search(this); if (target == null || (target.EndIndex - target.BeginIndex) == 0) { throw new ArgumentException( "Illegal argument target. " + " Argument can not be null or of length 0"); } search_.SetTarget(target); search_.BreakIterator = breaker; if (search_.BreakIterator != null) { search_.BreakIterator.SetText((CharacterIterator)target.Clone()); } search_.isOverlap_ = false; search_.isCanonicalMatch_ = false; search_.elementComparisonType_ = SearchIteratorElementComparisonType.StandardElementComparison; search_.isForwardSearching_ = true; search_.reset_ = true; search_.matchedIndex_ = Done; search_.MatchedLength = 0; }
/// <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="ArgumentException">Thrown when text is null or has 0 length.</exception> /// <see cref="Target"/> /// <stable>ICU 2.4</stable> public virtual void SetTarget(CharacterIterator text) { if (text == null || text.EndIndex == text.Index) { throw new ArgumentException("Illegal null or empty text"); } text.SetIndex(text.BeginIndex); search_.SetTarget(text); search_.matchedIndex_ = Done; search_.MatchedLength = 0; search_.reset_ = true; search_.isForwardSearching_ = true; if (search_.BreakIterator != null) { // Create a clone of CharacterItearator, so it won't // affect the position currently held by search_.text() search_.BreakIterator.SetText((CharacterIterator)text.Clone()); } if (search_.internalBreakIter_ != null) { search_.internalBreakIter_.SetText((CharacterIterator)text.Clone()); } }
public void TestUCharacterIteratorWrapper() { String source = "asdfasdfjoiuyoiuy2341235679886765"; UCharacterIterator it = UCharacterIterator.GetInstance(source); CharacterIterator wrap_ci = it.GetCharacterIterator(); CharacterIterator ci = new StringCharacterIterator(source); wrap_ci.SetIndex(10); ci.SetIndex(10); String moves = "0+0+0--0-0-+++0--+++++++0--------++++0000----0-"; int c1, c2; char m; int movesIndex = 0; while (movesIndex < moves.Length) { m = moves[movesIndex++]; if (m == '-') { c1 = wrap_ci.Previous(); c2 = ci.Previous(); } else if (m == '0') { c1 = wrap_ci.Current; c2 = ci.Current; } else {// m=='+' c1 = wrap_ci.Next(); c2 = ci.Next(); } // compare results if (c1 != c2) { // copy the moves until the current (m) move, and terminate String history = moves.Substring(0, movesIndex - 0); // ICU4N: Checked 2nd parameter Errln("error: mismatch in Normalizer iteration at " + history + ": " + "got c1= " + Hex(c1) + " != expected c2= " + Hex(c2)); break; } // compare indexes if (wrap_ci.Index != ci.Index) { // copy the moves until the current (m) move, and terminate String history = moves.Substring(0, movesIndex - 0); // ICU4N: Checked 2nd parameter Errln("error: index mismatch in Normalizer iteration at " + history + " : " + "Normalizer index " + wrap_ci.Index + " expected " + ci.Index); break; } } if (ci.First() != wrap_ci.First()) { Errln("CharacterIteratorWrapper.First() failed. expected: " + ci.First() + " got: " + wrap_ci.First()); } if (ci.Last() != wrap_ci.Last()) { Errln("CharacterIteratorWrapper.Last() failed expected: " + ci.Last() + " got: " + wrap_ci.Last()); } if (ci.BeginIndex != wrap_ci.BeginIndex) { Errln("CharacterIteratorWrapper.BeginIndex failed expected: " + ci.BeginIndex + " got: " + wrap_ci.BeginIndex); } if (ci.EndIndex != wrap_ci.EndIndex) { Errln("CharacterIteratorWrapper.EndIndex failed expected: " + ci.EndIndex + " got: " + wrap_ci.EndIndex); } try { CharacterIterator cloneWCI = (CharacterIterator)wrap_ci.Clone(); if (wrap_ci.Index != cloneWCI.Index) { Errln("CharacterIteratorWrapper.Clone() failed expected: " + wrap_ci.Index + " got: " + cloneWCI.Index); } } catch (Exception e) { Errln("CharacterIterator.Clone() failed"); } }
/// <seealso cref="UCharacterIterator.GetCharacterIterator()"/> public override CharacterIterator GetCharacterIterator() { return((CharacterIterator)iterator.Clone()); }