Apache
/
activemq
mirror of https://github.com/apache/activemq.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Applied modified generated code using Mats latest patch for the generator 

git-svn-id: https://svn.apache.org/repos/asf/incubator/activemq/trunk@382103 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
James Strachan 2006-03-01 17:52:38 +00:00
parent 283549bae6
commit 9efa4e6e68
75 changed files with 607 additions and 714 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
openwire-cpp/src/command/ActiveMQObjectMessage.hpp
View File

@ -18,16 +18,10 @@
#define ActiveMQObjectMessage_hpp_ #define ActiveMQObjectMessage_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/ActiveMQMessage.hpp" #include "command/ActiveMQMessage.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -62,6 +57,7 @@ public:
ActiveMQObjectMessage() ; ActiveMQObjectMessage() ;
virtual ~ActiveMQObjectMessage() ; virtual ~ActiveMQObjectMessage() ;
virtual int getCommandType() ;
} ; } ;

2
openwire-cpp/src/command/BrokerId.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
BrokerId::BrokerId() BrokerId::BrokerId()
{ {
this->value = NULL ; this->value = 0 ;
} }
BrokerId::~BrokerId() BrokerId::~BrokerId()

14
openwire-cpp/src/command/BrokerId.hpp
View File

@ -18,16 +18,10 @@
#define BrokerId_hpp_ #define BrokerId_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -63,6 +58,7 @@ public:
BrokerId() ; BrokerId() ;
virtual ~BrokerId() ; virtual ~BrokerId() ;
virtual int getCommandType() ;
virtual p<string> getValue() ; virtual p<string> getValue() ;
virtual void setValue(p<string> value) ; virtual void setValue(p<string> value) ;

14
openwire-cpp/src/command/BrokerInfo.cpp
View File

@ -30,11 +30,11 @@ using namespace apache::activemq::client::command;
*/ */
BrokerInfo::BrokerInfo() BrokerInfo::BrokerInfo()
{ {
this->brokerId = NULL ; this->brokerId = 0 ;
this->brokerURL = NULL ; this->brokerURL = 0 ;
this->peerBrokerInfos = NULL ; this->peerBrokerInfos = 0 ;
this->brokerName = NULL ; this->brokerName = 0 ;
this->slaveBroker = NULL ; this->slaveBroker = 0 ;
} }
BrokerInfo::~BrokerInfo() BrokerInfo::~BrokerInfo()
@ -64,12 +64,12 @@ void BrokerInfo::setBrokerURL(p<string> brokerURL)
} }
BrokerInfo[] BrokerInfo::getPeerBrokerInfos() ap<BrokerInfo> BrokerInfo::getPeerBrokerInfos()
{ {
return peerBrokerInfos ; return peerBrokerInfos ;
} }
void BrokerInfo::setPeerBrokerInfos(BrokerInfo[] peerBrokerInfos) void BrokerInfo::setPeerBrokerInfos(ap<BrokerInfo> peerBrokerInfos)
{ {
this->peerBrokerInfos = peerBrokerInfos ; this->peerBrokerInfos = peerBrokerInfos ;
} }

18
openwire-cpp/src/command/BrokerInfo.hpp
View File

@ -18,16 +18,12 @@
#define BrokerInfo_hpp_ #define BrokerInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp" #include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp" #include "command/BrokerInfo.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +35,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -56,7 +53,7 @@ class BrokerInfo : public BaseCommand
private: private:
p<BrokerId> brokerId ; p<BrokerId> brokerId ;
p<string> brokerURL ; p<string> brokerURL ;
BrokerInfo[] peerBrokerInfos ; ap<BrokerInfo> peerBrokerInfos ;
p<string> brokerName ; p<string> brokerName ;
bool slaveBroker ; bool slaveBroker ;
@ -67,6 +64,7 @@ public:
BrokerInfo() ; BrokerInfo() ;
virtual ~BrokerInfo() ; virtual ~BrokerInfo() ;
virtual int getCommandType() ;
virtual p<BrokerId> getBrokerId() ; virtual p<BrokerId> getBrokerId() ;
virtual void setBrokerId(p<BrokerId> brokerId) ; virtual void setBrokerId(p<BrokerId> brokerId) ;
@ -74,8 +72,8 @@ public:
virtual p<string> getBrokerURL() ; virtual p<string> getBrokerURL() ;
virtual void setBrokerURL(p<string> brokerURL) ; virtual void setBrokerURL(p<string> brokerURL) ;
virtual BrokerInfo[] getPeerBrokerInfos() ; virtual ap<BrokerInfo> getPeerBrokerInfos() ;
virtual void setPeerBrokerInfos(BrokerInfo[] peerBrokerInfos) ; virtual void setPeerBrokerInfos(ap<BrokerInfo> peerBrokerInfos) ;
virtual p<string> getBrokerName() ; virtual p<string> getBrokerName() ;
virtual void setBrokerName(p<string> brokerName) ; virtual void setBrokerName(p<string> brokerName) ;

8
openwire-cpp/src/command/ConnectionError.cpp
View File

@ -30,8 +30,8 @@ using namespace apache::activemq::client::command;
*/ */
ConnectionError::ConnectionError() ConnectionError::ConnectionError()
{ {
this->exception = NULL ; this->exception = 0 ;
this->connectionId = NULL ; this->connectionId = 0 ;
} }
ConnectionError::~ConnectionError() ConnectionError::~ConnectionError()
@ -39,12 +39,12 @@ ConnectionError::~ConnectionError()
} }
BrokerError ConnectionError::getException() p<BrokerError> ConnectionError::getException()
{ {
return exception ; return exception ;
} }
void ConnectionError::setException(BrokerError exception) void ConnectionError::setException(p<BrokerError> exception)
{ {
this->exception = exception ; this->exception = exception ;
} }

18
openwire-cpp/src/command/ConnectionError.hpp
View File

@ -18,16 +18,12 @@
#define ConnectionError_hpp_ #define ConnectionError_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "BrokerError.hpp"
#include "command/ConnectionId.hpp" #include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +35,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,7 +51,7 @@ namespace apache
class ConnectionError : public BaseCommand class ConnectionError : public BaseCommand
{ {
private: private:
BrokerError exception ; p<BrokerError> exception ;
p<ConnectionId> connectionId ; p<ConnectionId> connectionId ;
public: public:
@ -64,9 +61,10 @@ public:
ConnectionError() ; ConnectionError() ;
virtual ~ConnectionError() ; virtual ~ConnectionError() ;
virtual int getCommandType() ;
virtual BrokerError getException() ; virtual p<BrokerError> getException() ;
virtual void setException(BrokerError exception) ; virtual void setException(p<BrokerError> exception) ;
virtual p<ConnectionId> getConnectionId() ; virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ; virtual void setConnectionId(p<ConnectionId> connectionId) ;

2
openwire-cpp/src/command/ConnectionId.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
ConnectionId::ConnectionId() ConnectionId::ConnectionId()
{ {
this->value = NULL ; this->value = 0 ;
} }
ConnectionId::~ConnectionId() ConnectionId::~ConnectionId()

14
openwire-cpp/src/command/ConnectionId.hpp
View File

@ -18,16 +18,10 @@
#define ConnectionId_hpp_ #define ConnectionId_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -63,6 +58,7 @@ public:
ConnectionId() ; ConnectionId() ;
virtual ~ConnectionId() ; virtual ~ConnectionId() ;
virtual int getCommandType() ;
virtual p<string> getValue() ; virtual p<string> getValue() ;
virtual void setValue(p<string> value) ; virtual void setValue(p<string> value) ;

14
openwire-cpp/src/command/ConnectionInfo.cpp
View File

@ -30,11 +30,11 @@ using namespace apache::activemq::client::command;
*/ */
ConnectionInfo::ConnectionInfo() ConnectionInfo::ConnectionInfo()
{ {
this->connectionId = NULL ; this->connectionId = 0 ;
this->clientId = NULL ; this->clientId = 0 ;
this->password = NULL ; this->password = 0 ;
this->userName = NULL ; this->userName = 0 ;
this->brokerPath = NULL ; this->brokerPath = 0 ;
} }
ConnectionInfo::~ConnectionInfo() ConnectionInfo::~ConnectionInfo()
@ -86,12 +86,12 @@ void ConnectionInfo::setUserName(p<string> userName)
} }
BrokerId[] ConnectionInfo::getBrokerPath() ap<BrokerId> ConnectionInfo::getBrokerPath()
{ {
return brokerPath ; return brokerPath ;
} }
void ConnectionInfo::setBrokerPath(BrokerId[] brokerPath) void ConnectionInfo::setBrokerPath(ap<BrokerId> brokerPath)
{ {
this->brokerPath = brokerPath ; this->brokerPath = brokerPath ;
} }

18
openwire-cpp/src/command/ConnectionInfo.hpp
View File

@ -18,16 +18,12 @@
#define ConnectionInfo_hpp_ #define ConnectionInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp" #include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp" #include "command/BrokerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +35,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -58,7 +55,7 @@ private:
p<string> clientId ; p<string> clientId ;
p<string> password ; p<string> password ;
p<string> userName ; p<string> userName ;
BrokerId[] brokerPath ; ap<BrokerId> brokerPath ;
public: public:
const static int TYPE = 3; const static int TYPE = 3;
@ -67,6 +64,7 @@ public:
ConnectionInfo() ; ConnectionInfo() ;
virtual ~ConnectionInfo() ; virtual ~ConnectionInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ; virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ; virtual void setConnectionId(p<ConnectionId> connectionId) ;
@ -80,8 +78,8 @@ public:
virtual p<string> getUserName() ; virtual p<string> getUserName() ;
virtual void setUserName(p<string> userName) ; virtual void setUserName(p<string> userName) ;
virtual BrokerId[] getBrokerPath() ; virtual ap<BrokerId> getBrokerPath() ;
virtual void setBrokerPath(BrokerId[] brokerPath) ; virtual void setBrokerPath(ap<BrokerId> brokerPath) ;
} ; } ;

14
openwire-cpp/src/command/ConsumerId.cpp
View File

@ -30,9 +30,9 @@ using namespace apache::activemq::client::command;
*/ */
ConsumerId::ConsumerId() ConsumerId::ConsumerId()
{ {
this->connectionId = NULL ; this->connectionId = 0 ;
this->sessionId = NULL ; this->sessionId = 0 ;
this->value = NULL ; this->value = 0 ;
} }
ConsumerId::~ConsumerId() ConsumerId::~ConsumerId()
@ -51,23 +51,23 @@ void ConsumerId::setConnectionId(p<string> connectionId)
} }
long ConsumerId::getSessionId() long long ConsumerId::getSessionId()
{ {
return sessionId ; return sessionId ;
} }
void ConsumerId::setSessionId(long sessionId) void ConsumerId::setSessionId(long long sessionId)
{ {
this->sessionId = sessionId ; this->sessionId = sessionId ;
} }
long ConsumerId::getValue() long long ConsumerId::getValue()
{ {
return value ; return value ;
} }
void ConsumerId::setValue(long value) void ConsumerId::setValue(long long value)
{ {
this->value = value ; this->value = value ;
} }

26
openwire-cpp/src/command/ConsumerId.hpp
View File

@ -18,16 +18,10 @@
#define ConsumerId_hpp_ #define ConsumerId_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,8 +50,8 @@ class ConsumerId : public AbstractCommand
{ {
private: private:
p<string> connectionId ; p<string> connectionId ;
long sessionId ; long long sessionId ;
long value ; long long value ;
public: public:
const static int TYPE = 122; const static int TYPE = 122;
@ -65,15 +60,16 @@ public:
ConsumerId() ; ConsumerId() ;
virtual ~ConsumerId() ; virtual ~ConsumerId() ;
virtual int getCommandType() ;
virtual p<string> getConnectionId() ; virtual p<string> getConnectionId() ;
virtual void setConnectionId(p<string> connectionId) ; virtual void setConnectionId(p<string> connectionId) ;
virtual long getSessionId() ; virtual long long getSessionId() ;
virtual void setSessionId(long sessionId) ; virtual void setSessionId(long long sessionId) ;
virtual long getValue() ; virtual long long getValue() ;
virtual void setValue(long value) ; virtual void setValue(long long value) ;
} ; } ;

38
openwire-cpp/src/command/ConsumerInfo.cpp
View File

@ -30,19 +30,19 @@ using namespace apache::activemq::client::command;
*/ */
ConsumerInfo::ConsumerInfo() ConsumerInfo::ConsumerInfo()
{ {
this->consumerId = NULL ; this->consumerId = 0 ;
this->browser = NULL ; this->browser = 0 ;
this->destination = NULL ; this->destination = 0 ;
this->prefetchSize = NULL ; this->prefetchSize = 0 ;
this->dispatchAsync = NULL ; this->dispatchAsync = 0 ;
this->selector = NULL ; this->selector = 0 ;
this->subcriptionName = NULL ; this->subcriptionName = 0 ;
this->noLocal = NULL ; this->noLocal = 0 ;
this->exclusive = NULL ; this->exclusive = 0 ;
this->retroactive = NULL ; this->retroactive = 0 ;
this->priority = NULL ; this->priority = 0 ;
this->brokerPath = NULL ; this->brokerPath = 0 ;
this->networkSubscription = NULL ; this->networkSubscription = 0 ;
} }
ConsumerInfo::~ConsumerInfo() ConsumerInfo::~ConsumerInfo()
@ -72,12 +72,12 @@ void ConsumerInfo::setBrowser(bool browser)
} }
ActiveMQDestination ConsumerInfo::getDestination() p<ActiveMQDestination> ConsumerInfo::getDestination()
{ {
return destination ; return destination ;
} }
void ConsumerInfo::setDestination(ActiveMQDestination destination) void ConsumerInfo::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }
@ -160,23 +160,23 @@ void ConsumerInfo::setRetroactive(bool retroactive)
} }
byte ConsumerInfo::getPriority() char ConsumerInfo::getPriority()
{ {
return priority ; return priority ;
} }
void ConsumerInfo::setPriority(byte priority) void ConsumerInfo::setPriority(char priority)
{ {
this->priority = priority ; this->priority = priority ;
} }
BrokerId[] ConsumerInfo::getBrokerPath() ap<BrokerId> ConsumerInfo::getBrokerPath()
{ {
return brokerPath ; return brokerPath ;
} }
void ConsumerInfo::setBrokerPath(BrokerId[] brokerPath) void ConsumerInfo::setBrokerPath(ap<BrokerId> brokerPath)
{ {
this->brokerPath = brokerPath ; this->brokerPath = brokerPath ;
} }

31
openwire-cpp/src/command/ConsumerInfo.hpp
View File

@ -18,16 +18,13 @@
#define ConsumerInfo_hpp_ #define ConsumerInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp" #include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp" #include "command/ActiveMQDestination.hpp"
#include "command/SessionId.hpp" #include "command/BrokerId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -56,7 +54,7 @@ class ConsumerInfo : public BaseCommand
private: private:
p<ConsumerId> consumerId ; p<ConsumerId> consumerId ;
bool browser ; bool browser ;
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
int prefetchSize ; int prefetchSize ;
bool dispatchAsync ; bool dispatchAsync ;
p<string> selector ; p<string> selector ;
@ -64,8 +62,8 @@ private:
bool noLocal ; bool noLocal ;
bool exclusive ; bool exclusive ;
bool retroactive ; bool retroactive ;
byte priority ; char priority ;
BrokerId[] brokerPath ; ap<BrokerId> brokerPath ;
bool networkSubscription ; bool networkSubscription ;
public: public:
@ -75,6 +73,7 @@ public:
ConsumerInfo() ; ConsumerInfo() ;
virtual ~ConsumerInfo() ; virtual ~ConsumerInfo() ;
virtual int getCommandType() ;
virtual p<ConsumerId> getConsumerId() ; virtual p<ConsumerId> getConsumerId() ;
virtual void setConsumerId(p<ConsumerId> consumerId) ; virtual void setConsumerId(p<ConsumerId> consumerId) ;
@ -82,8 +81,8 @@ public:
virtual bool getBrowser() ; virtual bool getBrowser() ;
virtual void setBrowser(bool browser) ; virtual void setBrowser(bool browser) ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual int getPrefetchSize() ; virtual int getPrefetchSize() ;
virtual void setPrefetchSize(int prefetchSize) ; virtual void setPrefetchSize(int prefetchSize) ;
@ -106,11 +105,11 @@ public:
virtual bool getRetroactive() ; virtual bool getRetroactive() ;
virtual void setRetroactive(bool retroactive) ; virtual void setRetroactive(bool retroactive) ;
virtual byte getPriority() ; virtual char getPriority() ;
virtual void setPriority(byte priority) ; virtual void setPriority(char priority) ;
virtual BrokerId[] getBrokerPath() ; virtual ap<BrokerId> getBrokerPath() ;
virtual void setBrokerPath(BrokerId[] brokerPath) ; virtual void setBrokerPath(ap<BrokerId> brokerPath) ;
virtual bool getNetworkSubscription() ; virtual bool getNetworkSubscription() ;
virtual void setNetworkSubscription(bool networkSubscription) ; virtual void setNetworkSubscription(bool networkSubscription) ;

2
openwire-cpp/src/command/ControlCommand.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
ControlCommand::ControlCommand() ControlCommand::ControlCommand()
{ {
this->command = NULL ; this->command = 0 ;
} }
ControlCommand::~ControlCommand() ControlCommand::~ControlCommand()

12
openwire-cpp/src/command/ControlCommand.hpp
View File

@ -18,16 +18,10 @@
#define ControlCommand_hpp_ #define ControlCommand_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -63,6 +58,7 @@ public:
ControlCommand() ; ControlCommand() ;
virtual ~ControlCommand() ; virtual ~ControlCommand() ;
virtual int getCommandType() ;
virtual p<string> getCommand() ; virtual p<string> getCommand() ;
virtual void setCommand(p<string> command) ; virtual void setCommand(p<string> command) ;

6
openwire-cpp/src/command/DataArrayResponse.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
DataArrayResponse::DataArrayResponse() DataArrayResponse::DataArrayResponse()
{ {
this->data = NULL ; this->data = 0 ;
} }
DataArrayResponse::~DataArrayResponse() DataArrayResponse::~DataArrayResponse()
@ -38,12 +38,12 @@ DataArrayResponse::~DataArrayResponse()
} }
DataStructure[] DataArrayResponse::getData() ap<IDataStructure> DataArrayResponse::getData()
{ {
return data ; return data ;
} }
void DataArrayResponse::setData(DataStructure[] data) void DataArrayResponse::setData(ap<IDataStructure> data)
{ {
this->data = data ; this->data = data ;
} }

21
openwire-cpp/src/command/DataArrayResponse.hpp
View File

@ -18,16 +18,11 @@
#define DataArrayResponse_hpp_ #define DataArrayResponse_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/Response.hpp" #include "command/Response.hpp"
#include "command/IDataStructure.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,7 +50,7 @@ namespace apache
class DataArrayResponse : public Response class DataArrayResponse : public Response
{ {
private: private:
DataStructure[] data ; ap<IDataStructure> data ;
public: public:
const static int TYPE = 33; const static int TYPE = 33;
@ -63,9 +59,10 @@ public:
DataArrayResponse() ; DataArrayResponse() ;
virtual ~DataArrayResponse() ; virtual ~DataArrayResponse() ;
virtual int getCommandType() ;
virtual DataStructure[] getData() ; virtual ap<IDataStructure> getData() ;
virtual void setData(DataStructure[] data) ; virtual void setData(ap<IDataStructure> data) ;
} ; } ;

6
openwire-cpp/src/command/DataResponse.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
DataResponse::DataResponse() DataResponse::DataResponse()
{ {
this->data = NULL ; this->data = 0 ;
} }
DataResponse::~DataResponse() DataResponse::~DataResponse()
@ -38,12 +38,12 @@ DataResponse::~DataResponse()
} }
DataStructure DataResponse::getData() p<IDataStructure> DataResponse::getData()
{ {
return data ; return data ;
} }
void DataResponse::setData(DataStructure data) void DataResponse::setData(p<IDataStructure> data)
{ {
this->data = data ; this->data = data ;
} }

21
openwire-cpp/src/command/DataResponse.hpp
View File

@ -18,16 +18,11 @@
#define DataResponse_hpp_ #define DataResponse_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/Response.hpp" #include "command/Response.hpp"
#include "command/IDataStructure.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,7 +50,7 @@ namespace apache
class DataResponse : public Response class DataResponse : public Response
{ {
private: private:
DataStructure data ; p<IDataStructure> data ;
public: public:
const static int TYPE = 32; const static int TYPE = 32;
@ -63,9 +59,10 @@ public:
DataResponse() ; DataResponse() ;
virtual ~DataResponse() ; virtual ~DataResponse() ;
virtual int getCommandType() ;
virtual DataStructure getData() ; virtual p<IDataStructure> getData() ;
virtual void setData(DataStructure data) ; virtual void setData(p<IDataStructure> data) ;
} ; } ;

