| java.lang.Object
 java.io.InputStream
sun.net.www.http.ChunkedInputStream
| ChunkedInputStream | | public class ChunkedInputStream extends InputStream implements Hurryable(Code) | | A ChunkedInputStream provides a stream for reading a body of
a http message that can be sent as a series of chunks, each with its own
size indicator. Optionally the last chunk can be followed by trailers
containing entity-header fields.
A ChunkedInputStream is also Hurryable so it
can be hurried to the end of the stream if the bytes are available on
the underlying stream.
|
| Field Summary | |
| final static int | STATE_AWAITING_CHUNK_EOL
| | final static int | STATE_AWAITING_CHUNK_HEADER
| | final static int | STATE_AWAITING_TRAILERS
Indicates that all chunks have been read and the next field
should be optional trailers or an indication that the chunked
stream is complete. | | final static int | STATE_DONE
State to indicate that the chunked stream is complete and
no further bytes should be read from the underlying stream. | | final static int | STATE_READING_CHUNK
State to indicate that we are currently reading the chunk-data. |
| Method Summary | |
| public synchronized int | available()
Returns the number of bytes that can be read from this input
stream without blocking. | | public synchronized void | close()
Close the stream by either returning the connection to the
keep alive cache or closing the underlying stream. | | public synchronized boolean | hurry()
Hurry the input stream by reading everything from the underlying
stream. | | public synchronized int | read()
See
the general contract of the read
method of InputStream. | | public synchronized int | read(byte b, int off, int len)
Reads bytes from this stream into the specified byte array, starting at
the given offset.
Parameters:
b - destination buffer.
Parameters:
off - offset at which to start storing bytes.
Parameters:
len - maximum number of bytes to read. |
| STATE_AWAITING_CHUNK_EOL | | final static int STATE_AWAITING_CHUNK_EOL(Code) | | Indicates that a chunk has been completely read and the next
fields to be examine should be CRLF
|
| STATE_AWAITING_CHUNK_HEADER | | final static int STATE_AWAITING_CHUNK_HEADER(Code) | | State to indicate that next field should be :-
chunk-size [ chunk-extension ] CRLF
|
| STATE_AWAITING_TRAILERS | | final static int STATE_AWAITING_TRAILERS(Code) | | Indicates that all chunks have been read and the next field
should be optional trailers or an indication that the chunked
stream is complete.
|
| STATE_DONE | | final static int STATE_DONE(Code) | | State to indicate that the chunked stream is complete and
no further bytes should be read from the underlying stream.
|
| STATE_READING_CHUNK | | final static int STATE_READING_CHUNK(Code) | | State to indicate that we are currently reading the chunk-data.
|
| ChunkedInputStream | | public ChunkedInputStream(InputStream in, HttpClient hc, MessageHeader responses) throws IOException(Code) | | Creates a ChunkedInputStream and saves its arguments, for
later use.
Parameters:
in - the underlying input stream.
Parameters:
hc - the HttpClient
Parameters:
responses - the MessageHeader that should be populated with optionaltrailers. |
| available | | public synchronized int available() throws IOException(Code) | | Returns the number of bytes that can be read from this input
stream without blocking.
the number of bytes that can be read from this inputstream without blocking.
exception:
IOException - if an I/O error occurs.
See Also: java.io.FilterInputStream.in |
| close | | public synchronized void close() throws IOException(Code) | | Close the stream by either returning the connection to the
keep alive cache or closing the underlying stream.
If the chunked response hasn't been completely read we
try to "hurry" to the end of the response. If this is
possible (without blocking) then the connection can be
returned to the keep alive cache.
exception:
IOException - if an I/O error occurs. |
| hurry | | public synchronized boolean hurry()(Code) | | Hurry the input stream by reading everything from the underlying
stream. If the last chunk (and optional trailers) can be read without
blocking then the stream is considered hurried.
Note that if an error has occured or we can't get to last chunk
without blocking then this stream can't be hurried and should be
closed.
|
| read | | public synchronized int read(byte b, int off, int len) throws IOException(Code) | | Reads bytes from this stream into the specified byte array, starting at
the given offset.
Parameters:
b - destination buffer.
Parameters:
off - offset at which to start storing bytes.
Parameters:
len - maximum number of bytes to read. the number of bytes read, or -1 if the end ofthe stream has been reached.
exception:
IOException - if an I/O error occurs. |
|
|