[hornetq-commits] JBoss hornetq SVN: r10739 - in trunk: hornetq-commons/src/main/java/org/hornetq/api and 10 other directories.

Author: borges Date: 2011-05-26 08:50:50 -0400 (Thu, 26 May 2011) New Revision: 10739 Added: trunk/hornetq-commons/src/main/java/org/hornetq/api/ trunk/hornetq-commons/src/main/java/org/hornetq/api/core/ trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQBuffer.java trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQBuffers.java trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQException.java trunk/hornetq-commons/src/main/java/org/hornetq/api/core/Pair.java trunk/hornetq-commons/src/main/java/org/hornetq/api/core/SimpleString.java trunk/hornetq-commons/src/main/java/org/hornetq/core/buffers/ trunk/hornetq-commons/src/main/java/org/hornetq/core/buffers/impl/ trunk/hornetq-commons/src/main/java/org/hornetq/core/buffers/impl/ChannelBufferWrapper.java trunk/hornetq-commons/src/main/java/org/hornetq/core/server/ trunk/hornetq-commons/src/main/java/org/hornetq/core/server/HornetQComponent.java trunk/hornetq-commons/src/main/java/org/hornetq/utils/ trunk/hornetq-commons/src/main/java/org/hornetq/utils/DataConstants.java trunk/hornetq-commons/src/main/java/org/hornetq/utils/UTF8Util.java Removed: trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffer.java trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffers.java trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQException.java trunk/hornetq-core/src/main/java/org/hornetq/api/core/Pair.java trunk/hornetq-core/src/main/java/org/hornetq/api/core/SimpleString.java trunk/hornetq-core/src/main/java/org/hornetq/core/buffers/impl/ChannelBufferWrapper.java trunk/hornetq-core/src/main/java/org/hornetq/core/server/HornetQComponent.java trunk/hornetq-core/src/main/java/org/hornetq/utils/DataConstants.java trunk/hornetq-core/src/main/java/org/hornetq/utils/UTF8Util.java Log: HORNETQ-698 Move other necessary classes for hq-journal into hq-commons Copied: trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQBuffer.java (from rev 10738, trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffer.java) =================================================================== --- trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQBuffer.java (rev 0) +++ trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQBuffer.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -0,0 +1,1086 @@ +/* + * Copyright 2009 Red Hat, Inc. + * Red Hat 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.hornetq.api.core; + +import java.nio.ByteBuffer; + +import org.jboss.netty.buffer.ChannelBuffer; + +/** + * + * A HornetQBuffer wraps a Netty's ChannelBuffer and is used throughout HornetQ code base. + * + * Much of it derived from Netty ChannelBuffer by Trustin Lee + * + * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> + * + * @see HornetQBuffers + * + */ +public interface HornetQBuffer +{ + /** + * Returns the underlying Netty's ChannelBuffer + * + * @return the underlying Netty's ChannelBuffer + */ + ChannelBuffer channelBuffer(); + + /** + * Returns the number of bytes this buffer can contain. + */ + int capacity(); + + /** + * Returns the {@code readerIndex} of this buffer. + */ + int readerIndex(); + + /** + * Sets the {@code readerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code readerIndex} is + * less than {@code 0} or + * greater than {@code this.writerIndex} + */ + void readerIndex(int readerIndex); + + /** + * Returns the {@code writerIndex} of this buffer. + */ + int writerIndex(); + + /** + * Sets the {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code writerIndex} is + * less than {@code this.readerIndex} or + * greater than {@code this.capacity} + */ + void writerIndex(int writerIndex); + + /** + * Sets the {@code readerIndex} and {@code writerIndex} of this buffer + * in one shot. This method is useful when you have to worry about the + * invocation order of {@link #readerIndex(int)} and {@link #writerIndex(int)} + * methods. For example, the following code will fail: + * + * <pre> + * // Create a buffer whose readerIndex, writerIndex and capacity are + * // 0, 0 and 8 respectively. + * ChannelBuffer buf = ChannelBuffers.buffer(8); + * + * // IndexOutOfBoundsException is thrown because the specified + * // readerIndex (2) cannot be greater than the current writerIndex (0). + * buf.readerIndex(2); + * buf.writerIndex(4); + * </pre> + * + * The following code will also fail: + * + * <pre> + * // Create a buffer whose readerIndex, writerIndex and capacity are + * // 0, 8 and 8 respectively. + * ChannelBuffer buf = ChannelBuffers.wrappedBuffer(new byte[8]); + * + * // readerIndex becomes 8. + * buf.readLong(); + * + * // IndexOutOfBoundsException is thrown because the specified + * // writerIndex (4) cannot be less than the current readerIndex (8). + * buf.writerIndex(4); + * buf.readerIndex(2); + * </pre> + * + * By contrast, {@link #setIndex(int, int)} guarantees that it never + * throws an {@link IndexOutOfBoundsException} as long as the specified + * indexes meet basic constraints, regardless what the current index + * values of the buffer are: + * + * <pre> + * // No matter what the current state of the buffer is, the following + * // call always succeeds as long as the capacity of the buffer is not + * // less than 4. + * buf.setIndex(2, 4); + * </pre> + * + * @throws IndexOutOfBoundsException + * if the specified {@code readerIndex} is less than 0, + * if the specified {@code writerIndex} is less than the specified + * {@code readerIndex} or if the specified {@code writerIndex} is + * greater than {@code this.capacity} + */ + void setIndex(int readerIndex, int writerIndex); + + /** + * Returns the number of readable bytes which is equal to + * {@code (this.writerIndex - this.readerIndex)}. + */ + int readableBytes(); + + /** + * Returns the number of writable bytes which is equal to + * {@code (this.capacity - this.writerIndex)}. + */ + int writableBytes(); + + /** + * Returns {@code true} + * if and only if {@code (this.writerIndex - this.readerIndex)} is greater + * than {@code 0}. + */ + boolean readable(); + + /** + * Returns {@code true} + * if and only if {@code (this.capacity - this.writerIndex)} is greater + * than {@code 0}. + */ + boolean writable(); + + /** + * Sets the {@code readerIndex} and {@code writerIndex} of this buffer to + * {@code 0}. + * This method is identical to {@link #setIndex(int, int) setIndex(0, 0)}. + * <p> + * Please note that the behavior of this method is different + * from that of NIO buffer, which sets the {@code limit} to + * the {@code capacity} of the buffer. + */ + void clear(); + + /** + * Marks the current {@code readerIndex} in this buffer. You can + * reposition the current {@code readerIndex} to the marked + * {@code readerIndex} by calling {@link #resetReaderIndex()}. + * The initial value of the marked {@code readerIndex} is {@code 0}. + */ + void markReaderIndex(); + + /** + * Repositions the current {@code readerIndex} to the marked + * {@code readerIndex} in this buffer. + * + * @throws IndexOutOfBoundsException + * if the current {@code writerIndex} is less than the marked + * {@code readerIndex} + */ + void resetReaderIndex(); + + /** + * Marks the current {@code writerIndex} in this buffer. You can + * reposition the current {@code writerIndex} to the marked + * {@code writerIndex} by calling {@link #resetWriterIndex()}. + * The initial value of the marked {@code writerIndex} is {@code 0}. + */ + void markWriterIndex(); + + /** + * Repositions the current {@code writerIndex} to the marked + * {@code writerIndex} in this buffer. + * + * @throws IndexOutOfBoundsException + * if the current {@code readerIndex} is greater than the marked + * {@code writerIndex} + */ + void resetWriterIndex(); + + /** + * Discards the bytes between the 0th index and {@code readerIndex}. + * It moves the bytes between {@code readerIndex} and {@code writerIndex} + * to the 0th index, and sets {@code readerIndex} and {@code writerIndex} + * to {@code 0} and {@code oldWriterIndex - oldReaderIndex} respectively. + * <p> + * Please refer to the class documentation for more detailed explanation. + */ + void discardReadBytes(); + + /** + * Gets a byte at the specified absolute {@code index} in this buffer. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 1} is greater than {@code this.capacity} + */ + byte getByte(int index); + + /** + * Gets an unsigned byte at the specified absolute {@code index} in this + * buffer. This method does not modify {@code readerIndex} or + * {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 1} is greater than {@code this.capacity} + */ + short getUnsignedByte(int index); + + /** + * Gets a 16-bit short integer at the specified absolute {@code index} in + * this buffer. This method does not modify {@code readerIndex} or + * {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 2} is greater than {@code this.capacity} + */ + short getShort(int index); + + /** + * Gets an unsigned 16-bit short integer at the specified absolute + * {@code index} in this buffer. This method does not modify + * {@code readerIndex} or {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 2} is greater than {@code this.capacity} + */ + int getUnsignedShort(int index); + + /** + * Gets a 32-bit integer at the specified absolute {@code index} in + * this buffer. This method does not modify {@code readerIndex} or + * {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 4} is greater than {@code this.capacity} + */ + int getInt(int index); + + /** + * Gets an unsigned 32-bit integer at the specified absolute {@code index} + * in this buffer. This method does not modify {@code readerIndex} or + * {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 4} is greater than {@code this.capacity} + */ + long getUnsignedInt(int index); + + /** + * Gets a 64-bit long integer at the specified absolute {@code index} in + * this buffer. This method does not modify {@code readerIndex} or + * {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 8} is greater than {@code this.capacity} + */ + long getLong(int index); + + /** + * Transfers this buffer's data to the specified destination starting at + * the specified absolute {@code index} until the destination becomes + * non-writable. This method is basically same with + * {@link #getBytes(int, HornetQBuffer, int, int)}, except that this + * method increases the {@code writerIndex} of the destination by the + * number of the transferred bytes while + * {@link #getBytes(int, HornetQBuffer, int, int)} does not. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * the source buffer (i.e. {@code this}). + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * if {@code index + dst.writableBytes} is greater than + * {@code this.capacity} + */ + void getBytes(int index, HornetQBuffer dst); + + /** + * Transfers this buffer's data to the specified destination starting at + * the specified absolute {@code index}. This method is basically same + * with {@link #getBytes(int, HornetQBuffer, int, int)}, except that this + * method increases the {@code writerIndex} of the destination by the + * number of the transferred bytes while + * {@link #getBytes(int, HornetQBuffer, int, int)} does not. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * the source buffer (i.e. {@code this}). + * + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0}, + * if {@code index + length} is greater than + * {@code this.capacity}, or + * if {@code length} is greater than {@code dst.writableBytes} + */ + void getBytes(int index, HornetQBuffer dst, int length); + + /** + * Transfers this buffer's data to the specified destination starting at + * the specified absolute {@code index}. + * This method does not modify {@code readerIndex} or {@code writerIndex} + * of both the source (i.e. {@code this}) and the destination. + * + * @param dstIndex the first index of the destination + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0}, + * if the specified {@code dstIndex} is less than {@code 0}, + * if {@code index + length} is greater than + * {@code this.capacity}, or + * if {@code dstIndex + length} is greater than + * {@code dst.capacity} + */ + void getBytes(int index, HornetQBuffer dst, int dstIndex, int length); + + /** + * Transfers this buffer's data to the specified destination starting at + * the specified absolute {@code index}. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * if {@code index + dst.length} is greater than + * {@code this.capacity} + */ + void getBytes(int index, byte[] dst); + + /** + * Transfers this buffer's data to the specified destination starting at + * the specified absolute {@code index}. + * This method does not modify {@code readerIndex} or {@code writerIndex} + * of this buffer. + * + * @param dstIndex the first index of the destination + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0}, + * if the specified {@code dstIndex} is less than {@code 0}, + * if {@code index + length} is greater than + * {@code this.capacity}, or + * if {@code dstIndex + length} is greater than + * {@code dst.length} + */ + void getBytes(int index, byte[] dst, int dstIndex, int length); + + /** + * Transfers this buffer's data to the specified destination starting at + * the specified absolute {@code index} until the destination's position + * reaches its limit. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer while the destination's {@code position} will be increased. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * if {@code index + dst.remaining()} is greater than + * {@code this.capacity} + */ + void getBytes(int index, ByteBuffer dst); + + /** + * Gets a char at the specified absolute {@code index} in + * this buffer. This method does not modify {@code readerIndex} or + * {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 2} is greater than {@code this.capacity} + */ + char getChar(int index); + + /** + * Gets a float at the specified absolute {@code index} in + * this buffer. This method does not modify {@code readerIndex} or + * {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 4} is greater than {@code this.capacity} + */ + float getFloat(int index); + + /** + * Gets a double at the specified absolute {@code index} in + * this buffer. This method does not modify {@code readerIndex} or + * {@code writerIndex} of this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 8} is greater than {@code this.capacity} + */ + double getDouble(int index); + + /** + * Sets the specified byte at the specified absolute {@code index} in this + * buffer. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 1} is greater than {@code this.capacity} + */ + void setByte(int index, byte value); + + /** + * Sets the specified 16-bit short integer at the specified absolute + * {@code index} in this buffer. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 2} is greater than {@code this.capacity} + */ + void setShort(int index, short value); + + /** + * Sets the specified 32-bit integer at the specified absolute + * {@code index} in this buffer. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 4} is greater than {@code this.capacity} + */ + void setInt(int index, int value); + + /** + * Sets the specified 64-bit long integer at the specified absolute + * {@code index} in this buffer. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 8} is greater than {@code this.capacity} + */ + void setLong(int index, long value); + + /** + * Transfers the specified source buffer's data to this buffer starting at + * the specified absolute {@code index} until the destination becomes + * unreadable. This method is basically same with + * {@link #setBytes(int, HornetQBuffer, int, int)}, except that this + * method increases the {@code readerIndex} of the source buffer by + * the number of the transferred bytes while + * {@link #getBytes(int, HornetQBuffer, int, int)} does not. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * the source buffer (i.e. {@code this}). + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * if {@code index + src.readableBytes} is greater than + * {@code this.capacity} + */ + void setBytes(int index, HornetQBuffer src); + + /** + * Transfers the specified source buffer's data to this buffer starting at + * the specified absolute {@code index}. This method is basically same + * with {@link #setBytes(int, HornetQBuffer, int, int)}, except that this + * method increases the {@code readerIndex} of the source buffer by + * the number of the transferred bytes while + * {@link #getBytes(int, HornetQBuffer, int, int)} does not. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * the source buffer (i.e. {@code this}). + * + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0}, + * if {@code index + length} is greater than + * {@code this.capacity}, or + * if {@code length} is greater than {@code src.readableBytes} + */ + void setBytes(int index, HornetQBuffer src, int length); + + /** + * Transfers the specified source buffer's data to this buffer starting at + * the specified absolute {@code index}. + * This method does not modify {@code readerIndex} or {@code writerIndex} + * of both the source (i.e. {@code this}) and the destination. + * + * @param srcIndex the first index of the source + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0}, + * if the specified {@code srcIndex} is less than {@code 0}, + * if {@code index + length} is greater than + * {@code this.capacity}, or + * if {@code srcIndex + length} is greater than + * {@code src.capacity} + */ + void setBytes(int index, HornetQBuffer src, int srcIndex, int length); + + /** + * Transfers the specified source array's data to this buffer starting at + * the specified absolute {@code index}. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * if {@code index + src.length} is greater than + * {@code this.capacity} + */ + void setBytes(int index, byte[] src); + + /** + * Transfers the specified source array's data to this buffer starting at + * the specified absolute {@code index}. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0}, + * if the specified {@code srcIndex} is less than {@code 0}, + * if {@code index + length} is greater than + * {@code this.capacity}, or + * if {@code srcIndex + length} is greater than {@code src.length} + */ + void setBytes(int index, byte[] src, int srcIndex, int length); + + /** + * Transfers the specified source buffer's data to this buffer starting at + * the specified absolute {@code index} until the source buffer's position + * reaches its limit. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * if {@code index + src.remaining()} is greater than + * {@code this.capacity} + */ + void setBytes(int index, ByteBuffer src); + + /** + * Sets the specified char at the specified absolute + * {@code index} in this buffer. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 2} is greater than {@code this.capacity} + */ + void setChar(int index, char value); + + /** + * Sets the specified float at the specified absolute + * {@code index} in this buffer. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 4} is greater than {@code this.capacity} + */ + void setFloat(int index, float value); + + /** + * Sets the specified double at the specified absolute + * {@code index} in this buffer. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + * @throws IndexOutOfBoundsException + * if the specified {@code index} is less than {@code 0} or + * {@code index + 8} is greater than {@code this.capacity} + */ + void setDouble(int index, double value); + + /** + * Gets a byte at the current {@code readerIndex} and increases + * the {@code readerIndex} by {@code 1} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 1} + */ + byte readByte(); + + /** + * Gets an unsigned byte at the current {@code readerIndex} and increases + * the {@code readerIndex} by {@code 1} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 1} + */ + short readUnsignedByte(); + + /** + * Gets a 16-bit short integer at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 2} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 2} + */ + short readShort(); + + /** + * Gets an unsigned 16-bit short integer at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 2} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 2} + */ + int readUnsignedShort(); + + /** + * Gets a 32-bit integer at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 4} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 4} + */ + int readInt(); + + /** + * Gets an unsigned 32-bit integer at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 4} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 4} + */ + long readUnsignedInt(); + + /** + * Gets a 64-bit integer at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 8} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 8} + */ + long readLong(); + + /** + * Gets a char at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 2} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 2} + */ + char readChar(); + + /** + * Gets a float at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 4} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 4} + */ + float readFloat(); + + /** + * Gets a double at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 8} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 8} + */ + double readDouble(); + + /** + * Gets a boolean at the current {@code readerIndex} + * and increases the {@code readerIndex} by {@code 1} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.readableBytes} is less than {@code 1} + */ + boolean readBoolean(); + + /** + * Gets a SimpleString (potentially {@code null}) at the current {@code readerIndex} + */ + SimpleString readNullableSimpleString(); + + /** + * Gets a String (potentially {@code null}) at the current {@code readerIndex} + */ + String readNullableString(); + + /** + * Gets a non-null SimpleString at the current {@code readerIndex} + */ + SimpleString readSimpleString(); + + /** + * Gets a non-null String at the current {@code readerIndex} + */ + String readString(); + + /** + * Gets a UTF-8 String at the current {@code readerIndex} + */ + String readUTF(); + + /** + * Transfers this buffer's data to a newly created buffer starting at + * the current {@code readerIndex} and increases the {@code readerIndex} + * by the number of the transferred bytes (= {@code length}). + * The returned buffer's {@code readerIndex} and {@code writerIndex} are + * {@code 0} and {@code length} respectively. + * + * @param length the number of bytes to transfer + * + * @return the newly created buffer which contains the transferred bytes + * + * @throws IndexOutOfBoundsException + * if {@code length} is greater than {@code this.readableBytes} + */ + HornetQBuffer readBytes(int length); + + /** + * Returns a new slice of this buffer's sub-region starting at the current + * {@code readerIndex} and increases the {@code readerIndex} by the size + * of the new slice (= {@code length}). + * + * @param length the size of the new slice + * + * @return the newly created slice + * + * @throws IndexOutOfBoundsException + * if {@code length} is greater than {@code this.readableBytes} + */ + HornetQBuffer readSlice(int length); + + /** + * Transfers this buffer's data to the specified destination starting at + * the current {@code readerIndex} until the destination becomes + * non-writable, and increases the {@code readerIndex} by the number of the + * transferred bytes. This method is basically same with + * {@link #readBytes(HornetQBuffer, int, int)}, except that this method + * increases the {@code writerIndex} of the destination by the number of + * the transferred bytes while {@link #readBytes(HornetQBuffer, int, int)} + * does not. + * + * @throws IndexOutOfBoundsException + * if {@code dst.writableBytes} is greater than + * {@code this.readableBytes} + */ + void readBytes(HornetQBuffer dst); + + /** + * Transfers this buffer's data to the specified destination starting at + * the current {@code readerIndex} and increases the {@code readerIndex} + * by the number of the transferred bytes (= {@code length}). This method + * is basically same with {@link #readBytes(HornetQBuffer, int, int)}, + * except that this method increases the {@code writerIndex} of the + * destination by the number of the transferred bytes (= {@code length}) + * while {@link #readBytes(HornetQBuffer, int, int)} does not. + * + * @throws IndexOutOfBoundsException + * if {@code length} is greater than {@code this.readableBytes} or + * if {@code length} is greater than {@code dst.writableBytes} + */ + void readBytes(HornetQBuffer dst, int length); + + /** + * Transfers this buffer's data to the specified destination starting at + * the current {@code readerIndex} and increases the {@code readerIndex} + * by the number of the transferred bytes (= {@code length}). + * + * @param dstIndex the first index of the destination + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if the specified {@code dstIndex} is less than {@code 0}, + * if {@code length} is greater than {@code this.readableBytes}, or + * if {@code dstIndex + length} is greater than + * {@code dst.capacity} + */ + void readBytes(HornetQBuffer dst, int dstIndex, int length); + + /** + * Transfers this buffer's data to the specified destination starting at + * the current {@code readerIndex} and increases the {@code readerIndex} + * by the number of the transferred bytes (= {@code dst.length}). + * + * @throws IndexOutOfBoundsException + * if {@code dst.length} is greater than {@code this.readableBytes} + */ + void readBytes(byte[] dst); + + /** + * Transfers this buffer's data to the specified destination starting at + * the current {@code readerIndex} and increases the {@code readerIndex} + * by the number of the transferred bytes (= {@code length}). + * + * @param dstIndex the first index of the destination + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if the specified {@code dstIndex} is less than {@code 0}, + * if {@code length} is greater than {@code this.readableBytes}, or + * if {@code dstIndex + length} is greater than {@code dst.length} + */ + void readBytes(byte[] dst, int dstIndex, int length); + + /** + * Transfers this buffer's data to the specified destination starting at + * the current {@code readerIndex} until the destination's position + * reaches its limit, and increases the {@code readerIndex} by the + * number of the transferred bytes. + * + * @throws IndexOutOfBoundsException + * if {@code dst.remaining()} is greater than + * {@code this.readableBytes} + */ + void readBytes(ByteBuffer dst); + + /** + * Increases the current {@code readerIndex} by the specified + * {@code length} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code length} is greater than {@code this.readableBytes} + */ + void skipBytes(int length); + + /** + * Sets the specified byte at the current {@code writerIndex} + * and increases the {@code writerIndex} by {@code 1} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.writableBytes} is less than {@code 1} + */ + void writeByte(byte value); + + /** + * Sets the specified 16-bit short integer at the current + * {@code writerIndex} and increases the {@code writerIndex} by {@code 2} + * in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.writableBytes} is less than {@code 2} + */ + void writeShort(short value); + + /** + * Sets the specified 32-bit integer at the current {@code writerIndex} + * and increases the {@code writerIndex} by {@code 4} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.writableBytes} is less than {@code 4} + */ + void writeInt(int value); + + /** + * Sets the specified 64-bit long integer at the current + * {@code writerIndex} and increases the {@code writerIndex} by {@code 8} + * in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.writableBytes} is less than {@code 8} + */ + void writeLong(long value); + + /** + * Sets the specified char at the current {@code writerIndex} + * and increases the {@code writerIndex} by {@code 2} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.writableBytes} is less than {@code 2} + */ + void writeChar(char chr); + + /** + * Sets the specified float at the current {@code writerIndex} + * and increases the {@code writerIndex} by {@code 4} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.writableBytes} is less than {@code 4} + */ + void writeFloat(float value); + + /** + * Sets the specified double at the current {@code writerIndex} + * and increases the {@code writerIndex} by {@code 8} in this buffer. + * + * @throws IndexOutOfBoundsException + * if {@code this.writableBytes} is less than {@code 8} + */ + void writeDouble(double value); + + /** + * Sets the specified boolean at the current {@code writerIndex} + */ + void writeBoolean(boolean val); + + /** + * Sets the specified SimpleString (potentially {@code null}) at the current {@code writerIndex} + */ + void writeNullableSimpleString(SimpleString val); + + /** + * Sets the specified String (potentially {@code null}) at the current {@code writerIndex} + */ + void writeNullableString(String val); + + /** + * Sets the specified non-null SimpleString at the current {@code writerIndex} + */ + void writeSimpleString(SimpleString val); + + /** + * Sets the specified non-null String at the current {@code writerIndex} + */ + void writeString(String val); + + /** + * Sets the specified UTF-8 String at the current {@code writerIndex} + */ + + void writeUTF(String utf); + + /** + * Transfers the specified source buffer's data to this buffer starting at + * the current {@code writerIndex} and increases the {@code writerIndex} + * by the number of the transferred bytes (= {@code length}). This method + * is basically same with {@link #writeBytes(HornetQBuffer, int, int)}, + * except that this method increases the {@code readerIndex} of the source + * buffer by the number of the transferred bytes (= {@code length}) while + * {@link #writeBytes(HornetQBuffer, int, int)} does not. + * + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if {@code length} is greater than {@code this.writableBytes} or + * if {@code length} is greater then {@code src.readableBytes} + */ + void writeBytes(HornetQBuffer src, int length); + + /** + * Transfers the specified source buffer's data to this buffer starting at + * the current {@code writerIndex} and increases the {@code writerIndex} + * by the number of the transferred bytes (= {@code length}). + * + * @param srcIndex the first index of the source + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if the specified {@code srcIndex} is less than {@code 0}, + * if {@code srcIndex + length} is greater than + * {@code src.capacity}, or + * if {@code length} is greater than {@code this.writableBytes} + */ + void writeBytes(HornetQBuffer src, int srcIndex, int length); + + /** + * Transfers the specified source array's data to this buffer starting at + * the current {@code writerIndex} and increases the {@code writerIndex} + * by the number of the transferred bytes (= {@code src.length}). + * + * @throws IndexOutOfBoundsException + * if {@code src.length} is greater than {@code this.writableBytes} + */ + void writeBytes(byte[] src); + + /** + * Transfers the specified source array's data to this buffer starting at + * the current {@code writerIndex} and increases the {@code writerIndex} + * by the number of the transferred bytes (= {@code length}). + * + * @param srcIndex the first index of the source + * @param length the number of bytes to transfer + * + * @throws IndexOutOfBoundsException + * if the specified {@code srcIndex} is less than {@code 0}, + * if {@code srcIndex + length} is greater than + * {@code src.length}, or + * if {@code length} is greater than {@code this.writableBytes} + */ + void writeBytes(byte[] src, int srcIndex, int length); + + /** + * Transfers the specified source buffer's data to this buffer starting at + * the current {@code writerIndex} until the source buffer's position + * reaches its limit, and increases the {@code writerIndex} by the + * number of the transferred bytes. + * + * @throws IndexOutOfBoundsException + * if {@code src.remaining()} is greater than + * {@code this.writableBytes} + */ + void writeBytes(ByteBuffer src); + + /** + * Returns a copy of this buffer's readable bytes. Modifying the content + * of the returned buffer or this buffer does not affect each other at all. + * This method is identical to {@code buf.copy(buf.readerIndex(), buf.readableBytes())}. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + * + */ + HornetQBuffer copy(); + + /** + * Returns a copy of this buffer's sub-region. Modifying the content of + * the returned buffer or this buffer does not affect each other at all. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + */ + HornetQBuffer copy(int index, int length); + + /** + * Returns a slice of this buffer's readable bytes. Modifying the content + * of the returned buffer or this buffer affects each other's content + * while they maintain separate indexes and marks. This method is + * identical to {@code buf.slice(buf.readerIndex(), buf.readableBytes())}. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + */ + HornetQBuffer slice(); + + /** + * Returns a slice of this buffer's sub-region. Modifying the content of + * the returned buffer or this buffer affects each other's content while + * they maintain separate indexes and marks. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + */ + HornetQBuffer slice(int index, int length); + + /** + * Returns a buffer which shares the whole region of this buffer. + * Modifying the content of the returned buffer or this buffer affects + * each other's content while they maintain separate indexes and marks. + * This method is identical to {@code buf.slice(0, buf.capacity())}. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + */ + HornetQBuffer duplicate(); + + /** + * Converts this buffer's readable bytes into a NIO buffer. The returned + * buffer might or might not share the content with this buffer, while + * they have separate indexes and marks. This method is identical to + * {@code buf.toByteBuffer(buf.readerIndex(), buf.readableBytes())}. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + */ + ByteBuffer toByteBuffer(); + + /** + * Converts this buffer's sub-region into a NIO buffer. The returned + * buffer might or might not share the content with this buffer, while + * they have separate indexes and marks. + * This method does not modify {@code readerIndex} or {@code writerIndex} of + * this buffer. + */ + ByteBuffer toByteBuffer(int index, int length); +} Copied: trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQBuffers.java (from rev 10738, trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffers.java) =================================================================== --- trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQBuffers.java (rev 0) +++ trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQBuffers.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -0,0 +1,97 @@ +/* + * Copyright 2009 Red Hat, Inc. + * Red Hat 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.hornetq.api.core; + +import java.nio.ByteBuffer; + +import org.hornetq.core.buffers.impl.ChannelBufferWrapper; +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; + +/** + * Factory class to create HornetQBuffers + * + * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> + */ +public class HornetQBuffers +{ + /** + * Creates a <em>self-expanding</em> HornetQBuffer with the given initial size + * + * @param size the initial size of the created HornetQBuffer + * @return a self-expanding HornetQBuffer starting with the given size + */ + public static HornetQBuffer dynamicBuffer(final int size) + { + return new ChannelBufferWrapper(ChannelBuffers.dynamicBuffer(size)); + } + + /** + * Creates a <em>self-expanding</em> HornetQBuffer filled with the given byte array + * + * @param bytes the created buffer will be initially filled with this byte array + * @return a self-expanding HornetQBuffer filled with the given byte array + */ + public static HornetQBuffer dynamicBuffer(final byte[] bytes) + { + ChannelBuffer buff = ChannelBuffers.dynamicBuffer(bytes.length); + + buff.writeBytes(bytes); + + return new ChannelBufferWrapper(buff); + } + + /** + * Creates a HornetQBuffer wrapping an underlying NIO ByteBuffer + * + * The position on this buffer won't affect the position on the inner buffer + * + * @param underlying the underlying NIO ByteBuffer + * @return a HornetQBuffer wrapping the underlying NIO ByteBuffer + */ + public static HornetQBuffer wrappedBuffer(final ByteBuffer underlying) + { + HornetQBuffer buff = new ChannelBufferWrapper(ChannelBuffers.wrappedBuffer(underlying)); + + buff.clear(); + + return buff; + } + + /** + * Creates a HornetQBuffer wrapping an underlying byte array + * + * @param underlying the underlying byte array + * @return a HornetQBuffer wrapping the underlying byte array + */ + public static HornetQBuffer wrappedBuffer(final byte[] underlying) + { + return new ChannelBufferWrapper(ChannelBuffers.wrappedBuffer(underlying)); + } + + /** + * Creates a <em>fixed</em> HornetQBuffer of the given size + * + * @param size the size of the created HornetQBuffer + * @return a fixed HornetQBuffer with the given size + */ + public static HornetQBuffer fixedBuffer(final int size) + { + return new ChannelBufferWrapper(ChannelBuffers.buffer(size)); + } + + private HornetQBuffers() + { + } +} Copied: trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQException.java (from rev 10738, trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQException.java) =================================================================== --- trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQException.java (rev 0) +++ trunk/hornetq-commons/src/main/java/org/hornetq/api/core/HornetQException.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -0,0 +1,226 @@ +/* + * Copyright 2009 Red Hat, Inc. + * Red Hat 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.hornetq.api.core; + +/** + * + * HornetQException is the root exception for HornetQ API. + * + * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> + * + */ +public class HornetQException extends Exception +{ + private static final long serialVersionUID = -4802014152804997417L; + + // Error codes ------------------------------------------------- + + /** + * Internal error which prevented HornetQ to perform. + */ + public static final int INTERNAL_ERROR = 000; + + /** + * A packet of unsupported type was received by HornetQ PacketHandler. + */ + public static final int UNSUPPORTED_PACKET = 001; + + /** + * A client is not able to connect to HornetQ server. + */ + public static final int NOT_CONNECTED = 002; + + /** + * A client timed out will connecting to HornetQ server. + */ + public static final int CONNECTION_TIMEDOUT = 003; + + /** + * A client was disconnected from HornetQ server when the server has shut down. + */ + public static final int DISCONNECTED = 004; + + /** + * A blocking call from a client was unblocked during failover. + */ + public static final int UNBLOCKED = 005; + + /** + * Unexpected I/O error occured on the server. + */ + public static final int IO_ERROR = 006; + + /** + * An operation failed because a queue does not exist on the server. + */ + public static final int QUEUE_DOES_NOT_EXIST = 100; + + /** + * An operation failed because a queue exists on the server. + */ + public static final int QUEUE_EXISTS = 101; + + /** + * A client operation failed because the calling resource + * (ClientSession, ClientProducer, etc.) is closed. + */ + public static final int OBJECT_CLOSED = 102; + + /** + * An filter expression has not been validated + */ + public static final int INVALID_FILTER_EXPRESSION = 103; + + /** + * A HornetQ resource is not in a legal state (e.g. calling + * ClientConsumer.receive() if a MessageHandler is set) + */ + public static final int ILLEGAL_STATE = 104; + + /** + * A security problem occured (authentication issues, permission issues,...) + */ + public static final int SECURITY_EXCEPTION = 105; + + /** + * An operation failed because an address does not exist on the server. + */ + public static final int ADDRESS_DOES_NOT_EXIST = 106; + + /** + * An operation failed because an address exists on the server. + */ + public static final int ADDRESS_EXISTS = 107; + + /** + * A incompatibility between HornetQ versions on the client and the server has been detected + */ + public static final int INCOMPATIBLE_CLIENT_SERVER_VERSIONS = 108; + + /** + * An operation failed because a session exists on the server. + */ + public static final int SESSION_EXISTS = 109; + + /** + * An problem occurred while manipulating the body of a large message. + */ + public static final int LARGE_MESSAGE_ERROR_BODY = 110; + + /** + * A transaction was rolled back. + */ + public static final int TRANSACTION_ROLLED_BACK = 111; + + /** + * The creation of a session was rejected by the server (e.g. if the + * server is starting and has not finish to be initialized) + */ + public static final int SESSION_CREATION_REJECTED = 112; + + /** + * A DuplicateID was rejected. + */ + public static final int DUPLICATE_ID_REJECTED = 113; + + + // Native Error codes ---------------------------------------------- + + /** + * A internal error occured in the AIO native code + */ + public static final int NATIVE_ERROR_INTERNAL = 200; + + /** + * A buffer is invalid in the AIO native code + */ + public static final int NATIVE_ERROR_INVALID_BUFFER = 201; + + /** + * Alignment error in the AIO native code + */ + public static final int NATIVE_ERROR_NOT_ALIGNED = 202; + + /** + * AIO has not been properly initialized + */ + public static final int NATIVE_ERROR_CANT_INITIALIZE_AIO = 203; + + /** + * AIO has not been properly released + */ + public static final int NATIVE_ERROR_CANT_RELEASE_AIO = 204; + + /** + * A closed file has not be properly reopened + */ + public static final int NATIVE_ERROR_CANT_OPEN_CLOSE_FILE = 205; + + /** + * An error occured while allocating a queue in AIO native code + */ + public static final int NATIVE_ERROR_CANT_ALLOCATE_QUEUE = 206; + + /** + * An error occured while pre-allocating a file in AIO native code + */ + public static final int NATIVE_ERROR_PREALLOCATE_FILE = 208; + + /** + * An error occurred while allocating memory in the AIO native code + */ + public static final int NATIVE_ERROR_ALLOCATE_MEMORY = 209; + + /** + * AIO is full + */ + public static final int NATIVE_ERROR_AIO_FULL = 211; + + private int code; + + public HornetQException() + { + } + + public HornetQException(final int code) + { + this.code = code; + } + + public HornetQException(final int code, final String msg) + { + super(msg); + + this.code = code; + } + + public HornetQException(final int code, final String msg, final Throwable cause) + { + super(msg, cause); + + this.code = code; + } + + public int getCode() + { + return code; + } + + @Override + public String toString() + { + return "HornetQException[errorCode=" + code + " message=" + getMessage() + "]"; + } + +} Copied: trunk/hornetq-commons/src/main/java/org/hornetq/api/core/Pair.java (from rev 10738, trunk/hornetq-core/src/main/java/org/hornetq/api/core/Pair.java) =================================================================== --- trunk/hornetq-commons/src/main/java/org/hornetq/api/core/Pair.java (rev 0) +++ trunk/hornetq-commons/src/main/java/org/hornetq/api/core/Pair.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -0,0 +1,84 @@ +/* + * Copyright 2009 Red Hat, Inc. + * Red Hat 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.hornetq.api.core; + +import java.io.Serializable; + +/** + * + * A Pair is a holder for 2 objects. + * + * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> + * + */ +public class Pair<A, B> implements Serializable +{ + private static final long serialVersionUID = -2496357457812368127L; + + public Pair(final A a, final B b) + { + this.a = a; + + this.b = b; + } + + public A a; + + public B b; + + private int hash = -1; + + @Override + public int hashCode() + { + if (hash == -1) + { + if (a == null && b == null) + { + return super.hashCode(); + } + else + { + hash = (a == null ? 0 : a.hashCode()) + 37 * (b == null ? 0 : b.hashCode()); + } + } + + return hash; + } + + @Override + public boolean equals(final Object other) + { + if (other == this) + { + return true; + } + + if (other instanceof Pair == false) + { + return false; + } + + Pair<A, B> pother = (Pair<A, B>)other; + + return (pother.a == null ? a == null : pother.a.equals(a)) && (pother.b == null ? b == null : pother.b.equals(b)); + + } + + @Override + public String toString() + { + return "Pair[a=" + a + ", b=" + b + "]"; + } +} Copied: trunk/hornetq-commons/src/main/java/org/hornetq/api/core/SimpleString.java (from rev 10738, trunk/hornetq-core/src/main/java/org/hornetq/api/core/SimpleString.java) =================================================================== --- trunk/hornetq-commons/src/main/java/org/hornetq/api/core/SimpleString.java (rev 0) +++ trunk/hornetq-commons/src/main/java/org/hornetq/api/core/SimpleString.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -0,0 +1,426 @@ +/* + * Copyright 2009 Red Hat, Inc. + * Red Hat 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.hornetq.api.core; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + +import org.hornetq.core.logging.Logger; +import org.hornetq.utils.DataConstants; + +/** + * A simple String class that can store all characters, and stores as simple byte[], + * this minimises expensive copying between String objects. + * + * This object is used heavily throughout HornetQ for performance reasons. + * + * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> + * + */ + +public class SimpleString implements CharSequence, Serializable, Comparable<SimpleString> +{ + private static final long serialVersionUID = 4204223851422244307L; + + private static final Logger log = Logger.getLogger(SimpleString.class); + + // Attributes + // ------------------------------------------------------------------------ + private final byte[] data; + + private transient int hash; + + // Cache the string + private transient String str; + + // Static + // ---------------------------------------------------------------------- + + /** + * Returns a SimpleString constructed from the <code>string</code> parameter. + * If <code>string</code> is <code>null</code>, the return value will be <code>null</code> too. + */ + public static SimpleString toSimpleString(final String string) + { + if (string == null) + { + return null; + } + return new SimpleString(string); + } + + // Constructors + // ---------------------------------------------------------------------- + /** + * creates a SimpleString from a conventional String + * @param string the string to transform + */ + public SimpleString(final String string) + { + int len = string.length(); + + data = new byte[len << 1]; + + int j = 0; + + for (int i = 0; i < len; i++) + { + char c = string.charAt(i); + + byte low = (byte)(c & 0xFF); // low byte + + data[j++] = low; + + byte high = (byte)(c >> 8 & 0xFF); // high byte + + data[j++] = high; + } + + str = string; + } + + /** + * creates a SimpleString from a byte array + * @param data the byte array to use + */ + public SimpleString(final byte[] data) + { + this.data = data; + } + + // CharSequence implementation + // --------------------------------------------------------------------------- + + public int length() + { + return data.length >> 1; + } + + public char charAt(int pos) + { + if (pos < 0 || pos >= data.length >> 1) + { + throw new IndexOutOfBoundsException(); + } + pos <<= 1; + + return (char)(data[pos] | data[pos + 1] << 8); + } + + public CharSequence subSequence(final int start, final int end) + { + int len = data.length >> 1; + + if (end < start || start < 0 || end > len) + { + throw new IndexOutOfBoundsException(); + } + else + { + int newlen = end - start << 1; + byte[] bytes = new byte[newlen]; + + System.arraycopy(data, start << 1, bytes, 0, newlen); + + return new SimpleString(bytes); + } + } + + // Comparable implementation ------------------------------------- + + public int compareTo(final SimpleString o) + { + return toString().compareTo(o.toString()); + } + + // Public + // --------------------------------------------------------------------------- + + /** + * returns the underlying byte array of this SimpleString + * @return the byte array + */ + public byte[] getData() + { + return data; + } + + /** + * returns true if the SimpleString parameter starts with the same data as this one. false if not. + * @param other the SimpelString to look for + * @return true if this SimpleString starts with the same data + */ + public boolean startsWith(final SimpleString other) + { + byte[] otherdata = other.data; + + if (otherdata.length > data.length) + { + return false; + } + + for (int i = 0; i < otherdata.length; i++) + { + if (data[i] != otherdata[i]) + { + return false; + } + } + + return true; + } + + @Override + public String toString() + { + if (str == null) + { + int len = data.length >> 1; + + char[] chars = new char[len]; + + int j = 0; + + for (int i = 0; i < len; i++) + { + int low = data[j++] & 0xFF; + + int high = data[j++] << 8 & 0xFF00; + + chars[i] = (char)(low | high); + } + + str = new String(chars); + } + + return str; + } + + @Override + public boolean equals(final Object other) + { + if (this == other) + { + return true; + } + + if (other instanceof SimpleString) + { + SimpleString s = (SimpleString)other; + + if (data.length != s.data.length) + { + return false; + } + + for (int i = 0; i < data.length; i++) + { + if (data[i] != s.data[i]) + { + return false; + } + } + + return true; + } + else + { + return false; + } + } + + @Override + public int hashCode() + { + if (hash == 0) + { + int tmphash = 0; + for (byte element : data) + { + tmphash = (tmphash << 5) - tmphash + element; // (hash << 5) - hash is same as hash * 31 + } + hash = tmphash; + } + + return hash; + } + + /** + * splits this SimpleString into an array of SimpleString using the char param as the delimeter. + * + * i.e. "a.b" would return "a" and "b" if . was the delimeter + * @param delim + */ + public SimpleString[] split(final char delim) + { + if (!contains(delim)) + { + return new SimpleString[] { this }; + } + else + { + List<SimpleString> all = new ArrayList<SimpleString>(); + int lasPos = 0; + for (int i = 0; i < data.length; i += 2) + { + byte low = (byte)(delim & 0xFF); // low byte + byte high = (byte)(delim >> 8 & 0xFF); // high byte + if (data[i] == low && data[i + 1] == high) + { + byte[] bytes = new byte[i - lasPos]; + System.arraycopy(data, lasPos, bytes, 0, bytes.length); + lasPos = i + 2; + all.add(new SimpleString(bytes)); + } + } + byte[] bytes = new byte[data.length - lasPos]; + System.arraycopy(data, lasPos, bytes, 0, bytes.length); + all.add(new SimpleString(bytes)); + SimpleString[] parts = new SimpleString[all.size()]; + return all.toArray(parts); + } + } + + /** + * checks to see if this SimpleString contains the char parameter passed in + * + * @param c the char to check for + * @return true if the char is found, false otherwise. + */ + public boolean contains(final char c) + { + for (int i = 0; i < data.length; i += 2) + { + byte low = (byte)(c & 0xFF); // low byte + byte high = (byte)(c >> 8 & 0xFF); // high byte + if (data[i] == low && data[i + 1] == high) + { + return true; + } + } + return false; + } + + /** + * concatanates a SimpleString and a String + * + * @param toAdd the String to concate with. + * @return the concatanated SimpleString + */ + public SimpleString concat(final String toAdd) + { + return concat(new SimpleString(toAdd)); + } + + /** + * concatanates 2 SimpleString's + * + * @param toAdd the SimpleString to concate with. + * @return the concatanated SimpleString + */ + public SimpleString concat(final SimpleString toAdd) + { + byte[] bytes = new byte[data.length + toAdd.getData().length]; + System.arraycopy(data, 0, bytes, 0, data.length); + System.arraycopy(toAdd.getData(), 0, bytes, data.length, toAdd.getData().length); + return new SimpleString(bytes); + } + + /** + * concatanates a SimpleString and a char + * + * @param c the char to concate with. + * @return the concatanated SimpleString + */ + public SimpleString concat(final char c) + { + byte[] bytes = new byte[data.length + 2]; + System.arraycopy(data, 0, bytes, 0, data.length); + bytes[data.length] = (byte)(c & 0xFF); + bytes[data.length + 1] = (byte)(c >> 8 & 0xFF); + return new SimpleString(bytes); + } + + /** + * returns the size of this SimpleString + * @return the size + */ + public int sizeof() + { + return DataConstants.SIZE_INT + data.length; + } + + /** + * returns the size of a SimpleString + * @param str the SimpleString to check + * @return the size + */ + public static int sizeofString(final SimpleString str) + { + return str.sizeof(); + } + + /** + * returns the size of a SimpleString which could be null + * @param str the SimpleString to check + * @return the size + */ + public static int sizeofNullableString(final SimpleString str) + { + if (str == null) + { + return 1; + } + else + { + return 1 + str.sizeof(); + } + } + + /** + * + * @param srcBegin + * @param srcEnd + * @param dst + * @param dstBegin + */ + public void getChars(final int srcBegin, final int srcEnd, final char dst[], final int dstBegin) + { + if (srcBegin < 0) + { + throw new StringIndexOutOfBoundsException(srcBegin); + } + if (srcEnd > length()) + { + throw new StringIndexOutOfBoundsException(srcEnd); + } + if (srcBegin > srcEnd) + { + throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); + } + + int j = 0; + + for (int i = srcBegin; i < srcEnd - srcBegin; i++) + { + int low = data[j++] & 0xFF; + + int high = data[j++] << 8 & 0xFF00; + + dst[i] = (char)(low | high); + } + } + +} \ No newline at end of file Copied: trunk/hornetq-commons/src/main/java/org/hornetq/core/buffers/impl/ChannelBufferWrapper.java (from rev 10738, trunk/hornetq-core/src/main/java/org/hornetq/core/buffers/impl/ChannelBufferWrapper.java) =================================================================== --- trunk/hornetq-commons/src/main/java/org/hornetq/core/buffers/impl/ChannelBufferWrapper.java (rev 0) +++ trunk/hornetq-commons/src/main/java/org/hornetq/core/buffers/impl/ChannelBufferWrapper.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -0,0 +1,620 @@ +/* + * Copyright 2009 Red Hat, Inc. + * Red Hat 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.hornetq.core.buffers.impl; + +import java.nio.ByteBuffer; + +import org.hornetq.api.core.HornetQBuffer; +import org.hornetq.api.core.SimpleString; +import org.hornetq.core.logging.Logger; +import org.hornetq.utils.DataConstants; +import org.hornetq.utils.UTF8Util; +import org.jboss.netty.buffer.ChannelBuffer; + +/** + * + * A ChannelBufferWrapper + * + * @author Tim Fox + * + * + */ +public class ChannelBufferWrapper implements HornetQBuffer +{ + private static final Logger log = Logger.getLogger(ChannelBufferWrapper.class); + + protected ChannelBuffer buffer; + + public ChannelBufferWrapper(final ChannelBuffer buffer) + { + this.buffer = buffer; + } + + public boolean readBoolean() + { + return readByte() != 0; + } + + public SimpleString readNullableSimpleString() + { + int b = buffer.readByte(); + if (b == DataConstants.NULL) + { + return null; + } + else + { + return readSimpleStringInternal(); + } + } + + public String readNullableString() + { + int b = buffer.readByte(); + if (b == DataConstants.NULL) + { + return null; + } + else + { + return readStringInternal(); + } + } + + public SimpleString readSimpleString() + { + return readSimpleStringInternal(); + } + + private SimpleString readSimpleStringInternal() + { + int len = buffer.readInt(); + byte[] data = new byte[len]; + buffer.readBytes(data); + return new SimpleString(data); + } + + public String readString() + { + return readStringInternal(); + } + + private String readStringInternal() + { + int len = buffer.readInt(); + + if (len < 9) + { + char[] chars = new char[len]; + for (int i = 0; i < len; i++) + { + chars[i] = (char)buffer.readShort(); + } + return new String(chars); + } + else if (len < 0xfff) + { + return readUTF(); + } + else + { + return readSimpleStringInternal().toString(); + } + } + + public String readUTF() + { + return UTF8Util.readUTF(this); + } + + public void writeBoolean(final boolean val) + { + buffer.writeByte((byte)(val ? -1 : 0)); + } + + public void writeNullableSimpleString(final SimpleString val) + { + if (val == null) + { + buffer.writeByte(DataConstants.NULL); + } + else + { + buffer.writeByte(DataConstants.NOT_NULL); + writeSimpleStringInternal(val); + } + } + + public void writeNullableString(final String val) + { + if (val == null) + { + buffer.writeByte(DataConstants.NULL); + } + else + { + buffer.writeByte(DataConstants.NOT_NULL); + writeStringInternal(val); + } + } + + public void writeSimpleString(final SimpleString val) + { + writeSimpleStringInternal(val); + } + + private void writeSimpleStringInternal(final SimpleString val) + { + byte[] data = val.getData(); + buffer.writeInt(data.length); + buffer.writeBytes(data); + } + + public void writeString(final String val) + { + writeStringInternal(val); + } + + private void writeStringInternal(final String val) + { + int length = val.length(); + + buffer.writeInt(length); + + if (length < 9) + { + // If very small it's more performant to store char by char + for (int i = 0; i < val.length(); i++) + { + buffer.writeShort((short)val.charAt(i)); + } + } + else if (length < 0xfff) + { + // Store as UTF - this is quicker than char by char for most strings + writeUTF(val); + } + else + { + // Store as SimpleString, since can't store utf > 0xffff in length + writeSimpleStringInternal(new SimpleString(val)); + } + } + + public void writeUTF(final String utf) + { + UTF8Util.saveUTF(this, utf); + } + + public int capacity() + { + return buffer.capacity(); + } + + public ChannelBuffer channelBuffer() + { + return buffer; + } + + public void clear() + { + buffer.clear(); + } + + public HornetQBuffer copy() + { + return new ChannelBufferWrapper(buffer.copy()); + } + + public HornetQBuffer copy(final int index, final int length) + { + return new ChannelBufferWrapper(buffer.copy(index, length)); + } + + public void discardReadBytes() + { + buffer.discardReadBytes(); + } + + public HornetQBuffer duplicate() + { + return new ChannelBufferWrapper(buffer.duplicate()); + } + + public byte getByte(final int index) + { + return buffer.getByte(index); + } + + public void getBytes(final int index, final byte[] dst, final int dstIndex, final int length) + { + buffer.getBytes(index, dst, dstIndex, length); + } + + public void getBytes(final int index, final byte[] dst) + { + buffer.getBytes(index, dst); + } + + public void getBytes(final int index, final ByteBuffer dst) + { + buffer.getBytes(index, dst); + } + + public void getBytes(final int index, final HornetQBuffer dst, final int dstIndex, final int length) + { + buffer.getBytes(index, dst.channelBuffer(), dstIndex, length); + } + + public void getBytes(final int index, final HornetQBuffer dst, final int length) + { + buffer.getBytes(index, dst.channelBuffer(), length); + } + + public void getBytes(final int index, final HornetQBuffer dst) + { + buffer.getBytes(index, dst.channelBuffer()); + } + + public char getChar(final int index) + { + return (char)buffer.getShort(index); + } + + public double getDouble(final int index) + { + return Double.longBitsToDouble(buffer.getLong(index)); + } + + public float getFloat(final int index) + { + return Float.intBitsToFloat(buffer.getInt(index)); + } + + public int getInt(final int index) + { + return buffer.getInt(index); + } + + public long getLong(final int index) + { + return buffer.getLong(index); + } + + public short getShort(final int index) + { + return buffer.getShort(index); + } + + public short getUnsignedByte(final int index) + { + return buffer.getUnsignedByte(index); + } + + public long getUnsignedInt(final int index) + { + return buffer.getUnsignedInt(index); + } + + public int getUnsignedShort(final int index) + { + return buffer.getUnsignedShort(index); + } + + public void markReaderIndex() + { + buffer.markReaderIndex(); + } + + public void markWriterIndex() + { + buffer.markWriterIndex(); + } + + public boolean readable() + { + return buffer.readable(); + } + + public int readableBytes() + { + return buffer.readableBytes(); + } + + public byte readByte() + { + return buffer.readByte(); + } + + public void readBytes(final byte[] dst, final int dstIndex, final int length) + { + buffer.readBytes(dst, dstIndex, length); + } + + public void readBytes(final byte[] dst) + { + buffer.readBytes(dst); + } + + public void readBytes(final ByteBuffer dst) + { + buffer.readBytes(dst); + } + + public void readBytes(final HornetQBuffer dst, final int dstIndex, final int length) + { + buffer.readBytes(dst.channelBuffer(), dstIndex, length); + } + + public void readBytes(final HornetQBuffer dst, final int length) + { + buffer.readBytes(dst.channelBuffer(), length); + } + + public void readBytes(final HornetQBuffer dst) + { + buffer.readBytes(dst.channelBuffer()); + } + + public HornetQBuffer readBytes(final int length) + { + return new ChannelBufferWrapper(buffer.readBytes(length)); + } + + public char readChar() + { + return (char)buffer.readShort(); + } + + public double readDouble() + { + return Double.longBitsToDouble(buffer.readLong()); + } + + public int readerIndex() + { + return buffer.readerIndex(); + } + + public void readerIndex(final int readerIndex) + { + buffer.readerIndex(readerIndex); + } + + public float readFloat() + { + return Float.intBitsToFloat(buffer.readInt()); + } + + public int readInt() + { + return buffer.readInt(); + } + + public long readLong() + { + return buffer.readLong(); + } + + public short readShort() + { + return buffer.readShort(); + } + + public HornetQBuffer readSlice(final int length) + { + return new ChannelBufferWrapper(buffer.readSlice(length)); + } + + public short readUnsignedByte() + { + return buffer.readUnsignedByte(); + } + + public long readUnsignedInt() + { + return buffer.readUnsignedInt(); + } + + public int readUnsignedShort() + { + return buffer.readUnsignedShort(); + } + + public void resetReaderIndex() + { + buffer.resetReaderIndex(); + } + + public void resetWriterIndex() + { + buffer.resetWriterIndex(); + } + + public void setByte(final int index, final byte value) + { + buffer.setByte(index, value); + } + + public void setBytes(final int index, final byte[] src, final int srcIndex, final int length) + { + buffer.setBytes(index, src, srcIndex, length); + } + + public void setBytes(final int index, final byte[] src) + { + buffer.setBytes(index, src); + } + + public void setBytes(final int index, final ByteBuffer src) + { + buffer.setBytes(index, src); + } + + public void setBytes(final int index, final HornetQBuffer src, final int srcIndex, final int length) + { + buffer.setBytes(index, src.channelBuffer(), srcIndex, length); + } + + public void setBytes(final int index, final HornetQBuffer src, final int length) + { + buffer.setBytes(index, src.channelBuffer(), length); + } + + public void setBytes(final int index, final HornetQBuffer src) + { + buffer.setBytes(index, src.channelBuffer()); + } + + public void setChar(final int index, final char value) + { + buffer.setShort(index, (short)value); + } + + public void setDouble(final int index, final double value) + { + buffer.setLong(index, Double.doubleToLongBits(value)); + } + + public void setFloat(final int index, final float value) + { + buffer.setInt(index, Float.floatToIntBits(value)); + } + + public void setIndex(final int readerIndex, final int writerIndex) + { + buffer.setIndex(readerIndex, writerIndex); + } + + public void setInt(final int index, final int value) + { + buffer.setInt(index, value); + } + + public void setLong(final int index, final long value) + { + buffer.setLong(index, value); + } + + public void setShort(final int index, final short value) + { + buffer.setShort(index, value); + } + + public void skipBytes(final int length) + { + buffer.skipBytes(length); + } + + public HornetQBuffer slice() + { + return new ChannelBufferWrapper(buffer.slice()); + } + + public HornetQBuffer slice(final int index, final int length) + { + return new ChannelBufferWrapper(buffer.slice(index, length)); + } + + public ByteBuffer toByteBuffer() + { + return buffer.toByteBuffer(); + } + + public ByteBuffer toByteBuffer(final int index, final int length) + { + return buffer.toByteBuffer(index, length); + } + + public boolean writable() + { + return buffer.writable(); + } + + public int writableBytes() + { + return buffer.writableBytes(); + } + + public void writeByte(final byte value) + { + buffer.writeByte(value); + } + + public void writeBytes(final byte[] src, final int srcIndex, final int length) + { + buffer.writeBytes(src, srcIndex, length); + } + + public void writeBytes(final byte[] src) + { + buffer.writeBytes(src); + } + + public void writeBytes(final ByteBuffer src) + { + buffer.writeBytes(src); + } + + public void writeBytes(final HornetQBuffer src, final int srcIndex, final int length) + { + buffer.writeBytes(src.channelBuffer(), srcIndex, length); + } + + public void writeBytes(final HornetQBuffer src, final int length) + { + buffer.writeBytes(src.channelBuffer(), length); + } + + public void writeChar(final char chr) + { + buffer.writeShort((short)chr); + } + + public void writeDouble(final double value) + { + buffer.writeLong(Double.doubleToLongBits(value)); + } + + public void writeFloat(final float value) + { + buffer.writeInt(Float.floatToIntBits(value)); + } + + public void writeInt(final int value) + { + buffer.writeInt(value); + } + + public void writeLong(final long value) + { + buffer.writeLong(value); + } + + public int writerIndex() + { + return buffer.writerIndex(); + } + + public void writerIndex(final int writerIndex) + { + buffer.writerIndex(writerIndex); + } + + public void writeShort(final short value) + { + buffer.writeShort(value); + } + +} Copied: trunk/hornetq-commons/src/main/java/org/hornetq/core/server/HornetQComponent.java (from rev 10738, trunk/hornetq-core/src/main/java/org/hornetq/core/server/HornetQComponent.java) =================================================================== --- trunk/hornetq-commons/src/main/java/org/hornetq/core/server/HornetQComponent.java (rev 0) +++ trunk/hornetq-commons/src/main/java/org/hornetq/core/server/HornetQComponent.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -0,0 +1,32 @@ +/* + * Copyright 2009 Red Hat, Inc. + * Red Hat 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.hornetq.core.server; + +/** + * A HornetQComponent + * + * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> + * @version <tt>$Revision: 2796 $</tt> + * + * $Id: HornetQComponent.java 2796 2007-06-25 22:24:41Z timfox $ + * + */ +public interface HornetQComponent +{ + void start() throws Exception; + + void stop() throws Exception; + + boolean isStarted(); +} Copied: trunk/hornetq-commons/src/main/java/org/hornetq/utils/DataConstants.java (from rev 10738, trunk/hornetq-core/src/main/java/org/hornetq/utils/DataConstants.java) =================================================================== --- trunk/hornetq-commons/src/main/java/org/hornetq/utils/DataConstants.java (rev 0) +++ trunk/hornetq-commons/src/main/java/org/hornetq/utils/DataConstants.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -0,0 +1,68 @@ +/* + * Copyright 2009 Red Hat, Inc. + * Red Hat 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.hornetq.utils; + +/** + * + * A DataConstants + * + * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> + * + */ +public class DataConstants +{ + public static final int SIZE_INT = 4; + + public static final int SIZE_BOOLEAN = 1; + + public static final int SIZE_LONG = 8; + + public static final int SIZE_BYTE = 1; + + public static final int SIZE_SHORT = 2; + + public static final int SIZE_DOUBLE = 8; + + public static final int SIZE_FLOAT = 4; + + public static final int SIZE_CHAR = 2; + + public static final byte TRUE = 1; + + public static final byte FALSE = 0; + + public static final byte NULL = 0; + + public static final byte NOT_NULL = 1; + + public static final byte BOOLEAN = 2; + + public static final byte BYTE = 3; + + public static final byte BYTES = 4; + + public static final byte SHORT = 5; + + public static final byte INT = 6; + + public static final byte LONG = 7; + + public static final byte FLOAT = 8; + + public static final byte DOUBLE = 9; + + public static final byte STRING = 10; + + public static final byte CHAR = 11; +} Copied: trunk/hornetq-commons/src/main/java/org/hornetq/utils/UTF8Util.java (from rev 10738, trunk/hornetq-core/src/main/java/org/hornetq/utils/UTF8Util.java) =================================================================== --- trunk/hornetq-commons/src/main/java/org/hornetq/utils/UTF8Util.java (rev 0) +++ trunk/hornetq-commons/src/main/java/org/hornetq/utils/UTF8Util.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -0,0 +1,272 @@ +/* + * Copyright 2009 Red Hat, Inc. + * Red Hat 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.hornetq.utils; + +import java.lang.ref.SoftReference; + +import org.hornetq.api.core.HornetQBuffer; +import org.hornetq.core.logging.Logger; + +/** + * + * A UTF8Util + * + * This class will write UTFs directly to the ByteOutput (through the MessageBuffer interface) + * + * @author <a href="mailto:clebert.suconic@jboss.org">Clebert Suconic</a> + * + * Created Feb 20, 2009 1:37:18 PM + * + * + */ +public class UTF8Util +{ + static boolean optimizeStrings = true; + + private static final Logger log = Logger.getLogger(UTF8Util.class); + + private static final boolean isTrace = UTF8Util.log.isTraceEnabled(); + + private static ThreadLocal<SoftReference<StringUtilBuffer>> currenBuffer = new ThreadLocal<SoftReference<StringUtilBuffer>>(); + + public static void saveUTF(final HornetQBuffer out, final String str) + { + StringUtilBuffer buffer = UTF8Util.getThreadLocalBuffer(); + + if (str.length() > 0xffff) + { + throw new IllegalArgumentException("the specified string is too long (" + str.length() + ")"); + } + + final int len = UTF8Util.calculateUTFSize(str, buffer); + + if (len > 0xffff) + { + throw new IllegalArgumentException("the encoded string is too long (" + len + ")"); + } + + out.writeShort((short)len); + + if (len > buffer.byteBuffer.length) + { + buffer.resizeByteBuffer(len); + } + + if (len == (long)str.length()) + { + for (int byteLocation = 0; byteLocation < len; byteLocation++) + { + buffer.byteBuffer[byteLocation] = (byte)buffer.charBuffer[byteLocation]; + } + out.writeBytes(buffer.byteBuffer, 0, len); + } + else + { + if (UTF8Util.isTrace) + { + // This message is too verbose for debug, that's why we are using trace here + UTF8Util.log.trace("Saving string with utfSize=" + len + " stringSize=" + str.length()); + } + + int stringLength = str.length(); + + int charCount = 0; + + for (int i = 0; i < stringLength; i++) + { + char charAtPos = buffer.charBuffer[i]; + if (charAtPos >= 1 && charAtPos < 0x7f) + { + buffer.byteBuffer[charCount++] = (byte)charAtPos; + } + else if (charAtPos >= 0x800) + { + buffer.byteBuffer[charCount++] = (byte)(0xE0 | charAtPos >> 12 & 0x0F); + buffer.byteBuffer[charCount++] = (byte)(0x80 | charAtPos >> 6 & 0x3F); + buffer.byteBuffer[charCount++] = (byte)(0x80 | charAtPos >> 0 & 0x3F); + } + else + { + buffer.byteBuffer[charCount++] = (byte)(0xC0 | charAtPos >> 6 & 0x1F); + buffer.byteBuffer[charCount++] = (byte)(0x80 | charAtPos >> 0 & 0x3F); + + } + } + out.writeBytes(buffer.byteBuffer, 0, len); + } + } + + public static String readUTF(final HornetQBuffer input) + { + StringUtilBuffer buffer = UTF8Util.getThreadLocalBuffer(); + + final int size = input.readUnsignedShort(); + + if (size > buffer.byteBuffer.length) + { + buffer.resizeByteBuffer(size); + } + + if (size > buffer.charBuffer.length) + { + buffer.resizeCharBuffer(size); + } + + if (UTF8Util.isTrace) + { + // This message is too verbose for debug, that's why we are using trace here + UTF8Util.log.trace("Reading string with utfSize=" + size); + } + + int count = 0; + int byte1, byte2, byte3; + int charCount = 0; + + input.readBytes(buffer.byteBuffer, 0, size); + + while (count < size) + { + byte1 = buffer.byteBuffer[count++]; + + if (byte1 > 0 && byte1 <= 0x7F) + { + buffer.charBuffer[charCount++] = (char)byte1; + } + else + { + int c = byte1 & 0xff; + switch (c >> 4) + { + case 0xc: + case 0xd: + byte2 = buffer.byteBuffer[count++]; + buffer.charBuffer[charCount++] = (char)((c & 0x1F) << 6 | byte2 & 0x3F); + break; + case 0xe: + byte2 = buffer.byteBuffer[count++]; + byte3 = buffer.byteBuffer[count++]; + buffer.charBuffer[charCount++] = (char)((c & 0x0F) << 12 | (byte2 & 0x3F) << 6 | (byte3 & 0x3F) << 0); + break; + } + } + } + + return new String(buffer.charBuffer, 0, charCount); + + } + + private static StringUtilBuffer getThreadLocalBuffer() + { + SoftReference<StringUtilBuffer> softReference = UTF8Util.currenBuffer.get(); + StringUtilBuffer value; + if (softReference == null) + { + value = new StringUtilBuffer(); + softReference = new SoftReference<StringUtilBuffer>(value); + UTF8Util.currenBuffer.set(softReference); + } + else + { + value = softReference.get(); + } + + if (value == null) + { + value = new StringUtilBuffer(); + softReference = new SoftReference<StringUtilBuffer>(value); + UTF8Util.currenBuffer.set(softReference); + } + + return value; + } + + public static void clearBuffer() + { + SoftReference<StringUtilBuffer> ref = UTF8Util.currenBuffer.get(); + if (ref.get() != null) + { + ref.clear(); + } + } + + public static int calculateUTFSize(final String str, final StringUtilBuffer stringBuffer) + { + int calculatedLen = 0; + + int stringLength = str.length(); + + if (stringLength > stringBuffer.charBuffer.length) + { + stringBuffer.resizeCharBuffer(stringLength); + } + + str.getChars(0, stringLength, stringBuffer.charBuffer, 0); + + for (int i = 0; i < stringLength; i++) + { + char c = stringBuffer.charBuffer[i]; + + if (c >= 1 && c < 0x7f) + { + calculatedLen++; + } + else if (c >= 0x800) + { + calculatedLen += 3; + } + else + { + calculatedLen += 2; + } + } + return calculatedLen; + } + + private static class StringUtilBuffer + { + + public char charBuffer[]; + + public byte byteBuffer[]; + + public void resizeCharBuffer(final int newSize) + { + if (newSize > charBuffer.length) + { + charBuffer = new char[newSize]; + } + } + + public void resizeByteBuffer(final int newSize) + { + if (newSize > byteBuffer.length) + { + byteBuffer = new byte[newSize]; + } + } + + public StringUtilBuffer() + { + this(1024, 1024); + } + + public StringUtilBuffer(final int sizeChar, final int sizeByte) + { + charBuffer = new char[sizeChar]; + byteBuffer = new byte[sizeByte]; + } + + } + +} Deleted: trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffer.java =================================================================== --- trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffer.java 2011-05-26 12:31:10 UTC (rev 10738) +++ trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffer.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -1,1086 +0,0 @@ -/* - * Copyright 2009 Red Hat, Inc. - * Red Hat 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.hornetq.api.core; - -import java.nio.ByteBuffer; - -import org.jboss.netty.buffer.ChannelBuffer; - -/** - * - * A HornetQBuffer wraps a Netty's ChannelBuffer and is used throughout HornetQ code base. - * - * Much of it derived from Netty ChannelBuffer by Trustin Lee - * - * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> - * - * @see HornetQBuffers - * - */ -public interface HornetQBuffer -{ - /** - * Returns the underlying Netty's ChannelBuffer - * - * @return the underlying Netty's ChannelBuffer - */ - ChannelBuffer channelBuffer(); - - /** - * Returns the number of bytes this buffer can contain. - */ - int capacity(); - - /** - * Returns the {@code readerIndex} of this buffer. - */ - int readerIndex(); - - /** - * Sets the {@code readerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code readerIndex} is - * less than {@code 0} or - * greater than {@code this.writerIndex} - */ - void readerIndex(int readerIndex); - - /** - * Returns the {@code writerIndex} of this buffer. - */ - int writerIndex(); - - /** - * Sets the {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code writerIndex} is - * less than {@code this.readerIndex} or - * greater than {@code this.capacity} - */ - void writerIndex(int writerIndex); - - /** - * Sets the {@code readerIndex} and {@code writerIndex} of this buffer - * in one shot. This method is useful when you have to worry about the - * invocation order of {@link #readerIndex(int)} and {@link #writerIndex(int)} - * methods. For example, the following code will fail: - * - * <pre> - * // Create a buffer whose readerIndex, writerIndex and capacity are - * // 0, 0 and 8 respectively. - * ChannelBuffer buf = ChannelBuffers.buffer(8); - * - * // IndexOutOfBoundsException is thrown because the specified - * // readerIndex (2) cannot be greater than the current writerIndex (0). - * buf.readerIndex(2); - * buf.writerIndex(4); - * </pre> - * - * The following code will also fail: - * - * <pre> - * // Create a buffer whose readerIndex, writerIndex and capacity are - * // 0, 8 and 8 respectively. - * ChannelBuffer buf = ChannelBuffers.wrappedBuffer(new byte[8]); - * - * // readerIndex becomes 8. - * buf.readLong(); - * - * // IndexOutOfBoundsException is thrown because the specified - * // writerIndex (4) cannot be less than the current readerIndex (8). - * buf.writerIndex(4); - * buf.readerIndex(2); - * </pre> - * - * By contrast, {@link #setIndex(int, int)} guarantees that it never - * throws an {@link IndexOutOfBoundsException} as long as the specified - * indexes meet basic constraints, regardless what the current index - * values of the buffer are: - * - * <pre> - * // No matter what the current state of the buffer is, the following - * // call always succeeds as long as the capacity of the buffer is not - * // less than 4. - * buf.setIndex(2, 4); - * </pre> - * - * @throws IndexOutOfBoundsException - * if the specified {@code readerIndex} is less than 0, - * if the specified {@code writerIndex} is less than the specified - * {@code readerIndex} or if the specified {@code writerIndex} is - * greater than {@code this.capacity} - */ - void setIndex(int readerIndex, int writerIndex); - - /** - * Returns the number of readable bytes which is equal to - * {@code (this.writerIndex - this.readerIndex)}. - */ - int readableBytes(); - - /** - * Returns the number of writable bytes which is equal to - * {@code (this.capacity - this.writerIndex)}. - */ - int writableBytes(); - - /** - * Returns {@code true} - * if and only if {@code (this.writerIndex - this.readerIndex)} is greater - * than {@code 0}. - */ - boolean readable(); - - /** - * Returns {@code true} - * if and only if {@code (this.capacity - this.writerIndex)} is greater - * than {@code 0}. - */ - boolean writable(); - - /** - * Sets the {@code readerIndex} and {@code writerIndex} of this buffer to - * {@code 0}. - * This method is identical to {@link #setIndex(int, int) setIndex(0, 0)}. - * <p> - * Please note that the behavior of this method is different - * from that of NIO buffer, which sets the {@code limit} to - * the {@code capacity} of the buffer. - */ - void clear(); - - /** - * Marks the current {@code readerIndex} in this buffer. You can - * reposition the current {@code readerIndex} to the marked - * {@code readerIndex} by calling {@link #resetReaderIndex()}. - * The initial value of the marked {@code readerIndex} is {@code 0}. - */ - void markReaderIndex(); - - /** - * Repositions the current {@code readerIndex} to the marked - * {@code readerIndex} in this buffer. - * - * @throws IndexOutOfBoundsException - * if the current {@code writerIndex} is less than the marked - * {@code readerIndex} - */ - void resetReaderIndex(); - - /** - * Marks the current {@code writerIndex} in this buffer. You can - * reposition the current {@code writerIndex} to the marked - * {@code writerIndex} by calling {@link #resetWriterIndex()}. - * The initial value of the marked {@code writerIndex} is {@code 0}. - */ - void markWriterIndex(); - - /** - * Repositions the current {@code writerIndex} to the marked - * {@code writerIndex} in this buffer. - * - * @throws IndexOutOfBoundsException - * if the current {@code readerIndex} is greater than the marked - * {@code writerIndex} - */ - void resetWriterIndex(); - - /** - * Discards the bytes between the 0th index and {@code readerIndex}. - * It moves the bytes between {@code readerIndex} and {@code writerIndex} - * to the 0th index, and sets {@code readerIndex} and {@code writerIndex} - * to {@code 0} and {@code oldWriterIndex - oldReaderIndex} respectively. - * <p> - * Please refer to the class documentation for more detailed explanation. - */ - void discardReadBytes(); - - /** - * Gets a byte at the specified absolute {@code index} in this buffer. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 1} is greater than {@code this.capacity} - */ - byte getByte(int index); - - /** - * Gets an unsigned byte at the specified absolute {@code index} in this - * buffer. This method does not modify {@code readerIndex} or - * {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 1} is greater than {@code this.capacity} - */ - short getUnsignedByte(int index); - - /** - * Gets a 16-bit short integer at the specified absolute {@code index} in - * this buffer. This method does not modify {@code readerIndex} or - * {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 2} is greater than {@code this.capacity} - */ - short getShort(int index); - - /** - * Gets an unsigned 16-bit short integer at the specified absolute - * {@code index} in this buffer. This method does not modify - * {@code readerIndex} or {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 2} is greater than {@code this.capacity} - */ - int getUnsignedShort(int index); - - /** - * Gets a 32-bit integer at the specified absolute {@code index} in - * this buffer. This method does not modify {@code readerIndex} or - * {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 4} is greater than {@code this.capacity} - */ - int getInt(int index); - - /** - * Gets an unsigned 32-bit integer at the specified absolute {@code index} - * in this buffer. This method does not modify {@code readerIndex} or - * {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 4} is greater than {@code this.capacity} - */ - long getUnsignedInt(int index); - - /** - * Gets a 64-bit long integer at the specified absolute {@code index} in - * this buffer. This method does not modify {@code readerIndex} or - * {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 8} is greater than {@code this.capacity} - */ - long getLong(int index); - - /** - * Transfers this buffer's data to the specified destination starting at - * the specified absolute {@code index} until the destination becomes - * non-writable. This method is basically same with - * {@link #getBytes(int, HornetQBuffer, int, int)}, except that this - * method increases the {@code writerIndex} of the destination by the - * number of the transferred bytes while - * {@link #getBytes(int, HornetQBuffer, int, int)} does not. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * the source buffer (i.e. {@code this}). - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * if {@code index + dst.writableBytes} is greater than - * {@code this.capacity} - */ - void getBytes(int index, HornetQBuffer dst); - - /** - * Transfers this buffer's data to the specified destination starting at - * the specified absolute {@code index}. This method is basically same - * with {@link #getBytes(int, HornetQBuffer, int, int)}, except that this - * method increases the {@code writerIndex} of the destination by the - * number of the transferred bytes while - * {@link #getBytes(int, HornetQBuffer, int, int)} does not. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * the source buffer (i.e. {@code this}). - * - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0}, - * if {@code index + length} is greater than - * {@code this.capacity}, or - * if {@code length} is greater than {@code dst.writableBytes} - */ - void getBytes(int index, HornetQBuffer dst, int length); - - /** - * Transfers this buffer's data to the specified destination starting at - * the specified absolute {@code index}. - * This method does not modify {@code readerIndex} or {@code writerIndex} - * of both the source (i.e. {@code this}) and the destination. - * - * @param dstIndex the first index of the destination - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0}, - * if the specified {@code dstIndex} is less than {@code 0}, - * if {@code index + length} is greater than - * {@code this.capacity}, or - * if {@code dstIndex + length} is greater than - * {@code dst.capacity} - */ - void getBytes(int index, HornetQBuffer dst, int dstIndex, int length); - - /** - * Transfers this buffer's data to the specified destination starting at - * the specified absolute {@code index}. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * if {@code index + dst.length} is greater than - * {@code this.capacity} - */ - void getBytes(int index, byte[] dst); - - /** - * Transfers this buffer's data to the specified destination starting at - * the specified absolute {@code index}. - * This method does not modify {@code readerIndex} or {@code writerIndex} - * of this buffer. - * - * @param dstIndex the first index of the destination - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0}, - * if the specified {@code dstIndex} is less than {@code 0}, - * if {@code index + length} is greater than - * {@code this.capacity}, or - * if {@code dstIndex + length} is greater than - * {@code dst.length} - */ - void getBytes(int index, byte[] dst, int dstIndex, int length); - - /** - * Transfers this buffer's data to the specified destination starting at - * the specified absolute {@code index} until the destination's position - * reaches its limit. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer while the destination's {@code position} will be increased. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * if {@code index + dst.remaining()} is greater than - * {@code this.capacity} - */ - void getBytes(int index, ByteBuffer dst); - - /** - * Gets a char at the specified absolute {@code index} in - * this buffer. This method does not modify {@code readerIndex} or - * {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 2} is greater than {@code this.capacity} - */ - char getChar(int index); - - /** - * Gets a float at the specified absolute {@code index} in - * this buffer. This method does not modify {@code readerIndex} or - * {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 4} is greater than {@code this.capacity} - */ - float getFloat(int index); - - /** - * Gets a double at the specified absolute {@code index} in - * this buffer. This method does not modify {@code readerIndex} or - * {@code writerIndex} of this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 8} is greater than {@code this.capacity} - */ - double getDouble(int index); - - /** - * Sets the specified byte at the specified absolute {@code index} in this - * buffer. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 1} is greater than {@code this.capacity} - */ - void setByte(int index, byte value); - - /** - * Sets the specified 16-bit short integer at the specified absolute - * {@code index} in this buffer. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 2} is greater than {@code this.capacity} - */ - void setShort(int index, short value); - - /** - * Sets the specified 32-bit integer at the specified absolute - * {@code index} in this buffer. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 4} is greater than {@code this.capacity} - */ - void setInt(int index, int value); - - /** - * Sets the specified 64-bit long integer at the specified absolute - * {@code index} in this buffer. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 8} is greater than {@code this.capacity} - */ - void setLong(int index, long value); - - /** - * Transfers the specified source buffer's data to this buffer starting at - * the specified absolute {@code index} until the destination becomes - * unreadable. This method is basically same with - * {@link #setBytes(int, HornetQBuffer, int, int)}, except that this - * method increases the {@code readerIndex} of the source buffer by - * the number of the transferred bytes while - * {@link #getBytes(int, HornetQBuffer, int, int)} does not. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * the source buffer (i.e. {@code this}). - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * if {@code index + src.readableBytes} is greater than - * {@code this.capacity} - */ - void setBytes(int index, HornetQBuffer src); - - /** - * Transfers the specified source buffer's data to this buffer starting at - * the specified absolute {@code index}. This method is basically same - * with {@link #setBytes(int, HornetQBuffer, int, int)}, except that this - * method increases the {@code readerIndex} of the source buffer by - * the number of the transferred bytes while - * {@link #getBytes(int, HornetQBuffer, int, int)} does not. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * the source buffer (i.e. {@code this}). - * - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0}, - * if {@code index + length} is greater than - * {@code this.capacity}, or - * if {@code length} is greater than {@code src.readableBytes} - */ - void setBytes(int index, HornetQBuffer src, int length); - - /** - * Transfers the specified source buffer's data to this buffer starting at - * the specified absolute {@code index}. - * This method does not modify {@code readerIndex} or {@code writerIndex} - * of both the source (i.e. {@code this}) and the destination. - * - * @param srcIndex the first index of the source - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0}, - * if the specified {@code srcIndex} is less than {@code 0}, - * if {@code index + length} is greater than - * {@code this.capacity}, or - * if {@code srcIndex + length} is greater than - * {@code src.capacity} - */ - void setBytes(int index, HornetQBuffer src, int srcIndex, int length); - - /** - * Transfers the specified source array's data to this buffer starting at - * the specified absolute {@code index}. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * if {@code index + src.length} is greater than - * {@code this.capacity} - */ - void setBytes(int index, byte[] src); - - /** - * Transfers the specified source array's data to this buffer starting at - * the specified absolute {@code index}. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0}, - * if the specified {@code srcIndex} is less than {@code 0}, - * if {@code index + length} is greater than - * {@code this.capacity}, or - * if {@code srcIndex + length} is greater than {@code src.length} - */ - void setBytes(int index, byte[] src, int srcIndex, int length); - - /** - * Transfers the specified source buffer's data to this buffer starting at - * the specified absolute {@code index} until the source buffer's position - * reaches its limit. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * if {@code index + src.remaining()} is greater than - * {@code this.capacity} - */ - void setBytes(int index, ByteBuffer src); - - /** - * Sets the specified char at the specified absolute - * {@code index} in this buffer. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 2} is greater than {@code this.capacity} - */ - void setChar(int index, char value); - - /** - * Sets the specified float at the specified absolute - * {@code index} in this buffer. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 4} is greater than {@code this.capacity} - */ - void setFloat(int index, float value); - - /** - * Sets the specified double at the specified absolute - * {@code index} in this buffer. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - * @throws IndexOutOfBoundsException - * if the specified {@code index} is less than {@code 0} or - * {@code index + 8} is greater than {@code this.capacity} - */ - void setDouble(int index, double value); - - /** - * Gets a byte at the current {@code readerIndex} and increases - * the {@code readerIndex} by {@code 1} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 1} - */ - byte readByte(); - - /** - * Gets an unsigned byte at the current {@code readerIndex} and increases - * the {@code readerIndex} by {@code 1} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 1} - */ - short readUnsignedByte(); - - /** - * Gets a 16-bit short integer at the current {@code readerIndex} - * and increases the {@code readerIndex} by {@code 2} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 2} - */ - short readShort(); - - /** - * Gets an unsigned 16-bit short integer at the current {@code readerIndex} - * and increases the {@code readerIndex} by {@code 2} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 2} - */ - int readUnsignedShort(); - - /** - * Gets a 32-bit integer at the current {@code readerIndex} - * and increases the {@code readerIndex} by {@code 4} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 4} - */ - int readInt(); - - /** - * Gets an unsigned 32-bit integer at the current {@code readerIndex} - * and increases the {@code readerIndex} by {@code 4} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 4} - */ - long readUnsignedInt(); - - /** - * Gets a 64-bit integer at the current {@code readerIndex} - * and increases the {@code readerIndex} by {@code 8} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 8} - */ - long readLong(); - - /** - * Gets a char at the current {@code readerIndex} - * and increases the {@code readerIndex} by {@code 2} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 2} - */ - char readChar(); - - /** - * Gets a float at the current {@code readerIndex} - * and increases the {@code readerIndex} by {@code 4} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 4} - */ - float readFloat(); - - /** - * Gets a double at the current {@code readerIndex} - * and increases the {@code readerIndex} by {@code 8} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 8} - */ - double readDouble(); - - /** - * Gets a boolean at the current {@code readerIndex} - * and increases the {@code readerIndex} by {@code 1} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.readableBytes} is less than {@code 1} - */ - boolean readBoolean(); - - /** - * Gets a SimpleString (potentially {@code null}) at the current {@code readerIndex} - */ - SimpleString readNullableSimpleString(); - - /** - * Gets a String (potentially {@code null}) at the current {@code readerIndex} - */ - String readNullableString(); - - /** - * Gets a non-null SimpleString at the current {@code readerIndex} - */ - SimpleString readSimpleString(); - - /** - * Gets a non-null String at the current {@code readerIndex} - */ - String readString(); - - /** - * Gets a UTF-8 String at the current {@code readerIndex} - */ - String readUTF(); - - /** - * Transfers this buffer's data to a newly created buffer starting at - * the current {@code readerIndex} and increases the {@code readerIndex} - * by the number of the transferred bytes (= {@code length}). - * The returned buffer's {@code readerIndex} and {@code writerIndex} are - * {@code 0} and {@code length} respectively. - * - * @param length the number of bytes to transfer - * - * @return the newly created buffer which contains the transferred bytes - * - * @throws IndexOutOfBoundsException - * if {@code length} is greater than {@code this.readableBytes} - */ - HornetQBuffer readBytes(int length); - - /** - * Returns a new slice of this buffer's sub-region starting at the current - * {@code readerIndex} and increases the {@code readerIndex} by the size - * of the new slice (= {@code length}). - * - * @param length the size of the new slice - * - * @return the newly created slice - * - * @throws IndexOutOfBoundsException - * if {@code length} is greater than {@code this.readableBytes} - */ - HornetQBuffer readSlice(int length); - - /** - * Transfers this buffer's data to the specified destination starting at - * the current {@code readerIndex} until the destination becomes - * non-writable, and increases the {@code readerIndex} by the number of the - * transferred bytes. This method is basically same with - * {@link #readBytes(HornetQBuffer, int, int)}, except that this method - * increases the {@code writerIndex} of the destination by the number of - * the transferred bytes while {@link #readBytes(HornetQBuffer, int, int)} - * does not. - * - * @throws IndexOutOfBoundsException - * if {@code dst.writableBytes} is greater than - * {@code this.readableBytes} - */ - void readBytes(HornetQBuffer dst); - - /** - * Transfers this buffer's data to the specified destination starting at - * the current {@code readerIndex} and increases the {@code readerIndex} - * by the number of the transferred bytes (= {@code length}). This method - * is basically same with {@link #readBytes(HornetQBuffer, int, int)}, - * except that this method increases the {@code writerIndex} of the - * destination by the number of the transferred bytes (= {@code length}) - * while {@link #readBytes(HornetQBuffer, int, int)} does not. - * - * @throws IndexOutOfBoundsException - * if {@code length} is greater than {@code this.readableBytes} or - * if {@code length} is greater than {@code dst.writableBytes} - */ - void readBytes(HornetQBuffer dst, int length); - - /** - * Transfers this buffer's data to the specified destination starting at - * the current {@code readerIndex} and increases the {@code readerIndex} - * by the number of the transferred bytes (= {@code length}). - * - * @param dstIndex the first index of the destination - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if the specified {@code dstIndex} is less than {@code 0}, - * if {@code length} is greater than {@code this.readableBytes}, or - * if {@code dstIndex + length} is greater than - * {@code dst.capacity} - */ - void readBytes(HornetQBuffer dst, int dstIndex, int length); - - /** - * Transfers this buffer's data to the specified destination starting at - * the current {@code readerIndex} and increases the {@code readerIndex} - * by the number of the transferred bytes (= {@code dst.length}). - * - * @throws IndexOutOfBoundsException - * if {@code dst.length} is greater than {@code this.readableBytes} - */ - void readBytes(byte[] dst); - - /** - * Transfers this buffer's data to the specified destination starting at - * the current {@code readerIndex} and increases the {@code readerIndex} - * by the number of the transferred bytes (= {@code length}). - * - * @param dstIndex the first index of the destination - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if the specified {@code dstIndex} is less than {@code 0}, - * if {@code length} is greater than {@code this.readableBytes}, or - * if {@code dstIndex + length} is greater than {@code dst.length} - */ - void readBytes(byte[] dst, int dstIndex, int length); - - /** - * Transfers this buffer's data to the specified destination starting at - * the current {@code readerIndex} until the destination's position - * reaches its limit, and increases the {@code readerIndex} by the - * number of the transferred bytes. - * - * @throws IndexOutOfBoundsException - * if {@code dst.remaining()} is greater than - * {@code this.readableBytes} - */ - void readBytes(ByteBuffer dst); - - /** - * Increases the current {@code readerIndex} by the specified - * {@code length} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code length} is greater than {@code this.readableBytes} - */ - void skipBytes(int length); - - /** - * Sets the specified byte at the current {@code writerIndex} - * and increases the {@code writerIndex} by {@code 1} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.writableBytes} is less than {@code 1} - */ - void writeByte(byte value); - - /** - * Sets the specified 16-bit short integer at the current - * {@code writerIndex} and increases the {@code writerIndex} by {@code 2} - * in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.writableBytes} is less than {@code 2} - */ - void writeShort(short value); - - /** - * Sets the specified 32-bit integer at the current {@code writerIndex} - * and increases the {@code writerIndex} by {@code 4} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.writableBytes} is less than {@code 4} - */ - void writeInt(int value); - - /** - * Sets the specified 64-bit long integer at the current - * {@code writerIndex} and increases the {@code writerIndex} by {@code 8} - * in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.writableBytes} is less than {@code 8} - */ - void writeLong(long value); - - /** - * Sets the specified char at the current {@code writerIndex} - * and increases the {@code writerIndex} by {@code 2} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.writableBytes} is less than {@code 2} - */ - void writeChar(char chr); - - /** - * Sets the specified float at the current {@code writerIndex} - * and increases the {@code writerIndex} by {@code 4} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.writableBytes} is less than {@code 4} - */ - void writeFloat(float value); - - /** - * Sets the specified double at the current {@code writerIndex} - * and increases the {@code writerIndex} by {@code 8} in this buffer. - * - * @throws IndexOutOfBoundsException - * if {@code this.writableBytes} is less than {@code 8} - */ - void writeDouble(double value); - - /** - * Sets the specified boolean at the current {@code writerIndex} - */ - void writeBoolean(boolean val); - - /** - * Sets the specified SimpleString (potentially {@code null}) at the current {@code writerIndex} - */ - void writeNullableSimpleString(SimpleString val); - - /** - * Sets the specified String (potentially {@code null}) at the current {@code writerIndex} - */ - void writeNullableString(String val); - - /** - * Sets the specified non-null SimpleString at the current {@code writerIndex} - */ - void writeSimpleString(SimpleString val); - - /** - * Sets the specified non-null String at the current {@code writerIndex} - */ - void writeString(String val); - - /** - * Sets the specified UTF-8 String at the current {@code writerIndex} - */ - - void writeUTF(String utf); - - /** - * Transfers the specified source buffer's data to this buffer starting at - * the current {@code writerIndex} and increases the {@code writerIndex} - * by the number of the transferred bytes (= {@code length}). This method - * is basically same with {@link #writeBytes(HornetQBuffer, int, int)}, - * except that this method increases the {@code readerIndex} of the source - * buffer by the number of the transferred bytes (= {@code length}) while - * {@link #writeBytes(HornetQBuffer, int, int)} does not. - * - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if {@code length} is greater than {@code this.writableBytes} or - * if {@code length} is greater then {@code src.readableBytes} - */ - void writeBytes(HornetQBuffer src, int length); - - /** - * Transfers the specified source buffer's data to this buffer starting at - * the current {@code writerIndex} and increases the {@code writerIndex} - * by the number of the transferred bytes (= {@code length}). - * - * @param srcIndex the first index of the source - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if the specified {@code srcIndex} is less than {@code 0}, - * if {@code srcIndex + length} is greater than - * {@code src.capacity}, or - * if {@code length} is greater than {@code this.writableBytes} - */ - void writeBytes(HornetQBuffer src, int srcIndex, int length); - - /** - * Transfers the specified source array's data to this buffer starting at - * the current {@code writerIndex} and increases the {@code writerIndex} - * by the number of the transferred bytes (= {@code src.length}). - * - * @throws IndexOutOfBoundsException - * if {@code src.length} is greater than {@code this.writableBytes} - */ - void writeBytes(byte[] src); - - /** - * Transfers the specified source array's data to this buffer starting at - * the current {@code writerIndex} and increases the {@code writerIndex} - * by the number of the transferred bytes (= {@code length}). - * - * @param srcIndex the first index of the source - * @param length the number of bytes to transfer - * - * @throws IndexOutOfBoundsException - * if the specified {@code srcIndex} is less than {@code 0}, - * if {@code srcIndex + length} is greater than - * {@code src.length}, or - * if {@code length} is greater than {@code this.writableBytes} - */ - void writeBytes(byte[] src, int srcIndex, int length); - - /** - * Transfers the specified source buffer's data to this buffer starting at - * the current {@code writerIndex} until the source buffer's position - * reaches its limit, and increases the {@code writerIndex} by the - * number of the transferred bytes. - * - * @throws IndexOutOfBoundsException - * if {@code src.remaining()} is greater than - * {@code this.writableBytes} - */ - void writeBytes(ByteBuffer src); - - /** - * Returns a copy of this buffer's readable bytes. Modifying the content - * of the returned buffer or this buffer does not affect each other at all. - * This method is identical to {@code buf.copy(buf.readerIndex(), buf.readableBytes())}. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - * - */ - HornetQBuffer copy(); - - /** - * Returns a copy of this buffer's sub-region. Modifying the content of - * the returned buffer or this buffer does not affect each other at all. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - */ - HornetQBuffer copy(int index, int length); - - /** - * Returns a slice of this buffer's readable bytes. Modifying the content - * of the returned buffer or this buffer affects each other's content - * while they maintain separate indexes and marks. This method is - * identical to {@code buf.slice(buf.readerIndex(), buf.readableBytes())}. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - */ - HornetQBuffer slice(); - - /** - * Returns a slice of this buffer's sub-region. Modifying the content of - * the returned buffer or this buffer affects each other's content while - * they maintain separate indexes and marks. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - */ - HornetQBuffer slice(int index, int length); - - /** - * Returns a buffer which shares the whole region of this buffer. - * Modifying the content of the returned buffer or this buffer affects - * each other's content while they maintain separate indexes and marks. - * This method is identical to {@code buf.slice(0, buf.capacity())}. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - */ - HornetQBuffer duplicate(); - - /** - * Converts this buffer's readable bytes into a NIO buffer. The returned - * buffer might or might not share the content with this buffer, while - * they have separate indexes and marks. This method is identical to - * {@code buf.toByteBuffer(buf.readerIndex(), buf.readableBytes())}. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - */ - ByteBuffer toByteBuffer(); - - /** - * Converts this buffer's sub-region into a NIO buffer. The returned - * buffer might or might not share the content with this buffer, while - * they have separate indexes and marks. - * This method does not modify {@code readerIndex} or {@code writerIndex} of - * this buffer. - */ - ByteBuffer toByteBuffer(int index, int length); -} Deleted: trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffers.java =================================================================== --- trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffers.java 2011-05-26 12:31:10 UTC (rev 10738) +++ trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQBuffers.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -1,97 +0,0 @@ -/* - * Copyright 2009 Red Hat, Inc. - * Red Hat 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.hornetq.api.core; - -import java.nio.ByteBuffer; - -import org.hornetq.core.buffers.impl.ChannelBufferWrapper; -import org.jboss.netty.buffer.ChannelBuffer; -import org.jboss.netty.buffer.ChannelBuffers; - -/** - * Factory class to create HornetQBuffers - * - * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> - */ -public class HornetQBuffers -{ - /** - * Creates a <em>self-expanding</em> HornetQBuffer with the given initial size - * - * @param size the initial size of the created HornetQBuffer - * @return a self-expanding HornetQBuffer starting with the given size - */ - public static HornetQBuffer dynamicBuffer(final int size) - { - return new ChannelBufferWrapper(ChannelBuffers.dynamicBuffer(size)); - } - - /** - * Creates a <em>self-expanding</em> HornetQBuffer filled with the given byte array - * - * @param bytes the created buffer will be initially filled with this byte array - * @return a self-expanding HornetQBuffer filled with the given byte array - */ - public static HornetQBuffer dynamicBuffer(final byte[] bytes) - { - ChannelBuffer buff = ChannelBuffers.dynamicBuffer(bytes.length); - - buff.writeBytes(bytes); - - return new ChannelBufferWrapper(buff); - } - - /** - * Creates a HornetQBuffer wrapping an underlying NIO ByteBuffer - * - * The position on this buffer won't affect the position on the inner buffer - * - * @param underlying the underlying NIO ByteBuffer - * @return a HornetQBuffer wrapping the underlying NIO ByteBuffer - */ - public static HornetQBuffer wrappedBuffer(final ByteBuffer underlying) - { - HornetQBuffer buff = new ChannelBufferWrapper(ChannelBuffers.wrappedBuffer(underlying)); - - buff.clear(); - - return buff; - } - - /** - * Creates a HornetQBuffer wrapping an underlying byte array - * - * @param underlying the underlying byte array - * @return a HornetQBuffer wrapping the underlying byte array - */ - public static HornetQBuffer wrappedBuffer(final byte[] underlying) - { - return new ChannelBufferWrapper(ChannelBuffers.wrappedBuffer(underlying)); - } - - /** - * Creates a <em>fixed</em> HornetQBuffer of the given size - * - * @param size the size of the created HornetQBuffer - * @return a fixed HornetQBuffer with the given size - */ - public static HornetQBuffer fixedBuffer(final int size) - { - return new ChannelBufferWrapper(ChannelBuffers.buffer(size)); - } - - private HornetQBuffers() - { - } -} Deleted: trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQException.java =================================================================== --- trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQException.java 2011-05-26 12:31:10 UTC (rev 10738) +++ trunk/hornetq-core/src/main/java/org/hornetq/api/core/HornetQException.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -1,226 +0,0 @@ -/* - * Copyright 2009 Red Hat, Inc. - * Red Hat 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.hornetq.api.core; - -/** - * - * HornetQException is the root exception for HornetQ API. - * - * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> - * - */ -public class HornetQException extends Exception -{ - private static final long serialVersionUID = -4802014152804997417L; - - // Error codes ------------------------------------------------- - - /** - * Internal error which prevented HornetQ to perform. - */ - public static final int INTERNAL_ERROR = 000; - - /** - * A packet of unsupported type was received by HornetQ PacketHandler. - */ - public static final int UNSUPPORTED_PACKET = 001; - - /** - * A client is not able to connect to HornetQ server. - */ - public static final int NOT_CONNECTED = 002; - - /** - * A client timed out will connecting to HornetQ server. - */ - public static final int CONNECTION_TIMEDOUT = 003; - - /** - * A client was disconnected from HornetQ server when the server has shut down. - */ - public static final int DISCONNECTED = 004; - - /** - * A blocking call from a client was unblocked during failover. - */ - public static final int UNBLOCKED = 005; - - /** - * Unexpected I/O error occured on the server. - */ - public static final int IO_ERROR = 006; - - /** - * An operation failed because a queue does not exist on the server. - */ - public static final int QUEUE_DOES_NOT_EXIST = 100; - - /** - * An operation failed because a queue exists on the server. - */ - public static final int QUEUE_EXISTS = 101; - - /** - * A client operation failed because the calling resource - * (ClientSession, ClientProducer, etc.) is closed. - */ - public static final int OBJECT_CLOSED = 102; - - /** - * An filter expression has not been validated - */ - public static final int INVALID_FILTER_EXPRESSION = 103; - - /** - * A HornetQ resource is not in a legal state (e.g. calling - * ClientConsumer.receive() if a MessageHandler is set) - */ - public static final int ILLEGAL_STATE = 104; - - /** - * A security problem occured (authentication issues, permission issues,...) - */ - public static final int SECURITY_EXCEPTION = 105; - - /** - * An operation failed because an address does not exist on the server. - */ - public static final int ADDRESS_DOES_NOT_EXIST = 106; - - /** - * An operation failed because an address exists on the server. - */ - public static final int ADDRESS_EXISTS = 107; - - /** - * A incompatibility between HornetQ versions on the client and the server has been detected - */ - public static final int INCOMPATIBLE_CLIENT_SERVER_VERSIONS = 108; - - /** - * An operation failed because a session exists on the server. - */ - public static final int SESSION_EXISTS = 109; - - /** - * An problem occurred while manipulating the body of a large message. - */ - public static final int LARGE_MESSAGE_ERROR_BODY = 110; - - /** - * A transaction was rolled back. - */ - public static final int TRANSACTION_ROLLED_BACK = 111; - - /** - * The creation of a session was rejected by the server (e.g. if the - * server is starting and has not finish to be initialized) - */ - public static final int SESSION_CREATION_REJECTED = 112; - - /** - * A DuplicateID was rejected. - */ - public static final int DUPLICATE_ID_REJECTED = 113; - - - // Native Error codes ---------------------------------------------- - - /** - * A internal error occured in the AIO native code - */ - public static final int NATIVE_ERROR_INTERNAL = 200; - - /** - * A buffer is invalid in the AIO native code - */ - public static final int NATIVE_ERROR_INVALID_BUFFER = 201; - - /** - * Alignment error in the AIO native code - */ - public static final int NATIVE_ERROR_NOT_ALIGNED = 202; - - /** - * AIO has not been properly initialized - */ - public static final int NATIVE_ERROR_CANT_INITIALIZE_AIO = 203; - - /** - * AIO has not been properly released - */ - public static final int NATIVE_ERROR_CANT_RELEASE_AIO = 204; - - /** - * A closed file has not be properly reopened - */ - public static final int NATIVE_ERROR_CANT_OPEN_CLOSE_FILE = 205; - - /** - * An error occured while allocating a queue in AIO native code - */ - public static final int NATIVE_ERROR_CANT_ALLOCATE_QUEUE = 206; - - /** - * An error occured while pre-allocating a file in AIO native code - */ - public static final int NATIVE_ERROR_PREALLOCATE_FILE = 208; - - /** - * An error occurred while allocating memory in the AIO native code - */ - public static final int NATIVE_ERROR_ALLOCATE_MEMORY = 209; - - /** - * AIO is full - */ - public static final int NATIVE_ERROR_AIO_FULL = 211; - - private int code; - - public HornetQException() - { - } - - public HornetQException(final int code) - { - this.code = code; - } - - public HornetQException(final int code, final String msg) - { - super(msg); - - this.code = code; - } - - public HornetQException(final int code, final String msg, final Throwable cause) - { - super(msg, cause); - - this.code = code; - } - - public int getCode() - { - return code; - } - - @Override - public String toString() - { - return "HornetQException[errorCode=" + code + " message=" + getMessage() + "]"; - } - -} Deleted: trunk/hornetq-core/src/main/java/org/hornetq/api/core/Pair.java =================================================================== --- trunk/hornetq-core/src/main/java/org/hornetq/api/core/Pair.java 2011-05-26 12:31:10 UTC (rev 10738) +++ trunk/hornetq-core/src/main/java/org/hornetq/api/core/Pair.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -1,84 +0,0 @@ -/* - * Copyright 2009 Red Hat, Inc. - * Red Hat 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.hornetq.api.core; - -import java.io.Serializable; - -/** - * - * A Pair is a holder for 2 objects. - * - * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> - * - */ -public class Pair<A, B> implements Serializable -{ - private static final long serialVersionUID = -2496357457812368127L; - - public Pair(final A a, final B b) - { - this.a = a; - - this.b = b; - } - - public A a; - - public B b; - - private int hash = -1; - - @Override - public int hashCode() - { - if (hash == -1) - { - if (a == null && b == null) - { - return super.hashCode(); - } - else - { - hash = (a == null ? 0 : a.hashCode()) + 37 * (b == null ? 0 : b.hashCode()); - } - } - - return hash; - } - - @Override - public boolean equals(final Object other) - { - if (other == this) - { - return true; - } - - if (other instanceof Pair == false) - { - return false; - } - - Pair<A, B> pother = (Pair<A, B>)other; - - return (pother.a == null ? a == null : pother.a.equals(a)) && (pother.b == null ? b == null : pother.b.equals(b)); - - } - - @Override - public String toString() - { - return "Pair[a=" + a + ", b=" + b + "]"; - } -} Deleted: trunk/hornetq-core/src/main/java/org/hornetq/api/core/SimpleString.java =================================================================== --- trunk/hornetq-core/src/main/java/org/hornetq/api/core/SimpleString.java 2011-05-26 12:31:10 UTC (rev 10738) +++ trunk/hornetq-core/src/main/java/org/hornetq/api/core/SimpleString.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -1,426 +0,0 @@ -/* - * Copyright 2009 Red Hat, Inc. - * Red Hat 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.hornetq.api.core; - -import java.io.Serializable; -import java.util.ArrayList; -import java.util.List; - -import org.hornetq.core.logging.Logger; -import org.hornetq.utils.DataConstants; - -/** - * A simple String class that can store all characters, and stores as simple byte[], - * this minimises expensive copying between String objects. - * - * This object is used heavily throughout HornetQ for performance reasons. - * - * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> - * - */ - -public class SimpleString implements CharSequence, Serializable, Comparable<SimpleString> -{ - private static final long serialVersionUID = 4204223851422244307L; - - private static final Logger log = Logger.getLogger(SimpleString.class); - - // Attributes - // ------------------------------------------------------------------------ - private final byte[] data; - - private transient int hash; - - // Cache the string - private transient String str; - - // Static - // ---------------------------------------------------------------------- - - /** - * Returns a SimpleString constructed from the <code>string</code> parameter. - * If <code>string</code> is <code>null</code>, the return value will be <code>null</code> too. - */ - public static SimpleString toSimpleString(final String string) - { - if (string == null) - { - return null; - } - return new SimpleString(string); - } - - // Constructors - // ---------------------------------------------------------------------- - /** - * creates a SimpleString from a conventional String - * @param string the string to transform - */ - public SimpleString(final String string) - { - int len = string.length(); - - data = new byte[len << 1]; - - int j = 0; - - for (int i = 0; i < len; i++) - { - char c = string.charAt(i); - - byte low = (byte)(c & 0xFF); // low byte - - data[j++] = low; - - byte high = (byte)(c >> 8 & 0xFF); // high byte - - data[j++] = high; - } - - str = string; - } - - /** - * creates a SimpleString from a byte array - * @param data the byte array to use - */ - public SimpleString(final byte[] data) - { - this.data = data; - } - - // CharSequence implementation - // --------------------------------------------------------------------------- - - public int length() - { - return data.length >> 1; - } - - public char charAt(int pos) - { - if (pos < 0 || pos >= data.length >> 1) - { - throw new IndexOutOfBoundsException(); - } - pos <<= 1; - - return (char)(data[pos] | data[pos + 1] << 8); - } - - public CharSequence subSequence(final int start, final int end) - { - int len = data.length >> 1; - - if (end < start || start < 0 || end > len) - { - throw new IndexOutOfBoundsException(); - } - else - { - int newlen = end - start << 1; - byte[] bytes = new byte[newlen]; - - System.arraycopy(data, start << 1, bytes, 0, newlen); - - return new SimpleString(bytes); - } - } - - // Comparable implementation ------------------------------------- - - public int compareTo(final SimpleString o) - { - return toString().compareTo(o.toString()); - } - - // Public - // --------------------------------------------------------------------------- - - /** - * returns the underlying byte array of this SimpleString - * @return the byte array - */ - public byte[] getData() - { - return data; - } - - /** - * returns true if the SimpleString parameter starts with the same data as this one. false if not. - * @param other the SimpelString to look for - * @return true if this SimpleString starts with the same data - */ - public boolean startsWith(final SimpleString other) - { - byte[] otherdata = other.data; - - if (otherdata.length > data.length) - { - return false; - } - - for (int i = 0; i < otherdata.length; i++) - { - if (data[i] != otherdata[i]) - { - return false; - } - } - - return true; - } - - @Override - public String toString() - { - if (str == null) - { - int len = data.length >> 1; - - char[] chars = new char[len]; - - int j = 0; - - for (int i = 0; i < len; i++) - { - int low = data[j++] & 0xFF; - - int high = data[j++] << 8 & 0xFF00; - - chars[i] = (char)(low | high); - } - - str = new String(chars); - } - - return str; - } - - @Override - public boolean equals(final Object other) - { - if (this == other) - { - return true; - } - - if (other instanceof SimpleString) - { - SimpleString s = (SimpleString)other; - - if (data.length != s.data.length) - { - return false; - } - - for (int i = 0; i < data.length; i++) - { - if (data[i] != s.data[i]) - { - return false; - } - } - - return true; - } - else - { - return false; - } - } - - @Override - public int hashCode() - { - if (hash == 0) - { - int tmphash = 0; - for (byte element : data) - { - tmphash = (tmphash << 5) - tmphash + element; // (hash << 5) - hash is same as hash * 31 - } - hash = tmphash; - } - - return hash; - } - - /** - * splits this SimpleString into an array of SimpleString using the char param as the delimeter. - * - * i.e. "a.b" would return "a" and "b" if . was the delimeter - * @param delim - */ - public SimpleString[] split(final char delim) - { - if (!contains(delim)) - { - return new SimpleString[] { this }; - } - else - { - List<SimpleString> all = new ArrayList<SimpleString>(); - int lasPos = 0; - for (int i = 0; i < data.length; i += 2) - { - byte low = (byte)(delim & 0xFF); // low byte - byte high = (byte)(delim >> 8 & 0xFF); // high byte - if (data[i] == low && data[i + 1] == high) - { - byte[] bytes = new byte[i - lasPos]; - System.arraycopy(data, lasPos, bytes, 0, bytes.length); - lasPos = i + 2; - all.add(new SimpleString(bytes)); - } - } - byte[] bytes = new byte[data.length - lasPos]; - System.arraycopy(data, lasPos, bytes, 0, bytes.length); - all.add(new SimpleString(bytes)); - SimpleString[] parts = new SimpleString[all.size()]; - return all.toArray(parts); - } - } - - /** - * checks to see if this SimpleString contains the char parameter passed in - * - * @param c the char to check for - * @return true if the char is found, false otherwise. - */ - public boolean contains(final char c) - { - for (int i = 0; i < data.length; i += 2) - { - byte low = (byte)(c & 0xFF); // low byte - byte high = (byte)(c >> 8 & 0xFF); // high byte - if (data[i] == low && data[i + 1] == high) - { - return true; - } - } - return false; - } - - /** - * concatanates a SimpleString and a String - * - * @param toAdd the String to concate with. - * @return the concatanated SimpleString - */ - public SimpleString concat(final String toAdd) - { - return concat(new SimpleString(toAdd)); - } - - /** - * concatanates 2 SimpleString's - * - * @param toAdd the SimpleString to concate with. - * @return the concatanated SimpleString - */ - public SimpleString concat(final SimpleString toAdd) - { - byte[] bytes = new byte[data.length + toAdd.getData().length]; - System.arraycopy(data, 0, bytes, 0, data.length); - System.arraycopy(toAdd.getData(), 0, bytes, data.length, toAdd.getData().length); - return new SimpleString(bytes); - } - - /** - * concatanates a SimpleString and a char - * - * @param c the char to concate with. - * @return the concatanated SimpleString - */ - public SimpleString concat(final char c) - { - byte[] bytes = new byte[data.length + 2]; - System.arraycopy(data, 0, bytes, 0, data.length); - bytes[data.length] = (byte)(c & 0xFF); - bytes[data.length + 1] = (byte)(c >> 8 & 0xFF); - return new SimpleString(bytes); - } - - /** - * returns the size of this SimpleString - * @return the size - */ - public int sizeof() - { - return DataConstants.SIZE_INT + data.length; - } - - /** - * returns the size of a SimpleString - * @param str the SimpleString to check - * @return the size - */ - public static int sizeofString(final SimpleString str) - { - return str.sizeof(); - } - - /** - * returns the size of a SimpleString which could be null - * @param str the SimpleString to check - * @return the size - */ - public static int sizeofNullableString(final SimpleString str) - { - if (str == null) - { - return 1; - } - else - { - return 1 + str.sizeof(); - } - } - - /** - * - * @param srcBegin - * @param srcEnd - * @param dst - * @param dstBegin - */ - public void getChars(final int srcBegin, final int srcEnd, final char dst[], final int dstBegin) - { - if (srcBegin < 0) - { - throw new StringIndexOutOfBoundsException(srcBegin); - } - if (srcEnd > length()) - { - throw new StringIndexOutOfBoundsException(srcEnd); - } - if (srcBegin > srcEnd) - { - throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); - } - - int j = 0; - - for (int i = srcBegin; i < srcEnd - srcBegin; i++) - { - int low = data[j++] & 0xFF; - - int high = data[j++] << 8 & 0xFF00; - - dst[i] = (char)(low | high); - } - } - -} \ No newline at end of file Deleted: trunk/hornetq-core/src/main/java/org/hornetq/core/buffers/impl/ChannelBufferWrapper.java =================================================================== --- trunk/hornetq-core/src/main/java/org/hornetq/core/buffers/impl/ChannelBufferWrapper.java 2011-05-26 12:31:10 UTC (rev 10738) +++ trunk/hornetq-core/src/main/java/org/hornetq/core/buffers/impl/ChannelBufferWrapper.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -1,620 +0,0 @@ -/* - * Copyright 2009 Red Hat, Inc. - * Red Hat 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.hornetq.core.buffers.impl; - -import java.nio.ByteBuffer; - -import org.hornetq.api.core.HornetQBuffer; -import org.hornetq.api.core.SimpleString; -import org.hornetq.core.logging.Logger; -import org.hornetq.utils.DataConstants; -import org.hornetq.utils.UTF8Util; -import org.jboss.netty.buffer.ChannelBuffer; - -/** - * - * A ChannelBufferWrapper - * - * @author Tim Fox - * - * - */ -public class ChannelBufferWrapper implements HornetQBuffer -{ - private static final Logger log = Logger.getLogger(ChannelBufferWrapper.class); - - protected ChannelBuffer buffer; - - public ChannelBufferWrapper(final ChannelBuffer buffer) - { - this.buffer = buffer; - } - - public boolean readBoolean() - { - return readByte() != 0; - } - - public SimpleString readNullableSimpleString() - { - int b = buffer.readByte(); - if (b == DataConstants.NULL) - { - return null; - } - else - { - return readSimpleStringInternal(); - } - } - - public String readNullableString() - { - int b = buffer.readByte(); - if (b == DataConstants.NULL) - { - return null; - } - else - { - return readStringInternal(); - } - } - - public SimpleString readSimpleString() - { - return readSimpleStringInternal(); - } - - private SimpleString readSimpleStringInternal() - { - int len = buffer.readInt(); - byte[] data = new byte[len]; - buffer.readBytes(data); - return new SimpleString(data); - } - - public String readString() - { - return readStringInternal(); - } - - private String readStringInternal() - { - int len = buffer.readInt(); - - if (len < 9) - { - char[] chars = new char[len]; - for (int i = 0; i < len; i++) - { - chars[i] = (char)buffer.readShort(); - } - return new String(chars); - } - else if (len < 0xfff) - { - return readUTF(); - } - else - { - return readSimpleStringInternal().toString(); - } - } - - public String readUTF() - { - return UTF8Util.readUTF(this); - } - - public void writeBoolean(final boolean val) - { - buffer.writeByte((byte)(val ? -1 : 0)); - } - - public void writeNullableSimpleString(final SimpleString val) - { - if (val == null) - { - buffer.writeByte(DataConstants.NULL); - } - else - { - buffer.writeByte(DataConstants.NOT_NULL); - writeSimpleStringInternal(val); - } - } - - public void writeNullableString(final String val) - { - if (val == null) - { - buffer.writeByte(DataConstants.NULL); - } - else - { - buffer.writeByte(DataConstants.NOT_NULL); - writeStringInternal(val); - } - } - - public void writeSimpleString(final SimpleString val) - { - writeSimpleStringInternal(val); - } - - private void writeSimpleStringInternal(final SimpleString val) - { - byte[] data = val.getData(); - buffer.writeInt(data.length); - buffer.writeBytes(data); - } - - public void writeString(final String val) - { - writeStringInternal(val); - } - - private void writeStringInternal(final String val) - { - int length = val.length(); - - buffer.writeInt(length); - - if (length < 9) - { - // If very small it's more performant to store char by char - for (int i = 0; i < val.length(); i++) - { - buffer.writeShort((short)val.charAt(i)); - } - } - else if (length < 0xfff) - { - // Store as UTF - this is quicker than char by char for most strings - writeUTF(val); - } - else - { - // Store as SimpleString, since can't store utf > 0xffff in length - writeSimpleStringInternal(new SimpleString(val)); - } - } - - public void writeUTF(final String utf) - { - UTF8Util.saveUTF(this, utf); - } - - public int capacity() - { - return buffer.capacity(); - } - - public ChannelBuffer channelBuffer() - { - return buffer; - } - - public void clear() - { - buffer.clear(); - } - - public HornetQBuffer copy() - { - return new ChannelBufferWrapper(buffer.copy()); - } - - public HornetQBuffer copy(final int index, final int length) - { - return new ChannelBufferWrapper(buffer.copy(index, length)); - } - - public void discardReadBytes() - { - buffer.discardReadBytes(); - } - - public HornetQBuffer duplicate() - { - return new ChannelBufferWrapper(buffer.duplicate()); - } - - public byte getByte(final int index) - { - return buffer.getByte(index); - } - - public void getBytes(final int index, final byte[] dst, final int dstIndex, final int length) - { - buffer.getBytes(index, dst, dstIndex, length); - } - - public void getBytes(final int index, final byte[] dst) - { - buffer.getBytes(index, dst); - } - - public void getBytes(final int index, final ByteBuffer dst) - { - buffer.getBytes(index, dst); - } - - public void getBytes(final int index, final HornetQBuffer dst, final int dstIndex, final int length) - { - buffer.getBytes(index, dst.channelBuffer(), dstIndex, length); - } - - public void getBytes(final int index, final HornetQBuffer dst, final int length) - { - buffer.getBytes(index, dst.channelBuffer(), length); - } - - public void getBytes(final int index, final HornetQBuffer dst) - { - buffer.getBytes(index, dst.channelBuffer()); - } - - public char getChar(final int index) - { - return (char)buffer.getShort(index); - } - - public double getDouble(final int index) - { - return Double.longBitsToDouble(buffer.getLong(index)); - } - - public float getFloat(final int index) - { - return Float.intBitsToFloat(buffer.getInt(index)); - } - - public int getInt(final int index) - { - return buffer.getInt(index); - } - - public long getLong(final int index) - { - return buffer.getLong(index); - } - - public short getShort(final int index) - { - return buffer.getShort(index); - } - - public short getUnsignedByte(final int index) - { - return buffer.getUnsignedByte(index); - } - - public long getUnsignedInt(final int index) - { - return buffer.getUnsignedInt(index); - } - - public int getUnsignedShort(final int index) - { - return buffer.getUnsignedShort(index); - } - - public void markReaderIndex() - { - buffer.markReaderIndex(); - } - - public void markWriterIndex() - { - buffer.markWriterIndex(); - } - - public boolean readable() - { - return buffer.readable(); - } - - public int readableBytes() - { - return buffer.readableBytes(); - } - - public byte readByte() - { - return buffer.readByte(); - } - - public void readBytes(final byte[] dst, final int dstIndex, final int length) - { - buffer.readBytes(dst, dstIndex, length); - } - - public void readBytes(final byte[] dst) - { - buffer.readBytes(dst); - } - - public void readBytes(final ByteBuffer dst) - { - buffer.readBytes(dst); - } - - public void readBytes(final HornetQBuffer dst, final int dstIndex, final int length) - { - buffer.readBytes(dst.channelBuffer(), dstIndex, length); - } - - public void readBytes(final HornetQBuffer dst, final int length) - { - buffer.readBytes(dst.channelBuffer(), length); - } - - public void readBytes(final HornetQBuffer dst) - { - buffer.readBytes(dst.channelBuffer()); - } - - public HornetQBuffer readBytes(final int length) - { - return new ChannelBufferWrapper(buffer.readBytes(length)); - } - - public char readChar() - { - return (char)buffer.readShort(); - } - - public double readDouble() - { - return Double.longBitsToDouble(buffer.readLong()); - } - - public int readerIndex() - { - return buffer.readerIndex(); - } - - public void readerIndex(final int readerIndex) - { - buffer.readerIndex(readerIndex); - } - - public float readFloat() - { - return Float.intBitsToFloat(buffer.readInt()); - } - - public int readInt() - { - return buffer.readInt(); - } - - public long readLong() - { - return buffer.readLong(); - } - - public short readShort() - { - return buffer.readShort(); - } - - public HornetQBuffer readSlice(final int length) - { - return new ChannelBufferWrapper(buffer.readSlice(length)); - } - - public short readUnsignedByte() - { - return buffer.readUnsignedByte(); - } - - public long readUnsignedInt() - { - return buffer.readUnsignedInt(); - } - - public int readUnsignedShort() - { - return buffer.readUnsignedShort(); - } - - public void resetReaderIndex() - { - buffer.resetReaderIndex(); - } - - public void resetWriterIndex() - { - buffer.resetWriterIndex(); - } - - public void setByte(final int index, final byte value) - { - buffer.setByte(index, value); - } - - public void setBytes(final int index, final byte[] src, final int srcIndex, final int length) - { - buffer.setBytes(index, src, srcIndex, length); - } - - public void setBytes(final int index, final byte[] src) - { - buffer.setBytes(index, src); - } - - public void setBytes(final int index, final ByteBuffer src) - { - buffer.setBytes(index, src); - } - - public void setBytes(final int index, final HornetQBuffer src, final int srcIndex, final int length) - { - buffer.setBytes(index, src.channelBuffer(), srcIndex, length); - } - - public void setBytes(final int index, final HornetQBuffer src, final int length) - { - buffer.setBytes(index, src.channelBuffer(), length); - } - - public void setBytes(final int index, final HornetQBuffer src) - { - buffer.setBytes(index, src.channelBuffer()); - } - - public void setChar(final int index, final char value) - { - buffer.setShort(index, (short)value); - } - - public void setDouble(final int index, final double value) - { - buffer.setLong(index, Double.doubleToLongBits(value)); - } - - public void setFloat(final int index, final float value) - { - buffer.setInt(index, Float.floatToIntBits(value)); - } - - public void setIndex(final int readerIndex, final int writerIndex) - { - buffer.setIndex(readerIndex, writerIndex); - } - - public void setInt(final int index, final int value) - { - buffer.setInt(index, value); - } - - public void setLong(final int index, final long value) - { - buffer.setLong(index, value); - } - - public void setShort(final int index, final short value) - { - buffer.setShort(index, value); - } - - public void skipBytes(final int length) - { - buffer.skipBytes(length); - } - - public HornetQBuffer slice() - { - return new ChannelBufferWrapper(buffer.slice()); - } - - public HornetQBuffer slice(final int index, final int length) - { - return new ChannelBufferWrapper(buffer.slice(index, length)); - } - - public ByteBuffer toByteBuffer() - { - return buffer.toByteBuffer(); - } - - public ByteBuffer toByteBuffer(final int index, final int length) - { - return buffer.toByteBuffer(index, length); - } - - public boolean writable() - { - return buffer.writable(); - } - - public int writableBytes() - { - return buffer.writableBytes(); - } - - public void writeByte(final byte value) - { - buffer.writeByte(value); - } - - public void writeBytes(final byte[] src, final int srcIndex, final int length) - { - buffer.writeBytes(src, srcIndex, length); - } - - public void writeBytes(final byte[] src) - { - buffer.writeBytes(src); - } - - public void writeBytes(final ByteBuffer src) - { - buffer.writeBytes(src); - } - - public void writeBytes(final HornetQBuffer src, final int srcIndex, final int length) - { - buffer.writeBytes(src.channelBuffer(), srcIndex, length); - } - - public void writeBytes(final HornetQBuffer src, final int length) - { - buffer.writeBytes(src.channelBuffer(), length); - } - - public void writeChar(final char chr) - { - buffer.writeShort((short)chr); - } - - public void writeDouble(final double value) - { - buffer.writeLong(Double.doubleToLongBits(value)); - } - - public void writeFloat(final float value) - { - buffer.writeInt(Float.floatToIntBits(value)); - } - - public void writeInt(final int value) - { - buffer.writeInt(value); - } - - public void writeLong(final long value) - { - buffer.writeLong(value); - } - - public int writerIndex() - { - return buffer.writerIndex(); - } - - public void writerIndex(final int writerIndex) - { - buffer.writerIndex(writerIndex); - } - - public void writeShort(final short value) - { - buffer.writeShort(value); - } - -} Deleted: trunk/hornetq-core/src/main/java/org/hornetq/core/server/HornetQComponent.java =================================================================== --- trunk/hornetq-core/src/main/java/org/hornetq/core/server/HornetQComponent.java 2011-05-26 12:31:10 UTC (rev 10738) +++ trunk/hornetq-core/src/main/java/org/hornetq/core/server/HornetQComponent.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -1,32 +0,0 @@ -/* - * Copyright 2009 Red Hat, Inc. - * Red Hat 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.hornetq.core.server; - -/** - * A HornetQComponent - * - * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> - * @version <tt>$Revision: 2796 $</tt> - * - * $Id: HornetQComponent.java 2796 2007-06-25 22:24:41Z timfox $ - * - */ -public interface HornetQComponent -{ - void start() throws Exception; - - void stop() throws Exception; - - boolean isStarted(); -} Deleted: trunk/hornetq-core/src/main/java/org/hornetq/utils/DataConstants.java =================================================================== --- trunk/hornetq-core/src/main/java/org/hornetq/utils/DataConstants.java 2011-05-26 12:31:10 UTC (rev 10738) +++ trunk/hornetq-core/src/main/java/org/hornetq/utils/DataConstants.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -1,68 +0,0 @@ -/* - * Copyright 2009 Red Hat, Inc. - * Red Hat 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.hornetq.utils; - -/** - * - * A DataConstants - * - * @author <a href="mailto:tim.fox@jboss.com">Tim Fox</a> - * - */ -public class DataConstants -{ - public static final int SIZE_INT = 4; - - public static final int SIZE_BOOLEAN = 1; - - public static final int SIZE_LONG = 8; - - public static final int SIZE_BYTE = 1; - - public static final int SIZE_SHORT = 2; - - public static final int SIZE_DOUBLE = 8; - - public static final int SIZE_FLOAT = 4; - - public static final int SIZE_CHAR = 2; - - public static final byte TRUE = 1; - - public static final byte FALSE = 0; - - public static final byte NULL = 0; - - public static final byte NOT_NULL = 1; - - public static final byte BOOLEAN = 2; - - public static final byte BYTE = 3; - - public static final byte BYTES = 4; - - public static final byte SHORT = 5; - - public static final byte INT = 6; - - public static final byte LONG = 7; - - public static final byte FLOAT = 8; - - public static final byte DOUBLE = 9; - - public static final byte STRING = 10; - - public static final byte CHAR = 11; -} Deleted: trunk/hornetq-core/src/main/java/org/hornetq/utils/UTF8Util.java =================================================================== --- trunk/hornetq-core/src/main/java/org/hornetq/utils/UTF8Util.java 2011-05-26 12:31:10 UTC (rev 10738) +++ trunk/hornetq-core/src/main/java/org/hornetq/utils/UTF8Util.java 2011-05-26 12:50:50 UTC (rev 10739) @@ -1,272 +0,0 @@ -/* - * Copyright 2009 Red Hat, Inc. - * Red Hat 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.hornetq.utils; - -import java.lang.ref.SoftReference; - -import org.hornetq.api.core.HornetQBuffer; -import org.hornetq.core.logging.Logger; - -/** - * - * A UTF8Util - * - * This class will write UTFs directly to the ByteOutput (through the MessageBuffer interface) - * - * @author <a href="mailto:clebert.suconic@jboss.org">Clebert Suconic</a> - * - * Created Feb 20, 2009 1:37:18 PM - * - * - */ -public class UTF8Util -{ - static boolean optimizeStrings = true; - - private static final Logger log = Logger.getLogger(UTF8Util.class); - - private static final boolean isTrace = UTF8Util.log.isTraceEnabled(); - - private static ThreadLocal<SoftReference<StringUtilBuffer>> currenBuffer = new ThreadLocal<SoftReference<StringUtilBuffer>>(); - - public static void saveUTF(final HornetQBuffer out, final String str) - { - StringUtilBuffer buffer = UTF8Util.getThreadLocalBuffer(); - - if (str.length() > 0xffff) - { - throw new IllegalArgumentException("the specified string is too long (" + str.length() + ")"); - } - - final int len = UTF8Util.calculateUTFSize(str, buffer); - - if (len > 0xffff) - { - throw new IllegalArgumentException("the encoded string is too long (" + len + ")"); - } - - out.writeShort((short)len); - - if (len > buffer.byteBuffer.length) - { - buffer.resizeByteBuffer(len); - } - - if (len == (long)str.length()) - { - for (int byteLocation = 0; byteLocation < len; byteLocation++) - { - buffer.byteBuffer[byteLocation] = (byte)buffer.charBuffer[byteLocation]; - } - out.writeBytes(buffer.byteBuffer, 0, len); - } - else - { - if (UTF8Util.isTrace) - { - // This message is too verbose for debug, that's why we are using trace here - UTF8Util.log.trace("Saving string with utfSize=" + len + " stringSize=" + str.length()); - } - - int stringLength = str.length(); - - int charCount = 0; - - for (int i = 0; i < stringLength; i++) - { - char charAtPos = buffer.charBuffer[i]; - if (charAtPos >= 1 && charAtPos < 0x7f) - { - buffer.byteBuffer[charCount++] = (byte)charAtPos; - } - else if (charAtPos >= 0x800) - { - buffer.byteBuffer[charCount++] = (byte)(0xE0 | charAtPos >> 12 & 0x0F); - buffer.byteBuffer[charCount++] = (byte)(0x80 | charAtPos >> 6 & 0x3F); - buffer.byteBuffer[charCount++] = (byte)(0x80 | charAtPos >> 0 & 0x3F); - } - else - { - buffer.byteBuffer[charCount++] = (byte)(0xC0 | charAtPos >> 6 & 0x1F); - buffer.byteBuffer[charCount++] = (byte)(0x80 | charAtPos >> 0 & 0x3F); - - } - } - out.writeBytes(buffer.byteBuffer, 0, len); - } - } - - public static String readUTF(final HornetQBuffer input) - { - StringUtilBuffer buffer = UTF8Util.getThreadLocalBuffer(); - - final int size = input.readUnsignedShort(); - - if (size > buffer.byteBuffer.length) - { - buffer.resizeByteBuffer(size); - } - - if (size > buffer.charBuffer.length) - { - buffer.resizeCharBuffer(size); - } - - if (UTF8Util.isTrace) - { - // This message is too verbose for debug, that's why we are using trace here - UTF8Util.log.trace("Reading string with utfSize=" + size); - } - - int count = 0; - int byte1, byte2, byte3; - int charCount = 0; - - input.readBytes(buffer.byteBuffer, 0, size); - - while (count < size) - { - byte1 = buffer.byteBuffer[count++]; - - if (byte1 > 0 && byte1 <= 0x7F) - { - buffer.charBuffer[charCount++] = (char)byte1; - } - else - { - int c = byte1 & 0xff; - switch (c >> 4) - { - case 0xc: - case 0xd: - byte2 = buffer.byteBuffer[count++]; - buffer.charBuffer[charCount++] = (char)((c & 0x1F) << 6 | byte2 & 0x3F); - break; - case 0xe: - byte2 = buffer.byteBuffer[count++]; - byte3 = buffer.byteBuffer[count++]; - buffer.charBuffer[charCount++] = (char)((c & 0x0F) << 12 | (byte2 & 0x3F) << 6 | (byte3 & 0x3F) << 0); - break; - } - } - } - - return new String(buffer.charBuffer, 0, charCount); - - } - - private static StringUtilBuffer getThreadLocalBuffer() - { - SoftReference<StringUtilBuffer> softReference = UTF8Util.currenBuffer.get(); - StringUtilBuffer value; - if (softReference == null) - { - value = new StringUtilBuffer(); - softReference = new SoftReference<StringUtilBuffer>(value); - UTF8Util.currenBuffer.set(softReference); - } - else - { - value = softReference.get(); - } - - if (value == null) - { - value = new StringUtilBuffer(); - softReference = new SoftReference<StringUtilBuffer>(value); - UTF8Util.currenBuffer.set(softReference); - } - - return value; - } - - public static void clearBuffer() - { - SoftReference<StringUtilBuffer> ref = UTF8Util.currenBuffer.get(); - if (ref.get() != null) - { - ref.clear(); - } - } - - public static int calculateUTFSize(final String str, final StringUtilBuffer stringBuffer) - { - int calculatedLen = 0; - - int stringLength = str.length(); - - if (stringLength > stringBuffer.charBuffer.length) - { - stringBuffer.resizeCharBuffer(stringLength); - } - - str.getChars(0, stringLength, stringBuffer.charBuffer, 0); - - for (int i = 0; i < stringLength; i++) - { - char c = stringBuffer.charBuffer[i]; - - if (c >= 1 && c < 0x7f) - { - calculatedLen++; - } - else if (c >= 0x800) - { - calculatedLen += 3; - } - else - { - calculatedLen += 2; - } - } - return calculatedLen; - } - - private static class StringUtilBuffer - { - - public char charBuffer[]; - - public byte byteBuffer[]; - - public void resizeCharBuffer(final int newSize) - { - if (newSize > charBuffer.length) - { - charBuffer = new char[newSize]; - } - } - - public void resizeByteBuffer(final int newSize) - { - if (newSize > byteBuffer.length) - { - byteBuffer = new byte[newSize]; - } - } - - public StringUtilBuffer() - { - this(1024, 1024); - } - - public StringUtilBuffer(final int sizeChar, final int sizeByte) - { - charBuffer = new char[sizeChar]; - byteBuffer = new byte[sizeByte]; - } - - } - -}