ParseText (Java Utilities 2.4 API)

java.lang.Object
- net.pwall.util.ParseText

```
public class ParseText
extends Object
```
A class to assist with text parsing. A ParseText object contains a string of text to be examined (in the form of a CharSequence), an index denoting the current parse position and a start index pointing to the start of the last matched or skipped characters.
The class includes a number of "match" operations, which return true if the text matches the parameter(s) to the operation. On a successful match, these operations set the start index to the position of the first character matched, and increment the index past the matched characters. If the match is not successful, the index and start index are not modified.

For use following a successful match operation, there are several "getResult" operations that will extract the matched characters from the text in a variety of forms (int, long, String etc.).

The class takes text in the form of a CharSequence rather than a String, and some implementations of CharSequence allow modification of the contents. The results of any method of this class are undefined in the case of concurrent modification of the text.

Author:

Peter Wall

Constructor Summary

Constructors
Constructor and Description
`ParseText(CharSequence text)` Construct a `ParseText` object with the given text and an initial index value 0f 0.
`ParseText(CharSequence text, int index)` Construct a `ParseText` object with the given text and initial index value.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Appendable`	`appendResultTo(Appendable a)` Copy the result character sequence to an `Appendable`.
`StringBuilder`	`appendResultTo(StringBuilder sb)` Copy the result character sequence to a `StringBuilder`.
`boolean`	`available(int len)` Test whether the text has at least the specified number of characters left after the index.
`ParseText`	`back(int n)` Decrement the index by n.
`char`	`charAt(int index)` Get a specific character from the text.
`int`	`convertDecDigit(char ch)` Convert a decimal digit to the integer value of the digit.
`int`	`convertHexDigit(char ch)` Convert a hexadecimal digit to the integer value of the digit.
`boolean`	`equals(Object o)` Compare the `ParseText` with another object for equality.
`char`	`getChar()` Get the character at the current index and increment the index.
`int`	`getCodePoint()` Get the Unicode code point at the current character index and increment the index past the code point.
`int`	`getHexInt(int from, int to)` Get an `int` from the text, treating the digits as hexadecimal.
`long`	`getHexLong(int from, int to)` Get a `long` from the text, treating the digits as hexadecimal.
`int`	`getIndex()` Get the current index (the offset within the text).
`int`	`getInt(int from, int to)` Get an `int` from the text.
`long`	`getLong(int from, int to)` Get a `long` from the text.
`char`	`getResultChar()` Get the result of the last match operation (or the first character of a longer match) as a single character.
`int`	`getResultHexInt()` Get the result of the last match operation as an `int`, treating the digits as hexadecimal.
`long`	`getResultHexLong()` Get the result of the last match operation as a `long`, treating the digits as hexadecimal.
`int`	`getResultInt()` Get the result of the last match operation as an `int`.
`int`	`getResultLength()` Get the length of the result of the last match operation.
`long`	`getResultLong()` Get the result of the last match operation as a `long`.
`CharSequence`	`getResultSequence()` Get the result of the last match operation as a `CharSequence`.
`String`	`getResultString()` Get the result of the last match operation as a `String`.
`int`	`getStart()` Get the start index (the index of the start of the last matched sequence).
`String`	`getString(int from, int to)` Extract a string from the text, bounded by the given start and end offsets.
`CharSequence`	`getText()` Get the entire text from the `ParseText` object (as a `CharSequence`).
`int`	`getTextLength()` Get the length of the entire text.
`int`	`hashCode()` Compute the hash code for this object (for completeness).
`boolean`	`isDigit(char ch)` Test whether the given character is a digit.
`boolean`	`isExhausted()` Test whether the `ParseText` object is exhausted (the index has reached the end of the text).
`boolean`	`isHexDigit(char ch)` Test whether the given character is a hexadecimal digit.
`boolean`	`isNameContinuation(char ch)` Test whether the given character is a continuation character of a name.
`boolean`	`isNameStart(char ch)` Test whether the given character is the start character of a name.
`boolean`	`isSpace(char ch)` Test whether the given character is a space.
`int`	`length()` Get the length of the entire text.
`boolean`	`match(char ch)` Match the current character in the text against a given character.
`boolean`	`match(CharSequence target)` Match the characters at the index against a given `CharSequence` (`String`, `StringBuilder` etc.).
`boolean`	`match(int cp)` Match the current character in the text against a given Unicode code point.
`boolean`	`matchAnyOf(char... array)` Match the current character in the text against any of the characters in a given array.
`boolean`	`matchAnyOf(CharSequence... array)` Match the characters at the index against any of an array of `CharSequence` (`String`, `StringBuilder` etc.) objects.
`boolean`	`matchAnyOf(Collection<? extends CharSequence> collection)` Match the characters at the index against any of a `Collection` of `CharSequence` (`String`, `StringBuilder` etc.) objects.
`boolean`	`matchAnyOf(String str)` Match the current character in the text against any of the characters in a given `String`.
`boolean`	`matchDec()` Match the characters at the index as decimal digits, with a minimum of 1 digit and no maximum.
`boolean`	`matchDec(int maxDigits)` Match the characters at the index as decimal digits, with a minimum of 1 digit and an optional maximum.
`boolean`	`matchDec(int maxDigits, int minDigits)` Match the characters at the index as decimal digits, with a given minimum number of digits and an optional maximum.
`boolean`	`matchDecFixed(int numDigits)` Match the characters at the index as a fixed number of decimal digits.
`boolean`	`matchHex()` Match the characters at the index as hexadecimal digits, with a minimum of 1 digit and no maximum.
`boolean`	`matchHex(int maxDigits)` Match the characters at the index as hexadecimal digits, with a minimum of 1 digit and an optional maximum.
`boolean`	`matchHex(int maxDigits, int minDigits)` Match the characters at the index as hexadecimal digits, with a given minimum number of digits and an optional maximum.
`boolean`	`matchHexFixed(int numDigits)` Match the characters at the index as a fixed number of hexadecimal digits.
`boolean`	`matchIgnoreCase(char ch)` Match the current character in the text against a given character, ignoring case.
`boolean`	`matchIgnoreCase(CharSequence target)` Match the characters at the index against a given `CharSequence` (`String`, `StringBuilder` etc.), ignoring case.
`boolean`	`matchName()` Match the characters at the index as a name, where a name is defined as starting with a character that matches `isNameStart(char)`, followed by zero or more characters that match `isNameContinuation(char)`.
`boolean`	`matchName(CharSequence target)` Match the characters at the index against a given `CharSequence` (`String`, `StringBuilder` etc.), checking that the character following the match is not part of a name.
`boolean`	`matchRange(char from, char to)` Match the current character in the text against a given character range.
`boolean`	`matchSpaces()` Match the characters at the index as spaces.
`protected boolean`	`matchSuccess(int i)` Indicate successful match.
`ParseText`	`reset()` Reset the index to the start of the text.
`ParseText`	`revert()` Undo the effect of the last match operation.
`ParseText`	`setIndex(int index)` Set the index to a specified value.
`ParseText`	`setStart(int start)` Set the start index (the index of the start of the last matched sequence).
`ParseText`	`setText(CharSequence text)` Set the text.
`ParseText`	`setText(CharSequence text, int index)` Set the text and the index within the text.
`ParseText`	`skip(int n)` Increment the index by n.
`ParseText`	`skipPast(IntPredicate comparison)` Increment the index past any characters matching a given comparison function.
`ParseText`	`skipSpaces()` Increment the index past zero or more spaces.
`ParseText`	`skipTo(char ch)` Increment the index to the next occurrence of the given character.
`ParseText`	`skipTo(CharSequence target)` Increment the index to the next occurrence of the stopper sequence.
`ParseText`	`skipTo(IntPredicate comparison)` Increment the index past any characters matching a given comparison function.
`ParseText`	`skipToAnyOf(char... array)` Increment the index to the next occurrence of any of the given characters.
`ParseText`	`skipToAnyOf(CharSequence stoppers)` Increment the index to the next occurrence of any of the given characters.
`ParseText`	`skipToEnd()` Increment the index directly to the end of the text.
`ParseText`	`skipToSpace()` Increment the index to the next space.
`String`	`toString()` Create a `String` representation of the `ParseText` object.
`String`	`unescape(CharUnmapper charUnmapper, char stopper)` Unescape a string from the index, using the provided `CharUnmapper` and stopping on the given character stopper value.

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

- Constructor Detail
  - ParseText
```
public ParseText(CharSequence text,
                 int index)
