mirror of https://github.com/apache/activemq.git
2128 lines
58 KiB
C#
Executable File
2128 lines
58 KiB
C#
Executable File
using System;
|
|
using System.Collections;
|
|
|
|
namespace ActiveMQ
|
|
{
|
|
/// <summary>
|
|
/// Summary description for ActiveMQMessage.
|
|
/// </summary>
|
|
public class ActiveMQMessage : AbstractPacket
|
|
{
|
|
|
|
const int DEFAULT_DELIVERY_MODE = PERSISTENT;
|
|
|
|
/**
|
|
* The message producer's default priority is 4.
|
|
*/
|
|
const int DEFAULT_PRIORITY = 4;
|
|
|
|
/**
|
|
* The message producer's default time to live is unlimited; the message
|
|
* never expires.
|
|
*/
|
|
const long DEFAULT_TIME_TO_LIVE = 0;
|
|
|
|
/**
|
|
* message property types
|
|
*/
|
|
const byte EOF = 2;
|
|
const byte BYTES = 3;
|
|
const byte STRING = 4;
|
|
const byte BOOLEAN = 5;
|
|
const byte CHAR = 6;
|
|
const byte BYTE = 7;
|
|
const byte SHORT = 8;
|
|
const byte INT = 9;
|
|
const byte LONG = 10;
|
|
const byte FLOAT = 11;
|
|
const byte DOUBLE = 12;
|
|
const byte NULL = 13;
|
|
|
|
/**
|
|
* Message flag indexes (used for writing/reading to/from a Stream
|
|
*/
|
|
|
|
public const int CORRELATION_INDEX = 2;
|
|
public const int TYPE_INDEX = 3;
|
|
public const int BROKER_NAME_INDEX = 4;
|
|
public const int CLUSTER_NAME_INDEX = 5;
|
|
public const int TRANSACTION_ID_INDEX = 6;
|
|
public const int REPLY_TO_INDEX = 7;
|
|
public const int TIMESTAMP_INDEX = 8;
|
|
public const int EXPIRATION_INDEX = 9;
|
|
public const int REDELIVERED_INDEX = 10;
|
|
public const int XA_TRANS_INDEX = 11;
|
|
public const int CID_INDEX = 12;
|
|
public const int PROPERTIES_INDEX = 13;
|
|
public const int DISPATCHED_FROM_DLQ_INDEX = 14;
|
|
public const int PAYLOAD_INDEX = 15;
|
|
public const int EXTERNAL_MESSAGE_ID_INDEX = 16;
|
|
public const int MESSAGE_PART_INDEX = 17;
|
|
public const int CACHED_VALUES_INDEX = 18;
|
|
public const int CACHED_DESTINATION_INDEX = 19;
|
|
public const int LONG_SEQUENCE_INDEX = 20;
|
|
|
|
|
|
|
|
const String DELIVERY_COUNT_NAME = "JMSXDeliveryCount";
|
|
/**
|
|
* <code>readOnlyMessage</code> denotes if the message is read only
|
|
*/
|
|
protected bool readOnlyMessage;
|
|
|
|
private String jmsMessageID;
|
|
private String jmsClientID;
|
|
private String jmsCorrelationID;
|
|
private String producerKey;
|
|
private ActiveMQDestination jmsDestination;
|
|
private ActiveMQDestination jmsReplyTo;
|
|
private int jmsDeliveryMode = DEFAULT_DELIVERY_MODE;
|
|
private bool jmsRedelivered;
|
|
private String jmsType;
|
|
private long jmsExpiration;
|
|
private int jmsPriority = DEFAULT_PRIORITY;
|
|
private long jmsTimestamp;
|
|
private Hashtable properties;
|
|
private bool readOnlyProperties;
|
|
private String entryBrokerName;
|
|
private String entryClusterName;
|
|
private int[] consumerNos; //these are set by the broker, and only relevant to consuming connections
|
|
private Object transactionId;
|
|
private bool xaTransacted;
|
|
private String consumerIdentifier; //this is only used on the Client for acknowledging receipt of a message
|
|
private bool messageConsumed;//only used on the client - to denote if its been delivered and read
|
|
private bool transientConsumed;//only used on the client - to denote if its been delivered and read
|
|
private long sequenceNumber;//the sequence for this message from the producerId
|
|
private int deliveryCount = 1;//number of times the message has been delivered
|
|
private bool dispatchedFromDLQ;
|
|
private MessageAcknowledge messageAcknowledge;
|
|
private byte[] bodyAsBytes;
|
|
private Object jmsMessageIdentity;
|
|
private short messsageHandle;//refers to the id of the MessageProducer that sent the message
|
|
private bool externalMessageId;//is the messageId set from another JMS implementation ?
|
|
private bool messagePart;//is the message split into multiple packets
|
|
private short numberOfParts;
|
|
private short partNumber;
|
|
private String parentMessageID;//if split into multiple parts - the 'real' or first messageId
|
|
|
|
|
|
/**
|
|
* Retrieve if a JMS Message type or not
|
|
*
|
|
* @return true if it is a JMS Message
|
|
*/
|
|
public override bool isJMSMessage()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return pretty print of this Message
|
|
*/
|
|
public override String ToString()
|
|
{
|
|
return super.toString() + " ActiveMQMessage{ " +
|
|
", jmsMessageID = " + jmsMessageID +
|
|
", bodyAsBytes = " + bodyAsBytes +
|
|
", readOnlyMessage = " + readOnlyMessage +
|
|
", jmsClientID = '" + jmsClientID + "' " +
|
|
", jmsCorrelationID = '" + jmsCorrelationID + "' " +
|
|
", jmsDestination = " + jmsDestination +
|
|
", jmsReplyTo = " + jmsReplyTo +
|
|
", jmsDeliveryMode = " + jmsDeliveryMode +
|
|
", jmsRedelivered = " + jmsRedelivered +
|
|
", jmsType = '" + jmsType + "' " +
|
|
", jmsExpiration = " + jmsExpiration +
|
|
", jmsPriority = " + jmsPriority +
|
|
", jmsTimestamp = " + jmsTimestamp +
|
|
", properties = " + properties +
|
|
", readOnlyProperties = " + readOnlyProperties +
|
|
", entryBrokerName = '" + entryBrokerName + "' " +
|
|
", entryClusterName = '" + entryClusterName + "' " +
|
|
", consumerNos = " + consumerNos +
|
|
", transactionId = '" + transactionId + "' " +
|
|
", xaTransacted = " + xaTransacted +
|
|
", consumerIdentifer = '" + consumerIdentifier + "' " +
|
|
", messageConsumed = " + messageConsumed +
|
|
", transientConsumed = " + transientConsumed +
|
|
", sequenceNumber = " + sequenceNumber +
|
|
", deliveryCount = " + deliveryCount +
|
|
", dispatchedFromDLQ = " + dispatchedFromDLQ +
|
|
", messageAcknowledge = " + messageAcknowledge +
|
|
", jmsMessageIdentity = " + jmsMessageIdentity +
|
|
", producerKey = " + producerKey +
|
|
" }";
|
|
}
|
|
|
|
|
|
/**
|
|
* @return Returns the messageAcknowledge.
|
|
*/
|
|
public MessageAcknowledge getMessageAcknowledge()
|
|
{
|
|
return messageAcknowledge;
|
|
}
|
|
|
|
/**
|
|
* @param messageAcknowledge The messageAcknowledge to set.
|
|
*/
|
|
public void setMessageAcknowledge(MessageAcknowledge messageAcknowledge)
|
|
{
|
|
this.messageAcknowledge = messageAcknowledge;
|
|
}
|
|
|
|
/**
|
|
* Return the type of Packet
|
|
*
|
|
* @return integer representation of the type of Packet
|
|
*/
|
|
|
|
public new int getPacketType()
|
|
{
|
|
return ACTIVEMQ_MESSAGE;
|
|
}
|
|
|
|
|
|
/**
|
|
* set the message readOnly
|
|
*
|
|
* @param value
|
|
*/
|
|
public void setReadOnly(bool value)
|
|
{
|
|
this.readOnlyProperties = value;
|
|
this.readOnlyMessage = value;
|
|
}
|
|
|
|
/**
|
|
* test to see if a particular Consumer at a Connection
|
|
* is meant to receive this Message
|
|
*
|
|
* @param consumerNumber
|
|
* @return true if a target
|
|
*/
|
|
|
|
public bool isConsumerTarget(int consumerNumber)
|
|
{
|
|
if (consumerNos != null)
|
|
{
|
|
for (int i = 0; i < consumerNos.length; i++)
|
|
{
|
|
if (consumerNos[i] == consumerNumber)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @return consumer Nos as a String
|
|
*/
|
|
public String getConsumerNosAsString()
|
|
{
|
|
String result = "";
|
|
if (consumerNos != null)
|
|
{
|
|
for (int i = 0; i < consumerNos.length; i++)
|
|
{
|
|
result += consumerNos[i] + ",";
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @return true if the message is non-persistent or intended for a temporary destination
|
|
*/
|
|
public bool isTemporary()
|
|
{
|
|
return jmsDeliveryMode == DeliveryMode.NON_PERSISTENT ||
|
|
(jmsDestination != null && jmsDestination.isTemporary());
|
|
}
|
|
|
|
/**
|
|
* @return Returns hash code for this instance
|
|
*/
|
|
|
|
public new int GetHashCode()
|
|
{
|
|
return this.getJMSMessageID() != null ? this.getJMSMessageID().hashCode() : super.hashCode();
|
|
}
|
|
|
|
/**
|
|
* Returns true if this instance is equivalent to obj
|
|
*
|
|
* @param obj the other instance to test
|
|
* @return true/false
|
|
*/
|
|
|
|
public bool equals(Object obj)
|
|
{
|
|
bool result = obj == this;
|
|
if (!result && obj != null && obj is ActiveMQMessage)
|
|
{
|
|
ActiveMQMessage other = (ActiveMQMessage) obj;
|
|
//the call getJMSMessageID() will initialize the messageID
|
|
//if it hasn't already been set
|
|
result = this.getJMSMessageID() == other.getJMSMessageID();
|
|
if (!result)
|
|
{
|
|
if (this.jmsMessageID != null && this.jmsMessageID.length() > 0 ||
|
|
other.jmsMessageID != null && other.jmsMessageID.length() > 0)
|
|
{
|
|
if (this.jmsMessageID != null && other.jmsMessageID != null)
|
|
{
|
|
result = this.jmsMessageID.equals(other.jmsMessageID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = this.getId() == other.getId();
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* @return Returns a shallow copy of the message instance
|
|
* @
|
|
*/
|
|
|
|
public ActiveMQMessage shallowCopy()
|
|
{
|
|
ActiveMQMessage other = new ActiveMQMessage();
|
|
this.initializeOther(other);
|
|
return other;
|
|
}
|
|
|
|
/**
|
|
* @return Returns a deep copy of the message - note the header fields are only shallow copied
|
|
* @
|
|
*/
|
|
|
|
public ActiveMQMessage deepCopy()
|
|
{
|
|
return shallowCopy();
|
|
}
|
|
|
|
|
|
/**
|
|
* Indicates if the Message has expired
|
|
*
|
|
* @param currentTime -
|
|
* the current time in milliseconds
|
|
* @return true if the message can be expired
|
|
*/
|
|
public bool isExpired(long currentTime)
|
|
{
|
|
bool result = false;
|
|
long expiration = this.jmsExpiration;
|
|
if (jmsExpiration > 0 && jmsExpiration < currentTime)
|
|
{
|
|
result = true;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @return true if the message is expired
|
|
*/
|
|
public bool isExpired()
|
|
{
|
|
return !dispatchedFromDLQ && jmsExpiration > 0 && isExpired(System.currentTimeMillis());
|
|
}
|
|
|
|
/**
|
|
* @return true if an advisory message
|
|
*/
|
|
public bool isAdvisory()
|
|
{
|
|
return jmsDestination != null && jmsDestination.isAdvisory();
|
|
}
|
|
|
|
/**
|
|
* Initializes another message with current values from this instance
|
|
*
|
|
* @param other the other ActiveMQMessage to initialize
|
|
*/
|
|
protected void initializeOther(ActiveMQMessage other)
|
|
{
|
|
super.initializeOther(other);
|
|
other.jmsMessageID = this.jmsMessageID;
|
|
other.jmsClientID = this.jmsClientID;
|
|
other.jmsCorrelationID = this.jmsCorrelationID;
|
|
other.jmsDestination = this.jmsDestination;
|
|
other.jmsReplyTo = this.jmsReplyTo;
|
|
other.jmsDeliveryMode = this.jmsDeliveryMode;
|
|
other.jmsRedelivered = this.jmsRedelivered;
|
|
other.jmsType = this.jmsType;
|
|
other.jmsExpiration = this.jmsExpiration;
|
|
other.jmsPriority = this.jmsPriority;
|
|
other.jmsTimestamp = this.jmsTimestamp;
|
|
other.properties = this.properties != null ? new Hashtable(this.properties) : null;
|
|
other.readOnlyProperties = this.readOnlyProperties;
|
|
other.readOnlyMessage = this.readOnlyMessage;
|
|
other.entryBrokerName = this.entryBrokerName;
|
|
other.entryClusterName = this.entryClusterName;
|
|
other.consumerNos = this.consumerNos;
|
|
other.transactionId = this.transactionId;
|
|
other.xaTransacted = this.xaTransacted;
|
|
other.bodyAsBytes = this.bodyAsBytes;
|
|
other.messageAcknowledge = this.messageAcknowledge;
|
|
other.jmsMessageIdentity = this.jmsMessageIdentity;
|
|
other.sequenceNumber = this.sequenceNumber;
|
|
other.deliveryCount = this.deliveryCount;
|
|
other.dispatchedFromDLQ = this.dispatchedFromDLQ;
|
|
other.messsageHandle = this.messsageHandle;
|
|
other.consumerIdentifier = this.consumerIdentifier;
|
|
other.externalMessageId = this.externalMessageId;
|
|
other.producerKey = this.producerKey;
|
|
other.messagePart = this.messagePart;
|
|
other.numberOfParts = this.numberOfParts;
|
|
other.partNumber = this.partNumber;
|
|
other.parentMessageID = this.parentMessageID;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the message ID.
|
|
* <p/>
|
|
* <P>The <CODE>JMSMessageID</CODE> header field contains a value that
|
|
* uniquely identifies each message sent by a provider.
|
|
* <p/>
|
|
* <P>When a message is sent, <CODE>JMSMessageID</CODE> can be ignored.
|
|
* When the <CODE>send</CODE> or <CODE>publish</CODE> method returns, it
|
|
* contains a provider-assigned value.
|
|
* <p/>
|
|
* <P>A <CODE>JMSMessageID</CODE> is a <CODE>String</CODE> value that
|
|
* should function as a
|
|
* unique key for identifying messages in a historical repository.
|
|
* The exact scope of uniqueness is provider-defined. It should at
|
|
* least cover all messages for a specific installation of a
|
|
* provider, where an installation is some connected set of message
|
|
* routers.
|
|
* <p/>
|
|
* <P>All <CODE>JMSMessageID</CODE> values must start with the prefix
|
|
* <CODE>'ID:'</CODE>.
|
|
* Uniqueness of message ID values across different providers is
|
|
* not required.
|
|
* <p/>
|
|
* <P>Since message IDs take some effort to create and increase a
|
|
* message's size, some JMS providers may be able to optimize message
|
|
* overhead if they are given a hint that the message ID is not used by
|
|
* an application. By calling the
|
|
* <CODE>MessageProducer.setDisableMessageID</CODE> method, a JMS client
|
|
* enables this potential optimization for all messages sent by that
|
|
* message producer. If the JMS provider accepts this
|
|
* hint, these messages must have the message ID set to null; if the
|
|
* provider ignores the hint, the message ID must be set to its normal
|
|
* unique value.
|
|
*
|
|
* @return the message ID
|
|
* @see javax.jms.Message#setJMSMessageID(String)
|
|
* @see javax.jms.MessageProducer#setDisableMessageID(bool)
|
|
*/
|
|
|
|
public String getJMSMessageID()
|
|
{
|
|
if (jmsMessageID == null && producerKey != null)
|
|
{
|
|
jmsMessageID = producerKey + sequenceNumber;
|
|
}
|
|
return jmsMessageID;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the message ID.
|
|
* <p/>
|
|
* <P>JMS providers set this field when a message is sent. This method
|
|
* can be used to change the value for a message that has been received.
|
|
*
|
|
* @param id the ID of the message
|
|
* @see javax.jms.Message#getJMSMessageID()
|
|
*/
|
|
|
|
public void setJMSMessageID(String id)
|
|
{
|
|
this.jmsMessageID = id;
|
|
this.jmsMessageIdentity = null;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the message timestamp.
|
|
* <p/>
|
|
* <P>The <CODE>JMSTimestamp</CODE> header field contains the time a
|
|
* message was
|
|
* handed off to a provider to be sent. It is not the time the
|
|
* message was actually transmitted, because the actual send may occur
|
|
* later due to transactions or other client-side queueing of messages.
|
|
* <p/>
|
|
* <P>When a message is sent, <CODE>JMSTimestamp</CODE> is ignored. When
|
|
* the <CODE>send</CODE> or <CODE>publish</CODE>
|
|
* method returns, it contains a time value somewhere in the interval
|
|
* between the call and the return. The value is in the format of a normal
|
|
* millis time value in the Java programming language.
|
|
* <p/>
|
|
* <P>Since timestamps take some effort to create and increase a
|
|
* message's size, some JMS providers may be able to optimize message
|
|
* overhead if they are given a hint that the timestamp is not used by an
|
|
* application. By calling the
|
|
* <CODE>MessageProducer.setDisableMessageTimestamp</CODE> method, a JMS
|
|
* client enables this potential optimization for all messages sent by
|
|
* that message producer. If the JMS provider accepts this
|
|
* hint, these messages must have the timestamp set to zero; if the
|
|
* provider ignores the hint, the timestamp must be set to its normal
|
|
* value.
|
|
*
|
|
* @return the message timestamp
|
|
* @see javax.jms.Message#setJMSTimestamp(long)
|
|
* @see javax.jms.MessageProducer#setDisableMessageTimestamp(bool)
|
|
*/
|
|
|
|
public long getJMSTimestamp()
|
|
{
|
|
return jmsTimestamp;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the message timestamp.
|
|
* <p/>
|
|
* <P>JMS providers set this field when a message is sent. This method
|
|
* can be used to change the value for a message that has been received.
|
|
*
|
|
* @param timestamp the timestamp for this message
|
|
* @see javax.jms.Message#getJMSTimestamp()
|
|
*/
|
|
|
|
public void setJMSTimestamp(long timestamp)
|
|
{
|
|
this.jmsTimestamp = timestamp;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the correlation ID as an array of bytes for the message.
|
|
* <p/>
|
|
* <P>The use of a <CODE>byte[]</CODE> value for
|
|
* <CODE>JMSCorrelationID</CODE> is non-portable.
|
|
*
|
|
* @return the correlation ID of a message as an array of bytes
|
|
* @see javax.jms.Message#setJMSCorrelationID(String)
|
|
* @see javax.jms.Message#getJMSCorrelationID()
|
|
* @see javax.jms.Message#setJMSCorrelationIDAsBytes(byte[])
|
|
*/
|
|
|
|
public byte[] getJMSCorrelationIDAsBytes()
|
|
{
|
|
return this.jmsCorrelationID != null ? this.jmsCorrelationID.getBytes() : null;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the correlation ID as an array of bytes for the message.
|
|
* <p/>
|
|
* <P>The array is copied before the method returns, so
|
|
* future modifications to the array will not alter this message header.
|
|
* <p/>
|
|
* <P>If a provider supports the native concept of correlation ID, a
|
|
* JMS client may need to assign specific <CODE>JMSCorrelationID</CODE>
|
|
* values to match those expected by native messaging clients.
|
|
* JMS providers without native correlation ID values are not required to
|
|
* support this method and its corresponding get method; their
|
|
* implementation may throw a
|
|
* <CODE>java.lang.UnsupportedOperationException</CODE>.
|
|
* <p/>
|
|
* <P>The use of a <CODE>byte[]</CODE> value for
|
|
* <CODE>JMSCorrelationID</CODE> is non-portable.
|
|
*
|
|
* @param correlationID the correlation ID value as an array of bytes
|
|
* @see javax.jms.Message#setJMSCorrelationID(String)
|
|
* @see javax.jms.Message#getJMSCorrelationID()
|
|
* @see javax.jms.Message#getJMSCorrelationIDAsBytes()
|
|
*/
|
|
|
|
public void setJMSCorrelationIDAsBytes(byte[] correlationID)
|
|
{
|
|
if (correlationID == null)
|
|
{
|
|
this.jmsCorrelationID = null;
|
|
}
|
|
else
|
|
{
|
|
this.jmsCorrelationID = new String(correlationID);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the correlation ID for the message.
|
|
* <p/>
|
|
* <P>A client can use the <CODE>JMSCorrelationID</CODE> header field to
|
|
* link one message with another. A typical use is to link a response
|
|
* message with its request message.
|
|
* <p/>
|
|
* <P><CODE>JMSCorrelationID</CODE> can hold one of the following:
|
|
* <UL>
|
|
* <LI>A provider-specific message ID
|
|
* <LI>An application-specific <CODE>String</CODE>
|
|
* <LI>A provider-native <CODE>byte[]</CODE> value
|
|
* </UL>
|
|
* <p/>
|
|
* <P>Since each message sent by a JMS provider is assigned a message ID
|
|
* value, it is convenient to link messages via message ID. All message ID
|
|
* values must start with the <CODE>'ID:'</CODE> prefix.
|
|
* <p/>
|
|
* <P>In some cases, an application (made up of several clients) needs to
|
|
* use an application-specific value for linking messages. For instance,
|
|
* an application may use <CODE>JMSCorrelationID</CODE> to hold a value
|
|
* referencing some external information. Application-specified values
|
|
* must not start with the <CODE>'ID:'</CODE> prefix; this is reserved for
|
|
* provider-generated message ID values.
|
|
* <p/>
|
|
* <P>If a provider supports the native concept of correlation ID, a JMS
|
|
* client may need to assign specific <CODE>JMSCorrelationID</CODE> values
|
|
* to match those expected by clients that do not use the JMS API. A
|
|
* <CODE>byte[]</CODE> value is used for this
|
|
* purpose. JMS providers without native correlation ID values are not
|
|
* required to support <CODE>byte[]</CODE> values. The use of a
|
|
* <CODE>byte[]</CODE> value for <CODE>JMSCorrelationID</CODE> is
|
|
* non-portable.
|
|
*
|
|
* @param correlationID the message ID of a message being referred to
|
|
* @see javax.jms.Message#getJMSCorrelationID()
|
|
* @see javax.jms.Message#getJMSCorrelationIDAsBytes()
|
|
* @see javax.jms.Message#setJMSCorrelationIDAsBytes(byte[])
|
|
*/
|
|
|
|
public void setJMSCorrelationID(String correlationID)
|
|
{
|
|
this.jmsCorrelationID = correlationID;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the correlation ID for the message.
|
|
* <p/>
|
|
* <P>This method is used to return correlation ID values that are
|
|
* either provider-specific message IDs or application-specific
|
|
* <CODE>String</CODE> values.
|
|
*
|
|
* @return the correlation ID of a message as a <CODE>String</CODE>
|
|
* @see javax.jms.Message#setJMSCorrelationID(String)
|
|
* @see javax.jms.Message#getJMSCorrelationIDAsBytes()
|
|
* @see javax.jms.Message#setJMSCorrelationIDAsBytes(byte[])
|
|
*/
|
|
|
|
public String getJMSCorrelationID()
|
|
{
|
|
return this.jmsCorrelationID;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the <CODE>Destination</CODE> object to which a reply to this
|
|
* message should be sent.
|
|
*
|
|
* @return <CODE>Destination</CODE> to which to send a response to this
|
|
* message
|
|
* @see javax.jms.Message#setJMSReplyTo(Destination)
|
|
*/
|
|
|
|
public ActiveMQDestination getJMSReplyTo()
|
|
{
|
|
return this.jmsReplyTo;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the <CODE>Destination</CODE> object to which a reply to this
|
|
* message should be sent.
|
|
* <p/>
|
|
* <P>The <CODE>JMSReplyTo</CODE> header field contains the destination
|
|
* where a reply
|
|
* to the current message should be sent. If it is null, no reply is
|
|
* expected. The destination may be either a <CODE>Queue</CODE> object or
|
|
* a <CODE>Topic</CODE> object.
|
|
* <p/>
|
|
* <P>Messages sent with a null <CODE>JMSReplyTo</CODE> value may be a
|
|
* notification of some event, or they may just be some data the sender
|
|
* thinks is of interest.
|
|
* <p/>
|
|
* <P>Messages with a <CODE>JMSReplyTo</CODE> value typically expect a
|
|
* response. A response is optional; it is up to the client to decide.
|
|
* These messages are called requests. A message sent in response to a
|
|
* request is called a reply.
|
|
* <p/>
|
|
* <P>In some cases a client may wish to match a request it sent earlier
|
|
* with a reply it has just received. The client can use the
|
|
* <CODE>JMSCorrelationID</CODE> header field for this purpose.
|
|
*
|
|
* @param replyTo <CODE>Destination</CODE> to which to send a response to
|
|
* this message
|
|
* @see javax.jms.Message#getJMSReplyTo()
|
|
*/
|
|
|
|
public void setJMSReplyTo(ActiveMQDestination replyTo)
|
|
{
|
|
this.jmsReplyTo = (ActiveMQDestination) replyTo;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the <CODE>Destination</CODE> object for this message.
|
|
* <p/>
|
|
* <P>The <CODE>JMSDestination</CODE> header field contains the
|
|
* destination to which the message is being sent.
|
|
* <p/>
|
|
* <P>When a message is sent, this field is ignored. After completion
|
|
* of the <CODE>send</CODE> or <CODE>publish</CODE> method, the field
|
|
* holds the destination specified by the method.
|
|
* <p/>
|
|
* <P>When a message is received, its <CODE>JMSDestination</CODE> value
|
|
* must be equivalent to the value assigned when it was sent.
|
|
*
|
|
* @return the destination of this message
|
|
* @see javax.jms.Message#setJMSDestination(Destination)
|
|
*/
|
|
|
|
public ActiveMQDestination getJMSDestination()
|
|
{
|
|
return this.jmsDestination;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the <CODE>Destination</CODE> object for this message.
|
|
* <p/>
|
|
* <P>JMS providers set this field when a message is sent. This method
|
|
* can be used to change the value for a message that has been received.
|
|
*
|
|
* @param destination the destination for this message
|
|
* @see javax.jms.Message#getJMSDestination()
|
|
*/
|
|
|
|
public void setJMSDestination(ActiveMQDestination destination)
|
|
{
|
|
this.jmsDestination = (ActiveMQDestination) destination;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the <CODE>DeliveryMode</CODE> value specified for this message.
|
|
*
|
|
* @return the delivery mode for this message
|
|
* @see javax.jms.Message#setJMSDeliveryMode(int)
|
|
* @see javax.jms.DeliveryMode
|
|
*/
|
|
|
|
public int getJMSDeliveryMode()
|
|
{
|
|
return this.jmsDeliveryMode;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the <CODE>DeliveryMode</CODE> value for this message.
|
|
* <p/>
|
|
* <P>JMS providers set this field when a message is sent. This method
|
|
* can be used to change the value for a message that has been received.
|
|
*
|
|
* @param deliveryMode the delivery mode for this message
|
|
* @see javax.jms.Message#getJMSDeliveryMode()
|
|
* @see javax.jms.DeliveryMode
|
|
*/
|
|
|
|
public void setJMSDeliveryMode(int deliveryMode)
|
|
{
|
|
this.jmsDeliveryMode = deliveryMode;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets an indication of whether this message is being redelivered.
|
|
* <p/>
|
|
* <P>If a client receives a message with the <CODE>JMSRedelivered</CODE>
|
|
* field set,
|
|
* it is likely, but not guaranteed, that this message was delivered
|
|
* earlier but that its receipt was not acknowledged
|
|
* at that time.
|
|
*
|
|
* @return true if this message is being redelivered
|
|
* @see javax.jms.Message#setJMSRedelivered(bool)
|
|
*/
|
|
|
|
public bool getJMSRedelivered()
|
|
{
|
|
return this.jmsRedelivered;
|
|
}
|
|
|
|
|
|
/**
|
|
* Specifies whether this message is being redelivered.
|
|
* <p/>
|
|
* <P>This field is set at the time the message is delivered. This
|
|
* method can be used to change the value for a message that has
|
|
* been received.
|
|
*
|
|
* @param redelivered an indication of whether this message is being
|
|
* redelivered
|
|
* @see javax.jms.Message#getJMSRedelivered()
|
|
*/
|
|
|
|
public void setJMSRedelivered(bool redelivered)
|
|
{
|
|
this.jmsRedelivered = redelivered;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the message type identifier supplied by the client when the
|
|
* message was sent.
|
|
*
|
|
* @return the message type
|
|
* @see javax.jms.Message#setJMSType(String)
|
|
*/
|
|
|
|
public String getJMSType()
|
|
{
|
|
return this.jmsType;
|
|
}
|
|
|
|
/**
|
|
* Sets the message type.
|
|
* <p/>
|
|
* <P>Some JMS providers use a message repository that contains the
|
|
* definitions of messages sent by applications. The <CODE>JMSType</CODE>
|
|
* header field may reference a message's definition in the provider's
|
|
* repository.
|
|
* <p/>
|
|
* <P>The JMS API does not define a standard message definition repository,
|
|
* nor does it define a naming policy for the definitions it contains.
|
|
* <p/>
|
|
* <P>Some messaging systems require that a message type definition for
|
|
* each application message be created and that each message specify its
|
|
* type. In order to work with such JMS providers, JMS clients should
|
|
* assign a value to <CODE>JMSType</CODE>, whether the application makes
|
|
* use of it or not. This ensures that the field is properly set for those
|
|
* providers that require it.
|
|
* <p/>
|
|
* <P>To ensure portability, JMS clients should use symbolic values for
|
|
* <CODE>JMSType</CODE> that can be configured at installation time to the
|
|
* values defined in the current provider's message repository. If string
|
|
* literals are used, they may not be valid type names for some JMS
|
|
* providers.
|
|
*
|
|
* @param type the message type
|
|
* @see javax.jms.Message#getJMSType()
|
|
*/
|
|
|
|
public void setJMSType(String type)
|
|
{
|
|
this.jmsType = type;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the message's expiration value.
|
|
* <p/>
|
|
* <P>When a message is sent, the <CODE>JMSExpiration</CODE> header field
|
|
* is left unassigned. After completion of the <CODE>send</CODE> or
|
|
* <CODE>publish</CODE> method, it holds the expiration time of the
|
|
* message. This is the sum of the time-to-live value specified by the
|
|
* client and the GMT at the time of the <CODE>send</CODE> or
|
|
* <CODE>publish</CODE>.
|
|
* <p/>
|
|
* <P>If the time-to-live is specified as zero, <CODE>JMSExpiration</CODE>
|
|
* is set to zero to indicate that the message does not expire.
|
|
* <p/>
|
|
* <P>When a message's expiration time is reached, a provider should
|
|
* discard it. The JMS API does not define any form of notification of
|
|
* message expiration.
|
|
* <p/>
|
|
* <P>Clients should not receive messages that have expired; however,
|
|
* the JMS API does not guarantee that this will not happen.
|
|
*
|
|
* @return the time the message expires, which is the sum of the
|
|
* time-to-live value specified by the client and the GMT at the
|
|
* time of the send
|
|
* @see javax.jms.Message#setJMSExpiration(long)
|
|
*/
|
|
|
|
public long getJMSExpiration()
|
|
{
|
|
return this.jmsExpiration;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the message's expiration value.
|
|
* <p/>
|
|
* <P>JMS providers set this field when a message is sent. This method
|
|
* can be used to change the value for a message that has been received.
|
|
*
|
|
* @param expiration the message's expiration time
|
|
* @see javax.jms.Message#getJMSExpiration()
|
|
*/
|
|
|
|
public void setJMSExpiration(long expiration)
|
|
{
|
|
this.jmsExpiration = expiration;
|
|
}
|
|
|
|
/**
|
|
* Gets the message priority level.
|
|
* <p/>
|
|
* <P>The JMS API defines ten levels of priority value, with 0 as the
|
|
* lowest
|
|
* priority and 9 as the highest. In addition, clients should consider
|
|
* priorities 0-4 as gradations of normal priority and priorities 5-9
|
|
* as gradations of expedited priority.
|
|
* <p/>
|
|
* <P>The JMS API does not require that a provider strictly implement
|
|
* priority
|
|
* ordering of messages; however, it should do its best to deliver
|
|
* expedited messages ahead of normal messages.
|
|
*
|
|
* @return the default message priority
|
|
* @see javax.jms.Message#setJMSPriority(int)
|
|
*/
|
|
|
|
public int getJMSPriority()
|
|
{
|
|
return this.jmsPriority;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the priority level for this message.
|
|
* <p/>
|
|
* <P>JMS providers set this field when a message is sent. This method
|
|
* can be used to change the value for a message that has been received.
|
|
*
|
|
* @param priority the priority of this message
|
|
* @see javax.jms.Message#getJMSPriority()
|
|
*/
|
|
|
|
public void setJMSPriority(int priority)
|
|
{
|
|
this.jmsPriority = priority;
|
|
}
|
|
|
|
/**
|
|
* Clears a message's properties.
|
|
* <p/>
|
|
* <P>The message's header fields and body are not cleared.
|
|
*/
|
|
|
|
|
|
/**
|
|
* Indicates whether a property value exists.
|
|
*
|
|
* @param name the name of the property to test
|
|
* @return true if the property exists
|
|
*/
|
|
|
|
public bool propertyExists(String name)
|
|
{
|
|
return this.properties != null ? this.properties.containsKey(name) : false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the value of the <CODE>bool</CODE> property with the
|
|
* specified name.
|
|
*
|
|
* @param name the name of the <CODE>bool</CODE> property
|
|
* @return the <CODE>bool</CODE> property value for the specified name
|
|
* @ if the JMS provider fails to get the property
|
|
* value due to some internal error.
|
|
* @throws MessageFormatException if this type conversion is invalid.
|
|
*/
|
|
|
|
public bool getboolProperty(String name)
|
|
{
|
|
return vanillaTobool(this.properties, name);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the value of the <CODE>byte</CODE> property with the specified
|
|
* name.
|
|
*
|
|
* @param name the name of the <CODE>byte</CODE> property
|
|
* @return the <CODE>byte</CODE> property value for the specified name
|
|
* @ if the JMS provider fails to get the property
|
|
* value due to some internal error.
|
|
* @throws MessageFormatException if this type conversion is invalid.
|
|
*/
|
|
|
|
public byte getByteProperty(String name)
|
|
{
|
|
return vanillaToByte(this.properties, name);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the value of the <CODE>short</CODE> property with the specified
|
|
* name.
|
|
*
|
|
* @param name the name of the <CODE>short</CODE> property
|
|
* @return the <CODE>short</CODE> property value for the specified name
|
|
* @ if the JMS provider fails to get the property
|
|
* value due to some internal error.
|
|
* @throws MessageFormatException if this type conversion is invalid.
|
|
*/
|
|
|
|
public short getShortProperty(String name)
|
|
{
|
|
return vanillaToShort(this.properties, name);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the value of the <CODE>int</CODE> property with the specified
|
|
* name.
|
|
*
|
|
* @param name the name of the <CODE>int</CODE> property
|
|
* @return the <CODE>int</CODE> property value for the specified name
|
|
* @ if the JMS provider fails to get the property
|
|
* value due to some internal error.
|
|
* @throws MessageFormatException if this type conversion is invalid.
|
|
*/
|
|
|
|
public int getIntProperty(String name)
|
|
{
|
|
return vanillaToInt(this.properties, name);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the value of the <CODE>long</CODE> property with the specified
|
|
* name.
|
|
*
|
|
* @param name the name of the <CODE>long</CODE> property
|
|
* @return the <CODE>long</CODE> property value for the specified name
|
|
* @ if the JMS provider fails to get the property
|
|
* value due to some internal error.
|
|
* @throws MessageFormatException if this type conversion is invalid.
|
|
*/
|
|
|
|
public long getLongProperty(String name)
|
|
{
|
|
return vanillaToLong(this.properties, name);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the value of the <CODE>float</CODE> property with the specified
|
|
* name.
|
|
*
|
|
* @param name the name of the <CODE>float</CODE> property
|
|
* @return the <CODE>float</CODE> property value for the specified name
|
|
* @ if the JMS provider fails to get the property
|
|
* value due to some internal error.
|
|
* @throws MessageFormatException if this type conversion is invalid.
|
|
*/
|
|
|
|
public float getFloatProperty(String name)
|
|
{
|
|
return vanillaToFloat(this.properties, name);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the value of the <CODE>double</CODE> property with the specified
|
|
* name.
|
|
*
|
|
* @param name the name of the <CODE>double</CODE> property
|
|
* @return the <CODE>double</CODE> property value for the specified name
|
|
* @ if the JMS provider fails to get the property
|
|
* value due to some internal error.
|
|
* @throws MessageFormatException if this type conversion is invalid.
|
|
*/
|
|
|
|
public double getDoubleProperty(String name)
|
|
{
|
|
return vanillaToDouble(this.properties, name);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the value of the <CODE>String</CODE> property with the specified
|
|
* name.
|
|
*
|
|
* @param name the name of the <CODE>String</CODE> property
|
|
* @return the <CODE>String</CODE> property value for the specified name;
|
|
* if there is no property by this name, a null value is returned
|
|
* @ if the JMS provider fails to get the property
|
|
* value due to some internal error.
|
|
* @throws MessageFormatException if this type conversion is invalid.
|
|
*/
|
|
|
|
public String getStringProperty(String name)
|
|
{
|
|
return vanillaToString(this.properties, name);
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the value of the Java object property with the specified name.
|
|
* <p/>
|
|
* <P>This method can be used to return, in objectified format,
|
|
* an object that has been stored as a property in the message with the
|
|
* equivalent <CODE>setObjectProperty</CODE> method call, or its equivalent
|
|
* primitive <CODE>set<I>type</I>Property</CODE> method.
|
|
*
|
|
* @param name the name of the Java object property
|
|
* @return the Java object property value with the specified name, in
|
|
* objectified format (for example, if the property was set as an
|
|
* <CODE>int</CODE>, an <CODE>Integer</CODE> is
|
|
* returned); if there is no property by this name, a null value
|
|
* is returned
|
|
*/
|
|
|
|
public Object getObjectProperty(String name)
|
|
{
|
|
return this.properties != null ? this.properties.get(name) : null;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns an <CODE>Enumeration</CODE> of all the property names.
|
|
* <p/>
|
|
* <P>Note that JMS standard header fields are not considered
|
|
* properties and are not returned in this enumeration.
|
|
*
|
|
* @return an enumeration of all the names of property values
|
|
*/
|
|
|
|
public IDictionaryEnumerator getPropertyNames()
|
|
{
|
|
if (this.properties == null)
|
|
{
|
|
this.properties = new Hashtable();
|
|
}
|
|
return this.properties.GetEnumerator();
|
|
}
|
|
|
|
/**
|
|
* Retrieve the message properties as a Hashtable
|
|
*
|
|
* @return the Hashtable representing the properties or null if not set or used
|
|
*/
|
|
|
|
public Hashtable getProperties()
|
|
{
|
|
return this.properties;
|
|
}
|
|
|
|
/**
|
|
* Set the Message's properties from an external source
|
|
* No checking on correct types is done by this method
|
|
*
|
|
* @param newProperties
|
|
*/
|
|
|
|
public void setProperties(Hashtable newProperties)
|
|
{
|
|
this.properties = newProperties;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets a <CODE>bool</CODE> property value with the specified name into
|
|
* the message.
|
|
*
|
|
* @param name the name of the <CODE>bool</CODE> property
|
|
* @param value the <CODE>bool</CODE> property value to set
|
|
* @ if the JMS provider fails to set the property
|
|
* due to some internal error.
|
|
* @throws IllegalArgumentException if the name is null or if the name is
|
|
* an empty string.
|
|
* @throws MessageNotWriteableException if properties are read-only
|
|
*/
|
|
|
|
public void setboolProperty(String name, bool value)
|
|
{
|
|
prepareProperty(name);
|
|
this.properties.put(name, (value) ? bool.TRUE : bool.FALSE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets a <CODE>byte</CODE> property value with the specified name into
|
|
* the message.
|
|
*
|
|
* @param name the name of the <CODE>byte</CODE> property
|
|
* @param value the <CODE>byte</CODE> property value to set
|
|
* @ if the JMS provider fails to set the property
|
|
* due to some internal error.
|
|
* @throws IllegalArgumentException if the name is null or if the name is
|
|
* an empty string.
|
|
* @throws MessageNotWriteableException if properties are read-only
|
|
*/
|
|
|
|
public void setByteProperty(String name, byte value)
|
|
{
|
|
prepareProperty(name);
|
|
this.properties.put(name, new Byte(value));
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets a <CODE>short</CODE> property value with the specified name into
|
|
* the message.
|
|
*
|
|
* @param name the name of the <CODE>short</CODE> property
|
|
* @param value the <CODE>short</CODE> property value to set
|
|
* @ if the JMS provider fails to set the property
|
|
* due to some internal error.
|
|
* @throws IllegalArgumentException if the name is null or if the name is
|
|
* an empty string.
|
|
* @throws MessageNotWriteableException if properties are read-only
|
|
*/
|
|
|
|
public void setShortProperty(String name, short value)
|
|
{
|
|
prepareProperty(name);
|
|
this.properties.put(name, new Short(value));
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets an <CODE>int</CODE> property value with the specified name into
|
|
* the message.
|
|
*
|
|
* @param name the name of the <CODE>int</CODE> property
|
|
* @param value the <CODE>int</CODE> property value to set
|
|
* @ if the JMS provider fails to set the property
|
|
* due to some internal error.
|
|
* @throws IllegalArgumentException if the name is null or if the name is
|
|
* an empty string.
|
|
* @throws MessageNotWriteableException if properties are read-only
|
|
*/
|
|
|
|
public void setIntProperty(String name, int value)
|
|
{
|
|
prepareProperty(name);
|
|
this.properties.put(name, new Integer(value));
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets a <CODE>long</CODE> property value with the specified name into
|
|
* the message.
|
|
*
|
|
* @param name the name of the <CODE>long</CODE> property
|
|
* @param value the <CODE>long</CODE> property value to set
|
|
* @ if the JMS provider fails to set the property
|
|
* due to some internal error.
|
|
* @throws IllegalArgumentException if the name is null or if the name is
|
|
* an empty string.
|
|
* @throws MessageNotWriteableException if properties are read-only
|
|
*/
|
|
|
|
public void setLongProperty(String name, long value)
|
|
{
|
|
prepareProperty(name);
|
|
this.properties.put(name, new Long(value));
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets a <CODE>float</CODE> property value with the specified name into
|
|
* the message.
|
|
*
|
|
* @param name the name of the <CODE>float</CODE> property
|
|
* @param value the <CODE>float</CODE> property value to set
|
|
* @ if the JMS provider fails to set the property
|
|
* due to some internal error.
|
|
* @throws IllegalArgumentException if the name is null or if the name is
|
|
* an empty string.
|
|
* @throws MessageNotWriteableException if properties are read-only
|
|
*/
|
|
|
|
public void setFloatProperty(String name, float value)
|
|
{
|
|
prepareProperty(name);
|
|
this.properties.put(name, new Float(value));
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets a <CODE>double</CODE> property value with the specified name into
|
|
* the message.
|
|
*
|
|
* @param name the name of the <CODE>double</CODE> property
|
|
* @param value the <CODE>double</CODE> property value to set
|
|
* @ if the JMS provider fails to set the property
|
|
* due to some internal error.
|
|
* @throws IllegalArgumentException if the name is null or if the name is
|
|
* an empty string.
|
|
* @throws MessageNotWriteableException if properties are read-only
|
|
*/
|
|
|
|
public void setDoubleProperty(String name, double value)
|
|
{
|
|
prepareProperty(name);
|
|
this.properties.put(name, new Double(value));
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets a <CODE>String</CODE> property value with the specified name into
|
|
* the message.
|
|
*
|
|
* @param name the name of the <CODE>String</CODE> property
|
|
* @param value the <CODE>String</CODE> property value to set
|
|
* @ if the JMS provider fails to set the property
|
|
* due to some internal error.
|
|
* @throws IllegalArgumentException if the name is null or if the name is
|
|
* an empty string.
|
|
* @throws MessageNotWriteableException if properties are read-only
|
|
*/
|
|
|
|
public void setStringProperty(String name, String value)
|
|
{
|
|
prepareProperty(name);
|
|
if (value == null)
|
|
{
|
|
this.properties.remove(name);
|
|
}
|
|
else
|
|
{
|
|
this.properties.put(name, value);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets a Java object property value with the specified name into the
|
|
* message.
|
|
* <p/>
|
|
* <P>Note that this method works only for the objectified primitive
|
|
* object types (<CODE>Integer</CODE>, <CODE>Double</CODE>,
|
|
* <CODE>Long</CODE> ...) and <CODE>String</CODE> objects.
|
|
*
|
|
* @param name the name of the Java object property
|
|
* @param value the Java object property value to set
|
|
* @ if the JMS provider fails to set the property
|
|
* due to some internal error.
|
|
* @throws IllegalArgumentException if the name is null or if the name is
|
|
* an empty string.
|
|
* @throws MessageFormatException if the object is invalid
|
|
* @throws MessageNotWriteableException if properties are read-only
|
|
*/
|
|
|
|
public void setObjectProperty(String name, Object value)
|
|
{
|
|
prepareProperty(name);
|
|
if (value == null)
|
|
{
|
|
this.properties.remove(name);
|
|
}
|
|
else
|
|
{
|
|
if (value is Number ||
|
|
value is Character ||
|
|
value is bool ||
|
|
value is String)
|
|
{
|
|
this.properties.put(name, value);
|
|
}
|
|
else
|
|
{
|
|
throw new MessageFormatException("Cannot set property to type: " + value.getClass().getName());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Acknowledges all consumed messages of the session of this consumed
|
|
* message.
|
|
* <p/>
|
|
* <P>All consumed JMS messages support the <CODE>acknowledge</CODE>
|
|
* method for use when a client has specified that its JMS session's
|
|
* consumed messages are to be explicitly acknowledged. By invoking
|
|
* <CODE>acknowledge</CODE> on a consumed message, a client acknowledges
|
|
* all messages consumed by the session that the message was delivered to.
|
|
* <p/>
|
|
* <P>Calls to <CODE>acknowledge</CODE> are ignored for both transacted
|
|
* sessions and sessions specified to use implicit acknowledgement modes.
|
|
* <p/>
|
|
* <P>A client may individually acknowledge each message as it is consumed,
|
|
* or it may choose to acknowledge messages as an application-defined group
|
|
* (which is done by calling acknowledge on the last received message of the group,
|
|
* thereby acknowledging all messages consumed by the session.)
|
|
* <p/>
|
|
* <P>Messages that have been received but not acknowledged may be
|
|
* redelivered.
|
|
*
|
|
* @ if the JMS provider fails to acknowledge the
|
|
* messages due to some internal error.
|
|
* @throws javax.jms.IllegalStateException
|
|
* if this method is called on a closed
|
|
* session.
|
|
* @see javax.jms.Session#CLIENT_ACKNOWLEDGE
|
|
*/
|
|
|
|
public void acknowledge()
|
|
{
|
|
if (this.messageAcknowledge != null)
|
|
{
|
|
this.messageAcknowledge.acknowledge(this);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Clears out the message body. Clearing a message's body does not clear
|
|
* its header values or property entries.
|
|
* <p/>
|
|
* <P>If this message body was read-only, calling this method leaves
|
|
* the message body in the same state as an empty body in a newly
|
|
* created message.
|
|
*
|
|
* @ if the JMS provider fails to clear the message
|
|
* body due to some internal error.
|
|
*/
|
|
|
|
public void clearBody()
|
|
{
|
|
this.readOnlyMessage = false;
|
|
this.bodyAsBytes = null;
|
|
}
|
|
|
|
bool vanillaTobool(Hashtable table, String name)
|
|
{
|
|
bool result = false;
|
|
Object value = getVanillaProperty(table, name);
|
|
if (value != null)
|
|
{
|
|
if (value is bool)
|
|
{
|
|
result = ((bool) value).boolValue();
|
|
}
|
|
else if (value is String)
|
|
{
|
|
// will throw a runtime exception if cannot convert
|
|
result = bool.valueOf((String) value).boolValue();
|
|
}
|
|
else
|
|
{
|
|
throw new MessageFormatException(name + " not a bool type");
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
byte vanillaToByte(Hashtable table, String name)
|
|
{
|
|
byte result = 0;
|
|
Object value = getVanillaProperty(table, name);
|
|
if (value != null)
|
|
{
|
|
if (value is Byte)
|
|
{
|
|
result = ((Byte) value).byteValue();
|
|
}
|
|
else if (value is String)
|
|
{
|
|
result = Byte.valueOf((String) value).byteValue();
|
|
}
|
|
else
|
|
{
|
|
throw new MessageFormatException(name + " not a Byte type");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//object doesn't exist - so treat as a null ..
|
|
throw new NumberFormatException("Cannot interpret null as a Byte");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
short vanillaToShort(Hashtable table, String name)
|
|
{
|
|
short result = 0;
|
|
Object value = getVanillaProperty(table, name);
|
|
if (value != null)
|
|
{
|
|
if (value is Short)
|
|
{
|
|
result = ((Short) value).shortValue();
|
|
}
|
|
else if (value is String)
|
|
{
|
|
return Short.valueOf((String) value).shortValue();
|
|
}
|
|
else if (value is Byte)
|
|
{
|
|
result = ((Byte) value).byteValue();
|
|
}
|
|
else
|
|
{
|
|
throw new MessageFormatException(name + " not a Short type");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new NumberFormatException(name + " is null");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int vanillaToInt(Hashtable table, String name)
|
|
{
|
|
int result = 0;
|
|
Object value = getVanillaProperty(table, name);
|
|
if (value != null)
|
|
{
|
|
if (value is Integer)
|
|
{
|
|
result = ((Integer) value).intValue();
|
|
}
|
|
else if (value is String)
|
|
{
|
|
result = Integer.valueOf((String) value).intValue();
|
|
}
|
|
else if (value is Byte)
|
|
{
|
|
result = ((Byte) value).intValue();
|
|
}
|
|
else if (value is Short)
|
|
{
|
|
result = ((Short) value).intValue();
|
|
}
|
|
else
|
|
{
|
|
throw new MessageFormatException(name + " not an Integer type");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new NumberFormatException(name + " is null");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
long vanillaToLong(Hashtable table, String name)
|
|
{
|
|
long result = 0;
|
|
Object value = getVanillaProperty(table, name);
|
|
if (value != null)
|
|
{
|
|
if (value is Long)
|
|
{
|
|
result = ((Long) value).longValue();
|
|
}
|
|
else if (value is String)
|
|
{
|
|
// will throw a runtime exception if cannot convert
|
|
result = Long.valueOf((String) value).longValue();
|
|
}
|
|
else if (value is Byte)
|
|
{
|
|
result = ((Byte) value).byteValue();
|
|
}
|
|
else if (value is Short)
|
|
{
|
|
result = ((Short) value).shortValue();
|
|
}
|
|
else if (value is Integer)
|
|
{
|
|
result = ((Integer) value).intValue();
|
|
}
|
|
else
|
|
{
|
|
throw new MessageFormatException(name + " not a Long type");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new NumberFormatException(name + " is null");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
float vanillaToFloat(Hashtable table, String name)
|
|
{
|
|
float result = 0.0f;
|
|
Object value = getVanillaProperty(table, name);
|
|
if (value != null)
|
|
{
|
|
if (value is Float)
|
|
{
|
|
result = ((Float) value).floatValue();
|
|
}
|
|
else if (value is String)
|
|
{
|
|
result = Float.valueOf((String) value).floatValue();
|
|
}
|
|
else
|
|
{
|
|
throw new MessageFormatException(name + " not a Float type: " + value.getClass());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new NullPointerException(name + " is null");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
double vanillaToDouble(Hashtable table, String name)
|
|
{
|
|
double result = 0.0d;
|
|
Object value = getVanillaProperty(table, name);
|
|
if (value != null)
|
|
{
|
|
if (value is Double)
|
|
{
|
|
result = ((Double) value).doubleValue();
|
|
}
|
|
else if (value is String)
|
|
{
|
|
result = Double.valueOf((String) value).doubleValue();
|
|
}
|
|
else if (value is Float)
|
|
{
|
|
result = ((Float) value).floatValue();
|
|
}
|
|
else
|
|
{
|
|
throw new MessageFormatException(name + " not a Double type");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new NullPointerException(name + " is null");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Object getVanillaProperty(Hashtable table, String name)
|
|
{
|
|
Object result = null;
|
|
if (name == null)
|
|
{
|
|
throw new NullPointerException("name supplied is null");
|
|
}
|
|
result = getReservedProperty(name);
|
|
if (result == null && table != null)
|
|
{
|
|
result = table.get(name);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Object getReservedProperty(String name)
|
|
{
|
|
Object result = null;
|
|
if (name != null && name.equals(DELIVERY_COUNT_NAME))
|
|
{
|
|
result = new Integer(deliveryCount);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
String vanillaToString(Hashtable table, String name)
|
|
{
|
|
String result = null;
|
|
if (table != null)
|
|
{
|
|
Object value = table.get(name);
|
|
if (value != null)
|
|
{
|
|
if (value is String || value is Number || value is bool)
|
|
{
|
|
result = value.toString();
|
|
}
|
|
else
|
|
{
|
|
throw new MessageFormatException(name + " not a String type");
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void prepareProperty(String name)
|
|
{
|
|
if (name == null)
|
|
{
|
|
throw new IllegalArgumentException("Invalid property name: cannot be null");
|
|
}
|
|
if (name.length() == 0)
|
|
{
|
|
throw new IllegalArgumentException("Invalid property name: cannot be empty");
|
|
}
|
|
if (this.readOnlyProperties)
|
|
{
|
|
throw new MessageNotWriteableException("Properties are read-only");
|
|
}
|
|
if (this.properties == null)
|
|
{
|
|
this.properties = new Hashtable();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return Returns the entryBrokerName.
|
|
*/
|
|
public String getEntryBrokerName()
|
|
{
|
|
return this.entryBrokerName;
|
|
}
|
|
|
|
/**
|
|
* @param newEntryBrokerName The entryBrokerName to set.
|
|
*/
|
|
public void setEntryBrokerName(String newEntryBrokerName)
|
|
{
|
|
this.entryBrokerName = newEntryBrokerName;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the entryClusterName.
|
|
*/
|
|
public String getEntryClusterName()
|
|
{
|
|
return this.entryClusterName;
|
|
}
|
|
|
|
/**
|
|
* @param newEntryClusterName The entryClusterName to set.
|
|
*/
|
|
public void setEntryClusterName(String newEntryClusterName)
|
|
{
|
|
this.entryClusterName = newEntryClusterName;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the consumerNos.
|
|
*/
|
|
public int[] getConsumerNos()
|
|
{
|
|
return this.consumerNos;
|
|
}
|
|
|
|
/**
|
|
* @param newConsumerNos The consumerIDs to set.
|
|
*/
|
|
public void setConsumerNos(int[] newConsumerNos)
|
|
{
|
|
this.consumerNos = newConsumerNos;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the jmsClientID.
|
|
*/
|
|
public String getJMSClientID()
|
|
{
|
|
return this.jmsClientID;
|
|
}
|
|
|
|
/**
|
|
* @param newJmsClientID The jmsClientID to set.
|
|
*/
|
|
public void setJMSClientID(String newJmsClientID)
|
|
{
|
|
this.jmsClientID = newJmsClientID;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @return Returns true if this message is part of a transaction
|
|
*/
|
|
|
|
public bool isPartOfTransaction()
|
|
{
|
|
return this.transactionId != null;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the transactionId.
|
|
*/
|
|
public Object getTransactionId()
|
|
{
|
|
return this.transactionId;
|
|
}
|
|
|
|
/**
|
|
* @param newTransactionId The transactionId to set.
|
|
*/
|
|
public void setTransactionId(Object newTransactionId)
|
|
{
|
|
this.transactionId = newTransactionId;
|
|
//this.xaTransacted = newTransactionId!=null && newTransactionId.getClass()==ActiveMQXid.class;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the consumerId.
|
|
*/
|
|
public String getConsumerIdentifer()
|
|
{
|
|
return consumerIdentifier;
|
|
}
|
|
|
|
/**
|
|
* @param consId The consumerId to set.
|
|
*/
|
|
public void setConsumerIdentifer(String consId)
|
|
{
|
|
this.consumerIdentifier = consId;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the messageConsumed.
|
|
*/
|
|
public bool isMessageConsumed()
|
|
{
|
|
return messageConsumed;
|
|
}
|
|
|
|
/**
|
|
* @param messageConsumed The messageConsumed to set.
|
|
*/
|
|
public void setMessageConsumed(bool messageConsumed)
|
|
{
|
|
this.messageConsumed = messageConsumed;
|
|
}
|
|
|
|
|
|
public void prepareMessageBody()
|
|
{
|
|
}
|
|
|
|
public void convertBodyToBytes()
|
|
{
|
|
//TODO SERIALIZATION MECHANISM FUNKINESS HERE
|
|
}
|
|
|
|
public void buildBodyFromBytes()
|
|
{
|
|
//TODO SERIALIZATION MECHANISM FUNKINESS HERE
|
|
}
|
|
|
|
/**
|
|
|
|
public void writeBody(DataOutput dataOut) {
|
|
|
|
}
|
|
|
|
|
|
|
|
public void readBody(DataInput dataIn) throws IOException {
|
|
|
|
}
|
|
|
|
/**
|
|
* @return Returns the bodyAsBytes.
|
|
* @throws IOException
|
|
*/
|
|
public byte[] getBodyAsBytes()
|
|
{
|
|
return this.bodyAsBytes;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return true if the body is already stored as bytes
|
|
*/
|
|
public bool isBodyConvertedToBytes()
|
|
{
|
|
return bodyAsBytes != null;
|
|
}
|
|
|
|
|
|
public void setBodyAsBytes(byte[] data,int offset, int length)
|
|
{
|
|
this.bodyAsBytes = new ByteArray(data);
|
|
}
|
|
|
|
/**
|
|
* set the body as bytes
|
|
* @param ba
|
|
*/
|
|
public void setBodyAsBytes(byte[] ba)
|
|
{
|
|
this.bodyAsBytes = ba;
|
|
}
|
|
|
|
/**
|
|
* write map properties to an output stream
|
|
*
|
|
* @param table
|
|
* @param dataOut
|
|
* @throws IOException
|
|
*/
|
|
|
|
public void writeMapProperties(Hashtable table, Object output)
|
|
{
|
|
//TODO SERIALIZATION MECHANISM
|
|
}
|
|
|
|
/**
|
|
* @param dataIn
|
|
* @return
|
|
* @throws IOException
|
|
*/
|
|
public Hashtable readMapProperties(Object dataIn)
|
|
{
|
|
//TODO serilization stuff
|
|
}
|
|
|
|
/**
|
|
* @return Returns the xaTransacted.
|
|
*/
|
|
public bool isXaTransacted()
|
|
{
|
|
return xaTransacted;
|
|
}
|
|
|
|
/**
|
|
* @return the ActiveMQDestination
|
|
*/
|
|
public ActiveMQDestination getJMSActiveMQDestination()
|
|
{
|
|
return jmsDestination;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Determine if the message originated in the network from the named broker
|
|
* @param brokerName
|
|
* @return true if entry point matches the brokerName
|
|
*/
|
|
public bool isEntryBroker(String brokerName)
|
|
{
|
|
bool result = entryBrokerName != null && brokerName != null && entryBrokerName.equals(brokerName);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Determine if the message originated in the network from the named cluster
|
|
* @param clusterName
|
|
* @return true if the entry point matches the clusterName
|
|
*/
|
|
public bool isEntryCluster(String clusterName)
|
|
{
|
|
bool result = entryClusterName != null && clusterName != null && entryClusterName.equals(clusterName);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the transientConsumed.
|
|
*/
|
|
public bool isTransientConsumed()
|
|
{
|
|
return transientConsumed;
|
|
}
|
|
/**
|
|
* @param transientConsumed The transientConsumed to set.
|
|
*/
|
|
public void setTransientConsumed(bool transientConsumed)
|
|
{
|
|
this.transientConsumed = transientConsumed;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the sequenceNumber.
|
|
*/
|
|
public long getSequenceNumber()
|
|
{
|
|
return sequenceNumber;
|
|
}
|
|
/**
|
|
* @param sequenceNumber The sequenceNumber to set.
|
|
*/
|
|
public void setSequenceNumber(long sequenceNumber)
|
|
{
|
|
this.sequenceNumber = sequenceNumber;
|
|
}
|
|
/**
|
|
* @return Returns the deliveryCount.
|
|
*/
|
|
public int getDeliveryCount()
|
|
{
|
|
return deliveryCount;
|
|
}
|
|
/**
|
|
* @param deliveryCount The deliveredCount to set.
|
|
*/
|
|
public void setDeliveryCount(int deliveryCount)
|
|
{
|
|
this.deliveryCount = deliveryCount;
|
|
}
|
|
|
|
/**
|
|
* Increment the delivery count
|
|
* @return the new value of the delivery count
|
|
*/
|
|
public int incrementDeliveryCount()
|
|
{
|
|
return ++this.deliveryCount;
|
|
}
|
|
|
|
/**
|
|
* @return true if the delivery mode is persistent
|
|
*/
|
|
public bool isPersistent()
|
|
{
|
|
return jmsDeliveryMode == DeliveryMode.PERSISTENT;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the dispatchedFromDLQ.
|
|
*/
|
|
public bool isDispatchedFromDLQ()
|
|
{
|
|
return dispatchedFromDLQ;
|
|
}
|
|
/**
|
|
* @param dispatchedFromDLQ The dispatchedFromDLQ to set.
|
|
*/
|
|
public void setDispatchedFromDLQ(bool dispatchedFromDLQ)
|
|
{
|
|
this.dispatchedFromDLQ = dispatchedFromDLQ;
|
|
}
|
|
|
|
/**
|
|
* @return Returns the messsageHandle.
|
|
*/
|
|
public short getMesssageHandle()
|
|
{
|
|
return messsageHandle;
|
|
}
|
|
/**
|
|
* @param messsageHandle The messsageHandle to set.
|
|
*/
|
|
public void setMesssageHandle(short messsageHandle)
|
|
{
|
|
this.messsageHandle = messsageHandle;
|
|
}
|
|
/**
|
|
* @return Returns the externalMessageId.
|
|
*/
|
|
public bool isExternalMessageId()
|
|
{
|
|
return externalMessageId;
|
|
}
|
|
/**
|
|
* @param externalMessageId The externalMessageId to set.
|
|
*/
|
|
public void setExternalMessageId(bool externalMessageId)
|
|
{
|
|
this.externalMessageId = externalMessageId;
|
|
}
|
|
/**
|
|
* @return Returns the producerKey.
|
|
*/
|
|
public String getProducerKey()
|
|
{
|
|
return producerKey;
|
|
}
|
|
/**
|
|
* @param producerKey The producerKey to set.
|
|
*/
|
|
public void setProducerKey(String producerKey)
|
|
{
|
|
this.producerKey = producerKey;
|
|
}
|
|
|
|
/**
|
|
* reset message fragmentation infomation
|
|
* on this message
|
|
*
|
|
*/
|
|
public void resetMessagePart()
|
|
{
|
|
messagePart = false;
|
|
partNumber = 0;
|
|
parentMessageID = null;
|
|
}
|
|
/**
|
|
* @return Returns the messagePart.
|
|
*/
|
|
public bool isMessagePart()
|
|
{
|
|
return messagePart;
|
|
}
|
|
|
|
/**
|
|
* @return true if this is the last part of a fragmented message
|
|
*/
|
|
public bool isLastMessagePart()
|
|
{
|
|
return numberOfParts -1 == partNumber;
|
|
}
|
|
/**
|
|
* @param messagePart The messagePart to set.
|
|
*/
|
|
public void setMessagePart(bool messagePart)
|
|
{
|
|
this.messagePart = messagePart;
|
|
}
|
|
/**
|
|
* @return Returns the numberOfParts.
|
|
*/
|
|
public short getNumberOfParts()
|
|
{
|
|
return numberOfParts;
|
|
}
|
|
/**
|
|
* @param numberOfParts The numberOfParts to set.
|
|
*/
|
|
public void setNumberOfParts(short numberOfParts)
|
|
{
|
|
this.numberOfParts = numberOfParts;
|
|
}
|
|
/**
|
|
* @return Returns the partNumber.
|
|
*/
|
|
public short getPartNumber()
|
|
{
|
|
return partNumber;
|
|
}
|
|
/**
|
|
* @param partNumber The partNumber to set.
|
|
*/
|
|
public void setPartNumber(short partNumber)
|
|
{
|
|
this.partNumber = partNumber;
|
|
}
|
|
/**
|
|
* @return Returns the parentMessageId.
|
|
*/
|
|
public String getParentMessageID()
|
|
{
|
|
return parentMessageID;
|
|
}
|
|
/**
|
|
* @param parentMessageId The parentMessageId to set.
|
|
*/
|
|
public void setParentMessageID(String parentMessageId)
|
|
{
|
|
this.parentMessageID = parentMessageId;
|
|
}
|
|
}
|
|
}
|