FileDocCategorySizeDatePackage
AbstractSessionOutputBuffer.javaAPI DocAndroid 1.5 API6209Wed May 06 22:41:10 BST 2009org.apache.http.impl.io

AbstractSessionOutputBuffer

public abstract class AbstractSessionOutputBuffer extends Object implements SessionOutputBuffer
Abstract base class for session output buffers that stream data to an {@link OutputStream}.
author
Oleg Kalnichevski

Fields Summary
private static final byte[]
CRLF
private static final int
MAX_CHUNK
private OutputStream
outstream
private ByteArrayBuffer
buffer
private String
charset
private boolean
ascii
private HttpTransportMetricsImpl
metrics
Constructors Summary
Methods Summary
public voidflush()

        flushBuffer();
        this.outstream.flush();
    
protected voidflushBuffer()

        int len = this.buffer.length();
        if (len > 0) {
            this.outstream.write(this.buffer.buffer(), 0, len);
            this.buffer.clear();
            this.metrics.incrementBytesTransferred(len);
        }
    
public org.apache.http.io.HttpTransportMetricsgetMetrics()

        return this.metrics;
    
protected voidinit(java.io.OutputStream outstream, int buffersize, org.apache.http.params.HttpParams params)

    
              
        if (outstream == null) {
            throw new IllegalArgumentException("Input stream may not be null");
        }
        if (buffersize <= 0) {
            throw new IllegalArgumentException("Buffer size may not be negative or zero");
        }
        if (params == null) {
            throw new IllegalArgumentException("HTTP parameters may not be null");
        }
        this.outstream = outstream;
        this.buffer = new ByteArrayBuffer(buffersize);
        this.charset = HttpProtocolParams.getHttpElementCharset(params); 
        this.ascii = this.charset.equalsIgnoreCase(HTTP.US_ASCII)
                     || this.charset.equalsIgnoreCase(HTTP.ASCII);
        this.metrics = new HttpTransportMetricsImpl();
    
public voidwrite(byte[] b, int off, int len)

        if (b == null) {
            return;
        }
        // Do not want to buffer largish chunks
        // if the byte array is larger then MAX_CHUNK
        // write it directly to the output stream
        if (len > MAX_CHUNK || len > this.buffer.capacity()) {
            // flush the buffer
            flushBuffer();
            // write directly to the out stream
            this.outstream.write(b, off, len);
            this.metrics.incrementBytesTransferred(len);
        } else {
            // Do not let the buffer grow unnecessarily
            int freecapacity = this.buffer.capacity() - this.buffer.length();
            if (len > freecapacity) {
                // flush the buffer
                flushBuffer();
            }
            // buffer
            this.buffer.append(b, off, len);
        }
    
public voidwrite(byte[] b)

        if (b == null) {
            return;
        }
        write(b, 0, b.length);
    
public voidwrite(int b)

        if (this.buffer.isFull()) {
            flushBuffer();
        }
        this.buffer.append(b);
    
public voidwriteLine(java.lang.String s)

        if (s == null) {
            return;
        }
        if (s.length() > 0) {
            write(s.getBytes(this.charset));
        }
        write(CRLF);
    
public voidwriteLine(org.apache.http.util.CharArrayBuffer s)

        if (s == null) {
            return;
        }
        if (this.ascii) {
            int off = 0;
            int remaining = s.length();
            while (remaining > 0) {
                int chunk = this.buffer.capacity() - this.buffer.length();
                chunk = Math.min(chunk, remaining);
                if (chunk > 0) {
                    this.buffer.append(s, off, chunk);
                }
                if (this.buffer.isFull()) {
                    flushBuffer();
                }
                off += chunk;
                remaining -= chunk;
            }
        } else {
            // This is VERY memory inefficient, BUT since non-ASCII charsets are 
            // NOT meant to be used anyway, there's no point optimizing it
            byte[] tmp = s.toString().getBytes(this.charset);
            write(tmp);
        }
        write(CRLF);