blob: 611f2321fdac77bc2e4dc925b249fc3cd999d060 [file] [log] [blame]
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
// Turn off warning message for ignored exception specification
#ifdef _MSC_VER
#pragma warning( disable : 4290 )
#include <activemq/commands/ActiveMQDestination.h>
#include <activemq/commands/BaseCommand.h>
#include <activemq/commands/BrokerId.h>
#include <activemq/commands/ConsumerId.h>
#include <activemq/commands/DataStructure.h>
#include <activemq/commands/MessageId.h>
#include <activemq/commands/ProducerId.h>
#include <activemq/commands/TransactionId.h>
#include <activemq/core/ActiveMQAckHandler.h>
#include <activemq/util/Config.h>
#include <activemq/util/PrimitiveMap.h>
#include <decaf/lang/Pointer.h>
#include <string>
#include <vector>
namespace activemq{
namespace core{
class ActiveMQAckHandler;
class ActiveMQConnection;
namespace commands{
using decaf::lang::Pointer;
* Command code for OpenWire format for Message
* NOTE!: This file is auto generated - do not modify!
* if you need to make a change, please see the Java Classes
* in the activemq-cpp-openwire-generator module
class AMQCPP_API Message : public BaseCommand {
Pointer<ProducerId> producerId;
Pointer<ActiveMQDestination> destination;
Pointer<TransactionId> transactionId;
Pointer<ActiveMQDestination> originalDestination;
Pointer<MessageId> messageId;
Pointer<TransactionId> originalTransactionId;
std::string groupID;
int groupSequence;
std::string correlationId;
bool persistent;
long long expiration;
unsigned char priority;
Pointer<ActiveMQDestination> replyTo;
long long timestamp;
std::string type;
std::vector<unsigned char> content;
std::vector<unsigned char> marshalledProperties;
Pointer<DataStructure> dataStructure;
Pointer<ConsumerId> targetConsumerId;
bool compressed;
int redeliveryCounter;
std::vector< decaf::lang::Pointer<BrokerId> > brokerPath;
long long arrival;
std::string userID;
bool recievedByDFBridge;
bool droppable;
std::vector< decaf::lang::Pointer<BrokerId> > cluster;
long long brokerInTime;
long long brokerOutTime;
bool jMSXGroupFirstForConsumer;
const static unsigned char ID_MESSAGE = 0;
// Used to allow a client to call Message::acknowledge when in the Client
// Ack mode.
Pointer<core::ActiveMQAckHandler> ackHandler;
// Message properties, these are Marshaled and Unmarshaled from the Message
// Command's marshaledProperties vector.
activemq::util::PrimitiveMap properties;
// Indicates if the Message Properties are Read Only
bool readOnlyProperties;
// Indicates if the Message Body are Read Only
bool readOnlyBody;
core::ActiveMQConnection* connection;
static const unsigned int DEFAULT_MESSAGE_SIZE = 1024;
Message(const Message&);
Message& operator= (const Message&);
virtual ~Message();
virtual unsigned char getDataStructureType() const;
virtual Message* cloneDataStructure() const;
virtual void copyDataStructure(const DataStructure* src);
virtual std::string toString() const;
virtual bool equals(const DataStructure* value) const;
* Create a Pointer based copy of this message. Useful for chaining a clone
* operation with other operation such as casting to a cms Message type.
* Pointer<cms::Message> cmsMsg = message->copy().dynamic_cast<cms::Message>();
* @return a Pointer<Message> which is a duplicate of this object.
Pointer<Message> copy() const {
return Pointer<Message>(this->cloneDataStructure());
* Handles the marshaling of the objects properties into the
* internal byte array before the object is marshaled to the
* wire
* @param wireFormat - the wireformat controller
virtual void beforeMarshal(wireformat::WireFormat* wireFormat AMQCPP_UNUSED);
* Called after unmarshaling is started to cleanup the object being
* unmarshaled.
* @param wireFormat - the wireformat object to control unmarshaling
virtual void afterUnmarshal(wireformat::WireFormat* wireFormat AMQCPP_UNUSED);
* Indicates that this command is aware of Marshaling, and needs
* to have its Marshaling methods invoked.
* @return boolean indicating desire to be in marshaling stages
virtual bool isMarshalAware() const {
return true;
* Sets the Acknowledgment Handler that this Message will use
* when the Acknowledge method is called.
* @param handler ActiveMQAckHandler to call
virtual void setAckHandler(const Pointer<core::ActiveMQAckHandler>& handler) {
this->ackHandler = handler;
* Gets the Acknowledgment Handler that this Message will use
* when the Acknowledge method is called.
* @return handler ActiveMQAckHandler to call or NULL if not set
virtual Pointer<core::ActiveMQAckHandler> getAckHandler() const {
return this->ackHandler;
* Sets the ActiveMQConnection instance that this Command was created from
* when the session create methods are called to create a Message..
* @param handler ActiveMQConnection parent for this message
void setConnection(core::ActiveMQConnection* connection) {
this->connection = connection;
* Gets the ActiveMQConnection instance that this Command was created from
* when the session create methods are called to create a Message..
* @return the ActiveMQConnection parent for this Message or NULL if not set.
core::ActiveMQConnection* getConnection() const {
return this->connection;
* Returns the Size of this message in Bytes.
* @return number of bytes this message equates to.
virtual unsigned int getSize() const;
* Returns if this message has expired, meaning that its
* Expiration time has elapsed.
* @return true if message is expired.
virtual bool isExpired() const;
* Allows derived Message classes to perform tasks before a message is sent.
virtual void onSend() {}
* Gets a reference to the Message's Properties object, allows the derived
* classes to get and set their own specific properties.
* @return a reference to the Primitive Map that holds message properties.
util::PrimitiveMap& getMessageProperties() {
return this->properties;
const util::PrimitiveMap& getMessageProperties() const {
return this->properties;
* Returns if the Message Properties Are Read Only
* @return true if Message Properties are Read Only.
bool isReadOnlyProperties() const {
return this->readOnlyProperties;
* Set the Read Only State of the Message Properties.
* @param value - true if Properties should be read only.
void setReadOnlyProperties(bool value) {
this->readOnlyProperties = value;
* Returns if the Message Body is Read Only
* @return true if Message Content is Read Only.
bool isReadOnlyBody() const {
return this->readOnlyBody;
* Set the Read Only State of the Message Content.
* @param value - true if Content should be read only.
void setReadOnlyBody(bool value) {
this->readOnlyBody = value;
virtual const Pointer<ProducerId>& getProducerId() const;
virtual Pointer<ProducerId>& getProducerId();
virtual void setProducerId(const Pointer<ProducerId>& producerId);
virtual const Pointer<ActiveMQDestination>& getDestination() const;
virtual Pointer<ActiveMQDestination>& getDestination();
virtual void setDestination(const Pointer<ActiveMQDestination>& destination);
virtual const Pointer<TransactionId>& getTransactionId() const;
virtual Pointer<TransactionId>& getTransactionId();
virtual void setTransactionId(const Pointer<TransactionId>& transactionId);
virtual const Pointer<ActiveMQDestination>& getOriginalDestination() const;
virtual Pointer<ActiveMQDestination>& getOriginalDestination();
virtual void setOriginalDestination(const Pointer<ActiveMQDestination>& originalDestination);
virtual const Pointer<MessageId>& getMessageId() const;
virtual Pointer<MessageId>& getMessageId();
virtual void setMessageId(const Pointer<MessageId>& messageId);
virtual const Pointer<TransactionId>& getOriginalTransactionId() const;
virtual Pointer<TransactionId>& getOriginalTransactionId();
virtual void setOriginalTransactionId(const Pointer<TransactionId>& originalTransactionId);
virtual const std::string& getGroupID() const;
virtual std::string& getGroupID();
virtual void setGroupID(const std::string& groupID);
virtual int getGroupSequence() const;
virtual void setGroupSequence(int groupSequence);
virtual const std::string& getCorrelationId() const;
virtual std::string& getCorrelationId();
virtual void setCorrelationId(const std::string& correlationId);
virtual bool isPersistent() const;
virtual void setPersistent(bool persistent);
virtual long long getExpiration() const;
virtual void setExpiration(long long expiration);
virtual unsigned char getPriority() const;
virtual void setPriority(unsigned char priority);
virtual const Pointer<ActiveMQDestination>& getReplyTo() const;
virtual Pointer<ActiveMQDestination>& getReplyTo();
virtual void setReplyTo(const Pointer<ActiveMQDestination>& replyTo);
virtual long long getTimestamp() const;
virtual void setTimestamp(long long timestamp);
virtual const std::string& getType() const;
virtual std::string& getType();
virtual void setType(const std::string& type);
virtual const std::vector<unsigned char>& getContent() const;
virtual std::vector<unsigned char>& getContent();
virtual void setContent(const std::vector<unsigned char>& content);
virtual const std::vector<unsigned char>& getMarshalledProperties() const;
virtual std::vector<unsigned char>& getMarshalledProperties();
virtual void setMarshalledProperties(const std::vector<unsigned char>& marshalledProperties);
virtual const Pointer<DataStructure>& getDataStructure() const;
virtual Pointer<DataStructure>& getDataStructure();
virtual void setDataStructure(const Pointer<DataStructure>& dataStructure);
virtual const Pointer<ConsumerId>& getTargetConsumerId() const;
virtual Pointer<ConsumerId>& getTargetConsumerId();
virtual void setTargetConsumerId(const Pointer<ConsumerId>& targetConsumerId);
virtual bool isCompressed() const;
virtual void setCompressed(bool compressed);
virtual int getRedeliveryCounter() const;
virtual void setRedeliveryCounter(int redeliveryCounter);
virtual const std::vector< decaf::lang::Pointer<BrokerId> >& getBrokerPath() const;
virtual std::vector< decaf::lang::Pointer<BrokerId> >& getBrokerPath();
virtual void setBrokerPath(const std::vector< decaf::lang::Pointer<BrokerId> >& brokerPath);
virtual long long getArrival() const;
virtual void setArrival(long long arrival);
virtual const std::string& getUserID() const;
virtual std::string& getUserID();
virtual void setUserID(const std::string& userID);
virtual bool isRecievedByDFBridge() const;
virtual void setRecievedByDFBridge(bool recievedByDFBridge);
virtual bool isDroppable() const;
virtual void setDroppable(bool droppable);
virtual const std::vector< decaf::lang::Pointer<BrokerId> >& getCluster() const;
virtual std::vector< decaf::lang::Pointer<BrokerId> >& getCluster();
virtual void setCluster(const std::vector< decaf::lang::Pointer<BrokerId> >& cluster);
virtual long long getBrokerInTime() const;
virtual void setBrokerInTime(long long brokerInTime);
virtual long long getBrokerOutTime() const;
virtual void setBrokerOutTime(long long brokerOutTime);
virtual bool isJMSXGroupFirstForConsumer() const;
virtual void setJMSXGroupFirstForConsumer(bool jMSXGroupFirstForConsumer);
* @return an answer of true to the isMessage() query.
virtual bool isMessage() const {
return true;
virtual Pointer<Command> visit(activemq::state::CommandVisitor* visitor);