```
    Construct a ParseText object with the given text and initial index value.
    
    Parameters:
    
    text - the text
    
    index - the initial index
    
    Throws:
    
    NullPointerException - if the text is null
    
    StringIndexOutOfBoundsException - if the index is negative or beyond the end of the text
  - ParseText
```
public ParseText(CharSequence text)
```
    Construct a ParseText object with the given text and an initial index value 0f 0.
    
    Parameters:
    
    text - the text
    
    Throws:
    
    NullPointerException - if the text is null
- Method Detail
  - setText
```
public ParseText setText(CharSequence text,
                         int index)
```
    Set the text and the index within the text. The start index is set to the same value as the index.
    
    Parameters:
    
    text - the text
    
    index - the index
    
    Returns:
    
    the ParseText object (for chaining purposes)
    
    Throws:
    
    NullPointerException - if the text is null
    
    StringIndexOutOfBoundsException - if the index is outside the bounds of the text
  - setText
```
public ParseText setText(CharSequence text)
```
    Set the text. The index and start index are set to zero.
    
    Parameters:
    
    text - the text
    
    Returns:
    
    the ParseText object (for chaining purposes)
    
    Throws:
    
    NullPointerException - if the text is null
  - getText
```
public CharSequence getText()
```
    Get the entire text from the ParseText object (as a CharSequence).
    
    Returns:
    
    the text
  - getTextLength
```
public int getTextLength()
```
    Get the length of the entire text.
    
    Returns:
    
    the text length
  - isExhausted
```
public boolean isExhausted()
```
    Test whether the ParseText object is exhausted (the index has reached the end of the text).
    
    Returns:
    
    true if the index has reached the end of the text
  - getIndex
```
public int getIndex()
```
    Get the current index (the offset within the text).
    
    Returns:
    
    the index
  - setIndex
```
public ParseText setIndex(int index)
```
    Set the index to a specified value.
    
    Parameters:
    
    index - the new index
    
    Returns:
    
    the ParseText object (for chaining purposes)
    
    Throws:
    
    StringIndexOutOfBoundsException - if the index is outside the bounds of the text
  - matchSuccess
```
protected boolean matchSuccess(int i)
```
    Indicate successful match. This is intended to be used by derived classes.
    
    Parameters:
    
    i - the index at end of match
    
    Returns:
    
    true to indicate successful match
  - getChar
```
public char getChar()
```
    Get the character at the current index and increment the index.
    
    Returns:
    
    the current character
    
    Throws:
    
    StringIndexOutOfBoundsException - if the index is at or beyond end of string
  - getCodePoint
```
public int getCodePoint()
```
    Get the Unicode code point at the current character index and increment the index past the code point.
    
    Returns:
    
    the code point
    
    Throws:
    
    StringIndexOutOfBoundsException - if the index is at or beyond end of string
  - getString
```
public String getString(int from,
                        int to)
