public InternalNioOutputBuffer(Response response) 
{
    
        this(response, Constants.DEFAULT_HTTP_HEADER_BUFFER_SIZE);
}

Default constructor.

 public InternalNioOutputBuffer(Response response,
    int headerBufferSize) 
{
        this.response = response;
        headers = response.getMimeHeaders();
        buf = new byte[headerBufferSize];
        if (headerBufferSize <  (8 * 1024)) {
            bbufLimit = 6 * 1500;    
        } else {
            bbufLimit = (headerBufferSize / 1500 + 1) * 1500;
        }
        //bbuf = ByteBuffer.allocateDirect(bbufLimit);
        outputStreamOutputBuffer = new SocketOutputBuffer();
        filterLibrary = new OutputFilter[0];
        activeFilters = new OutputFilter[0];
        lastActiveFilter = -1;
        committed = false;
        finished = false;
        // Cause loading of HttpMessages
        HttpMessages.getMessage(200);
}

Alternate constructor.

 public  void addActiveFilter(OutputFilter filter) 
{
        if (lastActiveFilter == -1) {
            filter.setBuffer(outputStreamOutputBuffer);
        } else {
            for (int i = 0; i < = lastActiveFilter; i++) {
                if (activeFilters[i] == filter)
                    return;
            }
            filter.setBuffer(activeFilters[lastActiveFilter]);
        }
        activeFilters[++lastActiveFilter] = filter;
        filter.setResponse(response);
}

Add an output filter to the filter library.

 public  void addFilter(OutputFilter filter) 
{
        OutputFilter[] newFilterLibrary = 
            new OutputFilter[filterLibrary.length + 1];
        for (int i = 0; i <  filterLibrary.length; i++) {
            newFilterLibrary[i] = filterLibrary[i];
        }
        newFilterLibrary[filterLibrary.length] = filter;
        filterLibrary = newFilterLibrary;
        activeFilters = new OutputFilter[filterLibrary.length];
}

Add an output filter to the filter library.

 public  void clearFilters() 
{
        filterLibrary = new OutputFilter[0];
        lastActiveFilter = -1;
}

Clear filters.

 protected  void commit() throws IOException 
{
        // The response is now committed
        committed = true;
        response.setCommitted(true);
        if (pos  > 0) {
            // Sending the response header buffer
            addToBB(buf, 0, pos);
        }
}

Commit the response.

 public int doWrite(ByteChunk chunk,
    Response res) throws IOException 
{
        if (!committed) {
            // Send the connector a request for commit. The connector should
            // then validate the headers, send them (using sendHeaders) and 
            // set the filters accordingly.
            response.action(ActionCode.ACTION_COMMIT, null);
        }
        if (lastActiveFilter == -1)
            return outputStreamOutputBuffer.doWrite(chunk, res);
        else
            return activeFilters[lastActiveFilter].doWrite(chunk, res);
}

Write the contents of a byte chunk.

 public  void endHeaders() 
{
        buf[pos++] = Constants.CR;
        buf[pos++] = Constants.LF;
}

End the header block.

 public  void endRequest() throws IOException 
{
        if (!committed) {
            // Send the connector a request for commit. The connector should
            // then validate the headers, send them (using sendHeader) and 
            // set the filters accordingly.
            response.action(ActionCode.ACTION_COMMIT, null);
        }
        if (finished)
            return;
        if (lastActiveFilter != -1)
            activeFilters[lastActiveFilter].end();
        flushBuffer();
        finished = true;
}

End request.

 public  void flush() throws IOException 
{
        if (!committed) {
            // Send the connector a request for commit. The connector should
            // then validate the headers, send them (using sendHeader) and 
            // set the filters accordingly.
            response.action(ActionCode.ACTION_COMMIT, null);
        }
        // Flush the current buffer
        flushBuffer();
}

Flush the response.

 protected  void flushBuffer() throws IOException 
{
        //prevent timeout for async,
        SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());
        if (key != null) {
            NioEndpoint.KeyAttachment attach = (NioEndpoint.KeyAttachment) key.attachment();
            attach.access();
        }
        //write to the socket, if there is anything to write
        if (socket.getBufHandler().getWriteBuffer().position()  > 0) {
            socket.getBufHandler().getWriteBuffer().flip();
            writeToSocket(socket.getBufHandler().getWriteBuffer(),true, false);
        }
}

Callback to write data from the buffer.

 public OutputFilter[] getFilters() 
{
        return filterLibrary;
}

Get filters.

 public NioSelectorPool getSelectorPool() 
{
        return pool;
}

 public NioChannel getSocket() 
{
        return socket;
}

Get the underlying socket input stream.

 public boolean isWritable() 
{
        return lastWrite.get() >0;
}

 public  void nextRequest() 
{
        // Recycle Request object
        response.recycle();
        // Recycle filters
        for (int i = 0; i < = lastActiveFilter; i++) {
            activeFilters[i].recycle();
        }
        // Reset pointers
        pos = 0;
        lastActiveFilter = -1;
        committed = false;
        finished = false;
}

End processing of current HTTP request. Note: All bytes of the current request should have been already consumed. This method only resets all the pointers so that we are ready to parse the next HTTP request.

 public  void recycle() 
{
        // Recycle filters
        for (int i = 0; i < = lastActiveFilter; i++) {
            activeFilters[i].recycle();
        }
        // Recycle Request object
        response.recycle();
        socket.getBufHandler().getWriteBuffer().clear();
        socket = null;
        pos = 0;
        lastActiveFilter = -1;
        committed = false;
        finished = false;
        lastWrite.set(1);
}