26
openwire-cpp/src/command/DestinationInfo.cpp
View File

@ -30,11 +30,11 @@ using namespace apache::activemq::client::command;
*/ */
DestinationInfo::DestinationInfo() DestinationInfo::DestinationInfo()
{ {
this->connectionId = NULL ; this->connectionId = 0 ;
this->destination = NULL ; this->destination = 0 ;
this->operationType = NULL ; this->operationType = 0 ;
this->timeout = NULL ; this->timeout = 0 ;
this->brokerPath = NULL ; this->brokerPath = 0 ;
} }
DestinationInfo::~DestinationInfo() DestinationInfo::~DestinationInfo()
@ -53,45 +53,45 @@ void DestinationInfo::setConnectionId(p<ConnectionId> connectionId)
} }
ActiveMQDestination DestinationInfo::getDestination() p<ActiveMQDestination> DestinationInfo::getDestination()
{ {
return destination ; return destination ;
} }
void DestinationInfo::setDestination(ActiveMQDestination destination) void DestinationInfo::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }
byte DestinationInfo::getOperationType() char DestinationInfo::getOperationType()
{ {
return operationType ; return operationType ;
} }
void DestinationInfo::setOperationType(byte operationType) void DestinationInfo::setOperationType(char operationType)
{ {
this->operationType = operationType ; this->operationType = operationType ;
} }
long DestinationInfo::getTimeout() long long DestinationInfo::getTimeout()
{ {
return timeout ; return timeout ;
} }
void DestinationInfo::setTimeout(long timeout) void DestinationInfo::setTimeout(long long timeout)
{ {
this->timeout = timeout ; this->timeout = timeout ;
} }
BrokerId[] DestinationInfo::getBrokerPath() ap<BrokerId> DestinationInfo::getBrokerPath()
{ {
return brokerPath ; return brokerPath ;
} }
void DestinationInfo::setBrokerPath(BrokerId[] brokerPath) void DestinationInfo::setBrokerPath(ap<BrokerId> brokerPath)
{ {
this->brokerPath = brokerPath ; this->brokerPath = brokerPath ;
} }

37
openwire-cpp/src/command/DestinationInfo.hpp
View File

@ -18,16 +18,13 @@
#define DestinationInfo_hpp_ #define DestinationInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp" #include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp" #include "command/ActiveMQDestination.hpp"
#include "command/ProducerId.hpp" #include "command/BrokerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,10 +53,10 @@ class DestinationInfo : public BaseCommand
{ {
private: private:
p<ConnectionId> connectionId ; p<ConnectionId> connectionId ;
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
byte operationType ; char operationType ;
long timeout ; long long timeout ;
BrokerId[] brokerPath ; ap<BrokerId> brokerPath ;
public: public:
const static int TYPE = 8; const static int TYPE = 8;
@ -67,21 +65,22 @@ public:
DestinationInfo() ; DestinationInfo() ;
virtual ~DestinationInfo() ; virtual ~DestinationInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ; virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ; virtual void setConnectionId(p<ConnectionId> connectionId) ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual byte getOperationType() ; virtual char getOperationType() ;
virtual void setOperationType(byte operationType) ; virtual void setOperationType(char operationType) ;
virtual long getTimeout() ; virtual long long getTimeout() ;
virtual void setTimeout(long timeout) ; virtual void setTimeout(long long timeout) ;
virtual BrokerId[] getBrokerPath() ; virtual ap<BrokerId> getBrokerPath() ;
virtual void setBrokerPath(BrokerId[] brokerPath) ; virtual void setBrokerPath(ap<BrokerId> brokerPath) ;
} ; } ;

4
openwire-cpp/src/command/DiscoveryEvent.cpp
View File

@ -30,8 +30,8 @@ using namespace apache::activemq::client::command;
*/ */
DiscoveryEvent::DiscoveryEvent() DiscoveryEvent::DiscoveryEvent()
{ {
this->serviceName = NULL ; this->serviceName = 0 ;
this->brokerName = NULL ; this->brokerName = 0 ;
} }
DiscoveryEvent::~DiscoveryEvent() DiscoveryEvent::~DiscoveryEvent()

14
openwire-cpp/src/command/DiscoveryEvent.hpp
View File

@ -18,16 +18,10 @@
#define DiscoveryEvent_hpp_ #define DiscoveryEvent_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -64,6 +59,7 @@ public:
DiscoveryEvent() ; DiscoveryEvent() ;
virtual ~DiscoveryEvent() ; virtual ~DiscoveryEvent() ;
virtual int getCommandType() ;
virtual p<string> getServiceName() ; virtual p<string> getServiceName() ;
virtual void setServiceName(p<string> serviceName) ; virtual void setServiceName(p<string> serviceName) ;

6
openwire-cpp/src/command/ExceptionResponse.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
ExceptionResponse::ExceptionResponse() ExceptionResponse::ExceptionResponse()
{ {
this->exception = NULL ; this->exception = 0 ;
} }
ExceptionResponse::~ExceptionResponse() ExceptionResponse::~ExceptionResponse()
@ -38,12 +38,12 @@ ExceptionResponse::~ExceptionResponse()
} }
BrokerError ExceptionResponse::getException() p<BrokerError> ExceptionResponse::getException()
{ {
return exception ; return exception ;
} }
void ExceptionResponse::setException(BrokerError exception) void ExceptionResponse::setException(p<BrokerError> exception)
{ {
this->exception = exception ; this->exception = exception ;
} }

21
openwire-cpp/src/command/ExceptionResponse.hpp
View File

@ -18,16 +18,11 @@
#define ExceptionResponse_hpp_ #define ExceptionResponse_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/Response.hpp" #include "command/Response.hpp"
#include "BrokerError.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,7 +50,7 @@ namespace apache
class ExceptionResponse : public Response class ExceptionResponse : public Response
{ {
private: private:
BrokerError exception ; p<BrokerError> exception ;
public: public:
const static int TYPE = 31; const static int TYPE = 31;
@ -63,9 +59,10 @@ public:
ExceptionResponse() ; ExceptionResponse() ;
virtual ~ExceptionResponse() ; virtual ~ExceptionResponse() ;
virtual int getCommandType() ;
virtual BrokerError getException() ; virtual p<BrokerError> getException() ;
virtual void setException(BrokerError exception) ; virtual void setException(p<BrokerError> exception) ;
} ; } ;

12
openwire-cpp/src/command/FlushCommand.hpp
View File

@ -18,16 +18,10 @@
#define FlushCommand_hpp_ #define FlushCommand_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -62,6 +57,7 @@ public:
FlushCommand() ; FlushCommand() ;
virtual ~FlushCommand() ; virtual ~FlushCommand() ;
virtual int getCommandType() ;
} ; } ;

2
openwire-cpp/src/command/IntegerResponse.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
IntegerResponse::IntegerResponse() IntegerResponse::IntegerResponse()
{ {
this->result = NULL ; this->result = 0 ;
} }
IntegerResponse::~IntegerResponse() IntegerResponse::~IntegerResponse()

14
openwire-cpp/src/command/IntegerResponse.hpp
View File

@ -18,16 +18,10 @@
#define IntegerResponse_hpp_ #define IntegerResponse_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/Response.hpp" #include "command/Response.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -63,6 +58,7 @@ public:
IntegerResponse() ; IntegerResponse() ;
virtual ~IntegerResponse() ; virtual ~IntegerResponse() ;
virtual int getCommandType() ;
virtual int getResult() ; virtual int getResult() ;
virtual void setResult(int result) ; virtual void setResult(int result) ;

12
openwire-cpp/src/command/JournalQueueAck.cpp
View File

@ -30,8 +30,8 @@ using namespace apache::activemq::client::command;
*/ */
JournalQueueAck::JournalQueueAck() JournalQueueAck::JournalQueueAck()
{ {
this->destination = NULL ; this->destination = 0 ;
this->messageAck = NULL ; this->messageAck = 0 ;
} }
JournalQueueAck::~JournalQueueAck() JournalQueueAck::~JournalQueueAck()
@ -39,23 +39,23 @@ JournalQueueAck::~JournalQueueAck()
} }
ActiveMQDestination JournalQueueAck::getDestination() p<ActiveMQDestination> JournalQueueAck::getDestination()
{ {
return destination ; return destination ;
} }
void JournalQueueAck::setDestination(ActiveMQDestination destination) void JournalQueueAck::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }
MessageAck JournalQueueAck::getMessageAck() p<MessageAck> JournalQueueAck::getMessageAck()
{ {
return messageAck ; return messageAck ;
} }
void JournalQueueAck::setMessageAck(MessageAck messageAck) void JournalQueueAck::setMessageAck(p<MessageAck> messageAck)
{ {
this->messageAck = messageAck ; this->messageAck = messageAck ;
} }

28
openwire-cpp/src/command/JournalQueueAck.hpp
View File

@ -18,16 +18,12 @@
#define JournalQueueAck_hpp_ #define JournalQueueAck_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "command/ActiveMQDestination.hpp"
#include "command/MessageAck.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +35,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,8 +51,8 @@ namespace apache
class JournalQueueAck : public AbstractCommand class JournalQueueAck : public AbstractCommand
{ {
private: private:
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
MessageAck messageAck ; p<MessageAck> messageAck ;
public: public:
const static int TYPE = 52; const static int TYPE = 52;
@ -64,12 +61,13 @@ public:
JournalQueueAck() ; JournalQueueAck() ;
virtual ~JournalQueueAck() ; virtual ~JournalQueueAck() ;
virtual int getCommandType() ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual MessageAck getMessageAck() ; virtual p<MessageAck> getMessageAck() ;
virtual void setMessageAck(MessageAck messageAck) ; virtual void setMessageAck(p<MessageAck> messageAck) ;
} ; } ;

20
openwire-cpp/src/command/JournalTopicAck.cpp
View File