```
    Extract a string from the text, bounded by the given start and end offsets.
    
    Parameters:
    
    from - the start offset
    
    to - the end offset
    
    Returns:
    
    the specified string
    
    Throws:
    
    IndexOutOfBoundsException - if the start and end offsets are invalid
  - getStart
```
public int getStart()
```
    Get the start index (the index of the start of the last matched sequence).
    
    Returns:
    
    the start index
  - setStart
```
public ParseText setStart(int start)
```
    Set the start index (the index of the start of the last matched sequence). The start index must be less than or equal to the index (current position).
    
    Parameters:
    
    start - the new start index
    
    Returns:
    
    the ParseText object (for chaining purposes)
    
    Throws:
    
    StringIndexOutOfBoundsException - if the start index is invalid
  - getResultInt
```
public int getResultInt()
```
    Get the result of the last match operation as an int.
    
    Returns:
    
    the result of the last match as an int (always positive)
    
    Throws:
    
    NumberFormatException - if the start and end indices do not describe a valid int
  - getInt
```
public int getInt(int from,
                  int to)
```
    Get an int from the text.
    
    Parameters:
    
    from - the start offset
    
    to - the end offset
    
    Returns:
    
    the int (always positive)
    
    Throws:
    
    NumberFormatException - if the start and end indices do not describe a valid int
    
    IndexOutOfBoundsException - if the start and end indices are not contained within the text
  - getResultLong
```
public long getResultLong()
```
    Get the result of the last match operation as a long.
    
    Returns:
    
    the result of the last match as a long (always positive)
    
    Throws:
    
    NumberFormatException - if the start and end indices do not describe a valid long
  - getLong
```
public long getLong(int from,
                    int to)
