org.apache.commons.httpclient: public class: ContentLengthInputStream

org.apache.commons.httpclient
public class: ContentLengthInputStream [javadoc | source]

java.lang.Object
   java.io.InputStream
      org.apache.commons.httpclient.ContentLengthInputStream

All Implemented Interfaces:
Closeable

Cuts the wrapped InputStream off after a specified number of bytes.

Implementation note: Choices abound. One approach would pass through the InputStream#mark and InputStream#reset calls to the underlying stream. That's tricky, though, because you then have to start duplicating the work of keeping track of how much a reset rewinds. Further, you have to watch out for the "readLimit", and since the semantics for the readLimit leave room for differing implementations, you might get into a lot of trouble.

Alternatively, you could make this class extend java.io.BufferedInputStream and then use the protected members of that class to avoid duplicated effort. That solution has the side effect of adding yet another possible layer of buffering.

Then, there is the simple choice, which this takes - simply don't support InputStream#mark and InputStream#reset . That choice has the added benefit of keeping this class very simple.

author: Ortwin - Glueck

author: Eric - Johnson

author: < - a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler

since: 2.0 -

Constructor:

Constructor:
public ContentLengthInputStream(InputStream in, int contentLength) { this(in, (long)contentLength); } Parameters: `in` - The stream to wrap `contentLength` - The maximum number of bytes that can be read from the stream. Subsequent read operations will return -1.
public ContentLengthInputStream(InputStream in, long contentLength) { super(); this.wrappedStream = in; this.contentLength = contentLength; } Creates a new length limited stream Parameters: `in` - The stream to wrap `contentLength` - The maximum number of bytes that can be read from the stream. Subsequent read operations will return -1. since: `3.0` -

 public ContentLengthInputStream(InputStream in,
    int contentLength) {
                                               
        this(in, (long)contentLength);
}

Parameters:

in - The stream to wrap

contentLength - The maximum number of bytes that can be read from the stream. Subsequent read operations will return -1.

 public ContentLengthInputStream(InputStream in,
    long contentLength) {
        super();
        this.wrappedStream = in;
        this.contentLength = contentLength;
}

Creates a new length limited stream

Parameters:

in - The stream to wrap

contentLength - The maximum number of bytes that can be read from the stream. Subsequent read operations will return -1.

since: 3.0 -

Method from org.apache.commons.httpclient.ContentLengthInputStream Summary:
available, close, read, read, read, skip

Methods from java.io.InputStream:
available, close, mark, markSupported, read, read, read, reset, skip

Methods from java.lang.Object:
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from org.apache.commons.httpclient.ContentLengthInputStream Detail:
public int available() throws IOException { if (this.closed) { return 0; } int avail = this.wrappedStream.available(); if (this.pos + avail > this.contentLength ) { avail = (int)(this.contentLength - this.pos); } return avail; }
public void close() throws IOException { if (!closed) { try { ChunkedInputStream.exhaustInputStream(this); } finally { // close after above so that we don't throw an exception trying // to read after closed! closed = true; } } } Reads until the end of the known length of content. Does not close the underlying socket input, but instead leaves it primed to parse the next response.
public int read() throws IOException { if (closed) { throw new IOException("Attempted read from closed stream."); } if (pos >= contentLength) { return -1; } pos++; return this.wrappedStream.read(); } Read the next byte from the stream
public int read(byte[] b) throws IOException { return read(b, 0, b.length); } Read more bytes from the stream.
public int read(byte[] b, int off, int len) throws IOException { if (closed) { throw new IOException("Attempted read from closed stream."); } if (pos >= contentLength) { return -1; } if (pos + len > contentLength) { len = (int) (contentLength - pos); } int count = this.wrappedStream.read(b, off, len); pos += count; return count; } Does standard InputStream#read(byte[], int, int) behavior, but also notifies the watcher when the contents have been consumed.
public long skip(long n) throws IOException { // make sure we don't skip more bytes than are // still available long length = Math.min(n, contentLength - pos); // skip and keep track of the bytes actually skipped length = this.wrappedStream.skip(length); // only add the skipped bytes to the current position // if bytes were actually skipped if (length > 0) { pos += length; } return length; } Skips and discards a number of bytes from the input stream.

Method from org.apache.commons.httpclient.ContentLengthInputStream Detail:

 public int available() throws IOException {
        if (this.closed) {
            return 0;
        }
        int avail = this.wrappedStream.available();
        if (this.pos + avail  > this.contentLength ) {
            avail = (int)(this.contentLength - this.pos);
        }
        return avail;
}

 public  void close() throws IOException {
        if (!closed) {
            try {
                ChunkedInputStream.exhaustInputStream(this);
            } finally {
                // close after above so that we don't throw an exception trying
                // to read after closed!
                closed = true;
            }
        }
}

Reads until the end of the known length of content.

Does not close the underlying socket input, but instead leaves it primed to parse the next response.

 public int read() throws IOException {
        if (closed) {
            throw new IOException("Attempted read from closed stream.");
        }
        if (pos  >= contentLength) {
            return -1;
        }
        pos++;
        return this.wrappedStream.read();
}

Read the next byte from the stream

 public int read(byte[] b) throws IOException {
        return read(b, 0, b.length);
}

Read more bytes from the stream.

 public int read(byte[] b,
    int off,
    int len) throws IOException {
        if (closed) {
            throw new IOException("Attempted read from closed stream.");
        }
        if (pos  >= contentLength) {
            return -1;
        }
        if (pos + len  > contentLength) {
            len = (int) (contentLength - pos);
        }
        int count = this.wrappedStream.read(b, off, len);
        pos += count;
        return count;
}

InputStream#read(byte[], int, int)

 public long skip(long n) throws IOException {
        // make sure we don't skip more bytes than are 
        // still available
        long length = Math.min(n, contentLength - pos);
        // skip and keep track of the bytes actually skipped
        length = this.wrappedStream.skip(length);
        // only add the skipped bytes to the current position
        // if bytes were actually skipped
        if (length  > 0) {
            pos += length;
        }
        return length;
}

Skips and discards a number of bytes from the input stream.