/*
* Copyright (c) 2001, 2002, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.corba.se.impl.ior ;
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 byte elementData[];
/**
* The number of valid components in this {@code ByteBuffer} object.
* Components {@code elementData[0]} through
* {@code elementData[elementCount-1]} 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 byte[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 {@code 10} 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 {@code elementData},
* 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) {
byte oldData[] = elementData;
elementData = new byte[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) {
byte oldData[] = elementData;
int newCapacity = (capacityIncrement > 0) ?
(oldCapacity + capacityIncrement) : (oldCapacity * 2);
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
elementData = new byte[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 {@code elementData}
* 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} if and only if this ByteBuffer has
* no components, that is, its size is zero;
* {@code false} otherwise.
*/
public boolean isEmpty() {
return elementCount == 0;
}
public void append(byte 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 byte[] toArray() {
return elementData ;
}
}