```
    Get a long from the text.
    
    Parameters:
    
    from - the start offset
    
    to - the end offset
    
    Returns:
    
    the long (always positive)
    
    Throws:
    
    NumberFormatException - if the start and end indices do not describe a valid long
    
    IndexOutOfBoundsException - if the start and end indices are not contained within the text
  - convertDecDigit
```
public int convertDecDigit(char ch)
```
    Convert a decimal digit to the integer value of the digit. This method may be overridden to provide for different definitions of a decimal digit. If this method is overridden it may be necessary to override isDigit(char) as well.
    
    Parameters:
    
    ch - the decimal digit
    
    Returns:
    
    the integer value (0 - 9)
    
    Throws:
    
    NumberFormatException - if the digit is not valid
  - getResultHexInt
```
public int getResultHexInt()
```
    Get the result of the last match operation as an int, treating the digits as hexadecimal.
    
    Returns:
    
    the result of the last match as an int (always positive)
    
    Throws:
    
    NumberFormatException - if the start and end indices do not describe a valid int
  - getHexInt
```
public int getHexInt(int from,
                     int to)
```
    Get an int from the text, treating the digits as hexadecimal.
    
    Parameters:
    
    from - the start offset
    
    to - the end offset
    
    Returns:
    
    the hexadecimal int (always positive)
    
    Throws:
    
    NumberFormatException - if the start and end indices do not describe a valid int
    
    IndexOutOfBoundsException - if the start and end indices are not contained within the text
  - getResultHexLong
```
public long getResultHexLong()
```
    Get the result of the last match operation as a long, treating the digits as hexadecimal.
    
    Returns:
    
    the result of the last match as a long (always positive)
    
    Throws:
    
    NumberFormatException - if the start and end indices do not describe a valid long
  - getHexLong
```
public long getHexLong(int from,
                       int to)
```
    Get a long from the text, treating the digits as hexadecimal.
    
    Parameters:
    
    from - the start offset
    
    to - the end offset
    
    Returns:
    
    the hexadecimal long (always positive)
    
    Throws:
    
    NumberFormatException - if the start and end indices do not describe a valid long
    
    IndexOutOfBoundsException - if the start and end indices are not contained within the text
  - convertHexDigit
```
public int convertHexDigit(char ch)
```
    Convert a hexadecimal digit to the integer value of the digit. This method may be overridden to provide for different definitions of a hexadecimal digit. If this method is overridden it may be necessary to override isHexDigit(char) as well.
    
    Parameters:
    
    ch - the hexadecimal digit
    
    Returns:
    
    the integer value (0 - 15)
    
    Throws:
    
    NumberFormatException - if the digit is not valid
  - getResultLength
```
public int getResultLength()
```
    Get the length of the result of the last match operation.
    
    Returns:
    
    the length of the result of the last match
  - getResultChar
```
public char getResultChar()
```
    Get the result of the last match operation (or the first character of a longer match) as a single character.
    
    Returns:
    
    the first character of the result of the last match
  - getResultSequence
```
public CharSequence getResultSequence()
```
    Get the result of the last match operation as a CharSequence.
    
    Returns:
    
    the result of the last match
  - getResultString
```
public String getResultString()
```
    Get the result of the last match operation as a String.
    
    Returns:
    
    the result of the last match
  - appendResultTo
```
public StringBuilder appendResultTo(StringBuilder sb)
```
    Copy the result character sequence to a StringBuilder. This is equivalent to but more efficient than
```
     sb.append(xxx.getResultSequence());
 
