FileDocCategorySizeDatePackage
WrappedInputStream.javaAPI DocApache Xerces 3.0.15173Fri Sep 14 20:33:58 BST 2007socket.io

WrappedInputStream

public class WrappedInputStream extends FilterInputStream
This input stream works in conjunction with the WrappedOutputStream to introduce a protocol for reading arbitrary length data in a uniform way.

Note: See the javadoc for WrappedOutputStream for more information.

see
WrappedOutputStream
author
Andy Clark, IBM
version
$Id: WrappedInputStream.java 447688 2006-09-19 02:39:49Z mrglavas $

Fields Summary
protected int
fPacketCount
Bytes left on input stream for current packet.
protected DataInputStream
fDataInputStream
Data input stream. This stream is used to input the block sizes from the data stream that are written by the WrappedOutputStream.

Note: The data input stream is only used for reading the byte count for performance reasons. We avoid the method indirection for reading the byte data.

protected boolean
fClosed
To mark that the stream is "closed".
Constructors Summary
public WrappedInputStream(InputStream stream)
Constructs a wrapper for the given an input stream.

        super(stream);
        fDataInputStream = new DataInputStream(stream);
    
Methods Summary
public voidclose()
Closes the input stream. This method will search for the end of the wrapped input, positioning the stream at after the end packet.

Note: This method does not close the underlying input stream.

        if (!fClosed) {
            fClosed = true;
            do {
                super.in.skip(fPacketCount);
                fPacketCount = fDataInputStream.readInt() & 0x7FFFFFFF;
            } while (fPacketCount > 0);
        }
    
public intread()
Reads a single byte.


        // ignore, if already closed
        if (fClosed) {
            return -1;
        }

        // read packet header
        if (fPacketCount == 0) {
            fPacketCount = fDataInputStream.readInt() & 0x7FFFFFFF;
            if (fPacketCount == 0) {
                fClosed = true;
                return -1;
            }
        }

        // read a byte from the packet
        fPacketCount--;
        return super.in.read();

    
public intread(byte[] b, int offset, int length)
Reads a block of bytes and returns the total number of bytes read.


        // ignore, if already closed
        if (fClosed) {
            return -1;
        }

        // read packet header
        if (fPacketCount == 0) {
            fPacketCount = fDataInputStream.readInt() & 0x7FFFFFFF;
            if (fPacketCount == 0) {
                fClosed = true;
                return -1;
            }
        }

        // read bytes from packet
        if (length > fPacketCount) {
            length = fPacketCount;
        }
        int count = super.in.read(b, offset, length);
        if (count == -1) {
            // NOTE: This condition should not happen. The end of 
            //       the stream should always be designated by a 
            //       byte count header of 0. -Ac
            fClosed = true;
            return -1;
        }
        fPacketCount -= count;

        // return total bytes read
        return count;

    
public longskip(long n)
Skips the specified number of bytes from the input stream.

        if (!fClosed) {
            // NOTE: This should be rewritten to be more efficient. -Ac
            for (long i = 0; i < n; i++) {
                int b = read();
                if (b == -1) {
                    return i + 1;
                }
            }
            return n;
        }
        return 0;