SearchIterator

Kotlin |Java

abstract class SearchIterator

kotlin.Any
↳	android.icu.text.SearchIterator

Known Direct Subclasses

StringSearch

StringSearch is a SearchIterator that provides language-sensitive text searching based on the comparison rules defined in a RuleBasedCollator object.

SearchIterator is an abstract base class that provides methods to search for a pattern within a text string. Instances of SearchIterator maintain a current position and scan over the target text, returning the indices the pattern is matched and the length of each match.

SearchIterator defines a protocol for text searching. Subclasses provide concrete implementations of various search algorithms. For example, StringSearch implements language-sensitive pattern matching based on the comparison rules defined in a RuleBasedCollator object.

Other options for searching include using a BreakIterator to restrict the points at which matches are detected.

SearchIterator provides an API that is similar to that of other text iteration classes such as BreakIterator. Using this class, it is easy to scan through text looking for all occurrences of a given pattern. The following example uses a StringSearch object to find all instances of "fox" in the target string. Any other subclass of SearchIterator can be used in an identical manner.

<code>
  String target = "The quick brown fox jumped over the lazy fox";
  String pattern = "fox";
  SearchIterator iter = new StringSearch(pattern, target);
  for (int pos = iter.first(); pos != SearchIterator.DONE;
          pos = iter.next()) {
      System.out.println("Found match at " + pos +
              ", length is " + iter.getMatchLength());
  }
  </code>

Summary

Nested classes
	`ElementComparisonType` Option to control how collation elements are compared.

Constants
static Int	`DONE` DONE is returned by previous() and next() after all valid matches have been returned, and by first() and last() if there are no matches at all.

Protected constructors
`SearchIterator(target: CharacterIterator!, breaker: BreakIterator!)` Protected constructor for use by subclasses.

Public methods
Int	`first()` Returns the first index at which the string text matches the search pattern.
Int	`following(position: Int)` Returns the first index equal or greater than position at which the string text matches the search pattern.
open BreakIterator!	`getBreakIterator()` Returns the BreakIterator that is used to restrict the indexes at which matches are detected.
open SearchIterator.ElementComparisonType!	`getElementComparisonType()` Returns the collation element comparison type.
abstract Int	`getIndex()` Return the current index in the text being searched.
open Int	`getMatchLength()` Returns the length of text in the string which matches the search pattern.
open Int	`getMatchStart()` Returns the index to the match in the text string that was searched.
open String!	`getMatchedText()` Returns the text that was matched by the most recent call to `first`, `next`, `previous`, or `last`.
open CharacterIterator!	`getTarget()` Return the string text to be searched.
open Boolean	`isOverlapping()` Return true if the overlapping property has been set.
Int	`last()` Returns the last index in the target text at which it matches the search pattern.
open Int	`next()` Returns the index of the next point at which the text matches the search pattern, starting from the current position The iterator is adjusted so that its current index (as returned by `getIndex`) is the match position if one was found.
Int	`preceding(position: Int)` Returns the first index less than position at which the string text matches the search pattern.
open Int	`previous()` Returns the index of the previous point at which the string text matches the search pattern, starting at the current position.
open Unit	`reset()` Resets the iteration.
open Unit	`setBreakIterator(breakiter: BreakIterator!)` Set the BreakIterator that will be used to restrict the points at which matches are detected.
open Unit	`setElementComparisonType(type: SearchIterator.ElementComparisonType!)` Sets the collation element comparison type.
open Unit	`setIndex(position: Int)` Sets the position in the target text at which the next search will start.
open Unit	`setOverlapping(allowOverlap: Boolean)` Determines whether overlapping matches are returned.
open Unit	`setTarget(text: CharacterIterator!)` Set the target text to be searched.

Protected methods
abstract Int	`handleNext(start: Int)` Abstract method which subclasses override to provide the mechanism for finding the next match in the target text.
abstract Int	`handlePrevious(startAt: Int)` Abstract method which subclasses override to provide the mechanism for finding the previous match in the target text.
open Unit	`setMatchLength(length: Int)` Sets the length of the most recent match in the target text.

Properties
BreakIterator!	`breakIterator` The BreakIterator to define the boundaries of a logical match.
Int	`matchLength` Length of the most current match in target text.
CharacterIterator!	`targetText` Target text for searching.

Parameters
`target`	CharacterIterator!: The target text to be searched.
`breaker`	BreakIterator!: A `BreakIterator` that is used to determine the boundaries of a logical match. This argument can be null.

SearchIterator

Summary

Constants

DONE

Protected constructors

SearchIterator

Public methods

first

following

getBreakIterator

getElementComparisonType

getIndex

getMatchLength

getMatchStart

getMatchedText

getTarget

isOverlapping

last

next

preceding

previous

reset

setBreakIterator

setElementComparisonType

setIndex

setOverlapping

setTarget

Protected methods

handleNext

handlePrevious

setMatchLength

Properties

breakIterator

matchLength

targetText