```
    because it avoids the creation of an intermediate object.
    Parameters:
    
    sb - the StringBuilder
    
    Returns:
    
    the StringBuilder (for chaining purposes)
  - appendResultTo
```
public Appendable appendResultTo(Appendable a)
                          throws IOException
```
    Copy the result character sequence to an Appendable. This is equivalent to but more efficient than
```
     a.append(xxx.getResultSequence());
 
```
    because it avoids the creation of an intermediate object.
    Parameters:
    
    a - the Appendable
    
    Returns:
    
    the Appendable (for chaining purposes)
    
    Throws:
    
    IOException - if thrown by the Appendable
  - available
```
public boolean available(int len)
```
    Test whether the text has at least the specified number of characters left after the index.
    
    Parameters:
    
    len - the number of characters required
    
    Returns:
    
    true if that number of characters are available
  - length
```
public int length()
```
    Get the length of the entire text.
    
    Returns:
    
    the length of the text
  - charAt
```
public char charAt(int index)
```
    Get a specific character from the text.
    
    Parameters:
    
    index - the index of the character
    
    Returns:
    
    the character at the specified index
    
    Throws:
    
    IndexOutOfBoundsException - if the index is negative or beyond the end of the text
  - match
```
public boolean match(int cp)
```
    Match the current character in the text against a given Unicode code point. Following a successful match the start index will point to the matched code point and the index will be incremented past it.
    
    Parameters:
    
    cp - the code point to match against
    
    Returns:
    
    true if the code point in the text matches the given character
  - match
```
public boolean match(char ch)
```
    Match the current character in the text against a given character. Following a successful match the start index will point to the matched character and the index will be incremented past it.
    
    Parameters:
    
    ch - the character to match against
    
    Returns:
    
    true if the character in the text matches the given character
  - matchIgnoreCase
```
public boolean matchIgnoreCase(char ch)
```
    Match the current character in the text against a given character, ignoring case. Following a successful match the start index will point to the matched character and the index will be incremented past it.
    
    Parameters:
    
    ch - the character to match against
    
    Returns:
    
    true if the character in the text matches the given character
  - matchRange
```
public boolean matchRange(char from,
                          char to)
