## gnu.regexp
Class REMatch

    java.lang.Object
      gnu.regexp.REMatch

public class REMatch
extends Object

An instance of this class represents a match completed by a gnu.regexp matching function. It can be used to obtain relevant information about the location of a match or submatch.

Field Summary
`(package private) int` `anchor`
`(package private) int[]` `count`
`(package private) int[]` `end`
`(package private) int` `offset`
`(package private) int[]` `start`

Constructor Summary
`(package private)` `REMatch(int f_subs, int f_index)`

Method Summary
`(package private) void` `clear(int f_index)`
`(package private) void` `finish(CharIndexed text)`
`int` `getEndIndex()` Returns the index within the input string where the match in its entirety ends.
`int` `getStartIndex()` Returns the index within the input text where the match in its entirety began.
`int` `getSubEndIndex(int sub)` Returns the index within the input string used to generate this match where subexpression number sub ends, or `-1` if the subexpression does not exist.
`int` `getSubStartIndex(int sub)` Returns the index within the input string used to generate this match where subexpression number sub begins, or `-1` if the subexpression does not exist.
`(package private) void` `reset(int f_subIndex)`
`String` `substituteInto(String input)` Substitute the results of this match to create a new string.
`String` `toString()` Returns the string matching the pattern.
`String` `toString(int sub)` Returns the string matching the given subexpression.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### offset

    int offset

### anchor

    int anchor

### start

    int[] start

### end

    int[] end

### count

    int[] count

Constructor Detail

### REMatch

    REMatch(int f_subs,
            int f_index)

Method Detail

### finish

    void finish(CharIndexed text)

### reset

    void reset(int f_subIndex)

### clear

    void clear(int f_index)

### toString

    public String toString()

  Returns the string matching the pattern. This makes it convenient to write code like the following:

  `REMatch myMatch = myExpression.getMatch(myString);
  if (myMatch != null) System.out.println("Regexp found: "+myMatch);`

### getStartIndex

    public int getStartIndex()

  Returns the index within the input text where the match in its entirety began.

### getEndIndex

    public int getEndIndex()

  Returns the index within the input string where the match in its entirety ends. The return value is the next position after the end of the string; therefore, a match created by the following call:

  `REMatch myMatch = myExpression.getMatch(myString);`

  can be viewed (given that myMatch is not null) by creating

  `String theMatch = myString.substring(myMatch.getStartIndex(), myMatch.getEndIndex());`

  But you can save yourself that work, since the `toString()` method (above) does exactly that for you.

### toString

    public String toString(int sub)

  Returns the string matching the given subexpression.

  Parameters:
    `sub` - Index of the subexpression.

### getSubStartIndex

    public int getSubStartIndex(int sub)

  Returns the index within the input string used to generate this match where subexpression number sub begins, or `-1` if the subexpression does not exist.

  Parameters:
    `sub` - Subexpression index

### getSubEndIndex

    public int getSubEndIndex(int sub)

  Returns the index within the input string used to generate this match where subexpression number sub ends, or `-1` if the subexpression does not exist.

  Parameters:
    `sub` - Subexpression index

### substituteInto

    public String substituteInto(String input)

  Substitute the results of this match to create a new string. This is patterned after PERL, so the tokens to watch out for are `$0` through `$9`. `$0` matches the full substring matched; `$n` matches subexpression number n.

  Parameters:
    `input` - A string consisting of literals and `$n` tokens.