activemq/openwire-dotnet/comms-library/amqnet/ActiveMQMessage.cs

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;
}
}
}