@ -30,12 +30,12 @@ using namespace apache::activemq::client::command;
*/ */
JournalTopicAck::JournalTopicAck() JournalTopicAck::JournalTopicAck()
{ {
this->destination = NULL ; this->destination = 0 ;
this->messageId = NULL ; this->messageId = 0 ;
this->messageSequenceId = NULL ; this->messageSequenceId = 0 ;
this->subscritionName = NULL ; this->subscritionName = 0 ;
this->clientId = NULL ; this->clientId = 0 ;
this->transactionId = NULL ; this->transactionId = 0 ;
} }
JournalTopicAck::~JournalTopicAck() JournalTopicAck::~JournalTopicAck()
@ -43,12 +43,12 @@ JournalTopicAck::~JournalTopicAck()
} }
ActiveMQDestination JournalTopicAck::getDestination() p<ActiveMQDestination> JournalTopicAck::getDestination()
{ {
return destination ; return destination ;
} }
void JournalTopicAck::setDestination(ActiveMQDestination destination) void JournalTopicAck::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }
@ -65,12 +65,12 @@ void JournalTopicAck::setMessageId(p<MessageId> messageId)
} }
long JournalTopicAck::getMessageSequenceId() long long JournalTopicAck::getMessageSequenceId()
{ {
return messageSequenceId ; return messageSequenceId ;
} }
void JournalTopicAck::setMessageSequenceId(long messageSequenceId) void JournalTopicAck::setMessageSequenceId(long long messageSequenceId)
{ {
this->messageSequenceId = messageSequenceId ; this->messageSequenceId = messageSequenceId ;
} }

29
openwire-cpp/src/command/JournalTopicAck.hpp
View File

@ -18,16 +18,13 @@
#define JournalTopicAck_hpp_ #define JournalTopicAck_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "command/ActiveMQDestination.hpp"
#include "command/MessageId.hpp"
#include "command/TransactionId.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,9 +52,9 @@ namespace apache
class JournalTopicAck : public AbstractCommand class JournalTopicAck : public AbstractCommand
{ {
private: private:
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
p<MessageId> messageId ; p<MessageId> messageId ;
long messageSequenceId ; long long messageSequenceId ;
p<string> subscritionName ; p<string> subscritionName ;
p<string> clientId ; p<string> clientId ;
p<TransactionId> transactionId ; p<TransactionId> transactionId ;
@ -68,15 +66,16 @@ public:
JournalTopicAck() ; JournalTopicAck() ;
virtual ~JournalTopicAck() ; virtual ~JournalTopicAck() ;
virtual int getCommandType() ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<MessageId> getMessageId() ; virtual p<MessageId> getMessageId() ;
virtual void setMessageId(p<MessageId> messageId) ; virtual void setMessageId(p<MessageId> messageId) ;
virtual long getMessageSequenceId() ; virtual long long getMessageSequenceId() ;
virtual void setMessageSequenceId(long messageSequenceId) ; virtual void setMessageSequenceId(long long messageSequenceId) ;
virtual p<string> getSubscritionName() ; virtual p<string> getSubscritionName() ;
virtual void setSubscritionName(p<string> subscritionName) ; virtual void setSubscritionName(p<string> subscritionName) ;

2
openwire-cpp/src/command/JournalTrace.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
JournalTrace::JournalTrace() JournalTrace::JournalTrace()
{ {
this->message = NULL ; this->message = 0 ;
} }
JournalTrace::~JournalTrace() JournalTrace::~JournalTrace()

14
openwire-cpp/src/command/JournalTrace.hpp
View File

@ -18,16 +18,10 @@
#define JournalTrace_hpp_ #define JournalTrace_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -63,6 +58,7 @@ public:
JournalTrace() ; JournalTrace() ;
virtual ~JournalTrace() ; virtual ~JournalTrace() ;
virtual int getCommandType() ;
virtual p<string> getMessage() ; virtual p<string> getMessage() ;
virtual void setMessage(p<string> message) ; virtual void setMessage(p<string> message) ;

10
openwire-cpp/src/command/JournalTransaction.cpp
View File

@ -30,9 +30,9 @@ using namespace apache::activemq::client::command;
*/ */
JournalTransaction::JournalTransaction() JournalTransaction::JournalTransaction()
{ {
this->transactionId = NULL ; this->transactionId = 0 ;
this->type = NULL ; this->type = 0 ;
this->wasPrepared = NULL ; this->wasPrepared = 0 ;
} }
JournalTransaction::~JournalTransaction() JournalTransaction::~JournalTransaction()
@ -51,12 +51,12 @@ void JournalTransaction::setTransactionId(p<TransactionId> transactionId)
} }
byte JournalTransaction::getType() char JournalTransaction::getType()
{ {
return type ; return type ;
} }
void JournalTransaction::setType(byte type) void JournalTransaction::setType(char type)
{ {
this->type = type ; this->type = type ;
} }

21
openwire-cpp/src/command/JournalTransaction.hpp
View File

@ -18,16 +18,11 @@
#define JournalTransaction_hpp_ #define JournalTransaction_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "command/TransactionId.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,7 +51,7 @@ class JournalTransaction : public AbstractCommand
{ {
private: private:
p<TransactionId> transactionId ; p<TransactionId> transactionId ;
byte type ; char type ;
bool wasPrepared ; bool wasPrepared ;
public: public:
@ -65,12 +61,13 @@ public:
JournalTransaction() ; JournalTransaction() ;
virtual ~JournalTransaction() ; virtual ~JournalTransaction() ;
virtual int getCommandType() ;
virtual p<TransactionId> getTransactionId() ; virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ; virtual void setTransactionId(p<TransactionId> transactionId) ;
virtual byte getType() ; virtual char getType() ;
virtual void setType(byte type) ; virtual void setType(char type) ;
virtual bool getWasPrepared() ; virtual bool getWasPrepared() ;
virtual void setWasPrepared(bool wasPrepared) ; virtual void setWasPrepared(bool wasPrepared) ;

14
openwire-cpp/src/command/KeepAliveInfo.hpp
View File

@ -18,16 +18,10 @@
#define KeepAliveInfo_hpp_ #define KeepAliveInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -62,6 +57,7 @@ public:
KeepAliveInfo() ; KeepAliveInfo() ;
virtual ~KeepAliveInfo() ; virtual ~KeepAliveInfo() ;
virtual int getCommandType() ;
} ; } ;

8
openwire-cpp/src/command/LocalTransactionId.cpp
View File

@ -30,8 +30,8 @@ using namespace apache::activemq::client::command;
*/ */
LocalTransactionId::LocalTransactionId() LocalTransactionId::LocalTransactionId()
{ {
this->value = NULL ; this->value = 0 ;
this->connectionId = NULL ; this->connectionId = 0 ;
} }
LocalTransactionId::~LocalTransactionId() LocalTransactionId::~LocalTransactionId()
@ -39,12 +39,12 @@ LocalTransactionId::~LocalTransactionId()
} }
long LocalTransactionId::getValue() long long LocalTransactionId::getValue()
{ {
return value ; return value ;
} }
void LocalTransactionId::setValue(long value) void LocalTransactionId::setValue(long long value)
{ {
this->value = value ; this->value = value ;
} }

21
openwire-cpp/src/command/LocalTransactionId.hpp
View File

@ -18,16 +18,11 @@
#define LocalTransactionId_hpp_ #define LocalTransactionId_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/TransactionId.hpp" #include "command/TransactionId.hpp"
#include "command/ConnectionId.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,7 +50,7 @@ namespace apache
class LocalTransactionId : public TransactionId class LocalTransactionId : public TransactionId
{ {
private: private:
long value ; long long value ;
p<ConnectionId> connectionId ; p<ConnectionId> connectionId ;
public: public:
@ -64,9 +60,10 @@ public:
LocalTransactionId() ; LocalTransactionId() ;
virtual ~LocalTransactionId() ; virtual ~LocalTransactionId() ;
virtual int getCommandType() ;
virtual long getValue() ; virtual long long getValue() ;
virtual void setValue(long value) ; virtual void setValue(long long value) ;
virtual p<ConnectionId> getConnectionId() ; virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ; virtual void setConnectionId(p<ConnectionId> connectionId) ;

94
openwire-cpp/src/command/Message.cpp
View File

@ -30,31 +30,31 @@ using namespace apache::activemq::client::command;
*/ */
Message::Message() Message::Message()
{ {
this->producerId = NULL ; this->producerId = 0 ;
this->destination = NULL ; this->destination = 0 ;
this->transactionId = NULL ; this->transactionId = 0 ;
this->originalDestination = NULL ; this->originalDestination = 0 ;
this->messageId = NULL ; this->messageId = 0 ;
this->originalTransactionId = NULL ; this->originalTransactionId = 0 ;
this->groupID = NULL ; this->groupID = 0 ;
this->groupSequence = NULL ; this->groupSequence = 0 ;
this->correlationId = NULL ; this->correlationId = 0 ;
this->persistent = NULL ; this->persistent = 0 ;
this->expiration = NULL ; this->expiration = 0 ;
this->priority = NULL ; this->priority = 0 ;
this->replyTo = NULL ; this->replyTo = 0 ;
this->timestamp = NULL ; this->timestamp = 0 ;
this->type = NULL ; this->type = 0 ;
this->content = NULL ; this->content = 0 ;
this->marshalledProperties = NULL ; this->marshalledProperties = 0 ;
this->dataStructure = NULL ; this->dataStructure = 0 ;
this->targetConsumerId = NULL ; this->targetConsumerId = 0 ;
this->compressed = NULL ; this->compressed = 0 ;
this->redeliveryCounter = NULL ; this->redeliveryCounter = 0 ;
this->brokerPath = NULL ; this->brokerPath = 0 ;
this->arrival = NULL ; this->arrival = 0 ;
this->userID = NULL ; this->userID = 0 ;
this->recievedByDFBridge = NULL ; this->recievedByDFBridge = 0 ;
} }
Message::~Message() Message::~Message()
@ -73,12 +73,12 @@ void Message::setProducerId(p<ProducerId> producerId)
} }
ActiveMQDestination Message::getDestination() p<ActiveMQDestination> Message::getDestination()
{ {
return destination ; return destination ;
} }
void Message::setDestination(ActiveMQDestination destination) void Message::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }
@ -95,12 +95,12 @@ void Message::setTransactionId(p<TransactionId> transactionId)
} }
ActiveMQDestination Message::getOriginalDestination() p<ActiveMQDestination> Message::getOriginalDestination()
{ {
return originalDestination ; return originalDestination ;
} }
void Message::setOriginalDestination(ActiveMQDestination originalDestination) void Message::setOriginalDestination(p<ActiveMQDestination> originalDestination)
{ {
this->originalDestination = originalDestination ; this->originalDestination = originalDestination ;
} }
@ -172,45 +172,45 @@ void Message::setPersistent(bool persistent)
} }
long Message::getExpiration() long long Message::getExpiration()
{ {
return expiration ; return expiration ;
} }
void Message::setExpiration(long expiration) void Message::setExpiration(long long expiration)
{ {
this->expiration = expiration ; this->expiration = expiration ;
} }
byte Message::getPriority() char Message::getPriority()
{ {
return priority ; return priority ;
} }
void Message::setPriority(byte priority) void Message::setPriority(char priority)
{ {
this->priority = priority ; this->priority = priority ;
} }
ActiveMQDestination Message::getReplyTo() p<ActiveMQDestination> Message::getReplyTo()
{ {
return replyTo ; return replyTo ;
} }
void Message::setReplyTo(ActiveMQDestination replyTo) void Message::setReplyTo(p<ActiveMQDestination> replyTo)
{ {
this->replyTo = replyTo ; this->replyTo = replyTo ;
} }
long Message::getTimestamp() long long Message::getTimestamp()
{ {
return timestamp ; return timestamp ;
} }
void Message::setTimestamp(long timestamp) void Message::setTimestamp(long long timestamp)
{ {
this->timestamp = timestamp ; this->timestamp = timestamp ;
} }
@ -227,34 +227,34 @@ void Message::setType(p<string> type)
} }
void* Message::getContent() char* Message::getContent()
{ {
return content ; return content ;
} }
void Message::setContent(void* content) void Message::setContent(char* content)
{ {
this->content = content ; this->content = content ;
} }
void* Message::getMarshalledProperties() char* Message::getMarshalledProperties()
{ {
return marshalledProperties ; return marshalledProperties ;
} }
void Message::setMarshalledProperties(void* marshalledProperties) void Message::setMarshalledProperties(char* marshalledProperties)
{ {
this->marshalledProperties = marshalledProperties ; this->marshalledProperties = marshalledProperties ;
} }
DataStructure Message::getDataStructure() p<IDataStructure> Message::getDataStructure()
{ {
return dataStructure ; return dataStructure ;
} }
void Message::setDataStructure(DataStructure dataStructure) void Message::setDataStructure(p<IDataStructure> dataStructure)
{ {
this->dataStructure = dataStructure ; this->dataStructure = dataStructure ;
} }
@ -293,23 +293,23 @@ void Message::setRedeliveryCounter(int redeliveryCounter)
} }
BrokerId[] Message::getBrokerPath() ap<BrokerId> Message::getBrokerPath()
{ {
return brokerPath ; return brokerPath ;
} }
void Message::setBrokerPath(BrokerId[] brokerPath) void Message::setBrokerPath(ap<BrokerId> brokerPath)
{ {
this->brokerPath = brokerPath ; this->brokerPath = brokerPath ;
} }
long Message::getArrival() long long Message::getArrival()
{ {
return arrival ; return arrival ;
} }
void Message::setArrival(long arrival) void Message::setArrival(long long arrival)
{ {
this->arrival = arrival ; this->arrival = arrival ;
} }

