public InputBuffer() 
{
    // ----------------------------------------------------------- Constructors
        this(DEFAULT_BUFFER_SIZE);
}

Default constructor. Allocate the buffer with the default buffer size.

 public InputBuffer(int size) 
{
        this.size = size;
        bb = new ByteChunk(size);
        bb.setLimit(size);
        bb.setByteInputChannel(this);
        cb = new CharChunk(size);
        cb.setLimit(size);
        cb.setOptimizedWrite(false);
        cb.setCharInputChannel(this);
        cb.setCharOutputChannel(this);
}

Alternate constructor which allows specifying the initial buffer size.

Parameters:

size - Buffer size to use

 public int available() 
{
        int available = 0;
        if (state == BYTE_STATE) {
            available = bb.getLength();
        } else if (state == CHAR_STATE) {
            available = cb.getLength();
        }
        if (available == 0) {
            coyoteRequest.action(ActionCode.ACTION_AVAILABLE, null);
            available = (coyoteRequest.getAvailable()  > 0) ? 1 : 0;
        }
        return available;
}

 public  void checkConverter() throws IOException 
{
        if (!gotEnc)
            setConverter();
}

 public  void clearEncoders() 
{
        encoders.clear();
}

Clear cached encoders (to save memory for Comet requests).

 public  void close() throws IOException 
{
        closed = true;
}

Close the input buffer.

 public Request getRequest() 
{
        return this.coyoteRequest;
}

Get associated Coyote request.

 public  void mark(int readAheadLimit) throws IOException 
{
        if (cb.getLength() < = 0) {
            cb.setOffset(0);
            cb.setEnd(0);
        } else {
            if ((cb.getBuffer().length  > (2 * size)) 
                && (cb.getLength()) <  (cb.getStart())) {
                System.arraycopy(cb.getBuffer(), cb.getStart(), 
                                 cb.getBuffer(), 0, cb.getLength());
                cb.setEnd(cb.getLength());
                cb.setOffset(0);
            }
        }
        int offset = readAheadLimit;
        if (offset <  size) {
            offset = size;
        }
        cb.setLimit(cb.getStart() + offset);
        markPos = cb.getStart();
}

 public boolean markSupported() 
{
        return true;
}

 public int read() throws IOException 
{
        return cb.substract();
}

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

 public int read(byte[] b,
    int off,
    int len) throws IOException 
{
        return bb.substract(b, off, len);
}

 public int read(char[] cbuf,
    int off,
    int len) throws IOException 
{
        return cb.substract(cbuf, off, len);
}

 public int readByte() throws IOException 
{
        return bb.substract();
}

 public boolean ready() throws IOException 
{
        return (available()  > 0);
}

 public int realReadBytes(byte[] cbuf,
    int off,
    int len) throws IOException 
{
        if (closed)
            return -1;
        if (coyoteRequest == null)
            return -1;
        if(state == INITIAL_STATE)
            state = BYTE_STATE;
        int result = coyoteRequest.doRead(bb);
        return result;
}

Reads new bytes in the byte chunk.

 public int realReadChars(char[] cbuf,
    int off,
    int len) throws IOException 
{
        if (!gotEnc)
            setConverter();
        if (bb.getLength() < = 0) {
            int nRead = realReadBytes(bb.getBytes(), 0, bb.getBytes().length);
            if (nRead <  0) {
                return -1;
            }
        }
        if (markPos == -1) {
            cb.setOffset(0);
            cb.setEnd(0);
        }
        state = CHAR_STATE;
        conv.convert(bb, cb, len);
        bb.setOffset(bb.getEnd());
        return cb.getLength();
}

 public  void realWriteChars(char[] c,
    int off,
    int len) throws IOException 
{
        markPos = -1;
        cb.setOffset(0);
        cb.setEnd(0);
}

Since the converter will use append, it is possible to get chars to be removed from the buffer for "writing". Since the chars have already been read before, they are ignored. If a mark was set, then the mark is lost.

 public  void recycle() 
{
        
        state = INITIAL_STATE;
        bytesRead = 0;
        charsRead = 0;
        // If usage of mark made the buffer too big, reallocate it
        if (cb.getChars().length  > size) {
            cb = new CharChunk(size);
            cb.setLimit(size);
            cb.setOptimizedWrite(false);
            cb.setCharInputChannel(this);
            cb.setCharOutputChannel(this);
        } else {
            cb.recycle();
        }
        markPos = -1;
        bb.recycle(); 
        closed = false;
        if (conv != null) {
            conv.recycle();
        }
        gotEnc = false;
        enc = null;
}

Recycle the output buffer.

 public  void reset() throws IOException 
{
        if (state == CHAR_STATE) {
            if (markPos <  0) {
                cb.recycle();
                markPos = -1;
                throw new IOException();
            } else {
                cb.setOffset(markPos);
            }
        } else {
            bb.recycle();
        }
}

 protected  void setConverter() throws IOException 
{
        if (coyoteRequest != null)
            enc = coyoteRequest.getCharacterEncoding();
        gotEnc = true;
        if (enc == null)
            enc = DEFAULT_ENCODING;
        conv = (B2CConverter) encoders.get(enc);
        if (conv == null) {
            if (SecurityUtil.isPackageProtectionEnabled()){
                try{
                    conv = (B2CConverter)AccessController.doPrivileged(
                            new PrivilegedExceptionAction(){
                                public Object run() throws IOException{
                                    return new B2CConverter(enc);
                                }
                            }
                    );              
                }catch(PrivilegedActionException ex){
                    Exception e = ex.getException();
                    if (e instanceof IOException)
                        throw (IOException)e; 
                }
            } else {
                conv = new B2CConverter(enc);
            }
            encoders.put(enc, conv);
        }
}

 public  void setEncoding(String s) 
{
        enc = s;
}

 public  void setRequest(Request coyoteRequest) 
{
	this.coyoteRequest = coyoteRequest;
}

Associated Coyote request.

 public long skip(long n) throws IOException 
{
        if (n <  0) {
            throw new IllegalArgumentException();
        }
        long nRead = 0;
        while (nRead <  n) {
            if (cb.getLength()  >= n) {
                cb.setOffset(cb.getStart() + (int) n);
                nRead = n;
            } else {
                nRead += cb.getLength();
                cb.setOffset(cb.getEnd());
                int toRead = 0;
                if (cb.getChars().length <  (n - nRead)) {
                    toRead = cb.getChars().length;
                } else {
                    toRead = (int) (n - nRead);
                }
                int nb = realReadChars(cb.getChars(), 0, toRead);
                if (nb <  0)
                    break;
            }
        }
        return nRead;
}