org.hornetq.jms.client.HornetQBytesMessage Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote Jakarta Enterprise Beans and Jakarta Messaging, including
all dependencies. It is intended for use by those not using maven, maven users should just import the Jakarta Enterprise Beans and
Jakarta Messaging BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
/*
* Copyright 2005-2014 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.jms.client;
import javax.jms.BytesMessage;
import javax.jms.JMSException;
import javax.jms.MessageEOFException;
import javax.jms.MessageFormatException;
import org.hornetq.api.core.HornetQBuffer;
import org.hornetq.api.core.HornetQException;
import org.hornetq.api.core.Message;
import org.hornetq.api.core.client.ClientMessage;
import org.hornetq.api.core.client.ClientSession;
import org.hornetq.core.message.impl.MessageImpl;
/**
* HornetQ implementation of a JMS {@link BytesMessage}.
*
* @author Norbert Lataille ([email protected])
* @author Adrian Brock
* @author Tim Fox
* @author Ovidiu Feodorov
* @author Andy Taylor
*/
public class HornetQBytesMessage extends HornetQMessage implements BytesMessage
{
// Static -------------------------------------------------------
public static final byte TYPE = Message.BYTES_TYPE;
// Attributes ----------------------------------------------------
private int bodyLength;
// Constructor ---------------------------------------------------
/**
* This constructor is used to construct messages prior to sending
*/
protected HornetQBytesMessage(final ClientSession session)
{
super(HornetQBytesMessage.TYPE, session);
}
/**
* Constructor on receipt at client side
*/
protected HornetQBytesMessage(final ClientMessage message, final ClientSession session)
{
super(message, session);
}
/**
* Foreign message constructor
*/
public HornetQBytesMessage(final BytesMessage foreign, final ClientSession session) throws JMSException
{
super(foreign, HornetQBytesMessage.TYPE, session);
foreign.reset();
byte[] buffer = new byte[1024];
int n = foreign.readBytes(buffer);
while (n != -1)
{
writeBytes(buffer, 0, n);
n = foreign.readBytes(buffer);
}
}
// BytesMessage implementation -----------------------------------
public boolean readBoolean() throws JMSException
{
checkRead();
try
{
return getBuffer().readBoolean();
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public byte readByte() throws JMSException
{
checkRead();
try
{
return getBuffer().readByte();
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public int readUnsignedByte() throws JMSException
{
checkRead();
try
{
return getBuffer().readUnsignedByte();
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public short readShort() throws JMSException
{
checkRead();
try
{
return getBuffer().readShort();
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public int readUnsignedShort() throws JMSException
{
checkRead();
try
{
return getBuffer().readUnsignedShort();
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public char readChar() throws JMSException
{
checkRead();
try
{
return (char)getBuffer().readShort();
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public int readInt() throws JMSException
{
checkRead();
try
{
return getBuffer().readInt();
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public long readLong() throws JMSException
{
checkRead();
try
{
return getBuffer().readLong();
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public float readFloat() throws JMSException
{
checkRead();
try
{
return Float.intBitsToFloat(getBuffer().readInt());
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public double readDouble() throws JMSException
{
checkRead();
try
{
return Double.longBitsToDouble(getBuffer().readLong());
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
}
public String readUTF() throws JMSException
{
checkRead();
try
{
return getBuffer().readUTF();
}
catch (IndexOutOfBoundsException e)
{
throw new MessageEOFException("");
}
catch (Exception e)
{
JMSException je = new JMSException("Failed to get UTF");
je.setLinkedException(e);
je.initCause(e);
throw je;
}
}
public int readBytes(final byte[] value) throws JMSException
{
return readBytes(value, value.length);
}
public int readBytes(final byte[] value, final int length) throws JMSException
{
checkRead();
if (!getBuffer().readable())
{
return -1;
}
int read = Math.min(length, getBuffer().readableBytes());
if (read != 0)
{
getBuffer().readBytes(value, 0, read);
}
return read;
}
public void writeBoolean(final boolean value) throws JMSException
{
checkWrite();
getBuffer().writeBoolean(value);
}
public void writeByte(final byte value) throws JMSException
{
checkWrite();
getBuffer().writeByte(value);
}
public void writeShort(final short value) throws JMSException
{
checkWrite();
getBuffer().writeShort(value);
}
public void writeChar(final char value) throws JMSException
{
checkWrite();
getBuffer().writeShort((short)value);
}
public void writeInt(final int value) throws JMSException
{
checkWrite();
getBuffer().writeInt(value);
}
public void writeLong(final long value) throws JMSException
{
checkWrite();
getBuffer().writeLong(value);
}
public void writeFloat(final float value) throws JMSException
{
checkWrite();
getBuffer().writeInt(Float.floatToIntBits(value));
}
public void writeDouble(final double value) throws JMSException
{
checkWrite();
getBuffer().writeLong(Double.doubleToLongBits(value));
}
public void writeUTF(final String value) throws JMSException
{
checkWrite();
try
{
getBuffer().writeUTF(value);
}
catch (Exception e)
{
JMSException je = new JMSException("Failed to write UTF");
je.setLinkedException(e);
je.initCause(e);
throw je;
}
}
public void writeBytes(final byte[] value) throws JMSException
{
checkWrite();
getBuffer().writeBytes(value);
}
public void writeBytes(final byte[] value, final int offset, final int length) throws JMSException
{
checkWrite();
getBuffer().writeBytes(value, offset, length);
}
public void writeObject(final Object value) throws JMSException
{
if (value == null)
{
throw new NullPointerException("Attempt to write a null value");
}
if (value instanceof String)
{
writeUTF((String)value);
}
else if (value instanceof Boolean)
{
writeBoolean((Boolean)value);
}
else if (value instanceof Character)
{
writeChar((Character)value);
}
else if (value instanceof Byte)
{
writeByte((Byte)value);
}
else if (value instanceof Short)
{
writeShort((Short)value);
}
else if (value instanceof Integer)
{
writeInt((Integer)value);
}
else if (value instanceof Long)
{
writeLong((Long)value);
}
else if (value instanceof Float)
{
writeFloat((Float)value);
}
else if (value instanceof Double)
{
writeDouble((Double)value);
}
else if (value instanceof byte[])
{
writeBytes((byte[])value);
}
else
{
throw new MessageFormatException("Invalid object for properties");
}
}
public void reset() throws JMSException
{
if (!readOnly)
{
readOnly = true;
bodyLength = message.getBodySize();
getBuffer().resetReaderIndex();
}
else
{
getBuffer().resetReaderIndex();
}
}
@Override
public void doBeforeReceive() throws HornetQException
{
bodyLength = message.getBodySize();
}
// HornetQRAMessage overrides ----------------------------------------
@Override
public void clearBody() throws JMSException
{
super.clearBody();
try
{
getBuffer().clear();
}
catch (RuntimeException e)
{
JMSException e2 = new JMSException(e.getMessage());
e2.initCause(e);
throw e2;
}
}
public long getBodyLength() throws JMSException
{
checkRead();
return bodyLength;
}
@Override
public void doBeforeSend() throws Exception
{
reset();
}
// Public --------------------------------------------------------
@Override
public byte getType()
{
return HornetQBytesMessage.TYPE;
}
private HornetQBuffer getBuffer()
{
return message.getBodyBuffer();
}
@Override
public boolean isBodyAssignableTo(@SuppressWarnings("rawtypes")
Class c)
{
return c.isAssignableFrom(byte[].class);
}
@Override
protected T getBodyInternal(Class c)
{
if (bodyLength == 0)
return null;
byte[] dst = new byte[bodyLength];
message.getBodyBuffer().getBytes(MessageImpl.BODY_OFFSET, dst);
return (T)dst;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy