org.apache.http.message

## Class BasicLineParser

- java.lang.Object
- - org.apache.http.message.BasicLineParser

- All Implemented Interfaces:
    LineParser

      @Immutable
      public class BasicLineParser
      extends Object
      implements LineParser

  Basic parser for lines in the head section of an HTTP message. There are individual methods for parsing a request line, a status line, or a header line. The lines to parse are passed in memory, the parser does not depend on any specific IO mechanism. Instances of this class are stateless and thread-safe. Derived classes MUST maintain these properties.

  Note: This class was created by refactoring parsing code located in various other classes. The author tags from those other classes have been replicated here, although the association with the parsing code taken from there has not been traced.

  Since:
    4.0

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static BasicLineParser` | `DEFAULT` Deprecated. (4.3) use `INSTANCE`
    `static BasicLineParser` | `INSTANCE`
    `protected ProtocolVersion` | `protocol` A version of the protocol to parse.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BasicLineParser()` Creates a new line parser for HTTP.
    `BasicLineParser(ProtocolVersion proto)` Creates a new line parser for the given HTTP-like protocol.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected ProtocolVersion` | `createProtocolVersion(int major, int minor)` Creates a protocol version.
    `protected RequestLine` | `createRequestLine(String method, String uri, ProtocolVersion ver)` Instantiates a new request line.
    `protected StatusLine` | `createStatusLine(ProtocolVersion ver, int status, String reason)` Instantiates a new status line.
    `boolean` | `hasProtocolVersion(CharArrayBuffer buffer, ParserCursor cursor)` Checks whether there likely is a protocol version in a line.
    `Header` | `parseHeader(CharArrayBuffer buffer)` Creates a header from a line.
    `static Header` | `parseHeader(String value, LineParser parser)`
    `ProtocolVersion` | `parseProtocolVersion(CharArrayBuffer buffer, ParserCursor cursor)` Parses the textual representation of a protocol version.
    `static ProtocolVersion` | `parseProtocolVersion(String value, LineParser parser)`
    `RequestLine` | `parseRequestLine(CharArrayBuffer buffer, ParserCursor cursor)` Parses a request line.
    `static RequestLine` | `parseRequestLine(String value, LineParser parser)`
    `StatusLine` | `parseStatusLine(CharArrayBuffer buffer, ParserCursor cursor)` Parses a status line.
    `static StatusLine` | `parseStatusLine(String value, LineParser parser)`
    `protected void` | `skipWhitespace(CharArrayBuffer buffer, ParserCursor cursor)` Helper to skip whitespace.

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

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

- - ### Field Detail

    - #### DEFAULT

          @Deprecated
          public static final BasicLineParser DEFAULT

      Deprecated. (4.3) use `INSTANCE`
      A default instance of this class, for use as default or fallback. Note that `BasicLineParser` is not a singleton, there can be many instances of the class itself and of derived classes. The instance here provides non-customized, default behavior.

    - #### INSTANCE

          public static final BasicLineParser INSTANCE

    - #### protocol

          protected final ProtocolVersion protocol

      A version of the protocol to parse. The version is typically not relevant, but the protocol name.

  - ### Constructor Detail

    - #### BasicLineParser

          public BasicLineParser(ProtocolVersion proto)

      Creates a new line parser for the given HTTP-like protocol.
      Parameters:
        `proto` - a version of the protocol to parse, or `null` for HTTP. The actual version is not relevant, only the protocol name.

    - #### BasicLineParser

          public BasicLineParser()

      Creates a new line parser for HTTP.

  - ### Method Detail

    - #### parseProtocolVersion

          public static ProtocolVersion parseProtocolVersion(String value,
                                             LineParser parser)
                                                      throws ParseException

      Throws:
        `ParseException`

    - #### parseProtocolVersion

          public ProtocolVersion parseProtocolVersion(CharArrayBuffer buffer,
                                             ParserCursor cursor)
                                               throws ParseException

      Description copied from interface: `LineParser`
      Parses the textual representation of a protocol version. This is needed for parsing request lines (last element) as well as status lines (first element).
      Specified by:
        `parseProtocolVersion` in interface `LineParser`
      Parameters:
        `buffer` - a buffer holding the protocol version to parse
        `cursor` - the parser cursor containing the current position and the bounds within the buffer for the parsing operation
      Returns:
        the parsed protocol version
      Throws:
        `ParseException` - in case of a parse error

    - #### createProtocolVersion

          protected ProtocolVersion createProtocolVersion(int major,
                                              int minor)

      Creates a protocol version. Called from `parseProtocolVersion(java.lang.String, org.apache.http.message.LineParser)`.
      Parameters:
        `major` - the major version number, for example 1 in HTTP/1.0
        `minor` - the minor version number, for example 0 in HTTP/1.0
      Returns:
        the protocol version

    - #### hasProtocolVersion

          public boolean hasProtocolVersion(CharArrayBuffer buffer,
                                   ParserCursor cursor)

      Description copied from interface: `LineParser`
      Checks whether there likely is a protocol version in a line. This method implements a heuristic to check for a likely protocol version specification. It does not guarantee that `LineParser.parseProtocolVersion(org.apache.http.util.CharArrayBuffer, org.apache.http.message.ParserCursor)` would not detect a parse error. This can be used to detect garbage lines before a request or status line.
      Specified by:
        `hasProtocolVersion` in interface `LineParser`
      Parameters:
        `buffer` - a buffer holding the line to inspect
        `cursor` - the cursor at which to check for a protocol version, or negative for "end of line". Whether the check tolerates whitespace before or after the protocol version is implementation dependent.
      Returns:
        `true` if there is a protocol version at the argument index (possibly ignoring whitespace), `false` otherwise

    - #### parseRequestLine

          public static RequestLine parseRequestLine(String value,
                                     LineParser parser)
                                              throws ParseException

      Throws:
        `ParseException`

    - #### parseRequestLine

          public RequestLine parseRequestLine(CharArrayBuffer buffer,
                                     ParserCursor cursor)
                                       throws ParseException

      Parses a request line.
      Specified by:
        `parseRequestLine` in interface `LineParser`
      Parameters:
        `buffer` - a buffer holding the line to parse
        `cursor` - the parser cursor containing the current position and the bounds within the buffer for the parsing operation
      Returns:
        the parsed request line
      Throws:
        `ParseException` - in case of a parse error

    - #### createRequestLine

          protected RequestLine createRequestLine(String method,
                                      String uri,
                                      ProtocolVersion ver)

      Instantiates a new request line. Called from `parseRequestLine(java.lang.String, org.apache.http.message.LineParser)`.
      Parameters:
        `method` - the request method
        `uri` - the requested URI
        `ver` - the protocol version
      Returns:
        a new status line with the given data

    - #### parseStatusLine

          public static StatusLine parseStatusLine(String value,
                                   LineParser parser)
                                            throws ParseException

      Throws:
        `ParseException`

    - #### parseStatusLine

          public StatusLine parseStatusLine(CharArrayBuffer buffer,
                                   ParserCursor cursor)
                                     throws ParseException

      Description copied from interface: `LineParser`
      Parses a status line.
      Specified by:
        `parseStatusLine` in interface `LineParser`
      Parameters:
        `buffer` - a buffer holding the line to parse
        `cursor` - the parser cursor containing the current position and the bounds within the buffer for the parsing operation
      Returns:
        the parsed status line
      Throws:
        `ParseException` - in case of a parse error

    - #### createStatusLine

          protected StatusLine createStatusLine(ProtocolVersion ver,
                                    int status,
                                    String reason)

      Instantiates a new status line. Called from `parseStatusLine(java.lang.String, org.apache.http.message.LineParser)`.
      Parameters:
        `ver` - the protocol version
        `status` - the status code
        `reason` - the reason phrase
      Returns:
        a new status line with the given data

    - #### parseHeader

          public static Header parseHeader(String value,
                           LineParser parser)
                                    throws ParseException

      Throws:
        `ParseException`

    - #### parseHeader

          public Header parseHeader(CharArrayBuffer buffer)
                             throws ParseException

      Description copied from interface: `LineParser`
      Creates a header from a line. The full header line is expected here. Header continuation lines must be joined by the caller before invoking this method.
      Specified by:
        `parseHeader` in interface `LineParser`
      Parameters:
        `buffer` - a buffer holding the full header line. This buffer MUST NOT be re-used afterwards, since the returned object may reference the contents later.
      Returns:
        the header in the argument buffer. The returned object MAY be a wrapper for the argument buffer. The argument buffer MUST NOT be re-used or changed afterwards.
      Throws:
        `ParseException` - in case of a parse error

    - #### skipWhitespace

          protected void skipWhitespace(CharArrayBuffer buffer,
                            ParserCursor cursor)

      Helper to skip whitespace.

Copyright © 2005–2013 The Apache Software Foundation. All rights reserved.