public StringParser() 
{
        this(null);
}

Construct a string parser with no preset string to be parsed.

 public StringParser(String string) 
{
        super();
        setString(string);
}

Construct a string parser that is initialized to parse the specified string.

Parameters:

string - The string to be parsed

 public  void advance() 
{
        if (index <  length)
            index++;
}

Advance the current parsing position by one, if we are not already past the end of the string.

 public String extract(int start) 
{
        if ((start <  0) || (start  >= length))
            return ("");
        else
            return (string.substring(start));
}

Extract and return a substring that starts at the specified position, and extends to the end of the string being parsed. If this is not possible, a zero-length string is returned.

 public String extract(int start,
    int end) 
{
        if ((start <  0) || (start  >= end) || (end  > length))
            return ("");
        else
            return (string.substring(start, end));
}

Extract and return a substring that starts at the specified position, and ends at the character before the specified position. If this is not possible, a zero-length string is returned.

 public int findChar(char ch) 
{
        while ((index <  length) && (ch != chars[index]))
            index++;
        return (index);
}

Return the index of the next occurrence of the specified character, or the index of the character after the last position of the string if no more occurrences of this character are found. The current parsing position is updated to the returned value.

 public int findText() 
{
        while ((index <  length) && isWhite(chars[index]))
            index++;
        return (index);
}

Return the index of the next occurrence of a non-whitespace character, or the index of the character after the last position of the string if no more non-whitespace characters are found. The current parsing position is updated to the returned value.

 public int findWhite() 
{
        while ((index <  length) && !isWhite(chars[index]))
            index++;
        return (index);
}

Return the index of the next occurrence of a whitespace character, or the index of the character after the last position of the string if no more whitespace characters are found. The current parsing position is updated to the returned value.

 public int getIndex() 
{
    // ------------------------------------------------------------- Properties
        return (this.index);
}

Return the zero-relative index of our current parsing position within the string being parsed.

 public int getLength() 
{
        return (this.length);
}

Return the length of the string we are parsing.

 public String getString() 
{
        return (this.string);
}

Return the String we are currently parsing.

 protected boolean isWhite(char ch) 
{
        if ((ch == ' ") || (ch == '\t") || (ch == '\r") || (ch == '\n"))
            return (true);
        else
            return (false);
}

Is the specified character considered to be whitespace?

 public  void reset() 
{
        index = 0;
}

Reset the current state of the parser to the beginning of the current string being parsed.

 public  void setString(String string) 
{
        this.string = string;
        if (string != null) {
            this.length = string.length();
            chars = this.string.toCharArray();
        } else {
            this.length = 0;
            chars = new char[0];
        }
        reset();
}

Set the String we are currently parsing. The parser state is also reset to begin at the start of this string.

 public int skipChar(char ch) 
{
        while ((index <  length) && (ch == chars[index]))
            index++;
        return (index);
}

Advance the current parsing position while it is pointing at the specified character, or until it moves past the end of the string. Return the final value.

 public int skipText() 
{
        while ((index <  length) && !isWhite(chars[index]))
            index++;
        return (index);
}

Advance the current parsing position while it is pointing at a non-whitespace character, or until it moves past the end of the string. Return the final value.

 public int skipWhite() 
{
        while ((index <  length) && isWhite(chars[index]))
            index++;
        return (index);
}

Advance the current parsing position while it is pointing at a whitespace character, or until it moves past the end of the string. Return the final value.