package com.alimama.web;
public class ByteBuffer {
/**
* The array buffer into which the components of the ByteBuffer are
* stored. The capacity of the ByteBuffer is the length of this array buffer,
* and is at least large enough to contain all the ByteBuffer's elements.<p>
*
* Any array elements following the last element in the ByteBuffer are 0.
*/
protected char elementData[];
/**
* The number of valid components in this <tt>ByteBuffer</tt> object.
* Components <tt>elementData[0]</tt> through
* <tt>elementData[elementCount-1]</tt> are the actual items.
*
* @serial
*/
protected int elementCount;
/**
* The amount by which the capacity of the ByteBuffer is automatically
* incremented when its size becomes greater than its capacity. If
* the capacity increment is less than or equal to zero, the capacity
* of the ByteBuffer is doubled each time it needs to grow.
*
* @serial
*/
protected int capacityIncrement;
/**
* Constructs an empty ByteBuffer with the specified initial capacity and
* capacity increment.
*
* @param initialCapacity the initial capacity of the ByteBuffer.
* @param capacityIncrement the amount by which the capacity is
* increased when the ByteBuffer overflows.
* @exception IllegalArgumentException if the specified initial capacity
* is negative
*/
public ByteBuffer(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new char[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
/**
* Constructs an empty ByteBuffer with the specified initial capacity and
* with its capacity increment equal to zero.
*
* @param initialCapacity the initial capacity of the ByteBuffer.
* @exception IllegalArgumentException if the specified initial capacity
* is negative
*/
public ByteBuffer(int initialCapacity) {
this(initialCapacity, 0);
}
/**
* Constructs an empty ByteBuffer so that its internal data array
* has size <tt>10</tt> and its standard capacity increment is
* zero.
*/
public ByteBuffer() {
this(200);
}
/**
* Trims the capacity of this ByteBuffer to be the ByteBuffer's current
* size. If the capacity of this cector is larger than its current
* size, then the capacity is changed to equal the size by replacing
* its internal data array, kept in the field <tt>elementData</tt>,
* with a smaller one. An application can use this operation to
* minimize the storage of a ByteBuffer.
*/
public void trimToSize() {
int oldCapacity = elementData.length;
if (elementCount < oldCapacity) {
char oldData[] = elementData;
elementData = new char[elementCount];
System.arraycopy(oldData, 0, elementData, 0, elementCount);
}
}
/**
* This implements the unsynchronized semantics of ensureCapacity.
* Synchronized methods in this class can internally call this
* method for ensuring capacity without incurring the cost of an
* extra synchronization.
*
* @see java.util.ByteBuffer#ensureCapacity(int)
*/
private void ensureCapacityHelper(int minCapacity) {
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
char oldData[] = elementData;
int newCapacity = (capacityIncrement > 0) ?
(oldCapacity + capacityIncrement) : (oldCapacity * 2);
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
elementData = new char[newCapacity];
System.arraycopy(oldData, 0, elementData, 0, elementCount);
}
}
/**
* Returns the current capacity of this ByteBuffer.
*
* @return the current capacity (the length of its internal
* data arary, kept in the field <tt>elementData</tt>
* of this ByteBuffer.
*/
public int capacity() {
return elementData.length;
}
/**
* Returns the number of components in this ByteBuffer.
*
* @return the number of components in this ByteBuffer.
*/
public int size() {
return elementCount;
}
/**
* Tests if this ByteBuffer has no components.
*
* @return <code>true</code> if and only if this ByteBuffer has
* no components, that is, its size is zero;
* <code>false</code> otherwise.
*/
public boolean isEmpty() {
return elementCount == 0;
}
public void append(char value)
{
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = value;
}
// public void append( int value )
// {
// ensureCapacityHelper(elementCount + 4);
// doAppend( value ) ;
// }
// private void doAppend( int value )
// {
// int current = value ;
// for (int ctr=0; ctr<4; ctr++) {
// elementData[elementCount+ctr] = (byte)(current & 255) ;
// current = current >> 8 ;
// }
// elementCount += 4 ;
// }
//
// public void append( String value )
// {
// byte[] data = value.getBytes() ;
// ensureCapacityHelper( elementCount + data.length + 4 ) ;
// doAppend( data.length ) ;
// System.arraycopy( data, 0, elementData, elementCount, data.length ) ;
// elementCount += data.length ;
// }
/**
* Returns an array containing all of the elements in this ByteBuffer
* in the correct order.
*
* @since 1.2
*/
public char[] toArray() {
return elementData ;
}
}