com/scalagent/kjoram/Message.java

/*
 * JORAM: Java(TM) Open Reliable Asynchronous Messaging
 * Copyright (C) 2001 - 2008 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.util.Enumeration;

import com.scalagent.kjoram.excepts.IllegalStateException;
import com.scalagent.kjoram.excepts.JMSException;
import com.scalagent.kjoram.excepts.MessageEOFException;
import com.scalagent.kjoram.excepts.MessageException;
import com.scalagent.kjoram.excepts.MessageFormatException;
import com.scalagent.kjoram.excepts.MessageNotWriteableException;
import com.scalagent.kjoram.excepts.MessageROException;
import com.scalagent.kjoram.excepts.MessageValueException;
import com.scalagent.kjoram.messages.ConversionHelper;
import com.scalagent.kjoram.messages.MessageType;

public class Message
{
  protected com.scalagent.kjoram.messages.Message momMsg;
  protected Session sess = null;


  Message()
  {
    momMsg = new com.scalagent.kjoram.messages.Message();
  }

  Message(Session sess, com.scalagent.kjoram.messages.Message momMsg)
  {
    this.sess = sess;
    this.momMsg = momMsg;
  }

  
  public void acknowledge() throws JMSException
  {
    if (sess == null
        || sess.transacted
        || sess.acknowledgeMode != Session.CLIENT_ACKNOWLEDGE)
      return;

    if (sess.closed)
      throw new IllegalStateException("Forbidden call on a closed session.");

    sess.acknowledge();
  }

  public void clearBody() throws JMSException
  {
    momMsg.clearBody();
  }

  public void clearProperties() throws JMSException
  {
    momMsg.clearProperties();
  } 

  public boolean propertyExists(String name) throws JMSException
  {
    return momMsg.propertyExists(name);
  }

  public Enumeration getPropertyNames() throws JMSException
  {
    return momMsg.getPropertyNames();
  }

 
  public void setJMSMessageID(String id) throws JMSException
  {
    momMsg.setIdentifier(id);
  }

   
  public void setJMSPriority(int priority) throws JMSException
  {
    if (0 <= priority && priority <= 9)
      momMsg.setPriority(priority);
    else
      throw new JMSException("Priority of "+ priority +" is not valid"
                             + " (should be an integer between 0 and 9).");
  }

  public void setJMSDestination(Destination dest) throws JMSException
  {
    if (dest == null)
      momMsg.setDestination(null, true);

    if (dest instanceof Queue)
      momMsg.setDestination(((Queue) dest).getQueueName(), true);
    else
      momMsg.setDestination(((Topic) dest).getTopicName(), false);

    if (dest instanceof TemporaryQueue || dest instanceof TemporaryTopic)
      momMsg.setOptionalHeader("JMSTempDestination", new Boolean(true));
    else
      momMsg.setOptionalHeader("JMSTempDestination", new Boolean(false));
  }

  public void setJMSExpiration(long expiration) throws JMSException
  {
    momMsg.setExpiration(expiration);
  }

  public void setJMSRedelivered(boolean redelivered) throws JMSException
  {
    momMsg.denied = redelivered;
  }

  public void setJMSReplyTo(Destination replyTo) throws JMSException
  {
    if (replyTo == null)
      momMsg.setReplyTo(null, true);

    if (replyTo instanceof Queue)
      momMsg.setReplyTo(((Queue) replyTo).getQueueName(), true);
    else
      momMsg.setReplyTo(((Topic) replyTo).getTopicName(), false);

    if (replyTo instanceof TemporaryQueue || replyTo instanceof TemporaryTopic)
      momMsg.setOptionalHeader("JMSTempReplyTo", new Boolean(true));
    else
      momMsg.setOptionalHeader("JMSTempReplyTo", new Boolean(false));
  }
  
  public void setJMSTimestamp(long timestamp) throws JMSException
  {
    momMsg.setTimestamp(timestamp);
  }

  public void setJMSCorrelationID(String correlationID) throws JMSException
  {
    momMsg.setCorrelationId(correlationID);
  }
  
  public void setJMSCorrelationIDAsBytes(byte[] correlationID)
            throws JMSException
  {
    momMsg.setCorrelationId(ConversionHelper.toString(correlationID));
  }
  
  public void setJMSType(String type) throws JMSException
  {
    momMsg.setOptionalHeader("JMSType", type);
  }

  public void setJMSDeliveryMode(int deliveryMode) throws JMSException
  {
    if (deliveryMode != DeliveryMode.PERSISTENT 
        && deliveryMode != DeliveryMode.NON_PERSISTENT)
      throw new JMSException("Invalid delivery mode.");

    momMsg.setPersistent(deliveryMode == DeliveryMode.PERSISTENT);
  }

  public String getJMSMessageID() throws JMSException
  {
    return momMsg.getIdentifier();
  }
  
  public int getJMSPriority() throws JMSException
  {
    return momMsg.getPriority();
  }
 
  public int getJMSDeliveryMode() throws JMSException
  {
    if (momMsg.getPersistent()) 
      return DeliveryMode.PERSISTENT;
    else
      return DeliveryMode.NON_PERSISTENT;
  }

  public Destination getJMSDestination() throws JMSException
  {
    String id = momMsg.getDestinationId();
    boolean queue = momMsg.toQueue();
    Object temporaryValue = null;
    boolean temporary = false;

    try {
      temporaryValue = momMsg.getOptionalHeader("JMSTempDestination");
      temporary = ConversionHelper.toBoolean(temporaryValue);
    }
    // If the value can't be retrieved, it might be because the sender is
    // not a JMS client and did not know about temporary destinations...
    catch (Exception exc) {}

    if (queue) {
      if (temporary)
        return new TemporaryQueue(id, null);
      else
        return new Queue(id);
    }
    else {
      if (temporary)
        return new TemporaryTopic(id, null);
      else
        return new Topic(id);
    }
  }

  public long getJMSExpiration() throws JMSException
  {
    return momMsg.getExpiration();
  }

  public boolean getJMSRedelivered() throws JMSException
  {
    return momMsg.denied;
  }

  public Destination getJMSReplyTo() throws JMSException
  {
    String id = momMsg.getReplyToId();
    boolean queue = momMsg.replyToQueue();
    Object temporaryValue = null;
    boolean temporary = false;

    if (id == null)
      return null;

    try {
      temporaryValue = momMsg.getOptionalHeader("JMSTempReplyTo");
      temporary = ConversionHelper.toBoolean(temporaryValue);
    }
    // If the value can't be retrieved, it might be because the sender is not
    // a JMS client...
    catch (Exception exc) {}
  
    if (queue) {
      if (temporary)
        return new TemporaryQueue(id, null);
      else
        return new Queue(id);
    }
    else {
      if (temporary)
        return new TemporaryTopic(id, null);
      else
        return new Topic(id);
    } 
  }

  public long getJMSTimestamp() throws JMSException
  {
    return momMsg.getTimestamp();
  }

  public String getJMSType() throws JMSException
  {
    Object value = momMsg.getOptionalHeader("JMSType");
    return ConversionHelper.toString(value);
  }

  public String getJMSCorrelationID() throws JMSException
  {
    return momMsg.getCorrelationId();
  }
  
  public byte[] getJMSCorrelationIDAsBytes() throws JMSException
  {
    try {
      return ConversionHelper.toBytes(momMsg.getCorrelationId());
    }
    catch (MessageValueException mE) {
      throw new MessageFormatException(mE.getMessage());
    }
  }

  public void setBooleanProperty(String name, boolean value)
            throws JMSException
  {
    doSetProperty(name, new Boolean(value));
  }

  public void setByteProperty(String name, byte value) throws JMSException
  {
    doSetProperty(name, new Byte(value));
  }

//    public void setDoubleProperty(String name, double value) throws JMSException
//    {
//      doSetProperty(name, new Double(value));
//    }

//    public void setFloatProperty(String name, float value) throws JMSException
//    {
//      doSetProperty(name, new Float(value));
//    }

  public void setIntProperty(String name, int value) throws JMSException
  {
    doSetProperty(name, new Integer(value));
  }

  public void setLongProperty(String name, long value) throws JMSException
  {
    doSetProperty(name, new Long(value));
  }

  public void setObjectProperty(String name, Object value) throws JMSException
  {
    doSetProperty(name, value);
  }

  public void setShortProperty(String name, short value) throws JMSException
  {
    doSetProperty(name, new Short(value));
  }

  public void setStringProperty(String name, String value) throws JMSException
  {
    doSetProperty(name, value);
  }


  public boolean getBooleanProperty(String name) throws JMSException 
  {
    try {
      return ConversionHelper.toBoolean(doGetProperty(name));
    }
    catch (MessageValueException mE) {
      throw new MessageFormatException(mE.getMessage());
    }
  }
  
  public byte getByteProperty(String name) throws JMSException 
  {
    try {
      return ConversionHelper.toByte(doGetProperty(name));
    }
    catch (MessageValueException mE) {
      throw new MessageFormatException(mE.getMessage());
    }
  }

//    public double getDoubleProperty(String name) throws JMSException
//    {
//      try {
//        return ConversionHelper.toDouble(doGetProperty(name));
//      }
//      catch (MessageValueException mE) {
//        throw new MessageFormatException(mE.getMessage());
//      }
//    }

//    public float getFloatProperty(String name) throws JMSException
//    {
//      try {
//        return ConversionHelper.toFloat(doGetProperty(name));
//      }
//      catch (MessageValueException mE) {
//        throw new MessageFormatException(mE.getMessage());
//      }
//    }

  public int getIntProperty(String name) throws JMSException
  {
    try {
      return ConversionHelper.toInt(doGetProperty(name));
    }
    catch (MessageValueException mE) {
      throw new MessageFormatException(mE.getMessage());
    }
  }

  public long getLongProperty(String name) throws JMSException
  {
    try {
      return ConversionHelper.toLong(doGetProperty(name));
    }
    catch (MessageValueException mE) {
      throw new MessageFormatException(mE.getMessage());
    }
  }

  public Object getObjectProperty(String name) throws JMSException
  {
    return doGetProperty(name);
  }

  public short getShortProperty(String name) throws JMSException
  {
    try {
      return ConversionHelper.toShort(doGetProperty(name));
    }
    catch (MessageValueException mE) {
      throw new MessageFormatException(mE.getMessage());
    }
  }

  public String getStringProperty(String name) throws JMSException
  {
    return ConversionHelper.toString(doGetProperty(name));
  }

  private void doSetProperty(String name, Object value) throws JMSException
  {
    if (name == null || name.equals(""))
      throw new IllegalArgumentException("Invalid property name: " + name);

    String upName = name.toUpperCase();

    try {
      if (name.startsWith("JMSX")) {
        if (name.equals("JMSXGroupID"))
          momMsg.setOptionalHeader(name, ConversionHelper.toString(value));
        else if (name.equals("JMSXGroupSeq"))
          momMsg.setOptionalHeader(name,
                                   new Integer(ConversionHelper.toInt(value)));
        else
          throw new JMSException("Property names with prefix 'JMSX' are"
                                 + " reserved.");
      }
      else if (name.startsWith("JMS_"))
        throw new JMSException("Property names with prefix 'JMS_' are"
                               + " reserved.");
      else if (name.startsWith("JMS"))
        throw new JMSException("Property names with prefix 'JMS' are"
                               + " reserved.");
      else if (upName.equals("NULL")
               || upName.equals("TRUE")
               || upName.equals("FALSE")
               || upName.equals("NOT")
               || upName.equals("AND")
               || upName.equals("OR")
               || upName.equals("BETWEEN")
               || upName.equals("LIKE")
               || upName.equals("IN")
               || upName.equals("IS")
               || upName.equals("ESCAPE"))
        throw new JMSException("Invalid property name: " + name + " is a"
                               + " SQL terminal.");
      else
        momMsg.setObjectProperty(name, value);
    }
    catch (MessageException mE) {
      if (mE instanceof MessageValueException)
        throw new MessageFormatException(mE.getMessage());
      if (mE instanceof MessageROException)
        throw new MessageNotWriteableException(mE.getMessage());
    }
  }

  private Object doGetProperty(String name)
  {
    if (name == null || name.equals(""))
      throw new IllegalArgumentException("Invalid property name: " + name);

    Object value = null;

    if (name.startsWith("JMSX")) {
      if (name.equals("JMSXDeliveryCount"))
        value = new Integer(momMsg.deliveryCount);
      else
        value = momMsg.getOptionalHeader(name);
    }
    else
      value = momMsg.getObjectProperty(name);

    return value;
  }


  com.scalagent.kjoram.messages.Message getMomMessage()
    throws MessageFormatException
  {
    try {
      prepare();
      return momMsg;
    }
    catch (Exception e) {
      MessageFormatException jE =
        new MessageFormatException("The message body could not be"
                                   + " serialized.");
      jE.setLinkedException(e);
      throw jE;
    } 
  }
 
  static Message
         wrapMomMessage(Session sess, com.scalagent.kjoram.messages.Message momMsg)
         throws JMSException
  {
    Message msg = null;

    if (momMsg.getType() == MessageType.SIMPLE)
      msg = new Message(sess, momMsg);
    else if (momMsg.getType() == MessageType.TEXT)
      msg = new TextMessage(sess, momMsg);
    else if (momMsg.getType() == MessageType.MAP)
      msg = new MapMessage(sess, momMsg);
    else if (momMsg.getType() == MessageType.BYTES)
      msg = new BytesMessage(sess, momMsg);

    return msg;
  }

  static Message convertJMSMessage(Message jmsMsg)
         throws JMSException
  {
    Message msg = null;
    if (jmsMsg instanceof TextMessage) {
      msg = new TextMessage();
      ((TextMessage) msg).setText(((TextMessage)jmsMsg).getText());
    }
    else if (jmsMsg instanceof BytesMessage) {
      msg = new BytesMessage();
      try {
        while (true)
          ((BytesMessage) msg).writeByte(((BytesMessage)jmsMsg).readByte());
      }
      catch (MessageEOFException mE) {}
    }
    else if (jmsMsg instanceof MapMessage) {
      msg = new MapMessage();
      Enumeration mapNames = ((MapMessage) jmsMsg).getMapNames();
    }
    else
      msg = new Message();

    msg.setJMSCorrelationID(jmsMsg.getJMSCorrelationID());
    msg.setJMSReplyTo(jmsMsg.getJMSReplyTo());
    msg.setJMSType(jmsMsg.getJMSType());

    return msg;
  }

  protected void prepare() throws Exception
  {
    momMsg.denied = false;
    momMsg.deletedDest = false;
    momMsg.expired = false;
    momMsg.notWriteable = false;
    momMsg.undeliverable = false;
  }
}  

---