86
openwire-cpp/src/command/Message.hpp
View File

@ -18,16 +18,20 @@
#define Message_hpp_ #define Message_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp" #include "command/ProducerId.hpp"
#include "command/SessionId.hpp" #include "command/ActiveMQDestination.hpp"
#include "command/TransactionId.hpp"
#include "command/ActiveMQDestination.hpp"
#include "command/MessageId.hpp"
#include "command/TransactionId.hpp"
#include "command/ActiveMQDestination.hpp"
#include "command/IDataStructure.hpp"
#include "command/ConsumerId.hpp"
#include "command/BrokerId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +43,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,28 +60,28 @@ class Message : public BaseCommand
{ {
private: private:
p<ProducerId> producerId ; p<ProducerId> producerId ;
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
p<TransactionId> transactionId ; p<TransactionId> transactionId ;
ActiveMQDestination originalDestination ; p<ActiveMQDestination> originalDestination ;
p<MessageId> messageId ; p<MessageId> messageId ;
p<TransactionId> originalTransactionId ; p<TransactionId> originalTransactionId ;
p<string> groupID ; p<string> groupID ;
int groupSequence ; int groupSequence ;
p<string> correlationId ; p<string> correlationId ;
bool persistent ; bool persistent ;
long expiration ; long long expiration ;
byte priority ; char priority ;
ActiveMQDestination replyTo ; p<ActiveMQDestination> replyTo ;
long timestamp ; long long timestamp ;
p<string> type ; p<string> type ;
void* content ; char* content ;
void* marshalledProperties ; char* marshalledProperties ;
DataStructure dataStructure ; p<IDataStructure> dataStructure ;
p<ConsumerId> targetConsumerId ; p<ConsumerId> targetConsumerId ;
bool compressed ; bool compressed ;
int redeliveryCounter ; int redeliveryCounter ;
BrokerId[] brokerPath ; ap<BrokerId> brokerPath ;
long arrival ; long long arrival ;
p<string> userID ; p<string> userID ;
bool recievedByDFBridge ; bool recievedByDFBridge ;
@ -87,18 +92,19 @@ public:
Message() ; Message() ;
virtual ~Message() ; virtual ~Message() ;
virtual int getCommandType() ;
virtual p<ProducerId> getProducerId() ; virtual p<ProducerId> getProducerId() ;
virtual void setProducerId(p<ProducerId> producerId) ; virtual void setProducerId(p<ProducerId> producerId) ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<TransactionId> getTransactionId() ; virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ; virtual void setTransactionId(p<TransactionId> transactionId) ;
virtual ActiveMQDestination getOriginalDestination() ; virtual p<ActiveMQDestination> getOriginalDestination() ;
virtual void setOriginalDestination(ActiveMQDestination originalDestination) ; virtual void setOriginalDestination(p<ActiveMQDestination> originalDestination) ;
virtual p<MessageId> getMessageId() ; virtual p<MessageId> getMessageId() ;
virtual void setMessageId(p<MessageId> messageId) ; virtual void setMessageId(p<MessageId> messageId) ;
@ -118,29 +124,29 @@ public:
virtual bool getPersistent() ; virtual bool getPersistent() ;
virtual void setPersistent(bool persistent) ; virtual void setPersistent(bool persistent) ;
virtual long getExpiration() ; virtual long long getExpiration() ;
virtual void setExpiration(long expiration) ; virtual void setExpiration(long long expiration) ;
virtual byte getPriority() ; virtual char getPriority() ;
virtual void setPriority(byte priority) ; virtual void setPriority(char priority) ;
virtual ActiveMQDestination getReplyTo() ; virtual p<ActiveMQDestination> getReplyTo() ;
virtual void setReplyTo(ActiveMQDestination replyTo) ; virtual void setReplyTo(p<ActiveMQDestination> replyTo) ;
virtual long getTimestamp() ; virtual long long getTimestamp() ;
virtual void setTimestamp(long timestamp) ; virtual void setTimestamp(long long timestamp) ;
virtual p<string> getType() ; virtual p<string> getType() ;
virtual void setType(p<string> type) ; virtual void setType(p<string> type) ;
virtual void* getContent() ; virtual char* getContent() ;
virtual void setContent(void* content) ; virtual void setContent(char* content) ;
virtual void* getMarshalledProperties() ; virtual char* getMarshalledProperties() ;
virtual void setMarshalledProperties(void* marshalledProperties) ; virtual void setMarshalledProperties(char* marshalledProperties) ;
virtual DataStructure getDataStructure() ; virtual p<IDataStructure> getDataStructure() ;
virtual void setDataStructure(DataStructure dataStructure) ; virtual void setDataStructure(p<IDataStructure> dataStructure) ;
virtual p<ConsumerId> getTargetConsumerId() ; virtual p<ConsumerId> getTargetConsumerId() ;
virtual void setTargetConsumerId(p<ConsumerId> targetConsumerId) ; virtual void setTargetConsumerId(p<ConsumerId> targetConsumerId) ;
@ -151,11 +157,11 @@ public:
virtual int getRedeliveryCounter() ; virtual int getRedeliveryCounter() ;
virtual void setRedeliveryCounter(int redeliveryCounter) ; virtual void setRedeliveryCounter(int redeliveryCounter) ;
virtual BrokerId[] getBrokerPath() ; virtual ap<BrokerId> getBrokerPath() ;
virtual void setBrokerPath(BrokerId[] brokerPath) ; virtual void setBrokerPath(ap<BrokerId> brokerPath) ;
virtual long getArrival() ; virtual long long getArrival() ;
virtual void setArrival(long arrival) ; virtual void setArrival(long long arrival) ;
virtual p<string> getUserID() ; virtual p<string> getUserID() ;
virtual void setUserID(p<string> userID) ; virtual void setUserID(p<string> userID) ;

22
openwire-cpp/src/command/MessageAck.cpp
View File

@ -30,13 +30,13 @@ using namespace apache::activemq::client::command;
*/ */
MessageAck::MessageAck() MessageAck::MessageAck()
{ {
this->destination = NULL ; this->destination = 0 ;
this->transactionId = NULL ; this->transactionId = 0 ;
this->consumerId = NULL ; this->consumerId = 0 ;
this->ackType = NULL ; this->ackType = 0 ;
this->firstMessageId = NULL ; this->firstMessageId = 0 ;
this->lastMessageId = NULL ; this->lastMessageId = 0 ;
this->messageCount = NULL ; this->messageCount = 0 ;
} }
MessageAck::~MessageAck() MessageAck::~MessageAck()
@ -44,12 +44,12 @@ MessageAck::~MessageAck()
} }
ActiveMQDestination MessageAck::getDestination() p<ActiveMQDestination> MessageAck::getDestination()
{ {
return destination ; return destination ;
} }
void MessageAck::setDestination(ActiveMQDestination destination) void MessageAck::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }
@ -77,12 +77,12 @@ void MessageAck::setConsumerId(p<ConsumerId> consumerId)
} }
byte MessageAck::getAckType() char MessageAck::getAckType()
{ {
return ackType ; return ackType ;
} }
void MessageAck::setAckType(byte ackType) void MessageAck::setAckType(char ackType)
{ {
this->ackType = ackType ; this->ackType = ackType ;
} }

27
openwire-cpp/src/command/MessageAck.hpp
View File

