Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.jms.client;
 
 
HornetQ implementation of a JMS BytesMessage.

Author(s):
Norbert Lataille (Norbert.Lataille@m4x.org)
Adrian Brock
Tim Fox
Ovidiu Feodorov
Andy Taylor
Version:
$Revision: 3412 $ $Id: HornetQRABytesMessage.java 3412 2007-12-05 19:41:47Z timfox $
 
 public class HornetQBytesMessage extends HornetQMessage implements BytesMessage
 {
    // Static -------------------------------------------------------
    public static final byte TYPE = .;
 
    // Attributes ----------------------------------------------------
 
    private int bodyLength;
 
    // Constructor ---------------------------------------------------
 
    /*
     * This constructor is used to construct messages prior to sending
     */
    protected HornetQBytesMessage(final ClientSession session)
    {
       super(.session);
    }
 
    /*
     * Constructor on receipt at client side
     */
    protected HornetQBytesMessage(final ClientMessage messagefinal ClientSession session)
    {
       super(messagesession);
    }
 
    /*
     * Foreign message constructor
     */
    public HornetQBytesMessage(final BytesMessage foreignfinal ClientSession sessionthrows JMSException
    {
       super(foreign.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);
         throw je;
      }
   }
   public int readBytes(final byte[] valuethrows JMSException
   {
      return readBytes(valuevalue.length);
   }
   public int readBytes(final byte[] valuefinal int lengththrows JMSException
   {
      checkRead();
      if (!getBuffer().readable())
      {
         return -1;
      }
      int read = Math.min(lengthgetBuffer().readableBytes());
      if (read != 0)
      {
         getBuffer().readBytes(value, 0, read);
      }
      return read;
   }
   public void writeBoolean(final boolean valuethrows JMSException
   {
      checkWrite();
      getBuffer().writeBoolean(value);
   }
   public void writeByte(final byte valuethrows JMSException
   {
      checkWrite();
      getBuffer().writeByte(value);
   }
   public void writeShort(final short valuethrows JMSException
   {
      checkWrite();
      getBuffer().writeShort(value);
   }
   public void writeChar(final char valuethrows JMSException
   {
      checkWrite();
      getBuffer().writeShort((short)value);
   }
   public void writeInt(final int valuethrows JMSException
   {
      checkWrite();
      getBuffer().writeInt(value);
   }
   public void writeLong(final long valuethrows JMSException
   {
      checkWrite();
      getBuffer().writeLong(value);
   }
   public void writeFloat(final float valuethrows JMSException
   {
      checkWrite();
      getBuffer().writeInt(Float.floatToIntBits(value));
   }
   public void writeDouble(final double valuethrows JMSException
   {
      checkWrite();
      getBuffer().writeLong(Double.doubleToLongBits(value));
   }
   public void writeUTF(final String valuethrows JMSException
   {
      checkWrite();
      try
      {
         getBuffer().writeUTF(value);
      }
      catch (Exception e)
      {
         JMSException je = new JMSException("Failed to write UTF");
         je.setLinkedException(e);
         throw je;
      }
   }
   public void writeBytes(final byte[] valuethrows JMSException
   {
      checkWrite();
      getBuffer().writeBytes(value);
   }
   public void writeBytes(final byte[] valuefinal int offsetfinal int lengththrows JMSException
   {
      checkWrite();
      getBuffer().writeBytes(valueoffsetlength);
   }
   public void writeObject(final Object valuethrows 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 (!)
      {
          = true;
          = .getBodySize();
         getBuffer().resetReaderIndex();
      }
      else
      {
         getBuffer().resetReaderIndex();
      }
   }
   public void doBeforeReceive() throws Exception
   {
       = .getBodySize();
   }
   // HornetQRAMessage overrides ----------------------------------------
   public void clearBody() throws JMSException
   {
      super.clearBody();
      getBuffer().clear();
   }
   public long getBodyLength() throws JMSException
   {
      checkRead();
      return ;
   }
   public void doBeforeSend() throws Exception
   {
      reset();
   }
   // Public --------------------------------------------------------
   public byte getType()
   {
      return .;
   }
   // Package protected ---------------------------------------------
   // Protected -----------------------------------------------------
   // Private -------------------------------------------------------
   private HornetQBuffer getBuffer()
   {
      return .getBodyBuffer();
   }
   // Inner classes -------------------------------------------------
New to GrepCode? Check out our FAQ X