```
    Match the current character in the text against a given character range. Following a successful match the start index will point to the matched character and the index will be incremented past it.
    
    Parameters:
    
    from - the low character in the range to match against
    
    to - the high character in the range to match against (inclusive)
    
    Returns:
    
    true if the character in the text falls in the given range
  - matchAnyOf
```
public boolean matchAnyOf(String str)
```
    Match the current character in the text against any of the characters in a given String. Following a successful match the start index will point to the matched character and the index will be incremented past it.
    
    Parameters:
    
    str - the characters to match against (as a String)
    
    Returns:
    
    true if the character in the text matches any of the characters in the string
  - matchAnyOf
```
public boolean matchAnyOf(char... array)
```
    Match the current character in the text against any of the characters in a given array. Following a successful match the start index will point to the matched character and the index will be incremented past it.
    
    Parameters:
    
    array - the characters to match against (as an array or varargs list)
    
    Returns:
    
    true if the character in the text matches any of the characters in the array
    
    Throws:
    
    IllegalArgumentException - if the array is empty
  - match
```
public boolean match(CharSequence target)
```
    Match the characters at the index against a given CharSequence (String, StringBuilder etc.). Following a successful match the start index will point to the first character of the matched sequence and the index will be incremented past it.
    
    Parameters:
    
    target - the target CharSequence
    
    Returns:
    
    true if the characters in the text at the index match the target
  - matchName
```
public boolean matchName(CharSequence target)
```
    Match the characters at the index against a given CharSequence (String, StringBuilder etc.), checking that the character following the match is not part of a name. Following a successful match the start index will point to the first character of the matched sequence and the index will be incremented past it.
    
    Parameters:
    
    target - the target CharSequence
    
    Returns:
    
    true if the characters in the text at the index match the target
  - matchAnyOf
```
public boolean matchAnyOf(CharSequence... array)
```
    Match the characters at the index against any of an array of CharSequence (String, StringBuilder etc.) objects. Following a successful match the start index will point to the first character of the matched sequence and the index will be incremented past it.
    
    Parameters:
    
    array - the array (or varargs list) of CharSequence
    
    Returns:
    
    true if the characters in the text at the index match any of the entries in the array
    
    Throws:
    
    IllegalArgumentException - if the array is empty
  - matchAnyOf
```
public boolean matchAnyOf(Collection<? extends CharSequence> collection)
```
    Match the characters at the index against any of a Collection of CharSequence (String, StringBuilder etc.) objects. Following a successful match the start index will point to the first character of the matched sequence and the index will be incremented past it.
    
    Parameters:
    
    collection - the Collection of CharSequences
    
    Returns:
    
    true if the characters in the text at the index match any of the entries in the collection
  - matchIgnoreCase
```
public boolean matchIgnoreCase(CharSequence target)
```
    Match the characters at the index against a given CharSequence (String, StringBuilder etc.), ignoring case. Following a successful match the start index will point to the first character of the matched sequence and the index will be incremented past it.
    
    Parameters:
    
    target - the target CharSequence
    
    Returns:
    
    true if the characters in the text at the index match the target
  - matchDec
```
public boolean matchDec(int maxDigits,
                        int minDigits)
```
    Match the characters at the index as decimal digits, with a given minimum number of digits and an optional maximum.
    
    Parameters:
    
    maxDigits - the maximum number digits to match (or 0 to indicate no limit)
    
    minDigits - the minimum number digits for a successful match
    
    Returns:
    
    true if the characters in the text at the index are decimal digits (subject to the specified minimum and maximum number of digits)
  - matchDec
```
public boolean matchDec(int maxDigits)
```
    Match the characters at the index as decimal digits, with a minimum of 1 digit and an optional maximum.
    
    Parameters:
    
    maxDigits - the maximum number digits to match (or 0 to indicate no limit)
    
    Returns:
    
    true if the characters in the text at the index are decimal digits (subject to the specified maximum number of digits)
  - matchDec
```
public boolean matchDec()
```
    Match the characters at the index as decimal digits, with a minimum of 1 digit and no maximum.
    
    Returns:
    
    true if the characters in the text at the index are decimal digits
  - matchDecFixed
```
public boolean matchDecFixed(int numDigits)
```
    Match the characters at the index as a fixed number of decimal digits.
    
    Parameters:
    
    numDigits - the number of digits expected
    
    Returns:
    
    true if the characters in the text at the index are decimal digits
  - matchHex
```
public boolean matchHex(int maxDigits,
                        int minDigits)