@ -18,16 +18,15 @@
#define MessageAck_hpp_ #define MessageAck_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp" #include "command/ActiveMQDestination.hpp"
#include "command/TransactionId.hpp"
#include "command/ConsumerId.hpp" #include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp" #include "command/MessageId.hpp"
#include "command/SessionId.hpp" #include "command/MessageId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +38,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,10 +54,10 @@ namespace apache
class MessageAck : public BaseCommand class MessageAck : public BaseCommand
{ {
private: private:
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
p<TransactionId> transactionId ; p<TransactionId> transactionId ;
p<ConsumerId> consumerId ; p<ConsumerId> consumerId ;
byte ackType ; char ackType ;
p<MessageId> firstMessageId ; p<MessageId> firstMessageId ;
p<MessageId> lastMessageId ; p<MessageId> lastMessageId ;
int messageCount ; int messageCount ;
@ -69,9 +69,10 @@ public:
MessageAck() ; MessageAck() ;
virtual ~MessageAck() ; virtual ~MessageAck() ;
virtual int getCommandType() ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<TransactionId> getTransactionId() ; virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ; virtual void setTransactionId(p<TransactionId> transactionId) ;
@ -79,8 +80,8 @@ public:
virtual p<ConsumerId> getConsumerId() ; virtual p<ConsumerId> getConsumerId() ;
virtual void setConsumerId(p<ConsumerId> consumerId) ; virtual void setConsumerId(p<ConsumerId> consumerId) ;
virtual byte getAckType() ; virtual char getAckType() ;
virtual void setAckType(byte ackType) ; virtual void setAckType(char ackType) ;
virtual p<MessageId> getFirstMessageId() ; virtual p<MessageId> getFirstMessageId() ;
virtual void setFirstMessageId(p<MessageId> firstMessageId) ; virtual void setFirstMessageId(p<MessageId> firstMessageId) ;

16
openwire-cpp/src/command/MessageDispatch.cpp
View File

@ -30,10 +30,10 @@ using namespace apache::activemq::client::command;
*/ */
MessageDispatch::MessageDispatch() MessageDispatch::MessageDispatch()
{ {
this->consumerId = NULL ; this->consumerId = 0 ;
this->destination = NULL ; this->destination = 0 ;
this->message = NULL ; this->message = 0 ;
this->redeliveryCounter = NULL ; this->redeliveryCounter = 0 ;
} }
MessageDispatch::~MessageDispatch() MessageDispatch::~MessageDispatch()
@ -52,23 +52,23 @@ void MessageDispatch::setConsumerId(p<ConsumerId> consumerId)
} }
ActiveMQDestination MessageDispatch::getDestination() p<ActiveMQDestination> MessageDispatch::getDestination()
{ {
return destination ; return destination ;
} }
void MessageDispatch::setDestination(ActiveMQDestination destination) void MessageDispatch::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }
Message MessageDispatch::getMessage() p<Message> MessageDispatch::getMessage()
{ {
return message ; return message ;
} }
void MessageDispatch::setMessage(Message message) void MessageDispatch::setMessage(p<Message> message)
{ {
this->message = message ; this->message = message ;
} }

25
openwire-cpp/src/command/MessageDispatch.hpp
View File

@ -18,16 +18,13 @@
#define MessageDispatch_hpp_ #define MessageDispatch_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp" #include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp" #include "command/ActiveMQDestination.hpp"
#include "command/SessionId.hpp" #include "command/Message.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,8 +53,8 @@ class MessageDispatch : public BaseCommand
{ {
private: private:
p<ConsumerId> consumerId ; p<ConsumerId> consumerId ;
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
Message message ; p<Message> message ;
int redeliveryCounter ; int redeliveryCounter ;
public: public:
@ -66,15 +64,16 @@ public:
MessageDispatch() ; MessageDispatch() ;
virtual ~MessageDispatch() ; virtual ~MessageDispatch() ;
virtual int getCommandType() ;
virtual p<ConsumerId> getConsumerId() ; virtual p<ConsumerId> getConsumerId() ;
virtual void setConsumerId(p<ConsumerId> consumerId) ; virtual void setConsumerId(p<ConsumerId> consumerId) ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual Message getMessage() ; virtual p<Message> getMessage() ;
virtual void setMessage(Message message) ; virtual void setMessage(p<Message> message) ;
virtual int getRedeliveryCounter() ; virtual int getRedeliveryCounter() ;
virtual void setRedeliveryCounter(int redeliveryCounter) ; virtual void setRedeliveryCounter(int redeliveryCounter) ;

16
openwire-cpp/src/command/MessageDispatchNotification.cpp
View File

@ -30,10 +30,10 @@ using namespace apache::activemq::client::command;
*/ */
MessageDispatchNotification::MessageDispatchNotification() MessageDispatchNotification::MessageDispatchNotification()
{ {
this->consumerId = NULL ; this->consumerId = 0 ;
this->destination = NULL ; this->destination = 0 ;
this->deliverySequenceId = NULL ; this->deliverySequenceId = 0 ;
this->messageId = NULL ; this->messageId = 0 ;
} }
MessageDispatchNotification::~MessageDispatchNotification() MessageDispatchNotification::~MessageDispatchNotification()
@ -52,23 +52,23 @@ void MessageDispatchNotification::setConsumerId(p<ConsumerId> consumerId)
} }
ActiveMQDestination MessageDispatchNotification::getDestination() p<ActiveMQDestination> MessageDispatchNotification::getDestination()
{ {
return destination ; return destination ;
} }
void MessageDispatchNotification::setDestination(ActiveMQDestination destination) void MessageDispatchNotification::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }
long MessageDispatchNotification::getDeliverySequenceId() long long MessageDispatchNotification::getDeliverySequenceId()
{ {
return deliverySequenceId ; return deliverySequenceId ;
} }
void MessageDispatchNotification::setDeliverySequenceId(long deliverySequenceId) void MessageDispatchNotification::setDeliverySequenceId(long long deliverySequenceId)
{ {
this->deliverySequenceId = deliverySequenceId ; this->deliverySequenceId = deliverySequenceId ;
} }

25
openwire-cpp/src/command/MessageDispatchNotification.hpp
View File

@ -18,16 +18,13 @@
#define MessageDispatchNotification_hpp_ #define MessageDispatchNotification_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp" #include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp" #include "command/ActiveMQDestination.hpp"
#include "command/SessionId.hpp" #include "command/MessageId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,8 +53,8 @@ class MessageDispatchNotification : public BaseCommand
{ {
private: private:
p<ConsumerId> consumerId ; p<ConsumerId> consumerId ;
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
long deliverySequenceId ; long long deliverySequenceId ;
p<MessageId> messageId ; p<MessageId> messageId ;
public: public:
@ -66,15 +64,16 @@ public:
MessageDispatchNotification() ; MessageDispatchNotification() ;
virtual ~MessageDispatchNotification() ; virtual ~MessageDispatchNotification() ;
virtual int getCommandType() ;
virtual p<ConsumerId> getConsumerId() ; virtual p<ConsumerId> getConsumerId() ;
virtual void setConsumerId(p<ConsumerId> consumerId) ; virtual void setConsumerId(p<ConsumerId> consumerId) ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual long getDeliverySequenceId() ; virtual long long getDeliverySequenceId() ;
virtual void setDeliverySequenceId(long deliverySequenceId) ; virtual void setDeliverySequenceId(long long deliverySequenceId) ;
virtual p<MessageId> getMessageId() ; virtual p<MessageId> getMessageId() ;
virtual void setMessageId(p<MessageId> messageId) ; virtual void setMessageId(p<MessageId> messageId) ;

14
openwire-cpp/src/command/MessageId.cpp
View File

@ -30,9 +30,9 @@ using namespace apache::activemq::client::command;
*/ */
MessageId::MessageId() MessageId::MessageId()
{ {
this->producerId = NULL ; this->producerId = 0 ;
this->producerSequenceId = NULL ; this->producerSequenceId = 0 ;
this->brokerSequenceId = NULL ; this->brokerSequenceId = 0 ;
} }
MessageId::~MessageId() MessageId::~MessageId()
@ -51,23 +51,23 @@ void MessageId::setProducerId(p<ProducerId> producerId)
} }
long MessageId::getProducerSequenceId() long long MessageId::getProducerSequenceId()
{ {
return producerSequenceId ; return producerSequenceId ;
} }
void MessageId::setProducerSequenceId(long producerSequenceId) void MessageId::setProducerSequenceId(long long producerSequenceId)
{ {
this->producerSequenceId = producerSequenceId ; this->producerSequenceId = producerSequenceId ;
} }
long MessageId::getBrokerSequenceId() long long MessageId::getBrokerSequenceId()
{ {
return brokerSequenceId ; return brokerSequenceId ;
} }
void MessageId::setBrokerSequenceId(long brokerSequenceId) void MessageId::setBrokerSequenceId(long long brokerSequenceId)
{ {
this->brokerSequenceId = brokerSequenceId ; this->brokerSequenceId = brokerSequenceId ;
} }

27
openwire-cpp/src/command/MessageId.hpp
View File

@ -18,16 +18,11 @@
#define MessageId_hpp_ #define MessageId_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "command/ProducerId.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,8 +51,8 @@ class MessageId : public AbstractCommand
{ {
private: private:
p<ProducerId> producerId ; p<ProducerId> producerId ;
long producerSequenceId ; long long producerSequenceId ;
long brokerSequenceId ; long long brokerSequenceId ;
public: public:
const static int TYPE = 110; const static int TYPE = 110;
@ -65,15 +61,16 @@ public:
MessageId() ; MessageId() ;
virtual ~MessageId() ; virtual ~MessageId() ;
virtual int getCommandType() ;
virtual p<ProducerId> getProducerId() ; virtual p<ProducerId> getProducerId() ;
virtual void setProducerId(p<ProducerId> producerId) ; virtual void setProducerId(p<ProducerId> producerId) ;
virtual long getProducerSequenceId() ; virtual long long getProducerSequenceId() ;
virtual void setProducerSequenceId(long producerSequenceId) ; virtual void setProducerSequenceId(long long producerSequenceId) ;
virtual long getBrokerSequenceId() ; virtual long long getBrokerSequenceId() ;
virtual void setBrokerSequenceId(long brokerSequenceId) ; virtual void setBrokerSequenceId(long long brokerSequenceId) ;
} ; } ;

14
openwire-cpp/src/command/ProducerId.cpp
View File

@ -30,9 +30,9 @@ using namespace apache::activemq::client::command;
*/ */
ProducerId::ProducerId() ProducerId::ProducerId()
{ {
this->connectionId = NULL ; this->connectionId = 0 ;
this->value = NULL ; this->value = 0 ;
this->sessionId = NULL ; this->sessionId = 0 ;
} }
ProducerId::~ProducerId() ProducerId::~ProducerId()
@ -51,23 +51,23 @@ void ProducerId::setConnectionId(p<string> connectionId)
} }
long ProducerId::getValue() long long ProducerId::getValue()
{ {
return value ; return value ;
} }
void ProducerId::setValue(long value) void ProducerId::setValue(long long value)
{ {
this->value = value ; this->value = value ;
} }
long ProducerId::getSessionId() long long ProducerId::getSessionId()
{ {
return sessionId ; return sessionId ;
} }
void ProducerId::setSessionId(long sessionId) void ProducerId::setSessionId(long long sessionId)
{ {
this->sessionId = sessionId ; this->sessionId = sessionId ;
} }

