Package org.simpleframework.util.parse

## Class Parser

- java.lang.Object
- - org.simpleframework.util.parse.Parser

- Direct Known Subclasses:
    `AddressParser`, `ContentParser`, `CookieParser`, `DateParser`, `ListParser`, `MapParser`, `PathParser`, `PrincipalParser`

      public abstract class Parser
      extends java.lang.Object

  This `Parser` object is to be used as a simple template for parsing uncomplicated expressions. This object is used to parse a `String`. This provides a few methods that can be used to store and track the reading of data from a buffer. There are two abstract methods provided to allow this to be subclassed to create a `Parser` for a given `String`.
  Author:
    Niall Gallagher

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected char[]` | `buf` | This is the buffer that is being parsed.
    `protected int` | `count` | This represents the length of the buffer.
    `protected int` | `off` | This represents the current read offset.

  - ### Constructor Summary

    Constructors
    Modifier | Constructor | Description
    --- | --- | ---
    `protected` | `Parser()` | This is a no argument constructor for the `Parser`.

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `protected boolean` | `digit​(char c)` | This is used to determine wheather or not a given character is a digit character.
    `protected void` | `ensureCapacity​(int min)` | This ensure that there is enough space in the buffer to allow for more `char`'s to be added.
    `protected abstract void` | `init()` | This will initialize the `Parser` when it is ready to parse a new `String`.
    `protected abstract void` | `parse()` | This is the method that should be implemented to read the buf.
    `void` | `parse​(java.lang.String text)` | This is used to parse the `String` given to it.
    `protected boolean` | `skip​(java.lang.String text)` | This is used to skip an arbitrary `String` within the `char` buf.
    `protected boolean` | `space​(char c)` | This is used to determine if a given ISO-8859-1 character is a space character.
    `protected char` | `toLower​(char c)` | This takes a unicode character and assumes an encoding of ISO-8859-1.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### buf

          protected char[] buf

      This is the buffer that is being parsed.

    - #### off

          protected int off

      This represents the current read offset.

    - #### count

          protected int count

      This represents the length of the buffer.

  - ### Constructor Detail

    - #### Parser

          protected Parser()

      This is a no argument constructor for the `Parser`. This will be invoked by each subclass of this object. It will set the buffer to a zero length buffer so that when the `ensureCapacity` method is used the buf's length can be checked.

  - ### Method Detail

    - #### parse

          public void parse​(java.lang.String text)

      This is used to parse the `String` given to it. This will ensure that the `char` buffer has enough space to contain the characters from the `String`. This will firstly ensure that the buffer is resized if nessecary. The second step in this `parse` method is to initialize the `Parser` object so that multiple parse invokations can be made. The `init` method will reset this to an prepared state. Then finally the `parse` method is called to parse the `char` buffer.
      Parameters:
        `text` - the `String` to be parsed with this `Parser`

    - #### ensureCapacity

          protected void ensureCapacity​(int min)

      This ensure that there is enough space in the buffer to allow for more `char`'s to be added. If the buffer is already larger than min then the buffer will not be expanded at all.
      Parameters:
        `min` - the minimum size needed to accomodate the characters

    - #### space

          protected boolean space​(char c)

      This is used to determine if a given ISO-8859-1 character is a space character. That is a whitespace character this sees the, space, carrage return and line feed characters as whitespace characters.
      Parameters:
        `c` - the character that is being determined by this
      Returns:
        true if the character given it is a space character

    - #### digit

          protected boolean digit​(char c)

      This is used to determine wheather or not a given character is a digit character. It assumes iso-8859-1 encoding to compare.
      Parameters:
        `c` - the character being determined by this method
      Returns:
        true if the character given is a digit character

    - #### toLower

          protected char toLower​(char c)

      This takes a unicode character and assumes an encoding of ISO-8859-1. This then checks to see if the given character is uppercase if it is it converts it into is ISO-8859-1 lowercase char.
      Parameters:
        `c` - the `char` to be converted to lowercase
      Returns:
        the lowercase ISO-8859-1 of the given character

    - #### skip

          protected boolean skip​(java.lang.String text)

      This is used to skip an arbitrary `String` within the `char` buf. It checks the length of the `String` first to ensure that it will not go out of bounds. A comparison is then made with the buffers contents and the `String` if the reigon in the buffer matched the `String` then the offset within the buffer is increased by the `String`'s length so that it has effectively skipped it.
      Parameters:
        `text` - this is the `String` value to be skipped
      Returns:
        true if the `String` was skipped

    - #### init

          protected abstract void init()

      This will initialize the `Parser` when it is ready to parse a new `String`. This will reset the `Parser` to a ready state. The `init` method is invoked by the `Parser` when the `parse` method is invoked.

    - #### parse

          protected abstract void parse()

      This is the method that should be implemented to read the buf. This method should attempt to extract tokens from the buffer so that thes tokens may some how be used to determine the semantics. This method is invoked after the `init` method is invoked.