```
    Match the characters at the index as hexadecimal digits, with a given minimum number of digits and an optional maximum.
    
    Parameters:
    
    maxDigits - the maximum number digits to match (or 0 to indicate no limit)
    
    minDigits - the minimum number digits for a successful match
    
    Returns:
    
    true if the characters in the text at the index are hexadecimal digits (subject to the specified minimum and maximum number of digits)
  - matchHex
```
public boolean matchHex(int maxDigits)
```
    Match the characters at the index as hexadecimal digits, with a minimum of 1 digit and an optional maximum.
    
    Parameters:
    
    maxDigits - the maximum number digits to match (or 0 to indicate no limit)
    
    Returns:
    
    true if the characters in the text at the index are hexadecimal digits (subject to the specified maximum number of digits)
  - matchHex
```
public boolean matchHex()
```
    Match the characters at the index as hexadecimal digits, with a minimum of 1 digit and no maximum.
    
    Returns:
    
    true if the characters in the text at the index are hexadecimal digits
  - matchHexFixed
```
public boolean matchHexFixed(int numDigits)
```
    Match the characters at the index as a fixed number of hexadecimal digits.
    
    Parameters:
    
    numDigits - the number of digits expected
    
    Returns:
    
    true if the characters in the text at the index are hexadecimal digits
  - revert
```
public ParseText revert()
```
    Undo the effect of the last match operation.
    
    Returns:
    
    the ParseText object (for chaining purposes)
  - reset
```
public ParseText reset()
```
    Reset the index to the start of the text.
    
    Returns:
    
    the ParseText object (for chaining purposes)
  - skip
```
public ParseText skip(int n)
```
    Increment the index by n.
    
    Parameters:
    
    n - the amount to add to the index
    
    Returns:
    
    the ParseText object (for chaining purposes)
    
    Throws:
    
    StringIndexOutOfBoundsException - if the result index would be beyond the end of the text
  - back
```
public ParseText back(int n)
```
    Decrement the index by n.
    
    Parameters:
    
    n - the amount to subtract from the index
    
    Returns:
    
    the ParseText object (for chaining purposes)
    
    Throws:
    
    StringIndexOutOfBoundsException - if the result index would be negative
  - skipTo
```
public ParseText skipTo(char ch)
```
    Increment the index to the next occurrence of the given character. The index is left positioned at the matched character.
    
    Parameters:
    
    ch - the stopper character
    
    Returns:
    
    the ParseText object (for chaining purposes)
  - skipToAnyOf
```
public ParseText skipToAnyOf(char... array)
```
    Increment the index to the next occurrence of any of the given characters. The index is left positioned at the matched character.
    
    Parameters:
    
    array - the array (or varargs list) of possible stopper characters
    
    Returns:
    
    the ParseText object (for chaining purposes)
    
    Throws:
    
    IllegalArgumentException - if the array is empty
  - skipToAnyOf
```
public ParseText skipToAnyOf(CharSequence stoppers)
```
    Increment the index to the next occurrence of any of the given characters. The index is left positioned at the stopper character.
    
    Parameters:
    
    stoppers - a CharSequence of possible stopper characters
    
    Returns:
    
    the ParseText object (for chaining purposes)
    
    Throws:
    
    IllegalArgumentException - if the CharSequence is empty
  - skipTo
```
public ParseText skipTo(CharSequence target)
```
    Increment the index to the next occurrence of the stopper sequence. The index is left positioned at the stopper sequence.
    
    Parameters:
    
    target - the stopper sequence
    
    Returns:
    
    the ParseText object (for chaining purposes)
  - matchSpaces
```
public boolean matchSpaces()
```
    Match the characters at the index as spaces.
    
    Returns:
    
    true if the characters in the text at the index are one or more spaces
  - skipPast
```
public ParseText skipPast(IntPredicate comparison)
```
    Increment the index past any characters matching a given comparison function.
    
    Parameters:
    
    comparison - the comparison function
    
    Returns:
    
    the ParseText object (for chaining purposes)
  - skipSpaces
```
public ParseText skipSpaces()
```
    Increment the index past zero or more spaces.
    
    Returns:
    
    the ParseText object (for chaining purposes)
  - skipTo
```
public ParseText skipTo(IntPredicate comparison)
```
    Increment the index past any characters matching a given comparison function.
    
    Parameters:
    
    comparison - the comparison function
    
    Returns:
    
    the ParseText object (for chaining purposes)
  - skipToSpace
```
public ParseText skipToSpace()
```
    Increment the index to the next space.
    
    Returns:
    
    the ParseText object (for chaining purposes)
  - skipToEnd
```
public ParseText skipToEnd()
```
    Increment the index directly to the end of the text.
    
    Returns:
    
    the ParseText object (for chaining purposes)
  - matchName
```
public boolean matchName()
```
    Match the characters at the index as a name, where a name is defined as starting with a character that matches isNameStart(char), followed by zero or more characters that match isNameContinuation(char).
    
    Returns:
    
    true if the characters in the text at the index constitute a name
  - unescape
```
public String unescape(CharUnmapper charUnmapper,
                       char stopper)