26
openwire-cpp/src/command/ProducerId.hpp
View File

@ -18,16 +18,10 @@
#define ProducerId_hpp_ #define ProducerId_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,8 +50,8 @@ class ProducerId : public AbstractCommand
{ {
private: private:
p<string> connectionId ; p<string> connectionId ;
long value ; long long value ;
long sessionId ; long long sessionId ;
public: public:
const static int TYPE = 123; const static int TYPE = 123;
@ -65,15 +60,16 @@ public:
ProducerId() ; ProducerId() ;
virtual ~ProducerId() ; virtual ~ProducerId() ;
virtual int getCommandType() ;
virtual p<string> getConnectionId() ; virtual p<string> getConnectionId() ;
virtual void setConnectionId(p<string> connectionId) ; virtual void setConnectionId(p<string> connectionId) ;
virtual long getValue() ; virtual long long getValue() ;
virtual void setValue(long value) ; virtual void setValue(long long value) ;
virtual long getSessionId() ; virtual long long getSessionId() ;
virtual void setSessionId(long sessionId) ; virtual void setSessionId(long long sessionId) ;
} ; } ;

14
openwire-cpp/src/command/ProducerInfo.cpp
View File

@ -30,9 +30,9 @@ using namespace apache::activemq::client::command;
*/ */
ProducerInfo::ProducerInfo() ProducerInfo::ProducerInfo()
{ {
this->producerId = NULL ; this->producerId = 0 ;
this->destination = NULL ; this->destination = 0 ;
this->brokerPath = NULL ; this->brokerPath = 0 ;
} }
ProducerInfo::~ProducerInfo() ProducerInfo::~ProducerInfo()
@ -51,23 +51,23 @@ void ProducerInfo::setProducerId(p<ProducerId> producerId)
} }
ActiveMQDestination ProducerInfo::getDestination() p<ActiveMQDestination> ProducerInfo::getDestination()
{ {
return destination ; return destination ;
} }
void ProducerInfo::setDestination(ActiveMQDestination destination) void ProducerInfo::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }
BrokerId[] ProducerInfo::getBrokerPath() ap<BrokerId> ProducerInfo::getBrokerPath()
{ {
return brokerPath ; return brokerPath ;
} }
void ProducerInfo::setBrokerPath(BrokerId[] brokerPath) void ProducerInfo::setBrokerPath(ap<BrokerId> brokerPath)
{ {
this->brokerPath = brokerPath ; this->brokerPath = brokerPath ;
} }

25
openwire-cpp/src/command/ProducerInfo.hpp
View File

@ -18,16 +18,13 @@
#define ProducerInfo_hpp_ #define ProducerInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp" #include "command/ProducerId.hpp"
#include "command/SessionId.hpp" #include "command/ActiveMQDestination.hpp"
#include "command/BrokerId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,8 +53,8 @@ class ProducerInfo : public BaseCommand
{ {
private: private:
p<ProducerId> producerId ; p<ProducerId> producerId ;
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
BrokerId[] brokerPath ; ap<BrokerId> brokerPath ;
public: public:
const static int TYPE = 6; const static int TYPE = 6;
@ -65,15 +63,16 @@ public:
ProducerInfo() ; ProducerInfo() ;
virtual ~ProducerInfo() ; virtual ~ProducerInfo() ;
virtual int getCommandType() ;
virtual p<ProducerId> getProducerId() ; virtual p<ProducerId> getProducerId() ;
virtual void setProducerId(p<ProducerId> producerId) ; virtual void setProducerId(p<ProducerId> producerId) ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual BrokerId[] getBrokerPath() ; virtual ap<BrokerId> getBrokerPath() ;
virtual void setBrokerPath(BrokerId[] brokerPath) ; virtual void setBrokerPath(ap<BrokerId> brokerPath) ;
} ; } ;

6
openwire-cpp/src/command/RemoveInfo.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
RemoveInfo::RemoveInfo() RemoveInfo::RemoveInfo()
{ {
this->objectId = NULL ; this->objectId = 0 ;
} }
RemoveInfo::~RemoveInfo() RemoveInfo::~RemoveInfo()
@ -38,12 +38,12 @@ RemoveInfo::~RemoveInfo()
} }
DataStructure RemoveInfo::getObjectId() p<IDataStructure> RemoveInfo::getObjectId()
{ {
return objectId ; return objectId ;
} }
void RemoveInfo::setObjectId(DataStructure objectId) void RemoveInfo::setObjectId(p<IDataStructure> objectId)
{ {
this->objectId = objectId ; this->objectId = objectId ;
} }

19
openwire-cpp/src/command/RemoveInfo.hpp
View File

@ -18,16 +18,11 @@
#define RemoveInfo_hpp_ #define RemoveInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp" #include "command/IDataStructure.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,7 +50,7 @@ namespace apache
class RemoveInfo : public BaseCommand class RemoveInfo : public BaseCommand
{ {
private: private:
DataStructure objectId ; p<IDataStructure> objectId ;
public: public:
const static int TYPE = 12; const static int TYPE = 12;
@ -63,9 +59,10 @@ public:
RemoveInfo() ; RemoveInfo() ;
virtual ~RemoveInfo() ; virtual ~RemoveInfo() ;
virtual int getCommandType() ;
virtual DataStructure getObjectId() ; virtual p<IDataStructure> getObjectId() ;
virtual void setObjectId(DataStructure objectId) ; virtual void setObjectId(p<IDataStructure> objectId) ;
} ; } ;

6
openwire-cpp/src/command/RemoveSubscriptionInfo.cpp
View File

@ -30,9 +30,9 @@ using namespace apache::activemq::client::command;
*/ */
RemoveSubscriptionInfo::RemoveSubscriptionInfo() RemoveSubscriptionInfo::RemoveSubscriptionInfo()
{ {
this->connectionId = NULL ; this->connectionId = 0 ;
this->subcriptionName = NULL ; this->subcriptionName = 0 ;
this->clientId = NULL ; this->clientId = 0 ;
} }
RemoveSubscriptionInfo::~RemoveSubscriptionInfo() RemoveSubscriptionInfo::~RemoveSubscriptionInfo()

11
openwire-cpp/src/command/RemoveSubscriptionInfo.hpp
View File

@ -18,16 +18,11 @@
#define RemoveSubscriptionInfo_hpp_ #define RemoveSubscriptionInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp" #include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -65,6 +61,7 @@ public:
RemoveSubscriptionInfo() ; RemoveSubscriptionInfo() ;
virtual ~RemoveSubscriptionInfo() ; virtual ~RemoveSubscriptionInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ; virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ; virtual void setConnectionId(p<ConnectionId> connectionId) ;

2
openwire-cpp/src/command/Response.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
Response::Response() Response::Response()
{ {
this->correlationId = NULL ; this->correlationId = 0 ;
} }
Response::~Response() Response::~Response()

12
openwire-cpp/src/command/Response.hpp
View File

@ -18,16 +18,10 @@
#define Response_hpp_ #define Response_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -63,6 +58,7 @@ public:
Response() ; Response() ;
virtual ~Response() ; virtual ~Response() ;
virtual int getCommandType() ;
virtual short getCorrelationId() ; virtual short getCorrelationId() ;
virtual void setCorrelationId(short correlationId) ; virtual void setCorrelationId(short correlationId) ;

8
openwire-cpp/src/command/SessionId.cpp
View File

@ -30,8 +30,8 @@ using namespace apache::activemq::client::command;
*/ */
SessionId::SessionId() SessionId::SessionId()
{ {
this->connectionId = NULL ; this->connectionId = 0 ;
this->value = NULL ; this->value = 0 ;
} }
SessionId::~SessionId() SessionId::~SessionId()
@ -50,12 +50,12 @@ void SessionId::setConnectionId(p<string> connectionId)
} }
long SessionId::getValue() long long SessionId::getValue()
{ {
return value ; return value ;
} }
void SessionId::setValue(long value) void SessionId::setValue(long long value)
{ {
this->value = value ; this->value = value ;
} }

20
openwire-cpp/src/command/SessionId.hpp
View File

@ -18,16 +18,10 @@
#define SessionId_hpp_ #define SessionId_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,7 +50,7 @@ class SessionId : public AbstractCommand
{ {
private: private:
p<string> connectionId ; p<string> connectionId ;
long value ; long long value ;
public: public:
const static int TYPE = 121; const static int TYPE = 121;
@ -64,12 +59,13 @@ public:
SessionId() ; SessionId() ;
virtual ~SessionId() ; virtual ~SessionId() ;
virtual int getCommandType() ;
virtual p<string> getConnectionId() ; virtual p<string> getConnectionId() ;
virtual void setConnectionId(p<string> connectionId) ; virtual void setConnectionId(p<string> connectionId) ;
virtual long getValue() ; virtual long long getValue() ;
virtual void setValue(long value) ; virtual void setValue(long long value) ;
} ; } ;

2
openwire-cpp/src/command/SessionInfo.cpp
View File

@ -30,7 +30,7 @@ using namespace apache::activemq::client::command;
*/ */
SessionInfo::SessionInfo() SessionInfo::SessionInfo()
{ {
this->sessionId = NULL ; this->sessionId = 0 ;
} }
SessionInfo::~SessionInfo() SessionInfo::~SessionInfo()

11
openwire-cpp/src/command/SessionInfo.hpp
View File

@ -18,16 +18,11 @@
#define SessionInfo_hpp_ #define SessionInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp" #include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -63,6 +59,7 @@ public:
SessionInfo() ; SessionInfo() ;
virtual ~SessionInfo() ; virtual ~SessionInfo() ;
virtual int getCommandType() ;
virtual p<SessionId> getSessionId() ; virtual p<SessionId> getSessionId() ;
virtual void setSessionId(p<SessionId> sessionId) ; virtual void setSessionId(p<SessionId> sessionId) ;

12
openwire-cpp/src/command/ShutdownInfo.hpp
View File

@ -18,16 +18,10 @@
#define ShutdownInfo_hpp_ #define ShutdownInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -62,6 +57,7 @@ public:
ShutdownInfo() ; ShutdownInfo() ;
virtual ~ShutdownInfo() ; virtual ~ShutdownInfo() ;
virtual int getCommandType() ;
} ; } ;

