// ========================================================================
// $Id: ByteBufferOutputStream.java,v 1.18 2006/10/08 14:13:19 gregwilkins Exp $
// Copyright 2001-2004 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ========================================================================
package org.browsermob.proxy.jetty.util;
import org.apache.commons.logging.Log;
import org.browsermob.proxy.jetty.log.LogFactory;
import java.io.IOException;
import java.io.OutputStream;
/* ------------------------------------------------------------ */
/** ByteBuffer OutputStream.
* This stream is similar to the java.io.ByteArrayOutputStream,
* except that it maintains a reserve of bytes at the start of the
* buffer and allows efficient prepending of data.
*
* @version $Revision: 1.18 $
* @author Greg Wilkins (gregw)
*/
public class ByteBufferOutputStream extends OutputStream
{
private static Log log = LogFactory.getLog(ByteBufferOutputStream.class);
protected byte[] _buf;
/** The start of data capacity in the buffer
*/
private int _start;
/** The end of data capacity in the buffer
*/
private int _end;
/** The last byte of data written to the buffer
* _start <= _pos <= _end
*/
private int _pos;
private int _preReserve;
private int _postReserve;
private boolean _resized;
private boolean _fixed ;
/* ------------------------------------------------------------ */
/** Constructor.
*/
public ByteBufferOutputStream(){this(4096,0,0);}
/* ------------------------------------------------------------ */
/** Constructor.
* @param capacity Buffer capacity
*/
public ByteBufferOutputStream(int capacity)
{
this(capacity,0,0);
}
/* ------------------------------------------------------------ */
/** Constructor.
* @param capacity Buffer capacity.
* @param preReserve The reserve of byte for prepending
*/
public ByteBufferOutputStream(int capacity,int preReserve)
{
this(capacity,preReserve,0);
}
/* ------------------------------------------------------------ */
/** Constructor.
* @param bufferSize The size of the buffer == capacity+preReserve+postReserve
* @param preReserve The reserve of byte for prepending
* @param postReserve The reserve of byte for appending
*/
public ByteBufferOutputStream(int bufferSize,int preReserve,int postReserve)
{
_buf=ByteArrayPool.getByteArray(bufferSize);
_end=_buf.length-postReserve;
_preReserve=preReserve;
_start=preReserve;
_pos=preReserve;
_postReserve=postReserve;
}
/* ------------------------------------------------------------ */
/**
* @return True if the buffer cannot be expanded
*/
public boolean isFixed()
{
return _fixed;
}
/* ------------------------------------------------------------ */
/**
* @param fixed True if the buffer cannot be expanded
*/
public void setFixed(boolean fixed)
{
_fixed = fixed;
}
/* ------------------------------------------------------------ */
/**
* @return The size of valid data in the buffer.
*/
public int size()
{
return _pos-_start;
}
/* ------------------------------------------------------------ */
/**
* @return The size of the buffer.
*/
public int bufferSize()
{
return _buf.length;
}
/* ------------------------------------------------------------ */
/**
* @return The capacity of the buffer excluding pre and post reserves.
*/
public int capacity()
{
return _end-_start;
}
/* ------------------------------------------------------------ */
/**
* @return The available capacity of the buffer excluding pre and post
* reserves and data already written.
*/
public int spareCapacity()
{
return _end-_pos;
}
/* ------------------------------------------------------------ */
/**
* @return The current pre reserve.
*/
public int preReserve()
{
return _start;
}
/* ------------------------------------------------------------ */
/**
* @return The current post reserve.
*/
public int postReserve()
{
return _buf.length-_end;
}
/* ------------------------------------------------------------ */
public void writeTo(OutputStream out)
throws IOException
{
out.write(_buf,_start,_pos-_start);
}
/* ------------------------------------------------------------ */
public void write(int b)
throws IOException
{
ensureSpareCapacity(1);
_buf[_pos++]=(byte)b;
}
/* ------------------------------------------------------------ */
public void write(byte[] b)
throws IOException
{
ensureSpareCapacity(b.length);
System.arraycopy(b,0,_buf,_pos,b.length);
_pos+=b.length;
}
/* ------------------------------------------------------------ */
public void write(byte[] b,int offset, int length)
throws IOException
{
ensureSpareCapacity(length);
System.arraycopy(b,offset,_buf,_pos,length);
_pos+=length;
}
/* ------------------------------------------------------------ */
/** Write byte to start of the buffer.
* @param b
*/
public void prewrite(int b)
{
ensureReserve(1);
_buf[--_start]=(byte)b;
}
/* ------------------------------------------------------------ */
/** Write byte array to start of the buffer.
* @param b
*/
public void prewrite(byte[] b)
{
ensureReserve(b.length);
System.arraycopy(b,0,_buf,_start-b.length,b.length);
_start-=b.length;
}
/* ------------------------------------------------------------ */
/** Write byte range to start of the buffer.
* @param b
* @param offset
* @param length
*/
public void prewrite(byte[] b,int offset, int length)
{
ensureReserve(length);
System.arraycopy(b,offset,_buf,_start-length,length);
_start-=length;
}
/* ------------------------------------------------------------ */
/** Write bytes into the postreserve.
* The capacity is not checked.
* @param b
* @param offset
* @param length
* @exception IOException
*/
public void postwrite(byte b)
throws IOException
{
_buf[_pos++]=b;
}
/* ------------------------------------------------------------ */
/** Write bytes into the postreserve.
* The capacity is not checked.
* @param b
* @param offset
* @param length
* @exception IOException
*/
public void postwrite(byte[] b,int offset, int length)
throws IOException
{
System.arraycopy(b,offset,_buf,_pos,length);
_pos+=length;
}
/* ------------------------------------------------------------ */
public void flush()
throws IOException
{
}
/* ------------------------------------------------------------ */
public void resetStream()
{
_pos=_preReserve;
_start=_preReserve;
}
/* ------------------------------------------------------------ */
public void reset(int reserve)
{
_preReserve=reserve;
_pos=_preReserve;
_start=_preReserve;
}
/* ------------------------------------------------------------ */
public void close()
throws IOException
{
flush();
}
/* ------------------------------------------------------------ */
public void destroy()
{
if (!_resized)
ByteArrayPool.returnByteArray(_buf);
_buf=null;
}
/* ------------------------------------------------------------ */
public void ensureReserve(int n)
{
if (n>_start)
{
if (log.isDebugEnabled())log.debug("Reserve: "+n+">"+_start);
if ((_pos+n)<_end)
{
if (log.isDebugEnabled())log.debug("Shift reserve: "+_pos+"+"+n+"<"+_end);
System.arraycopy(_buf,_start,_buf,n,_pos-_start);
_pos=_pos+n-_start;
_start=n;
}
else
{
if (log.isDebugEnabled())log.debug("New reserve: "+_pos+"+"+n+">="+_end);
byte[] buf = new byte[_buf.length+n-_start];
System.arraycopy(_buf,_start,buf,n,_pos-_start);
_pos=n+_pos-_start;
_start=n;
_buf=buf;
_end=_buf.length-_postReserve;
}
}
}
/* ------------------------------------------------------------ */
public void ensureSize(int bufSize)
throws IOException
{
ensureSize(bufSize,_preReserve,_postReserve);
}
/* ------------------------------------------------------------ */
public void ensureSize(int bufSize, int pre, int post)
throws IOException
{
// Do we have space?
if (bufSize>_buf.length || pre>_preReserve || post>_postReserve)
{
// Make a bigger buffer if we are allowed.
if (_fixed)
throw new IllegalStateException("Fixed");
byte[] old=_buf;
_buf=ByteArrayPool.getByteArray(bufSize);
if (_pos>_start)
System.arraycopy(old,_start,_buf,pre,_pos-_start);
if (!_resized)
ByteArrayPool.returnByteArray(old);
_end=_buf.length-post;
_preReserve=pre;
_start=pre;
_pos=pre;
_postReserve=post;
}
}
/* ------------------------------------------------------------ */
public void ensureSpareCapacity(int n)
throws IOException
{
// Do we have space?
if (n>spareCapacity())
{
// No, then try flushing what we do have
if (_pos>_start )
flush();
ensureCapacity(n);
}
}
/* ------------------------------------------------------------ */
public void ensureCapacity(int n)
throws IOException
{
// Do we have space?
if (n>capacity())
{
// Make a bigger buffer if we are allowed.
if (_fixed)
throw new IllegalStateException("Fixed");
int new_size = ((n+_preReserve+_postReserve+4095)/4096)*4096;
byte[] old = _buf;
_buf = new byte[new_size];
if (_pos>_start)
System.arraycopy(old,_start,_buf,_start,_pos-_start);
if (!_resized)
ByteArrayPool.returnByteArray(old);
_end=_buf.length-_postReserve;
_resized=true;
}
}
}