/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.mina.util.byteaccess;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.util.byteaccess.ByteArrayList.Node;
/**
* A ByteArray composed of other ByteArrays. Optimised for fast relative access
* via cursors. Absolute access methods are provided, but may perform poorly.
*
* TODO: Write about laziness of cursor implementation - how movement doesn't
* happen until actual get/put.
*
* @author <a href="http://mina.apache.org">Apache MINA Project</a>
*/
public final class CompositeByteArray extends AbstractByteArray {
/**
* Allows for efficient detection of component boundaries when using a cursor.
*
* TODO: Is this interface right?
*/
public interface CursorListener {
/**
* Called when the first component in the composite is entered by the cursor.
*/
public void enteredFirstComponent( int componentIndex, ByteArray component );
/**
* Called when the next component in the composite is entered by the cursor.
*/
public void enteredNextComponent( int componentIndex, ByteArray component );
/**
* Called when the previous component in the composite is entered by the cursor.
*/
public void enteredPreviousComponent( int componentIndex, ByteArray component );
/**
* Called when the last component in the composite is entered by the cursor.
*/
public void enteredLastComponent( int componentIndex, ByteArray component );
}
/**
* Stores the underlying <code>ByteArray</code>s.
*/
private final ByteArrayList bas = new ByteArrayList();
/**
* The byte order for data in the buffer
*/
private ByteOrder order;
/**
* May be used in <code>getSingleIoBuffer</code>. Optional.
*/
private final ByteArrayFactory byteArrayFactory;
/**
* Creates a new instance of CompositeByteArray.
*/
public CompositeByteArray() {
this( null );
}
/**
*
* Creates a new instance of CompositeByteArray.
*
* @param byteArrayFactory
* The factory used to create the ByteArray objects
*/
public CompositeByteArray( ByteArrayFactory byteArrayFactory ) {
this.byteArrayFactory = byteArrayFactory;
}
/**
* Returns the first {@link ByteArray} in the list
*
* @return
* The first ByteArray in the list
*/
public ByteArray getFirst() {
if ( bas.isEmpty() ) {
return null;
}
return bas.getFirst().getByteArray();
}
/**
* Adds the specified {@link ByteArray} to the first
* position in the list
*
* @param ba
* The ByteArray to add to the list
*/
public void addFirst( ByteArray ba ) {
addHook( ba );
bas.addFirst( ba );
}
/**
* Remove the first {@link ByteArray} in the list
*
* @return
* The first ByteArray in the list
*/
public ByteArray removeFirst() {
Node node = bas.removeFirst();
return node == null ? null : node.getByteArray();
}
/**
* Remove component <code>ByteArray</code>s to the given index (splitting
* them if necessary) and returning them in a single <code>ByteArray</code>.
* The caller is responsible for freeing the returned object.
*
* TODO: Document free behaviour more thoroughly.
*/
public ByteArray removeTo( int index ) {
if ( index < first() || index > last() ) {
throw new IndexOutOfBoundsException();
}
// Optimisation when removing exactly one component.
// if (index == start() + getFirst().length()) {
// ByteArray component = getFirst();
// removeFirst();
// return component;
// }
// Removing
CompositeByteArray prefix = new CompositeByteArray( byteArrayFactory );
int remaining = index - first();
while ( remaining > 0 ) {
ByteArray component = removeFirst();
if ( component.last() <= remaining ) {
// Remove entire component.
prefix.addLast( component );
remaining -= component.last();
} else {
// Remove part of component. Do this by removing entire
// component then readding remaining bytes.
// TODO: Consider using getIoBuffers(), as would avoid
// performance problems for nested ComponentByteArrays.
IoBuffer bb = component.getSingleIoBuffer();
// get the limit of the buffer
int originalLimit = bb.limit();
// set the position to the beginning of the buffer
bb.position( 0 );
// set the limit of the buffer to what is remaining
bb.limit( remaining );
// create a new IoBuffer, sharing the data with 'bb'
IoBuffer bb1 = bb.slice();
// set the position at the end of the buffer
bb.position( remaining );
// gets the limit of the buffer
bb.limit( originalLimit );
// create a new IoBuffer, sharing teh data with 'bb'
IoBuffer bb2 = bb.slice();
// create a new ByteArray with 'bb1'
ByteArray ba1 = new BufferByteArray( bb1 ) {
@Override
public void free() {
// Do not free. This will get freed
}
};
// add the new ByteArray to the CompositeByteArray
prefix.addLast( ba1 );
remaining -= ba1.last();
// final for anonymous inner class
final ByteArray componentFinal = component;
ByteArray ba2 = new BufferByteArray( bb2 ) {
@Override
public void free() {
componentFinal.free();
}
};
// add the new ByteArray to the CompositeByteArray
addFirst( ba2 );
}
}
// return the CompositeByteArray
return prefix;
}
/**
* Adds the specified {@link ByteArray} to the end of the list
*
* @param ba
* The ByteArray to add to the end of the list
*/
public void addLast( ByteArray ba ) {
addHook( ba );
bas.addLast( ba );
}
/**
* Removes the last {@link ByteArray} in the list
*
* @return
* The ByteArray that was removed
*/
public ByteArray removeLast() {
Node node = bas.removeLast();
return node == null ? null : node.getByteArray();
}
/**
* @inheritDoc
*/
public void free() {
while ( !bas.isEmpty() ) {
Node node = bas.getLast();
node.getByteArray().free();
bas.removeLast();
}
}
private void checkBounds( int index, int accessSize ) {
int lower = index;
int upper = index + accessSize;
if ( lower < first() ) {
throw new IndexOutOfBoundsException( "Index " + lower + " less than start " + first() + "." );
}
if ( upper > last() ) {
throw new IndexOutOfBoundsException( "Index " + upper + " greater than length " + last() + "." );
}
}
/**
* @inheritDoc
*/
public Iterable<IoBuffer> getIoBuffers() {
if ( bas.isEmpty() ) {
return Collections.emptyList();
}
Collection<IoBuffer> result = new ArrayList<IoBuffer>();
Node node = bas.getFirst();
for ( IoBuffer bb : node.getByteArray().getIoBuffers() ) {
result.add( bb );
}
while ( node.hasNextNode() ) {
node = node.getNextNode();
for ( IoBuffer bb : node.getByteArray().getIoBuffers() ) {
result.add( bb );
}
}
return result;
}
/**
* @inheritDoc
*/
public IoBuffer getSingleIoBuffer() {
if ( byteArrayFactory == null ) {
throw new IllegalStateException(
"Can't get single buffer from CompositeByteArray unless it has a ByteArrayFactory." );
}
if ( bas.isEmpty() ) {
ByteArray ba = byteArrayFactory.create( 1 );
return ba.getSingleIoBuffer();
}
int actualLength = last() - first();
{
Node node = bas.getFirst();
ByteArray ba = node.getByteArray();
if ( ba.last() == actualLength ) {
return ba.getSingleIoBuffer();
}
}
// Replace all nodes with a single node.
ByteArray target = byteArrayFactory.create( actualLength );
IoBuffer bb = target.getSingleIoBuffer();
Cursor cursor = cursor();
cursor.put( bb ); // Copy all existing data into target IoBuffer.
while ( !bas.isEmpty() ) {
Node node = bas.getLast();
ByteArray component = node.getByteArray();
bas.removeLast();
component.free();
}
bas.addLast( target );
return bb;
}
/**
* @inheritDoc
*/
public Cursor cursor() {
return new CursorImpl();
}
/**
* @inheritDoc
*/
public Cursor cursor( int index ) {
return new CursorImpl( index );
}
/**
* Get a cursor starting at index 0 (which may not be the start of the
* array) and with the given listener.
*
* @param listener
* Returns a new {@link Cursor} instance
*/
public Cursor cursor( CursorListener listener ) {
return new CursorImpl( listener );
}
/**
* Get a cursor starting at the given index and with the given listener.
*
* @param index
* The position of the array to start the Cursor at
* @param listener
* The listener for the Cursor that is returned
*/
public Cursor cursor( int index, CursorListener listener ) {
return new CursorImpl( index, listener );
}
/**
* @inheritDoc
*/
public ByteArray slice( int index, int length ) {
return cursor( index ).slice( length );
}
/**
* @inheritDoc
*/
public byte get( int index ) {
return cursor( index ).get();
}
/**
* @inheritDoc
*/
public void put( int index, byte b )
{
cursor( index ).put( b );
}
/**
* @inheritDoc
*/
public void get( int index, IoBuffer bb )
{
cursor( index ).get( bb );
}
/**
* @inheritDoc
*/
public void put( int index, IoBuffer bb )
{
cursor( index ).put( bb );
}
/**
* @inheritDoc
*/
public int first()
{
return bas.firstByte();
}
/**
* @inheritDoc
*/
public int last()
{
return bas.lastByte();
}
/**
* This method should be called prior to adding any component
* <code>ByteArray</code> to a composite.
*
* @param ba
* The component to add.
*/
private void addHook( ByteArray ba )
{
// Check first() is zero, otherwise cursor might not work.
// TODO: Remove this restriction?
if ( ba.first() != 0 )
{
throw new IllegalArgumentException( "Cannot add byte array that doesn't start from 0: " + ba.first() );
}
// Check order.
if ( order == null )
{
order = ba.order();
}
else if ( !order.equals( ba.order() ) )
{
throw new IllegalArgumentException( "Cannot add byte array with different byte order: " + ba.order() );
}
}
/**
* @inheritDoc
*/
public ByteOrder order()
{
if ( order == null )
{
throw new IllegalStateException( "Byte order not yet set." );
}
return order;
}
/**
* @inheritDoc
*/
public void order( ByteOrder order ) {
if ( order == null || !order.equals( this.order ) ) {
this.order = order;
if ( !bas.isEmpty() ) {
for ( Node node = bas.getFirst(); node.hasNextNode(); node = node.getNextNode() ) {
node.getByteArray().order( order );
}
}
}
}
/**
* @inheritDoc
*/
public short getShort( int index ) {
return cursor( index ).getShort();
}
/**
* @inheritDoc
*/
public void putShort( int index, short s ) {
cursor( index ).putShort( s );
}
/**
* @inheritDoc
*/
public int getInt( int index )
{
return cursor( index ).getInt();
}
/**
* @inheritDoc
*/
public void putInt( int index, int i )
{
cursor( index ).putInt( i );
}
/**
* @inheritDoc
*/
public long getLong( int index )
{
return cursor( index ).getLong();
}
/**
* @inheritDoc
*/
public void putLong( int index, long l )
{
cursor( index ).putLong( l );
}
/**
* @inheritDoc
*/
public float getFloat( int index )
{
return cursor( index ).getFloat();
}
/**
* @inheritDoc
*/
public void putFloat( int index, float f )
{
cursor( index ).putFloat( f );
}
/**
* @inheritDoc
*/
public double getDouble( int index )
{
return cursor( index ).getDouble();
}
/**
* @inheritDoc
*/
public void putDouble( int index, double d )
{
cursor( index ).putDouble( d );
}
/**
* @inheritDoc
*/
public char getChar( int index )
{
return cursor( index ).getChar();
}
/**
* @inheritDoc
*/
public void putChar( int index, char c )
{
cursor( index ).putChar( c );
}
private class CursorImpl implements Cursor
{
private int index;
private final CursorListener listener;
private Node componentNode;
// Index of start of current component.
private int componentIndex;
// Cursor within current component.
private ByteArray.Cursor componentCursor;
public CursorImpl()
{
this( 0, null );
}
public CursorImpl( int index )
{
this( index, null );
}
public CursorImpl( CursorListener listener )
{
this( 0, listener );
}
public CursorImpl( int index, CursorListener listener )
{
this.index = index;
this.listener = listener;
}
/**
* @inheritDoc
*/
public int getIndex()
{
return index;
}
/**
* @inheritDoc
*/
public void setIndex( int index )
{
checkBounds( index, 0 );
this.index = index;
}
/**
* @inheritDoc
*/
public void skip( int length )
{
setIndex( index + length );
}
/**
* @inheritDoc
*/
public ByteArray slice( int length )
{
CompositeByteArray slice = new CompositeByteArray( byteArrayFactory );
int remaining = length;
while ( remaining > 0 )
{
prepareForAccess( remaining );
int componentSliceSize = Math.min( remaining, componentCursor.getRemaining() );
ByteArray componentSlice = componentCursor.slice( componentSliceSize );
slice.addLast( componentSlice );
index += componentSliceSize;
remaining -= componentSliceSize;
}
return slice;
}
/**
* @inheritDoc
*/
public ByteOrder order()
{
return CompositeByteArray.this.order();
}
private void prepareForAccess( int accessSize )
{
// Handle removed node. Do this first so we can remove the reference
// even if bounds checking fails.
if ( componentNode != null && componentNode.isRemoved() )
{
componentNode = null;
componentCursor = null;
}
// Bounds checks
checkBounds( index, accessSize );
// Remember the current node so we can later tell whether or not we
// need to create a new cursor.
Node oldComponentNode = componentNode;
// Handle missing node.
if ( componentNode == null )
{
int basMidpoint = ( last() - first() ) / 2 + first();
if ( index <= basMidpoint )
{
// Search from the start.
componentNode = bas.getFirst();
componentIndex = first();
if ( listener != null )
{
listener.enteredFirstComponent( componentIndex, componentNode.getByteArray() );
}
}
else
{
// Search from the end.
componentNode = bas.getLast();
componentIndex = last() - componentNode.getByteArray().last();
if ( listener != null )
{
listener.enteredLastComponent( componentIndex, componentNode.getByteArray() );
}
}
}
// Go back, if necessary.
while ( index < componentIndex )
{
componentNode = componentNode.getPreviousNode();
componentIndex -= componentNode.getByteArray().last();
if ( listener != null )
{
listener.enteredPreviousComponent( componentIndex, componentNode.getByteArray() );
}
}
// Go forward, if necessary.
while ( index >= componentIndex + componentNode.getByteArray().length() )
{
componentIndex += componentNode.getByteArray().last();
componentNode = componentNode.getNextNode();
if ( listener != null )
{
listener.enteredNextComponent( componentIndex, componentNode.getByteArray() );
}
}
// Update the cursor.
int internalComponentIndex = index - componentIndex;
if ( componentNode == oldComponentNode )
{
// Move existing cursor.
componentCursor.setIndex( internalComponentIndex );
}
else
{
// Create new cursor.
componentCursor = componentNode.getByteArray().cursor( internalComponentIndex );
}
}
/**
* @inheritDoc
*/
public int getRemaining()
{
return last() - index + 1;
}
/**
* @inheritDoc
*/
public boolean hasRemaining()
{
return getRemaining() > 0;
}
/**
* @inheritDoc
*/
public byte get()
{
prepareForAccess( 1 );
byte b = componentCursor.get();
index += 1;
return b;
}
/**
* @inheritDoc
*/
public void put( byte b )
{
prepareForAccess( 1 );
componentCursor.put( b );
index += 1;
}
/**
* @inheritDoc
*/
public void get( IoBuffer bb )
{
while ( bb.hasRemaining() )
{
int remainingBefore = bb.remaining();
prepareForAccess( remainingBefore );
componentCursor.get( bb );
int remainingAfter = bb.remaining();
// Advance index by actual amount got.
int chunkSize = remainingBefore - remainingAfter;
index += chunkSize;
}
}
/**
* @inheritDoc
*/
public void put( IoBuffer bb )
{
while ( bb.hasRemaining() )
{
int remainingBefore = bb.remaining();
prepareForAccess( remainingBefore );
componentCursor.put( bb );
int remainingAfter = bb.remaining();
// Advance index by actual amount put.
int chunkSize = remainingBefore - remainingAfter;
index += chunkSize;
}
}
/**
* @inheritDoc
*/
public short getShort()
{
prepareForAccess( 2 );
if ( componentCursor.getRemaining() >= 4 )
{
short s = componentCursor.getShort();
index += 2;
return s;
}
else
{
byte b0 = get();
byte b1 = get();
if ( order.equals( ByteOrder.BIG_ENDIAN ) )
{
return ( short ) ( ( b0 << 8 ) | ( b1 << 0 ) );
}
else
{
return ( short ) ( ( b1 << 8 ) | ( b0 << 0 ) );
}
}
}
/**
* @inheritDoc
*/
public void putShort( short s )
{
prepareForAccess( 2 );
if ( componentCursor.getRemaining() >= 4 )
{
componentCursor.putShort( s );
index += 2;
}
else
{
byte b0;
byte b1;
if ( order.equals( ByteOrder.BIG_ENDIAN ) )
{
b0 = ( byte ) ( ( s >> 8 ) & 0xff );
b1 = ( byte ) ( ( s >> 0 ) & 0xff );
}
else
{
b0 = ( byte ) ( ( s >> 0 ) & 0xff );
b1 = ( byte ) ( ( s >> 8 ) & 0xff );
}
put( b0 );
put( b1 );
}
}
/**
* @inheritDoc
*/
public int getInt()
{
prepareForAccess( 4 );
if ( componentCursor.getRemaining() >= 4 )
{
int i = componentCursor.getInt();
index += 4;
return i;
}
else
{
byte b0 = get();
byte b1 = get();
byte b2 = get();
byte b3 = get();
if ( order.equals( ByteOrder.BIG_ENDIAN ) )
{
return ( ( b0 << 24 ) | ( b1 << 16 ) | ( b2 << 8 ) | ( b3 << 0 ) );
}
else
{
return ( ( b3 << 24 ) | ( b2 << 16 ) | ( b1 << 8 ) | ( b0 << 0 ) );
}
}
}
/**
* @inheritDoc
*/
public void putInt( int i )
{
prepareForAccess( 4 );
if ( componentCursor.getRemaining() >= 4 )
{
componentCursor.putInt( i );
index += 4;
}
else
{
byte b0;
byte b1;
byte b2;
byte b3;
if ( order.equals( ByteOrder.BIG_ENDIAN ) )
{
b0 = ( byte ) ( ( i >> 24 ) & 0xff );
b1 = ( byte ) ( ( i >> 16 ) & 0xff );
b2 = ( byte ) ( ( i >> 8 ) & 0xff );
b3 = ( byte ) ( ( i >> 0 ) & 0xff );
}
else
{
b0 = ( byte ) ( ( i >> 0 ) & 0xff );
b1 = ( byte ) ( ( i >> 8 ) & 0xff );
b2 = ( byte ) ( ( i >> 16 ) & 0xff );
b3 = ( byte ) ( ( i >> 24 ) & 0xff );
}
put( b0 );
put( b1 );
put( b2 );
put( b3 );
}
}
/**
* @inheritDoc
*/
public long getLong()
{
prepareForAccess( 8 );
if ( componentCursor.getRemaining() >= 4 )
{
long l = componentCursor.getLong();
index += 8;
return l;
}
else
{
byte b0 = get();
byte b1 = get();
byte b2 = get();
byte b3 = get();
byte b4 = get();
byte b5 = get();
byte b6 = get();
byte b7 = get();
if ( order.equals( ByteOrder.BIG_ENDIAN ) )
{
return ( ( b0 & 0xffL ) << 56 ) | ( ( b1 & 0xffL ) << 48 ) | ( ( b2 & 0xffL ) << 40 )
| ( ( b3 & 0xffL ) << 32 ) | ( ( b4 & 0xffL ) << 24 ) | ( ( b5 & 0xffL ) << 16 )
| ( ( b6 & 0xffL ) << 8 ) | ( ( b7 & 0xffL ) << 0 );
}
else
{
return ( ( b7 & 0xffL ) << 56 ) | ( ( b6 & 0xffL ) << 48 ) | ( ( b5 & 0xffL ) << 40 )
| ( ( b4 & 0xffL ) << 32 ) | ( ( b3 & 0xffL ) << 24 ) | ( ( b2 & 0xffL ) << 16 )
| ( ( b1 & 0xffL ) << 8 ) | ( ( b0 & 0xffL ) << 0 );
}
}
}
/**
* @inheritDoc
*/
public void putLong( long l )
{
//TODO: see if there is some optimizing that can be done here
prepareForAccess( 8 );
if ( componentCursor.getRemaining() >= 4 )
{
componentCursor.putLong( l );
index += 8;
}
else
{
byte b0;
byte b1;
byte b2;
byte b3;
byte b4;
byte b5;
byte b6;
byte b7;
if ( order.equals( ByteOrder.BIG_ENDIAN ) )
{
b0 = ( byte ) ( ( l >> 56 ) & 0xff );
b1 = ( byte ) ( ( l >> 48 ) & 0xff );
b2 = ( byte ) ( ( l >> 40 ) & 0xff );
b3 = ( byte ) ( ( l >> 32 ) & 0xff );
b4 = ( byte ) ( ( l >> 24 ) & 0xff );
b5 = ( byte ) ( ( l >> 16 ) & 0xff );
b6 = ( byte ) ( ( l >> 8 ) & 0xff );
b7 = ( byte ) ( ( l >> 0 ) & 0xff );
}
else
{
b0 = ( byte ) ( ( l >> 0 ) & 0xff );
b1 = ( byte ) ( ( l >> 8 ) & 0xff );
b2 = ( byte ) ( ( l >> 16 ) & 0xff );
b3 = ( byte ) ( ( l >> 24 ) & 0xff );
b4 = ( byte ) ( ( l >> 32 ) & 0xff );
b5 = ( byte ) ( ( l >> 40 ) & 0xff );
b6 = ( byte ) ( ( l >> 48 ) & 0xff );
b7 = ( byte ) ( ( l >> 56 ) & 0xff );
}
put( b0 );
put( b1 );
put( b2 );
put( b3 );
put( b4 );
put( b5 );
put( b6 );
put( b7 );
}
}
/**
* @inheritDoc
*/
public float getFloat()
{
prepareForAccess( 4 );
if ( componentCursor.getRemaining() >= 4 )
{
float f = componentCursor.getFloat();
index += 4;
return f;
}
else
{
int i = getInt();
return Float.intBitsToFloat( i );
}
}
/**
* @inheritDoc
*/
public void putFloat( float f )
{
prepareForAccess( 4 );
if ( componentCursor.getRemaining() >= 4 )
{
componentCursor.putFloat( f );
index += 4;
}
else
{
int i = Float.floatToIntBits( f );
putInt( i );
}
}
/**
* @inheritDoc
*/
public double getDouble()
{
prepareForAccess( 8 );
if ( componentCursor.getRemaining() >= 4 )
{
double d = componentCursor.getDouble();
index += 8;
return d;
}
else
{
long l = getLong();
return Double.longBitsToDouble( l );
}
}
/**
* @inheritDoc
*/
public void putDouble( double d )
{
prepareForAccess( 8 );
if ( componentCursor.getRemaining() >= 4 )
{
componentCursor.putDouble( d );
index += 8;
}
else
{
long l = Double.doubleToLongBits( d );
putLong( l );
}
}
/**
* @inheritDoc
*/
public char getChar()
{
prepareForAccess( 2 );
if ( componentCursor.getRemaining() >= 4 )
{
char c = componentCursor.getChar();
index += 2;
return c;
}
else
{
byte b0 = get();
byte b1 = get();
if ( order.equals( ByteOrder.BIG_ENDIAN ) )
{
return ( char ) ( ( b0 << 8 ) | ( b1 << 0 ) );
}
else
{
return ( char ) ( ( b1 << 8 ) | ( b0 << 0 ) );
}
}
}
/**
* @inheritDoc
*/
public void putChar( char c )
{
prepareForAccess( 2 );
if ( componentCursor.getRemaining() >= 4 )
{
componentCursor.putChar( c );
index += 2;
}
else
{
byte b0;
byte b1;
if ( order.equals( ByteOrder.BIG_ENDIAN ) )
{
b0 = ( byte ) ( ( c >> 8 ) & 0xff );
b1 = ( byte ) ( ( c >> 0 ) & 0xff );
}
else
{
b0 = ( byte ) ( ( c >> 0 ) & 0xff );
b1 = ( byte ) ( ( c >> 8 ) & 0xff );
}
put( b0 );
put( b1 );
}
}
}
}