Recycle the output buffer. This should be called when closing the connection.

 public  void reset() 
{
        if (committed)
            throw new IllegalStateException(/*FIXME:Put an error message*/);
        // Recycle Request object
        response.recycle();
}

Reset current response.

 public  void sendAck() throws IOException 
{
        if (!committed) {
            //Socket.send(socket, Constants.ACK_BYTES, 0, Constants.ACK_BYTES.length) <  0
            socket.getBufHandler() .getWriteBuffer().put(Constants.ACK_BYTES,0,Constants.ACK_BYTES.length);    
            writeToSocket(socket.getBufHandler() .getWriteBuffer(),true,true);
        }
}

Send an acknoledgement.

 public  void sendHeader(MessageBytes name,
    MessageBytes value) 
{
        write(name);
        buf[pos++] = Constants.COLON;
        buf[pos++] = Constants.SP;
        write(value);
        buf[pos++] = Constants.CR;
        buf[pos++] = Constants.LF;
}

Send a header.

 public  void sendHeader(ByteChunk name,
    ByteChunk value) 
{
        write(name);
        buf[pos++] = Constants.COLON;
        buf[pos++] = Constants.SP;
        write(value);
        buf[pos++] = Constants.CR;
        buf[pos++] = Constants.LF;
}

Send a header.

 public  void sendHeader(String name,
    String value) 
{
        write(name);
        buf[pos++] = Constants.COLON;
        buf[pos++] = Constants.SP;
        write(value);
        buf[pos++] = Constants.CR;
        buf[pos++] = Constants.LF;
}

Send a header.

 public  void sendStatus() 
{
        // Write protocol name
        write(Constants.HTTP_11_BYTES);
        buf[pos++] = Constants.SP;
        // Write status code
        int status = response.getStatus();
        switch (status) {
        case 200:
            write(Constants._200_BYTES);
            break;
        case 400:
            write(Constants._400_BYTES);
            break;
        case 404:
            write(Constants._404_BYTES);
            break;
        default:
            write(status);
        }
        buf[pos++] = Constants.SP;
        // Write message
        String message = response.getMessage();
        if (message == null) {
            write(HttpMessages.getMessage(status));
        } else {
            write(message);
        }
        // End the response status line
        buf[pos++] = Constants.CR;
        buf[pos++] = Constants.LF;
}

Send the response status line.

 public  void setSelectorPool(NioSelectorPool pool) 
{
 
        this.pool = pool;
}

 public  void setSocket(NioChannel socket) 
{
    
    // ------------------------------------------------------------- Properties
        this.socket = socket;
}

Set the underlying socket.

 public  void setSocketBuffer(int socketBufferSize) 
{
        // FIXME: Remove
}

Set the socket buffer size.

 protected  void write(MessageBytes mb) 
{
        if (mb.getType() == MessageBytes.T_BYTES) {
            ByteChunk bc = mb.getByteChunk();
            write(bc);
        } else if (mb.getType() == MessageBytes.T_CHARS) {
            CharChunk cc = mb.getCharChunk();
            write(cc);
        } else {
            write(mb.toString());
        }
}

This method will write the contents of the specyfied message bytes buffer to the output stream, without filtering. This method is meant to be used to write the response header.

 protected  void write(ByteChunk bc) 
{
        // Writing the byte chunk to the output buffer
        int length = bc.getLength();
        System.arraycopy(bc.getBytes(), bc.getStart(), buf, pos, length);
        pos = pos + length;
}

This method will write the contents of the specyfied message bytes buffer to the output stream, without filtering. This method is meant to be used to write the response header.

 protected  void write(CharChunk cc) 
{
        int start = cc.getStart();
        int end = cc.getEnd();
        char[] cbuf = cc.getBuffer();
        for (int i = start; i <  end; i++) {
            char c = cbuf[i];
            // Note:  This is clearly incorrect for many strings,
            // but is the only consistent approach within the current
            // servlet framework.  It must suffice until servlet output
            // streams properly encode their output.
            if ((c < = 31) && (c != 9)) {
                c = ' ";
            } else if (c == 127) {
                c = ' ";
            }
            buf[pos++] = (byte) c;
        }
}

This method will write the contents of the specyfied char buffer to the output stream, without filtering. This method is meant to be used to write the response header.

 public  void write(byte[] b) 
{
        // Writing the byte chunk to the output buffer
        System.arraycopy(b, 0, buf, pos, b.length);
        pos = pos + b.length;
}

This method will write the contents of the specyfied byte buffer to the output stream, without filtering. This method is meant to be used to write the response header.

 protected  void write(String s) 
{
        if (s == null)
            return;
        // From the Tomcat 3.3 HTTP/1.0 connector
        int len = s.length();
        for (int i = 0; i <  len; i++) {
            char c = s.charAt (i);
            // Note:  This is clearly incorrect for many strings,
            // but is the only consistent approach within the current
            // servlet framework.  It must suffice until servlet output
            // streams properly encode their output.
            if ((c < = 31) && (c != 9)) {
                c = ' ";
            } else if (c == 127) {
                c = ' ";
            }
            buf[pos++] = (byte) c;
        }
}

This method will write the contents of the specyfied String to the output stream, without filtering. This method is meant to be used to write the response header.

 protected  void write(int i) 
{
        write(String.valueOf(i));
}

This method will print the specified integer to the output stream, without filtering. This method is meant to be used to write the response header.