com/scalagent/kjoram/BytesMessage.java

/*
 * JORAM: Java(TM) Open Reliable Asynchronous Messaging
 * Copyright (C) 2001 - ScalAgent Distributed Technologies
 * Copyright (C) 1996 - Dyade
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA.
 *
 * Initial developer(s): Frederic Maistre (INRIA)
 * Contributor(s): Nicolas Tachker (ScalAgent)
 */
package com.scalagent.kjoram;

import java.io.*;

import com.scalagent.kjoram.excepts.JMSException;
import com.scalagent.kjoram.excepts.MessageFormatException;
import com.scalagent.kjoram.excepts.MessageNotWriteableException;
import com.scalagent.kjoram.excepts.MessageNotReadableException;
import com.scalagent.kjoram.excepts.MessageEOFException;


public class BytesMessage extends Message
{
  private ByteArrayOutputStream outputBuffer = null;
  private DataOutputStream outputStream = null;
  private DataInputStream inputStream = null;

  private boolean RObody = false;
  private boolean WObody = true;

  private byte[] bytes = null;
  private boolean prepared = false;


  BytesMessage()
  {
    super();
    outputBuffer = new ByteArrayOutputStream();
    outputStream = new DataOutputStream(outputBuffer);
  }

  BytesMessage(Session sess, com.scalagent.kjoram.messages.Message momMsg)
  {
    super(sess, momMsg);
    bytes = momMsg.getBytes();

    inputStream = new DataInputStream(new ByteArrayInputStream(bytes));

    RObody = true;
    WObody = false;
  }
 

  public long getBodyLength() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't get not readable message's"
                                            + " size.");
    return bytes.length;
  } 

  public void clearBody() throws JMSException
  {
    super.clearBody();

    try {
      if (WObody) {
        outputStream.close();
        outputBuffer.close();
      }
      else
        inputStream.close();

      outputBuffer = new ByteArrayOutputStream();
      outputStream = new DataOutputStream(outputBuffer);
      bytes = null;
      RObody = false;
      WObody = true;
      prepared = false;
    }
    catch (IOException ioE) {
      JMSException jE = new JMSException("Error while closing the stream"
                                         + " facilities.");
      jE.setLinkedException(ioE);
      throw jE;
    }
  }


  public void writeBoolean(boolean value) throws JMSException
  {
    writeObject(new Boolean(value));
  }
 
  public void writeByte(byte value) throws JMSException
  {
    writeObject(new Byte(value));
  }
 
  public void writeBytes(byte[] value) throws JMSException
  {
    writeObject(value);
  }

  public void writeBytes(byte[] value, int offset, int length)
              throws JMSException
  {
    if (RObody)
      throw new MessageNotWriteableException("Can't write a value as the"
                                             + " message body is read-only.");

    if (prepared) {
      prepared = false;
      outputBuffer = new ByteArrayOutputStream();
      outputStream = new DataOutputStream(outputBuffer);
    }

    try {
      outputStream.write(value, offset, length);
    }
    catch (IOException ioE) {
      JMSException jE = new JMSException("Error while writing the value.");
      jE.setLinkedException(ioE);
      throw jE;
    }
  }
 
  public void writeChar(char value) throws JMSException
  {
    writeObject(new Character(value));
  }
 
//    public void writeDouble(double value) throws JMSException
//    {
//      writeObject(new Double(value));
//    }
 
//    /** 
//     * API method.
//     *
//     * @exception MessageNotWriteableException  If the message body is read-only.
//     * @exception JMSException  If the value could not be written on the stream.
//     */   
//    public void writeFloat(float value) throws JMSException
//    {
//      writeObject(new Float(value));
//    }
 
  public void writeInt(int value) throws JMSException
  {
    writeObject(new Integer(value));
  }
 
  public void writeLong(long value) throws JMSException
  {
    writeObject(new Long(value));
  }

  public void writeShort(short value) throws JMSException
  {
    writeObject(new Short(value));
  }
 
  public void writeUTF(String value) throws JMSException
  {
    writeObject(value);
  }

  public void writeObject(Object value) throws JMSException
  {
    if (RObody)
      throw new MessageNotWriteableException("Can't write a value as the"
                                             + " message body is read-only.");

    if (value == null)
      throw new NullPointerException("Forbidden null value.");

    if (prepared) {
      prepared = false;
      outputBuffer = new ByteArrayOutputStream();
      outputStream = new DataOutputStream(outputBuffer);
    }

    try {
      if (value instanceof Boolean)
        outputStream.writeBoolean(((Boolean) value).booleanValue());
      else if (value instanceof Character)
        outputStream.writeChar(((Character) value).charValue());
      else if (value instanceof Integer)
        outputStream.writeInt(((Integer) value).intValue());
      else if (value instanceof Long)
        outputStream.writeLong(((Long) value).longValue());
//        else if (value instanceof Float)
//          outputStream.writeFloat(((Float) value).floatValue());
//        else if (value instanceof Double)
//          outputStream.writeDouble(((Double) value).doubleValue());
      else if (value instanceof String)
        outputStream.writeUTF((String) value);
      else if (value instanceof byte[])
        outputStream.write((byte[]) value);
      else
        throw new MessageFormatException("Can't write non Java primitive type"
                                         + " as a bytes array.");
    }
    catch (IOException ioE) {
      JMSException jE = new JMSException("Error while writing the value.");
      jE.setLinkedException(ioE);
      throw jE;
    }
  }
  
  
  public boolean readBoolean() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    try {
      return inputStream.readBoolean();
    }
    catch (Exception e) {
      JMSException jE = null;
      if (e instanceof EOFException)
        jE = new MessageEOFException("Unexpected end of bytes array.");
      else if (e instanceof IOException)
        jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(e);
      throw jE;
    }
  }

  public byte readByte() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    try {
      return inputStream.readByte();
    }
    catch (Exception e) {
      JMSException jE = null;
      if (e instanceof EOFException)
        jE = new MessageEOFException("Unexpected end of bytes array.");
      else if (e instanceof IOException)
        jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(e);
      throw jE;
    }
  }

  public int readUnsignedByte() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    try {
      return inputStream.readUnsignedByte();
    }
    catch (Exception e) {
      JMSException jE = null;
      if (e instanceof EOFException)
        jE = new MessageEOFException("Unexpected end of bytes array.");
      else if (e instanceof IOException)
        jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(e);
      throw jE;
    }
  }

  public short readShort() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    try {
      return inputStream.readShort();
    }
    catch (Exception e) {
      JMSException jE = null;
      if (e instanceof EOFException)
        jE = new MessageEOFException("Unexpected end of bytes array.");
      else if (e instanceof IOException)
        jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(e);
      throw jE;
    }
  }
  
  public int readUnsignedShort() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    try {
      return inputStream.readUnsignedShort();
    }
    catch (Exception e) {
      JMSException jE = null;
      if (e instanceof EOFException)
        jE = new MessageEOFException("Unexpected end of bytes array.");
      else if (e instanceof IOException)
        jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(e);
      throw jE;
    }
  }

  public char readChar() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    try {
      return inputStream.readChar();
    }
    catch (Exception e) {
      JMSException jE = null;
      if (e instanceof EOFException)
        jE = new MessageEOFException("Unexpected end of bytes array.");
      else if (e instanceof IOException)
        jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(e);
      throw jE;
    }
  }

  public int readInt() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    try {
      return inputStream.readInt();
    }
    catch (Exception e) {
      JMSException jE = null;
      if (e instanceof EOFException)
        jE = new MessageEOFException("Unexpected end of bytes array.");
      else if (e instanceof IOException)
        jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(e);
      throw jE;
    }
  }

  public long readLong() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    try {
      return inputStream.readLong();
    }
    catch (Exception e) {
      JMSException jE = null;
      if (e instanceof EOFException)
        jE = new MessageEOFException("Unexpected end of bytes array.");
      else if (e instanceof IOException)
        jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(e);
      throw jE;
    }
  }