12
openwire-cpp/src/command/SubscriptionInfo.cpp
View File

@ -30,10 +30,10 @@ using namespace apache::activemq::client::command;
*/ */
SubscriptionInfo::SubscriptionInfo() SubscriptionInfo::SubscriptionInfo()
{ {
this->clientId = NULL ; this->clientId = 0 ;
this->destination = NULL ; this->destination = 0 ;
this->selector = NULL ; this->selector = 0 ;
this->subcriptionName = NULL ; this->subcriptionName = 0 ;
} }
SubscriptionInfo::~SubscriptionInfo() SubscriptionInfo::~SubscriptionInfo()
@ -52,12 +52,12 @@ void SubscriptionInfo::setClientId(p<string> clientId)
} }
ActiveMQDestination SubscriptionInfo::getDestination() p<ActiveMQDestination> SubscriptionInfo::getDestination()
{ {
return destination ; return destination ;
} }
void SubscriptionInfo::setDestination(ActiveMQDestination destination) void SubscriptionInfo::setDestination(p<ActiveMQDestination> destination)
{ {
this->destination = destination ; this->destination = destination ;
} }

21
openwire-cpp/src/command/SubscriptionInfo.hpp
View File

@ -18,16 +18,11 @@
#define SubscriptionInfo_hpp_ #define SubscriptionInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "command/ActiveMQDestination.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,7 +51,7 @@ class SubscriptionInfo : public AbstractCommand
{ {
private: private:
p<string> clientId ; p<string> clientId ;
ActiveMQDestination destination ; p<ActiveMQDestination> destination ;
p<string> selector ; p<string> selector ;
p<string> subcriptionName ; p<string> subcriptionName ;
@ -66,12 +62,13 @@ public:
SubscriptionInfo() ; SubscriptionInfo() ;
virtual ~SubscriptionInfo() ; virtual ~SubscriptionInfo() ;
virtual int getCommandType() ;
virtual p<string> getClientId() ; virtual p<string> getClientId() ;
virtual void setClientId(p<string> clientId) ; virtual void setClientId(p<string> clientId) ;
virtual ActiveMQDestination getDestination() ; virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ; virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<string> getSelector() ; virtual p<string> getSelector() ;
virtual void setSelector(p<string> selector) ; virtual void setSelector(p<string> selector) ;

14
openwire-cpp/src/command/TransactionId.hpp
View File

@ -18,16 +18,10 @@
#define TransactionId_hpp_ #define TransactionId_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -62,6 +57,7 @@ public:
TransactionId() ; TransactionId() ;
virtual ~TransactionId() ; virtual ~TransactionId() ;
virtual int getCommandType() ;
} ; } ;

10
openwire-cpp/src/command/TransactionInfo.cpp
View File

@ -30,9 +30,9 @@ using namespace apache::activemq::client::command;
*/ */
TransactionInfo::TransactionInfo() TransactionInfo::TransactionInfo()
{ {
this->connectionId = NULL ; this->connectionId = 0 ;
this->transactionId = NULL ; this->transactionId = 0 ;
this->type = NULL ; this->type = 0 ;
} }
TransactionInfo::~TransactionInfo() TransactionInfo::~TransactionInfo()
@ -62,12 +62,12 @@ void TransactionInfo::setTransactionId(p<TransactionId> transactionId)
} }
byte TransactionInfo::getType() char TransactionInfo::getType()
{ {
return type ; return type ;
} }
void TransactionInfo::setType(byte type) void TransactionInfo::setType(char type)
{ {
this->type = type ; this->type = type ;
} }

18
openwire-cpp/src/command/TransactionInfo.hpp
View File

@ -18,16 +18,12 @@
#define TransactionInfo_hpp_ #define TransactionInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp" #include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp" #include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp" #include "command/TransactionId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/BaseCommand.hpp" #include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +35,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -56,7 +53,7 @@ class TransactionInfo : public BaseCommand
private: private:
p<ConnectionId> connectionId ; p<ConnectionId> connectionId ;
p<TransactionId> transactionId ; p<TransactionId> transactionId ;
byte type ; char type ;
public: public:
const static int TYPE = 7; const static int TYPE = 7;
@ -65,6 +62,7 @@ public:
TransactionInfo() ; TransactionInfo() ;
virtual ~TransactionInfo() ; virtual ~TransactionInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ; virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ; virtual void setConnectionId(p<ConnectionId> connectionId) ;
@ -72,8 +70,8 @@ public:
virtual p<TransactionId> getTransactionId() ; virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ; virtual void setTransactionId(p<TransactionId> transactionId) ;
virtual byte getType() ; virtual char getType() ;
virtual void setType(byte type) ; virtual void setType(char type) ;
} ; } ;

18
openwire-cpp/src/command/WireFormatInfo.cpp
View File

@ -30,13 +30,13 @@ using namespace apache::activemq::client::command;
*/ */
WireFormatInfo::WireFormatInfo() WireFormatInfo::WireFormatInfo()
{ {
this->magic = NULL ; this->magic = 0 ;
this->version = NULL ; this->version = 0 ;
this->cacheEnabled = NULL ; this->cacheEnabled = 0 ;
this->stackTraceEnabled = NULL ; this->stackTraceEnabled = 0 ;
this->tcpNoDelayEnabled = NULL ; this->tcpNoDelayEnabled = 0 ;
this->prefixPacketSize = NULL ; this->prefixPacketSize = 0 ;
this->tightEncodingEnabled = NULL ; this->tightEncodingEnabled = 0 ;
} }
WireFormatInfo::~WireFormatInfo() WireFormatInfo::~WireFormatInfo()
@ -44,12 +44,12 @@ WireFormatInfo::~WireFormatInfo()
} }
byte[] WireFormatInfo::getMagic() ap<char> WireFormatInfo::getMagic()
{ {
return magic ; return magic ;
} }
void WireFormatInfo::setMagic(byte[] magic) void WireFormatInfo::setMagic(ap<char> magic)
{ {
this->magic = magic ; this->magic = magic ;
} }

20
openwire-cpp/src/command/WireFormatInfo.hpp
View File

@ -18,16 +18,10 @@
#define WireFormatInfo_hpp_ #define WireFormatInfo_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/AbstractCommand.hpp" #include "command/AbstractCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -54,7 +49,7 @@ namespace apache
class WireFormatInfo : public AbstractCommand class WireFormatInfo : public AbstractCommand
{ {
private: private:
byte[] magic ; ap<char> magic ;
int version ; int version ;
bool cacheEnabled ; bool cacheEnabled ;
bool stackTraceEnabled ; bool stackTraceEnabled ;
@ -69,9 +64,10 @@ public:
WireFormatInfo() ; WireFormatInfo() ;
virtual ~WireFormatInfo() ; virtual ~WireFormatInfo() ;
virtual int getCommandType() ;
virtual byte[] getMagic() ; virtual ap<char> getMagic() ;
virtual void setMagic(byte[] magic) ; virtual void setMagic(ap<char> magic) ;
virtual int getVersion() ; virtual int getVersion() ;
virtual void setVersion(int version) ; virtual void setVersion(int version) ;

14
openwire-cpp/src/command/XATransactionId.cpp
View File

@ -30,9 +30,9 @@ using namespace apache::activemq::client::command;
*/ */
XATransactionId::XATransactionId() XATransactionId::XATransactionId()
{ {
this->formatId = NULL ; this->formatId = 0 ;
this->globalTransactionId = NULL ; this->globalTransactionId = 0 ;
this->branchQualifier = NULL ; this->branchQualifier = 0 ;
} }
XATransactionId::~XATransactionId() XATransactionId::~XATransactionId()
@ -51,23 +51,23 @@ void XATransactionId::setFormatId(int formatId)
} }
byte[] XATransactionId::getGlobalTransactionId() ap<char> XATransactionId::getGlobalTransactionId()
{ {
return globalTransactionId ; return globalTransactionId ;
} }
void XATransactionId::setGlobalTransactionId(byte[] globalTransactionId) void XATransactionId::setGlobalTransactionId(ap<char> globalTransactionId)
{ {
this->globalTransactionId = globalTransactionId ; this->globalTransactionId = globalTransactionId ;
} }
byte[] XATransactionId::getBranchQualifier() ap<char> XATransactionId::getBranchQualifier()
{ {
return branchQualifier ; return branchQualifier ;
} }
void XATransactionId::setBranchQualifier(byte[] branchQualifier) void XATransactionId::setBranchQualifier(ap<char> branchQualifier)
{ {
this->branchQualifier = branchQualifier ; this->branchQualifier = branchQualifier ;
} }

26
openwire-cpp/src/command/XATransactionId.hpp
View File

@ -18,16 +18,10 @@
#define XATransactionId_hpp_ #define XATransactionId_hpp_
#include <string> #include <string>
/* we could cut this down - for now include all possible headers */
#include "command/BaseCommand.hpp"
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/TransactionId.hpp" #include "command/TransactionId.hpp"
#include "util/ifr/ap"
#include "util/ifr/p" #include "util/ifr/p"
namespace apache namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command namespace command
{ {
using namespace ifr; using namespace ifr;
using namespace std;
using namespace apache::activemq::client; using namespace apache::activemq::client;
/* /*
@ -55,8 +50,8 @@ class XATransactionId : public TransactionId
{ {
private: private:
int formatId ; int formatId ;
byte[] globalTransactionId ; ap<char> globalTransactionId ;
byte[] branchQualifier ; ap<char> branchQualifier ;
public: public:
const static int TYPE = 112; const static int TYPE = 112;
@ -65,15 +60,16 @@ public:
XATransactionId() ; XATransactionId() ;
virtual ~XATransactionId() ; virtual ~XATransactionId() ;
virtual int getCommandType() ;
virtual int getFormatId() ; virtual int getFormatId() ;
virtual void setFormatId(int formatId) ; virtual void setFormatId(int formatId) ;
virtual byte[] getGlobalTransactionId() ; virtual ap<char> getGlobalTransactionId() ;
virtual void setGlobalTransactionId(byte[] globalTransactionId) ; virtual void setGlobalTransactionId(ap<char> globalTransactionId) ;
virtual byte[] getBranchQualifier() ; virtual ap<char> getBranchQualifier() ;
virtual void setBranchQualifier(byte[] branchQualifier) ; virtual void setBranchQualifier(ap<char> branchQualifier) ;
} ; } ;