public SessionOutputBufferImpl(int buffersize,
    int linebuffersize,
    HttpParams params) 
{
        this(buffersize, linebuffersize, new HeapByteBufferAllocator(), params);
}

 public SessionOutputBufferImpl(int buffersize,
    int linebuffersize,
    ByteBufferAllocator allocator,
    HttpParams params) 
{
        super(buffersize, allocator);
        this.charbuffer = CharBuffer.allocate(linebuffersize);
        this.charset = Charset.forName(HttpProtocolParams.getHttpElementCharset(params)); 
        this.charencoder = this.charset.newEncoder();
}

 public int flush(WritableByteChannel channel) throws IOException 
{
        if (channel == null) {
            throw new IllegalArgumentException("Channel may not be null");
        }
        setOutputMode();
        int noWritten = channel.write(this.buffer);
        return noWritten;
}

 public  void reset(HttpParams params) 
{
        clear();
}

 public  void write(ByteBuffer src) 
{
        if (src == null) {
            return;
        }
        setInputMode();
        int requiredCapacity = this.buffer.position() + src.remaining();
        ensureCapacity(requiredCapacity);
        this.buffer.put(src);
}

 public  void write(ReadableByteChannel src) throws IOException 
{
        if (src == null) {
            return;
        }
        setInputMode();
        src.read(this.buffer);
}

 public  void writeLine(CharArrayBuffer linebuffer) throws CharacterCodingException 
{
        if (linebuffer == null) {
            return;
        }
        // Do not bother if the buffer is empty
        if (linebuffer.length()  > 0 ) {
            setInputMode();
            this.charencoder.reset();
            // transfer the string in small chunks
            int remaining = linebuffer.length();
            int offset = 0;
            while (remaining  > 0) {
                int l = this.charbuffer.remaining();
                boolean eol = false;
                if (remaining < = l) {
                    l = remaining;
                    // terminate the encoding process
                    eol = true;
                }
                this.charbuffer.put(linebuffer.buffer(), offset, l);
                this.charbuffer.flip();
                boolean retry = true;
                while (retry) {
                    CoderResult result = this.charencoder.encode(this.charbuffer, this.buffer, eol);
                    if (result.isError()) {
                        result.throwException();
                    }
                    if (result.isOverflow()) {
                        expand();
                    }
                    retry = !result.isUnderflow();
                }
                this.charbuffer.compact();
                offset += l;
                remaining -= l;
            }
            // flush the encoder
            boolean retry = true;
            while (retry) {
                CoderResult result = this.charencoder.flush(this.buffer);
                if (result.isError()) {
                    result.throwException();
                }
                if (result.isOverflow()) {
                    expand();
                }
                retry = !result.isUnderflow();
            }
        }
        writeCRLF();
}

 public  void writeLine(String s) throws IOException 
{
        if (s == null) {
            return;
        }
        if (s.length()  > 0) {
            CharArrayBuffer tmp = new CharArrayBuffer(s.length());
            tmp.append(s);
            writeLine(tmp);
        } else {
            write(CRLF);
        }
}