```
    Unescape a string from the index, using the provided CharUnmapper and stopping on the given character stopper value. The index is left positioned at the stopper character so that the caller can test whether the stopper was present. A call to getResultString() or getResultSequence() following this method will return the section of the text prior to unescaping.
    
    Parameters:
    
    charUnmapper - the CharUnmapper
    
    stopper - the stopper character (e.g. the closing quote)
    
    Returns:
    
    the unescaped string
    
    Throws:
    
    IllegalArgumentException - if thrown by the CharUnmapper
  - isSpace
```
public boolean isSpace(char ch)
```
    Test whether the given character is a space. This method may be overridden to provide for different definitions of a space.
    
    Parameters:
    
    ch - the character
    
    Returns:
    
    true if the character is a space
  - isDigit
```
public boolean isDigit(char ch)
```
    Test whether the given character is a digit. This method may be overridden to provide for different definitions of a digit. If this method is overridden it may be necessary to override convertDecDigit(char) as well.
    
    Parameters:
    
    ch - the character
    
    Returns:
    
    true if the character is a digit
  - isHexDigit
```
public boolean isHexDigit(char ch)
```
    Test whether the given character is a hexadecimal digit. This method may be overridden to provide for different definitions of a hex digit. If this method is overridden it may be necessary to override convertHexDigit(char) as well.
    
    Parameters:
    
    ch - the character
    
    Returns:
    
    true if the character is a hexadecimal digit
  - isNameStart
```
public boolean isNameStart(char ch)
```
    Test whether the given character is the start character of a name. This method may be overridden to provide for different definitions of a name.
    
    Parameters:
    
    ch - the character
    
    Returns:
    
    true if the character is a name start character
  - isNameContinuation
```
public boolean isNameContinuation(char ch)
```
    Test whether the given character is a continuation character of a name. This method may be overridden to provide for different definitions of a name.
    
    Parameters:
    
    ch - the character
    
    Returns:
    
    true if the character is a name continuation character
  - toString
```
public String toString()
```
    Create a String representation of the ParseText object. This is primarily intended for debugging purposes; the resulting string consists of the text enclosed in square brackets, with a "~" indicating the start position and a "^" for the index.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    the String representation of the object
  - equals
```
public boolean equals(Object o)
```
    Compare the ParseText with another object for equality.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    o - the other object
    
    Returns:
    
    true if the the other object is a ParseText and the objects are equal
  - hashCode
```
public int hashCode()
```
    Compute the hash code for this object (for completeness).
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    the hash code

Class ParseText

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ParseText

ParseText

Method Detail

setText

setText

getText

getTextLength

isExhausted

getIndex

setIndex

matchSuccess

getChar

getCodePoint

getString

getStart

setStart

getResultInt

getInt

getResultLong

getLong

convertDecDigit

getResultHexInt

getHexInt

getResultHexLong

getHexLong

convertHexDigit

getResultLength

getResultChar

getResultSequence

getResultString

appendResultTo

appendResultTo

available

length

charAt

match

match

matchIgnoreCase

matchRange

matchAnyOf

matchAnyOf

match

matchName

matchAnyOf

matchAnyOf

matchIgnoreCase

matchDec

matchDec

matchDec

matchDecFixed

matchHex

matchHex

matchHex

matchHexFixed

revert

reset

skip

back

skipTo

skipToAnyOf

skipToAnyOf

skipTo

matchSpaces

skipPast

skipSpaces

skipTo

skipToSpace

skipToEnd

matchName

unescape

isSpace

isDigit

isHexDigit

isNameStart

isNameContinuation