//    public float readFloat() throws JMSException
//    {
//      if (WObody)
//        throw new MessageNotReadableException("Can't read the message body as"
//                                              + " it is write-only.");
//      try {
//        return inputStream.readFloat();
//      }
//      catch (Exception e) {
//        JMSException jE = null;
//        if (e instanceof EOFException)
//          jE = new MessageEOFException("Unexpected end of bytes array.");
//        else if (e instanceof IOException)
//          jE = new JMSException("Could not read the bytes array.");
//        jE.setLinkedException(e);
//        throw jE;
//      }
//    }

//    public double readDouble() throws JMSException
//    {
//      if (WObody)
//        throw new MessageNotReadableException("Can't read the message body as"
//                                              + " it is write-only.");
//      try {
//        return inputStream.readDouble();
//      }
//      catch (Exception e) {
//        JMSException jE = null;
//        if (e instanceof EOFException)
//          jE = new MessageEOFException("Unexpected end of bytes array.");
//        else if (e instanceof IOException)
//          jE = new JMSException("Could not read the bytes array.");
//        jE.setLinkedException(e);
//        throw jE;
//      }
//    }

  public int readBytes(byte[] value) throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    int counter = 0;

    try {
      for (int i = 0; i < value.length; i ++) {
        value[i] = inputStream.readByte();
        counter++;
      }
    }
    // End of array has been reached:
    catch (EOFException eofE) {}
    // An error has occured!
    catch (IOException ioE) {
      JMSException jE = null;
      jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(ioE);
      throw jE;
    }
    if (counter == 0)
      return -1;
    return counter;
  }

  public int readBytes(byte[] value, int length) throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    if (length > value.length || length < 0)
      throw new IndexOutOfBoundsException("Invalid length parameter: "
                                          + length);
    int counter = 0;

    try {
      for (int i = 0; i < length; i ++) {
        value[i] = inputStream.readByte();
        counter++;
      }
    }
    // End of array has been reached:
    catch (EOFException eofE) {}
    // An error has occured!
    catch (IOException ioE) {
      JMSException jE = null;
      jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(ioE);
      throw jE;
    }
    if (counter == 0)
      return -1;
    return counter;
  }

  public String readUTF() throws JMSException
  {
    if (WObody)
      throw new MessageNotReadableException("Can't read the message body as"
                                            + " it is write-only.");
    try {
      return inputStream.readUTF();
    }
    catch (Exception e) {
      JMSException jE = null;
      if (e instanceof EOFException)
        jE = new MessageEOFException("Unexpected end of bytes array.");
      else if (e instanceof IOException)
        jE = new JMSException("Could not read the bytes array.");
      jE.setLinkedException(e);
      throw jE;
    }
  }

  
  public void reset() throws JMSException
  {
    try {
      if (WObody) {
        outputStream.flush();
        bytes = outputBuffer.toByteArray();
      }
      else
        inputStream.close();
      
      inputStream = new DataInputStream(new ByteArrayInputStream(bytes));

      RObody = true;
      WObody = false;
    }
    catch (IOException iE) {
      JMSException jE =
        new JMSException("Error while manipulating the stream facilities.");
      jE.setLinkedException(iE);
      throw jE;
    }
  }

  protected void prepare() throws Exception
  {
    super.prepare();

    if (WObody) {
      outputStream.flush();
      bytes = outputBuffer.toByteArray();
      prepared = true;
    }

    momMsg.clearBody();
    momMsg.setBytes(bytes);
  } 
}

---