Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| HTML Parser Home Page
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.htmlparser.lexer
Class Stream

    java.lang.Object
      java.io.InputStream
          org.htmlparser.lexer.Stream

All Implemented Interfaces:
  Runnable

public class Stream
extends InputStream
implements Runnable

Provides for asynchronous fetching from a stream.

Field Summary
`protected static int` | `BUFFER_SIZE` An initial buffer size.
`protected static int` | `EOF` Return value when no more characters are left.
`int` | `fills`
`byte[]` | `mBuffer` The bytes read so far.
`protected int` | `mContentLength` The content length from the HTTP header.
`protected InputStream` | `mIn` The underlying stream.
`int` | `mLevel` The number of valid bytes in the buffer.
`protected int` | `mMark` The bookmark.
`protected int` | `mOffset` The offset of the next byte returned by read().
`int` | `reallocations`
`int` | `synchronous`

Constructor Summary
`Stream(InputStream in)` Construct a stream with no assumptions about the number of bytes available.
`Stream(InputStream in, int bytes)` Construct a stream to read the given number of bytes.

Method Summary
`int` | `available()` Returns the number of bytes that can be read (or skipped over) from this input stream without blocking by the next caller of a method for this input stream.
`void` | `close()` Closes this input stream and releases any system resources associated with the stream.
`protected boolean` | `fill(boolean force)` Fetch more bytes from the underlying stream.
`void` | `mark(int readlimit)` Marks the current position in this input stream.
`boolean` | `markSupported()` Tests if this input stream supports the `mark` and `reset` methods.
`int` | `read()` Reads the next byte of data from the input stream.
`void` | `reset()` Repositions this stream to the position at the time the `mark` method was last called on this input stream.
`void` | `run()` Continually read the underlying stream untill exhausted.

Methods inherited from class java.io.InputStream
`read, read, skip`

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

Field Detail

### fills

    public int fills

### reallocations

    public int reallocations

### synchronous

    public int synchronous

### BUFFER_SIZE

    protected static final int BUFFER_SIZE

  An initial buffer size.

  See Also:
    Constant Field Values

### EOF

    protected static final int EOF

  Return value when no more characters are left.

  See Also:
    Constant Field Values

### mIn

    protected volatile InputStream mIn

  The underlying stream.

### mBuffer

    public volatile byte[] mBuffer

  The bytes read so far.

### mLevel

    public volatile int mLevel

  The number of valid bytes in the buffer.

### mOffset

    protected int mOffset

  The offset of the next byte returned by read().

### mContentLength

    protected int mContentLength

  The content length from the HTTP header.

### mMark

    protected int mMark

  The bookmark.

Constructor Detail

### Stream

    public Stream(InputStream in)

  Construct a stream with no assumptions about the number of bytes available.

Parameters:
  `in` - The input stream to use.

### Stream

    public Stream(InputStream in,
                  int bytes)

  Construct a stream to read the given number of bytes.

Parameters:
  `in` - The input stream to use.
  `bytes` - The maximum number of bytes to read. This should be set to the ContentLength from the HTTP header. A negative or zero value indicates an unknown number of bytes.

Method Detail

### fill

    protected boolean fill(boolean force)
                    throws IOException

  Fetch more bytes from the underlying stream. Has no effect if the underlying stream has been drained.

  Parameters:
    `force` - If `true`, an attempt is made to read from the underlying stream, even if bytes are available, If `false`, a read of the underlying stream will not occur if there are already bytes available.
  Returns:
    `true` if not at the end of the input stream.
  Throws:
    `IOException` - If the underlying stream read() or available() throws one.

### run

    public void run()

  Continually read the underlying stream untill exhausted.

  Specified by:
    `run` in interface `Runnable`
  See Also:
    `Thread.run()`

### read

    public int read()
             throws IOException

  Reads the next byte of data from the input stream. The value byte is returned as an `int` in the range `0` to `255`. If no byte is available because the end of the stream has been reached, the value `-1` is returned. This method blocks until input data is available, the end of the stream is detected, or an exception is thrown.

  Returns:
    The next byte of data, or `-1` if the end of the stream is reached.
  Throws:
    `IOException` - If an I/O error occurs.

### available

    public int available()
                  throws IOException

  Returns the number of bytes that can be read (or skipped over) from this input stream without blocking by the next caller of a method for this input stream. The next caller might be the same thread or or another thread.

  Returns:
    The number of bytes that can be read from this input stream without blocking.
  Throws:
    `IOException` - If an I/O error occurs.

### close

    public void close()
               throws IOException

  Closes this input stream and releases any system resources associated with the stream.

  Throws:
    `IOException` - If an I/O error occurs.

### reset

    public void reset()
               throws IOException

  Repositions this stream to the position at the time the `mark` method was last called on this input stream.

  The general contract of `reset` is:

  - If the method `markSupported` returns `true`, then:
    - If the method `mark` has not been called since the stream was created, or the number of bytes read from the stream since `mark` was last called is larger than the argument to `mark` at that last call, then an `IOException` might be thrown.
    - If such an `IOException` is not thrown, then the stream is reset to a state such that all the bytes read since the most recent call to `mark` (or since the start of the file, if `mark` has not been called) will be resupplied to subsequent callers of the `read` method, followed by any bytes that otherwise would have been the next input data as of the time of the call to `reset`.
  - If the method `markSupported` returns `false`, then:
    - The call to `reset` may throw an `IOException`.
    - If an `IOException` is not thrown, then the stream is reset to a fixed state that depends on the particular type of the input stream and how it was created. The bytes that will be supplied to subsequent callers of the `read` method depend on the particular type of the input stream.

  Throws:
    `IOException` - Never thrown. Just for subclassers.
  See Also:
    `InputStream.mark(int)`, `IOException`

### markSupported

    public boolean markSupported()

  Tests if this input stream supports the `mark` and `reset` methods. Whether or not `mark` and `reset` are supported is an invariant property of a particular input stream instance. The `markSupported` method of `InputStream` returns `false`.

  Returns:
    `true`.
  See Also:
    `InputStream.mark(int)`, `InputStream.reset()`

### mark

    public void mark(int readlimit)

  Marks the current position in this input stream. A subsequent call to the `reset` method repositions this stream at the last marked position so that subsequent reads re-read the same bytes.

  The `readlimit` arguments tells this input stream to allow that many bytes to be read before the mark position gets invalidated.

  The general contract of `mark` is that, if the method `markSupported` returns `true`, the stream somehow remembers all the bytes read after the call to `mark` and stands ready to supply those same bytes again if and whenever the method `reset` is called. However, the stream is not required to remember any data at all if more than `readlimit` bytes are read from the stream before `reset` is called.

  Parameters:
    `readlimit` - Not used.
  See Also:
    `InputStream.reset()`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| © 2004 Somik Raha Mar 14, 2004
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

HTML Parser is an open source library released under LGPL.