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_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -62,6 +57,7 @@ public:
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()
{
this->value = NULL ;
this->value = 0 ;
}
BrokerId::~BrokerId()

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

@ -18,16 +18,10 @@
#define BrokerId_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -63,6 +58,7 @@ public:
BrokerId() ;
virtual ~BrokerId() ;
virtual int getCommandType() ;
virtual p<string> getValue() ;
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()
{
this->brokerId = NULL ;
this->brokerURL = NULL ;
this->peerBrokerInfos = NULL ;
this->brokerName = NULL ;
this->slaveBroker = NULL ;
this->brokerId = 0 ;
this->brokerURL = 0 ;
this->peerBrokerInfos = 0 ;
this->brokerName = 0 ;
this->slaveBroker = 0 ;
}
BrokerInfo::~BrokerInfo()
@ -64,12 +64,12 @@ void BrokerInfo::setBrokerURL(p<string> brokerURL)
}
BrokerInfo[] BrokerInfo::getPeerBrokerInfos()
ap<BrokerInfo> BrokerInfo::getPeerBrokerInfos()
{
return peerBrokerInfos ;
}
void BrokerInfo::setPeerBrokerInfos(BrokerInfo[] peerBrokerInfos)
void BrokerInfo::setPeerBrokerInfos(ap<BrokerInfo> peerBrokerInfos)
{
this->peerBrokerInfos = peerBrokerInfos ;
}

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

@ -18,16 +18,12 @@
#define BrokerInfo_hpp_
#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/BrokerInfo.hpp"
#include "command/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +35,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -56,7 +53,7 @@ class BrokerInfo : public BaseCommand
private:
p<BrokerId> brokerId ;
p<string> brokerURL ;
BrokerInfo[] peerBrokerInfos ;
ap<BrokerInfo> peerBrokerInfos ;
p<string> brokerName ;
bool slaveBroker ;
@ -67,6 +64,7 @@ public:
BrokerInfo() ;
virtual ~BrokerInfo() ;
virtual int getCommandType() ;
virtual p<BrokerId> getBrokerId() ;
virtual void setBrokerId(p<BrokerId> brokerId) ;
@ -74,8 +72,8 @@ public:
virtual p<string> getBrokerURL() ;
virtual void setBrokerURL(p<string> brokerURL) ;
virtual BrokerInfo[] getPeerBrokerInfos() ;
virtual void setPeerBrokerInfos(BrokerInfo[] peerBrokerInfos) ;
virtual ap<BrokerInfo> getPeerBrokerInfos() ;
virtual void setPeerBrokerInfos(ap<BrokerInfo> peerBrokerInfos) ;
virtual p<string> getBrokerName() ;
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()
{
this->exception = NULL ;
this->connectionId = NULL ;
this->exception = 0 ;
this->connectionId = 0 ;
}
ConnectionError::~ConnectionError()
@ -39,12 +39,12 @@ ConnectionError::~ConnectionError()
}
BrokerError ConnectionError::getException()
p<BrokerError> ConnectionError::getException()
{
return exception ;
}
void ConnectionError::setException(BrokerError exception)
void ConnectionError::setException(p<BrokerError> exception)
{
this->exception = exception ;
}

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

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

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

@ -18,16 +18,10 @@
#define ConnectionId_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -63,6 +58,7 @@ public:
ConnectionId() ;
virtual ~ConnectionId() ;
virtual int getCommandType() ;
virtual p<string> getValue() ;
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()
{
this->connectionId = NULL ;
this->clientId = NULL ;
this->password = NULL ;
this->userName = NULL ;
this->brokerPath = NULL ;
this->connectionId = 0 ;
this->clientId = 0 ;
this->password = 0 ;
this->userName = 0 ;
this->brokerPath = 0 ;
}
ConnectionInfo::~ConnectionInfo()
@ -86,12 +86,12 @@ void ConnectionInfo::setUserName(p<string> userName)
}
BrokerId[] ConnectionInfo::getBrokerPath()
ap<BrokerId> ConnectionInfo::getBrokerPath()
{
return brokerPath ;
}
void ConnectionInfo::setBrokerPath(BrokerId[] brokerPath)
void ConnectionInfo::setBrokerPath(ap<BrokerId> brokerPath)
{
this->brokerPath = brokerPath ;
}

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

@ -18,16 +18,12 @@
#define ConnectionInfo_hpp_
#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/BrokerId.hpp"
#include "command/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +35,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -58,7 +55,7 @@ private:
p<string> clientId ;
p<string> password ;
p<string> userName ;
BrokerId[] brokerPath ;
ap<BrokerId> brokerPath ;
public:
const static int TYPE = 3;
@ -67,6 +64,7 @@ public:
ConnectionInfo() ;
virtual ~ConnectionInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ;
@ -80,8 +78,8 @@ public:
virtual p<string> getUserName() ;
virtual void setUserName(p<string> userName) ;
virtual BrokerId[] getBrokerPath() ;
virtual void setBrokerPath(BrokerId[] brokerPath) ;
virtual ap<BrokerId> getBrokerPath() ;
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()
{
this->connectionId = NULL ;
this->sessionId = NULL ;
this->value = NULL ;
this->connectionId = 0 ;
this->sessionId = 0 ;
this->value = 0 ;
}
ConsumerId::~ConsumerId()
@ -51,23 +51,23 @@ void ConsumerId::setConnectionId(p<string> connectionId)
}
long ConsumerId::getSessionId()
long long ConsumerId::getSessionId()
{
return sessionId ;
}
void ConsumerId::setSessionId(long sessionId)
void ConsumerId::setSessionId(long long sessionId)
{
this->sessionId = sessionId ;
}
long ConsumerId::getValue()
long long ConsumerId::getValue()
{
return value ;
}
void ConsumerId::setValue(long value)
void ConsumerId::setValue(long long value)
{
this->value = value ;
}

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

@ -18,16 +18,10 @@
#define ConsumerId_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,8 +50,8 @@ class ConsumerId : public AbstractCommand
{
private:
p<string> connectionId ;
long sessionId ;
long value ;
long long sessionId ;
long long value ;
public:
const static int TYPE = 122;
@ -65,15 +60,16 @@ public:
ConsumerId() ;
virtual ~ConsumerId() ;
virtual int getCommandType() ;
virtual p<string> getConnectionId() ;
virtual void setConnectionId(p<string> connectionId) ;
virtual long getSessionId() ;
virtual void setSessionId(long sessionId) ;
virtual long long getSessionId() ;
virtual void setSessionId(long long sessionId) ;
virtual long getValue() ;
virtual void setValue(long value) ;
virtual long long getValue() ;
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()
{
this->consumerId = NULL ;
this->browser = NULL ;
this->destination = NULL ;
this->prefetchSize = NULL ;
this->dispatchAsync = NULL ;
this->selector = NULL ;
this->subcriptionName = NULL ;
this->noLocal = NULL ;
this->exclusive = NULL ;
this->retroactive = NULL ;
this->priority = NULL ;
this->brokerPath = NULL ;
this->networkSubscription = NULL ;
this->consumerId = 0 ;
this->browser = 0 ;
this->destination = 0 ;
this->prefetchSize = 0 ;
this->dispatchAsync = 0 ;
this->selector = 0 ;
this->subcriptionName = 0 ;
this->noLocal = 0 ;
this->exclusive = 0 ;
this->retroactive = 0 ;
this->priority = 0 ;
this->brokerPath = 0 ;
this->networkSubscription = 0 ;
}
ConsumerInfo::~ConsumerInfo()
@ -72,12 +72,12 @@ void ConsumerInfo::setBrowser(bool browser)
}
ActiveMQDestination ConsumerInfo::getDestination()
p<ActiveMQDestination> ConsumerInfo::getDestination()
{
return destination ;
}
void ConsumerInfo::setDestination(ActiveMQDestination destination)
void ConsumerInfo::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}
@ -160,23 +160,23 @@ void ConsumerInfo::setRetroactive(bool retroactive)
}
byte ConsumerInfo::getPriority()
char ConsumerInfo::getPriority()
{
return priority ;
}
void ConsumerInfo::setPriority(byte priority)
void ConsumerInfo::setPriority(char priority)
{
this->priority = priority ;
}
BrokerId[] ConsumerInfo::getBrokerPath()
ap<BrokerId> ConsumerInfo::getBrokerPath()
{
return brokerPath ;
}
void ConsumerInfo::setBrokerPath(BrokerId[] brokerPath)
void ConsumerInfo::setBrokerPath(ap<BrokerId> brokerPath)
{
this->brokerPath = brokerPath ;
}

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

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

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

@ -18,16 +18,10 @@
#define ControlCommand_hpp_
#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/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -63,6 +58,7 @@ public:
ControlCommand() ;
virtual ~ControlCommand() ;
virtual int getCommandType() ;
virtual p<string> getCommand() ;
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()
{
this->data = NULL ;
this->data = 0 ;
}
DataArrayResponse::~DataArrayResponse()
@ -38,12 +38,12 @@ DataArrayResponse::~DataArrayResponse()
}
DataStructure[] DataArrayResponse::getData()
ap<IDataStructure> DataArrayResponse::getData()
{
return data ;
}
void DataArrayResponse::setData(DataStructure[] data)
void DataArrayResponse::setData(ap<IDataStructure> data)
{
this->data = data ;
}

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

@ -18,16 +18,11 @@
#define DataArrayResponse_hpp_
#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/IDataStructure.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -54,7 +50,7 @@ namespace apache
class DataArrayResponse : public Response
{
private:
DataStructure[] data ;
ap<IDataStructure> data ;
public:
const static int TYPE = 33;
@ -63,9 +59,10 @@ public:
DataArrayResponse() ;
virtual ~DataArrayResponse() ;
virtual int getCommandType() ;
virtual DataStructure[] getData() ;
virtual void setData(DataStructure[] data) ;
virtual ap<IDataStructure> getData() ;
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()
{
this->data = NULL ;
this->data = 0 ;
}
DataResponse::~DataResponse()
@ -38,12 +38,12 @@ DataResponse::~DataResponse()
}
DataStructure DataResponse::getData()
p<IDataStructure> DataResponse::getData()
{
return data ;
}
void DataResponse::setData(DataStructure data)
void DataResponse::setData(p<IDataStructure> data)
{
this->data = data ;
}

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

@ -18,16 +18,11 @@
#define DataResponse_hpp_
#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/IDataStructure.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -54,7 +50,7 @@ namespace apache
class DataResponse : public Response
{
private:
DataStructure data ;
p<IDataStructure> data ;
public:
const static int TYPE = 32;
@ -63,9 +59,10 @@ public:
DataResponse() ;
virtual ~DataResponse() ;
virtual int getCommandType() ;
virtual DataStructure getData() ;
virtual void setData(DataStructure data) ;
virtual p<IDataStructure> getData() ;
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()
{
this->connectionId = NULL ;
this->destination = NULL ;
this->operationType = NULL ;
this->timeout = NULL ;
this->brokerPath = NULL ;
this->connectionId = 0 ;
this->destination = 0 ;
this->operationType = 0 ;
this->timeout = 0 ;
this->brokerPath = 0 ;
}
DestinationInfo::~DestinationInfo()
@ -53,45 +53,45 @@ void DestinationInfo::setConnectionId(p<ConnectionId> connectionId)
}
ActiveMQDestination DestinationInfo::getDestination()
p<ActiveMQDestination> DestinationInfo::getDestination()
{
return destination ;
}
void DestinationInfo::setDestination(ActiveMQDestination destination)
void DestinationInfo::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}
byte DestinationInfo::getOperationType()
char DestinationInfo::getOperationType()
{
return operationType ;
}
void DestinationInfo::setOperationType(byte operationType)
void DestinationInfo::setOperationType(char operationType)
{
this->operationType = operationType ;
}
long DestinationInfo::getTimeout()
long long DestinationInfo::getTimeout()
{
return timeout ;
}
void DestinationInfo::setTimeout(long timeout)
void DestinationInfo::setTimeout(long long timeout)
{
this->timeout = timeout ;
}
BrokerId[] DestinationInfo::getBrokerPath()
ap<BrokerId> DestinationInfo::getBrokerPath()
{
return brokerPath ;
}
void DestinationInfo::setBrokerPath(BrokerId[] brokerPath)
void DestinationInfo::setBrokerPath(ap<BrokerId> brokerPath)
{
this->brokerPath = brokerPath ;
}

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

@ -18,16 +18,13 @@
#define DestinationInfo_hpp_
#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/ActiveMQDestination.hpp"
#include "command/BrokerId.hpp"
#include "command/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,10 +53,10 @@ class DestinationInfo : public BaseCommand
{
private:
p<ConnectionId> connectionId ;
ActiveMQDestination destination ;
byte operationType ;
long timeout ;
BrokerId[] brokerPath ;
p<ActiveMQDestination> destination ;
char operationType ;
long long timeout ;
ap<BrokerId> brokerPath ;
public:
const static int TYPE = 8;
@ -67,21 +65,22 @@ public:
DestinationInfo() ;
virtual ~DestinationInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ;
virtual ActiveMQDestination getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual byte getOperationType() ;
virtual void setOperationType(byte operationType) ;
virtual char getOperationType() ;
virtual void setOperationType(char operationType) ;
virtual long getTimeout() ;
virtual void setTimeout(long timeout) ;
virtual long long getTimeout() ;
virtual void setTimeout(long long timeout) ;
virtual BrokerId[] getBrokerPath() ;
virtual void setBrokerPath(BrokerId[] brokerPath) ;
virtual ap<BrokerId> getBrokerPath() ;
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()
{
this->serviceName = NULL ;
this->brokerName = NULL ;
this->serviceName = 0 ;
this->brokerName = 0 ;
}
DiscoveryEvent::~DiscoveryEvent()

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

@ -18,16 +18,10 @@
#define DiscoveryEvent_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -64,6 +59,7 @@ public:
DiscoveryEvent() ;
virtual ~DiscoveryEvent() ;
virtual int getCommandType() ;
virtual p<string> getServiceName() ;
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()
{
this->exception = NULL ;
this->exception = 0 ;
}
ExceptionResponse::~ExceptionResponse()
@ -38,12 +38,12 @@ ExceptionResponse::~ExceptionResponse()
}
BrokerError ExceptionResponse::getException()
p<BrokerError> ExceptionResponse::getException()
{
return exception ;
}
void ExceptionResponse::setException(BrokerError exception)
void ExceptionResponse::setException(p<BrokerError> exception)
{
this->exception = exception ;
}

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

@ -18,16 +18,11 @@
#define ExceptionResponse_hpp_
#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 "BrokerError.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -54,7 +50,7 @@ namespace apache
class ExceptionResponse : public Response
{
private:
BrokerError exception ;
p<BrokerError> exception ;
public:
const static int TYPE = 31;
@ -63,9 +59,10 @@ public:
ExceptionResponse() ;
virtual ~ExceptionResponse() ;
virtual int getCommandType() ;
virtual BrokerError getException() ;
virtual void setException(BrokerError exception) ;
virtual p<BrokerError> getException() ;
virtual void setException(p<BrokerError> exception) ;
} ;

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

@ -18,16 +18,10 @@
#define FlushCommand_hpp_
#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/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -62,6 +57,7 @@ public:
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()
{
this->result = NULL ;
this->result = 0 ;
}
IntegerResponse::~IntegerResponse()

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

@ -18,16 +18,10 @@
#define IntegerResponse_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -63,6 +58,7 @@ public:
IntegerResponse() ;
virtual ~IntegerResponse() ;
virtual int getCommandType() ;
virtual int getResult() ;
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()
{
this->destination = NULL ;
this->messageAck = NULL ;
this->destination = 0 ;
this->messageAck = 0 ;
}
JournalQueueAck::~JournalQueueAck()
@ -39,23 +39,23 @@ JournalQueueAck::~JournalQueueAck()
}
ActiveMQDestination JournalQueueAck::getDestination()
p<ActiveMQDestination> JournalQueueAck::getDestination()
{
return destination ;
}
void JournalQueueAck::setDestination(ActiveMQDestination destination)
void JournalQueueAck::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}
MessageAck JournalQueueAck::getMessageAck()
p<MessageAck> JournalQueueAck::getMessageAck()
{
return messageAck ;
}
void JournalQueueAck::setMessageAck(MessageAck messageAck)
void JournalQueueAck::setMessageAck(p<MessageAck> messageAck)
{
this->messageAck = messageAck ;
}

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

@ -18,16 +18,12 @@
#define JournalQueueAck_hpp_
#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/ActiveMQDestination.hpp"
#include "command/MessageAck.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +35,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -54,8 +51,8 @@ namespace apache
class JournalQueueAck : public AbstractCommand
{
private:
ActiveMQDestination destination ;
MessageAck messageAck ;
p<ActiveMQDestination> destination ;
p<MessageAck> messageAck ;
public:
const static int TYPE = 52;
@ -64,12 +61,13 @@ public:
JournalQueueAck() ;
virtual ~JournalQueueAck() ;
virtual int getCommandType() ;
virtual ActiveMQDestination getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual MessageAck getMessageAck() ;
virtual void setMessageAck(MessageAck messageAck) ;
virtual p<MessageAck> getMessageAck() ;
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()
{
this->destination = NULL ;
this->messageId = NULL ;
this->messageSequenceId = NULL ;
this->subscritionName = NULL ;
this->clientId = NULL ;
this->transactionId = NULL ;
this->destination = 0 ;
this->messageId = 0 ;
this->messageSequenceId = 0 ;
this->subscritionName = 0 ;
this->clientId = 0 ;
this->transactionId = 0 ;
}
JournalTopicAck::~JournalTopicAck()
@ -43,12 +43,12 @@ JournalTopicAck::~JournalTopicAck()
}
ActiveMQDestination JournalTopicAck::getDestination()
p<ActiveMQDestination> JournalTopicAck::getDestination()
{
return destination ;
}
void JournalTopicAck::setDestination(ActiveMQDestination destination)
void JournalTopicAck::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}
@ -65,12 +65,12 @@ void JournalTopicAck::setMessageId(p<MessageId> messageId)
}
long JournalTopicAck::getMessageSequenceId()
long long JournalTopicAck::getMessageSequenceId()
{
return messageSequenceId ;
}
void JournalTopicAck::setMessageSequenceId(long messageSequenceId)
void JournalTopicAck::setMessageSequenceId(long long messageSequenceId)
{
this->messageSequenceId = messageSequenceId ;
}

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

@ -18,16 +18,13 @@
#define JournalTopicAck_hpp_
#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/ActiveMQDestination.hpp"
#include "command/MessageId.hpp"
#include "command/TransactionId.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -54,9 +52,9 @@ namespace apache
class JournalTopicAck : public AbstractCommand
{
private:
ActiveMQDestination destination ;
p<ActiveMQDestination> destination ;
p<MessageId> messageId ;
long messageSequenceId ;
long long messageSequenceId ;
p<string> subscritionName ;
p<string> clientId ;
p<TransactionId> transactionId ;
@ -68,15 +66,16 @@ public:
JournalTopicAck() ;
virtual ~JournalTopicAck() ;
virtual int getCommandType() ;
virtual ActiveMQDestination getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<MessageId> getMessageId() ;
virtual void setMessageId(p<MessageId> messageId) ;
virtual long getMessageSequenceId() ;
virtual void setMessageSequenceId(long messageSequenceId) ;
virtual long long getMessageSequenceId() ;
virtual void setMessageSequenceId(long long messageSequenceId) ;
virtual p<string> getSubscritionName() ;
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()
{
this->message = NULL ;
this->message = 0 ;
}
JournalTrace::~JournalTrace()

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

@ -18,16 +18,10 @@
#define JournalTrace_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -63,6 +58,7 @@ public:
JournalTrace() ;
virtual ~JournalTrace() ;
virtual int getCommandType() ;
virtual p<string> getMessage() ;
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()
{
this->transactionId = NULL ;
this->type = NULL ;
this->wasPrepared = NULL ;
this->transactionId = 0 ;
this->type = 0 ;
this->wasPrepared = 0 ;
}
JournalTransaction::~JournalTransaction()
@ -51,12 +51,12 @@ void JournalTransaction::setTransactionId(p<TransactionId> transactionId)
}
byte JournalTransaction::getType()
char JournalTransaction::getType()
{
return type ;
}
void JournalTransaction::setType(byte type)
void JournalTransaction::setType(char type)
{
this->type = type ;
}

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

@ -18,16 +18,11 @@
#define JournalTransaction_hpp_
#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/TransactionId.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,7 +51,7 @@ class JournalTransaction : public AbstractCommand
{
private:
p<TransactionId> transactionId ;
byte type ;
char type ;
bool wasPrepared ;
public:
@ -65,12 +61,13 @@ public:
JournalTransaction() ;
virtual ~JournalTransaction() ;
virtual int getCommandType() ;
virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ;
virtual byte getType() ;
virtual void setType(byte type) ;
virtual char getType() ;
virtual void setType(char type) ;
virtual bool getWasPrepared() ;
virtual void setWasPrepared(bool wasPrepared) ;

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

@ -18,16 +18,10 @@
#define KeepAliveInfo_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -62,6 +57,7 @@ public:
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()
{
this->value = NULL ;
this->connectionId = NULL ;
this->value = 0 ;
this->connectionId = 0 ;
}
LocalTransactionId::~LocalTransactionId()
@ -39,12 +39,12 @@ LocalTransactionId::~LocalTransactionId()
}
long LocalTransactionId::getValue()
long long LocalTransactionId::getValue()
{
return value ;
}
void LocalTransactionId::setValue(long value)
void LocalTransactionId::setValue(long long value)
{
this->value = value ;
}

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

@ -18,16 +18,11 @@
#define LocalTransactionId_hpp_
#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/ConnectionId.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -54,7 +50,7 @@ namespace apache
class LocalTransactionId : public TransactionId
{
private:
long value ;
long long value ;
p<ConnectionId> connectionId ;
public:
@ -64,9 +60,10 @@ public:
LocalTransactionId() ;
virtual ~LocalTransactionId() ;
virtual int getCommandType() ;
virtual long getValue() ;
virtual void setValue(long value) ;
virtual long long getValue() ;
virtual void setValue(long long value) ;
virtual p<ConnectionId> getConnectionId() ;
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()
{
this->producerId = NULL ;
this->destination = NULL ;
this->transactionId = NULL ;
this->originalDestination = NULL ;
this->messageId = NULL ;
this->originalTransactionId = NULL ;
this->groupID = NULL ;
this->groupSequence = NULL ;
this->correlationId = NULL ;
this->persistent = NULL ;
this->expiration = NULL ;
this->priority = NULL ;
this->replyTo = NULL ;
this->timestamp = NULL ;
this->type = NULL ;
this->content = NULL ;
this->marshalledProperties = NULL ;
this->dataStructure = NULL ;
this->targetConsumerId = NULL ;
this->compressed = NULL ;
this->redeliveryCounter = NULL ;
this->brokerPath = NULL ;
this->arrival = NULL ;
this->userID = NULL ;
this->recievedByDFBridge = NULL ;
this->producerId = 0 ;
this->destination = 0 ;
this->transactionId = 0 ;
this->originalDestination = 0 ;
this->messageId = 0 ;
this->originalTransactionId = 0 ;
this->groupID = 0 ;
this->groupSequence = 0 ;
this->correlationId = 0 ;
this->persistent = 0 ;
this->expiration = 0 ;
this->priority = 0 ;
this->replyTo = 0 ;
this->timestamp = 0 ;
this->type = 0 ;
this->content = 0 ;
this->marshalledProperties = 0 ;
this->dataStructure = 0 ;
this->targetConsumerId = 0 ;
this->compressed = 0 ;
this->redeliveryCounter = 0 ;
this->brokerPath = 0 ;
this->arrival = 0 ;
this->userID = 0 ;
this->recievedByDFBridge = 0 ;
}
Message::~Message()
@ -73,12 +73,12 @@ void Message::setProducerId(p<ProducerId> producerId)
}
ActiveMQDestination Message::getDestination()
p<ActiveMQDestination> Message::getDestination()
{
return destination ;
}
void Message::setDestination(ActiveMQDestination destination)
void Message::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}
@ -95,12 +95,12 @@ void Message::setTransactionId(p<TransactionId> transactionId)
}
ActiveMQDestination Message::getOriginalDestination()
p<ActiveMQDestination> Message::getOriginalDestination()
{
return originalDestination ;
}
void Message::setOriginalDestination(ActiveMQDestination originalDestination)
void Message::setOriginalDestination(p<ActiveMQDestination> originalDestination)
{
this->originalDestination = originalDestination ;
}
@ -172,45 +172,45 @@ void Message::setPersistent(bool persistent)
}
long Message::getExpiration()
long long Message::getExpiration()
{
return expiration ;
}
void Message::setExpiration(long expiration)
void Message::setExpiration(long long expiration)
{
this->expiration = expiration ;
}
byte Message::getPriority()
char Message::getPriority()
{
return priority ;
}
void Message::setPriority(byte priority)
void Message::setPriority(char priority)
{
this->priority = priority ;
}
ActiveMQDestination Message::getReplyTo()
p<ActiveMQDestination> Message::getReplyTo()
{
return replyTo ;
}
void Message::setReplyTo(ActiveMQDestination replyTo)
void Message::setReplyTo(p<ActiveMQDestination> replyTo)
{
this->replyTo = replyTo ;
}
long Message::getTimestamp()
long long Message::getTimestamp()
{
return timestamp ;
}
void Message::setTimestamp(long timestamp)
void Message::setTimestamp(long long timestamp)
{
this->timestamp = timestamp ;
}
@ -227,34 +227,34 @@ void Message::setType(p<string> type)
}
void* Message::getContent()
char* Message::getContent()
{
return content ;
}
void Message::setContent(void* content)
void Message::setContent(char* content)
{
this->content = content ;
}
void* Message::getMarshalledProperties()
char* Message::getMarshalledProperties()
{
return marshalledProperties ;
}
void Message::setMarshalledProperties(void* marshalledProperties)
void Message::setMarshalledProperties(char* marshalledProperties)
{
this->marshalledProperties = marshalledProperties ;
}
DataStructure Message::getDataStructure()
p<IDataStructure> Message::getDataStructure()
{
return dataStructure ;
}
void Message::setDataStructure(DataStructure dataStructure)
void Message::setDataStructure(p<IDataStructure> dataStructure)
{
this->dataStructure = dataStructure ;
}
@ -293,23 +293,23 @@ void Message::setRedeliveryCounter(int redeliveryCounter)
}
BrokerId[] Message::getBrokerPath()
ap<BrokerId> Message::getBrokerPath()
{
return brokerPath ;
}
void Message::setBrokerPath(BrokerId[] brokerPath)
void Message::setBrokerPath(ap<BrokerId> brokerPath)
{
this->brokerPath = brokerPath ;
}
long Message::getArrival()
long long Message::getArrival()
{
return arrival ;
}
void Message::setArrival(long arrival)
void Message::setArrival(long long arrival)
{
this->arrival = arrival ;
}

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

@ -18,16 +18,20 @@
#define Message_hpp_
#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/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"
namespace apache
@ -39,6 +43,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,28 +60,28 @@ class Message : public BaseCommand
{
private:
p<ProducerId> producerId ;
ActiveMQDestination destination ;
p<ActiveMQDestination> destination ;
p<TransactionId> transactionId ;
ActiveMQDestination originalDestination ;
p<ActiveMQDestination> originalDestination ;
p<MessageId> messageId ;
p<TransactionId> originalTransactionId ;
p<string> groupID ;
int groupSequence ;
p<string> correlationId ;
bool persistent ;
long expiration ;
byte priority ;
ActiveMQDestination replyTo ;
long timestamp ;
long long expiration ;
char priority ;
p<ActiveMQDestination> replyTo ;
long long timestamp ;
p<string> type ;
void* content ;
void* marshalledProperties ;
DataStructure dataStructure ;
char* content ;
char* marshalledProperties ;
p<IDataStructure> dataStructure ;
p<ConsumerId> targetConsumerId ;
bool compressed ;
int redeliveryCounter ;
BrokerId[] brokerPath ;
long arrival ;
ap<BrokerId> brokerPath ;
long long arrival ;
p<string> userID ;
bool recievedByDFBridge ;
@ -87,18 +92,19 @@ public:
Message() ;
virtual ~Message() ;
virtual int getCommandType() ;
virtual p<ProducerId> getProducerId() ;
virtual void setProducerId(p<ProducerId> producerId) ;
virtual ActiveMQDestination getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ;
virtual ActiveMQDestination getOriginalDestination() ;
virtual void setOriginalDestination(ActiveMQDestination originalDestination) ;
virtual p<ActiveMQDestination> getOriginalDestination() ;
virtual void setOriginalDestination(p<ActiveMQDestination> originalDestination) ;
virtual p<MessageId> getMessageId() ;
virtual void setMessageId(p<MessageId> messageId) ;
@ -118,29 +124,29 @@ public:
virtual bool getPersistent() ;
virtual void setPersistent(bool persistent) ;
virtual long getExpiration() ;
virtual void setExpiration(long expiration) ;
virtual long long getExpiration() ;
virtual void setExpiration(long long expiration) ;
virtual byte getPriority() ;
virtual void setPriority(byte priority) ;
virtual char getPriority() ;
virtual void setPriority(char priority) ;
virtual ActiveMQDestination getReplyTo() ;
virtual void setReplyTo(ActiveMQDestination replyTo) ;
virtual p<ActiveMQDestination> getReplyTo() ;
virtual void setReplyTo(p<ActiveMQDestination> replyTo) ;
virtual long getTimestamp() ;
virtual void setTimestamp(long timestamp) ;
virtual long long getTimestamp() ;
virtual void setTimestamp(long long timestamp) ;
virtual p<string> getType() ;
virtual void setType(p<string> type) ;
virtual void* getContent() ;
virtual void setContent(void* content) ;
virtual char* getContent() ;
virtual void setContent(char* content) ;
virtual void* getMarshalledProperties() ;
virtual void setMarshalledProperties(void* marshalledProperties) ;
virtual char* getMarshalledProperties() ;
virtual void setMarshalledProperties(char* marshalledProperties) ;
virtual DataStructure getDataStructure() ;
virtual void setDataStructure(DataStructure dataStructure) ;
virtual p<IDataStructure> getDataStructure() ;
virtual void setDataStructure(p<IDataStructure> dataStructure) ;
virtual p<ConsumerId> getTargetConsumerId() ;
virtual void setTargetConsumerId(p<ConsumerId> targetConsumerId) ;
@ -151,11 +157,11 @@ public:
virtual int getRedeliveryCounter() ;
virtual void setRedeliveryCounter(int redeliveryCounter) ;
virtual BrokerId[] getBrokerPath() ;
virtual void setBrokerPath(BrokerId[] brokerPath) ;
virtual ap<BrokerId> getBrokerPath() ;
virtual void setBrokerPath(ap<BrokerId> brokerPath) ;
virtual long getArrival() ;
virtual void setArrival(long arrival) ;
virtual long long getArrival() ;
virtual void setArrival(long long arrival) ;
virtual p<string> getUserID() ;
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()
{
this->destination = NULL ;
this->transactionId = NULL ;
this->consumerId = NULL ;
this->ackType = NULL ;
this->firstMessageId = NULL ;
this->lastMessageId = NULL ;
this->messageCount = NULL ;
this->destination = 0 ;
this->transactionId = 0 ;
this->consumerId = 0 ;
this->ackType = 0 ;
this->firstMessageId = 0 ;
this->lastMessageId = 0 ;
this->messageCount = 0 ;
}
MessageAck::~MessageAck()
@ -44,12 +44,12 @@ MessageAck::~MessageAck()
}
ActiveMQDestination MessageAck::getDestination()
p<ActiveMQDestination> MessageAck::getDestination()
{
return destination ;
}
void MessageAck::setDestination(ActiveMQDestination destination)
void MessageAck::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}
@ -77,12 +77,12 @@ void MessageAck::setConsumerId(p<ConsumerId> consumerId)
}
byte MessageAck::getAckType()
char MessageAck::getAckType()
{
return ackType ;
}
void MessageAck::setAckType(byte ackType)
void MessageAck::setAckType(char ackType)
{
this->ackType = ackType ;
}

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

@ -18,16 +18,15 @@
#define MessageAck_hpp_
#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/ActiveMQDestination.hpp"
#include "command/TransactionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "command/MessageId.hpp"
#include "command/MessageId.hpp"
#include "command/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +38,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -54,10 +54,10 @@ namespace apache
class MessageAck : public BaseCommand
{
private:
ActiveMQDestination destination ;
p<ActiveMQDestination> destination ;
p<TransactionId> transactionId ;
p<ConsumerId> consumerId ;
byte ackType ;
char ackType ;
p<MessageId> firstMessageId ;
p<MessageId> lastMessageId ;
int messageCount ;
@ -69,9 +69,10 @@ public:
MessageAck() ;
virtual ~MessageAck() ;
virtual int getCommandType() ;
virtual ActiveMQDestination getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ;
@ -79,8 +80,8 @@ public:
virtual p<ConsumerId> getConsumerId() ;
virtual void setConsumerId(p<ConsumerId> consumerId) ;
virtual byte getAckType() ;
virtual void setAckType(byte ackType) ;
virtual char getAckType() ;
virtual void setAckType(char ackType) ;
virtual p<MessageId> getFirstMessageId() ;
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()
{
this->consumerId = NULL ;
this->destination = NULL ;
this->message = NULL ;
this->redeliveryCounter = NULL ;
this->consumerId = 0 ;
this->destination = 0 ;
this->message = 0 ;
this->redeliveryCounter = 0 ;
}
MessageDispatch::~MessageDispatch()
@ -52,23 +52,23 @@ void MessageDispatch::setConsumerId(p<ConsumerId> consumerId)
}
ActiveMQDestination MessageDispatch::getDestination()
p<ActiveMQDestination> MessageDispatch::getDestination()
{
return destination ;
}
void MessageDispatch::setDestination(ActiveMQDestination destination)
void MessageDispatch::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}
Message MessageDispatch::getMessage()
p<Message> MessageDispatch::getMessage()
{
return message ;
}
void MessageDispatch::setMessage(Message message)
void MessageDispatch::setMessage(p<Message> message)
{
this->message = message ;
}

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

@ -18,16 +18,13 @@
#define MessageDispatch_hpp_
#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/ActiveMQDestination.hpp"
#include "command/Message.hpp"
#include "command/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,8 +53,8 @@ class MessageDispatch : public BaseCommand
{
private:
p<ConsumerId> consumerId ;
ActiveMQDestination destination ;
Message message ;
p<ActiveMQDestination> destination ;
p<Message> message ;
int redeliveryCounter ;
public:
@ -66,15 +64,16 @@ public:
MessageDispatch() ;
virtual ~MessageDispatch() ;
virtual int getCommandType() ;
virtual p<ConsumerId> getConsumerId() ;
virtual void setConsumerId(p<ConsumerId> consumerId) ;
virtual ActiveMQDestination getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual Message getMessage() ;
virtual void setMessage(Message message) ;
virtual p<Message> getMessage() ;
virtual void setMessage(p<Message> message) ;
virtual int getRedeliveryCounter() ;
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()
{
this->consumerId = NULL ;
this->destination = NULL ;
this->deliverySequenceId = NULL ;
this->messageId = NULL ;
this->consumerId = 0 ;
this->destination = 0 ;
this->deliverySequenceId = 0 ;
this->messageId = 0 ;
}
MessageDispatchNotification::~MessageDispatchNotification()
@ -52,23 +52,23 @@ void MessageDispatchNotification::setConsumerId(p<ConsumerId> consumerId)
}
ActiveMQDestination MessageDispatchNotification::getDestination()
p<ActiveMQDestination> MessageDispatchNotification::getDestination()
{
return destination ;
}
void MessageDispatchNotification::setDestination(ActiveMQDestination destination)
void MessageDispatchNotification::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}
long MessageDispatchNotification::getDeliverySequenceId()
long long MessageDispatchNotification::getDeliverySequenceId()
{
return deliverySequenceId ;
}
void MessageDispatchNotification::setDeliverySequenceId(long deliverySequenceId)
void MessageDispatchNotification::setDeliverySequenceId(long long deliverySequenceId)
{
this->deliverySequenceId = deliverySequenceId ;
}

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

@ -18,16 +18,13 @@
#define MessageDispatchNotification_hpp_
#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/ActiveMQDestination.hpp"
#include "command/MessageId.hpp"
#include "command/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,8 +53,8 @@ class MessageDispatchNotification : public BaseCommand
{
private:
p<ConsumerId> consumerId ;
ActiveMQDestination destination ;
long deliverySequenceId ;
p<ActiveMQDestination> destination ;
long long deliverySequenceId ;
p<MessageId> messageId ;
public:
@ -66,15 +64,16 @@ public:
MessageDispatchNotification() ;
virtual ~MessageDispatchNotification() ;
virtual int getCommandType() ;
virtual p<ConsumerId> getConsumerId() ;
virtual void setConsumerId(p<ConsumerId> consumerId) ;
virtual ActiveMQDestination getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual long getDeliverySequenceId() ;
virtual void setDeliverySequenceId(long deliverySequenceId) ;
virtual long long getDeliverySequenceId() ;
virtual void setDeliverySequenceId(long long deliverySequenceId) ;
virtual p<MessageId> getMessageId() ;
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()
{
this->producerId = NULL ;
this->producerSequenceId = NULL ;
this->brokerSequenceId = NULL ;
this->producerId = 0 ;
this->producerSequenceId = 0 ;
this->brokerSequenceId = 0 ;
}
MessageId::~MessageId()
@ -51,23 +51,23 @@ void MessageId::setProducerId(p<ProducerId> producerId)
}
long MessageId::getProducerSequenceId()
long long MessageId::getProducerSequenceId()
{
return producerSequenceId ;
}
void MessageId::setProducerSequenceId(long producerSequenceId)
void MessageId::setProducerSequenceId(long long producerSequenceId)
{
this->producerSequenceId = producerSequenceId ;
}
long MessageId::getBrokerSequenceId()
long long MessageId::getBrokerSequenceId()
{
return brokerSequenceId ;
}
void MessageId::setBrokerSequenceId(long brokerSequenceId)
void MessageId::setBrokerSequenceId(long long brokerSequenceId)
{
this->brokerSequenceId = brokerSequenceId ;
}

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

@ -18,16 +18,11 @@
#define MessageId_hpp_
#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/ProducerId.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,8 +51,8 @@ class MessageId : public AbstractCommand
{
private:
p<ProducerId> producerId ;
long producerSequenceId ;
long brokerSequenceId ;
long long producerSequenceId ;
long long brokerSequenceId ;
public:
const static int TYPE = 110;
@ -65,15 +61,16 @@ public:
MessageId() ;
virtual ~MessageId() ;
virtual int getCommandType() ;
virtual p<ProducerId> getProducerId() ;
virtual void setProducerId(p<ProducerId> producerId) ;
virtual long getProducerSequenceId() ;
virtual void setProducerSequenceId(long producerSequenceId) ;
virtual long long getProducerSequenceId() ;
virtual void setProducerSequenceId(long long producerSequenceId) ;
virtual long getBrokerSequenceId() ;
virtual void setBrokerSequenceId(long brokerSequenceId) ;
virtual long long getBrokerSequenceId() ;
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()
{
this->connectionId = NULL ;
this->value = NULL ;
this->sessionId = NULL ;
this->connectionId = 0 ;
this->value = 0 ;
this->sessionId = 0 ;
}
ProducerId::~ProducerId()
@ -51,23 +51,23 @@ void ProducerId::setConnectionId(p<string> connectionId)
}
long ProducerId::getValue()
long long ProducerId::getValue()
{
return value ;
}
void ProducerId::setValue(long value)
void ProducerId::setValue(long long value)
{
this->value = value ;
}
long ProducerId::getSessionId()
long long ProducerId::getSessionId()
{
return sessionId ;
}
void ProducerId::setSessionId(long sessionId)
void ProducerId::setSessionId(long long sessionId)
{
this->sessionId = sessionId ;
}

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

@ -18,16 +18,10 @@
#define ProducerId_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,8 +50,8 @@ class ProducerId : public AbstractCommand
{
private:
p<string> connectionId ;
long value ;
long sessionId ;
long long value ;
long long sessionId ;
public:
const static int TYPE = 123;
@ -65,15 +60,16 @@ public:
ProducerId() ;
virtual ~ProducerId() ;
virtual int getCommandType() ;
virtual p<string> getConnectionId() ;
virtual void setConnectionId(p<string> connectionId) ;
virtual long getValue() ;
virtual void setValue(long value) ;
virtual long long getValue() ;
virtual void setValue(long long value) ;
virtual long getSessionId() ;
virtual void setSessionId(long sessionId) ;
virtual long long getSessionId() ;
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()
{
this->producerId = NULL ;
this->destination = NULL ;
this->brokerPath = NULL ;
this->producerId = 0 ;
this->destination = 0 ;
this->brokerPath = 0 ;
}
ProducerInfo::~ProducerInfo()
@ -51,23 +51,23 @@ void ProducerInfo::setProducerId(p<ProducerId> producerId)
}
ActiveMQDestination ProducerInfo::getDestination()
p<ActiveMQDestination> ProducerInfo::getDestination()
{
return destination ;
}
void ProducerInfo::setDestination(ActiveMQDestination destination)
void ProducerInfo::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}
BrokerId[] ProducerInfo::getBrokerPath()
ap<BrokerId> ProducerInfo::getBrokerPath()
{
return brokerPath ;
}
void ProducerInfo::setBrokerPath(BrokerId[] brokerPath)
void ProducerInfo::setBrokerPath(ap<BrokerId> brokerPath)
{
this->brokerPath = brokerPath ;
}

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

@ -18,16 +18,13 @@
#define ProducerInfo_hpp_
#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/ActiveMQDestination.hpp"
#include "command/BrokerId.hpp"
#include "command/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +36,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,8 +53,8 @@ class ProducerInfo : public BaseCommand
{
private:
p<ProducerId> producerId ;
ActiveMQDestination destination ;
BrokerId[] brokerPath ;
p<ActiveMQDestination> destination ;
ap<BrokerId> brokerPath ;
public:
const static int TYPE = 6;
@ -65,15 +63,16 @@ public:
ProducerInfo() ;
virtual ~ProducerInfo() ;
virtual int getCommandType() ;
virtual p<ProducerId> getProducerId() ;
virtual void setProducerId(p<ProducerId> producerId) ;
virtual ActiveMQDestination getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual BrokerId[] getBrokerPath() ;
virtual void setBrokerPath(BrokerId[] brokerPath) ;
virtual ap<BrokerId> getBrokerPath() ;
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()
{
this->objectId = NULL ;
this->objectId = 0 ;
}
RemoveInfo::~RemoveInfo()
@ -38,12 +38,12 @@ RemoveInfo::~RemoveInfo()
}
DataStructure RemoveInfo::getObjectId()
p<IDataStructure> RemoveInfo::getObjectId()
{
return objectId ;
}
void RemoveInfo::setObjectId(DataStructure objectId)
void RemoveInfo::setObjectId(p<IDataStructure> objectId)
{
this->objectId = objectId ;
}

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

@ -18,16 +18,11 @@
#define RemoveInfo_hpp_
#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/BaseCommand.hpp"
#include "command/IDataStructure.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -54,7 +50,7 @@ namespace apache
class RemoveInfo : public BaseCommand
{
private:
DataStructure objectId ;
p<IDataStructure> objectId ;
public:
const static int TYPE = 12;
@ -63,9 +59,10 @@ public:
RemoveInfo() ;
virtual ~RemoveInfo() ;
virtual int getCommandType() ;
virtual DataStructure getObjectId() ;
virtual void setObjectId(DataStructure objectId) ;
virtual p<IDataStructure> getObjectId() ;
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()
{
this->connectionId = NULL ;
this->subcriptionName = NULL ;
this->clientId = NULL ;
this->connectionId = 0 ;
this->subcriptionName = 0 ;
this->clientId = 0 ;
}
RemoveSubscriptionInfo::~RemoveSubscriptionInfo()

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

@ -18,16 +18,11 @@
#define RemoveSubscriptionInfo_hpp_
#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/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -65,6 +61,7 @@ public:
RemoveSubscriptionInfo() ;
virtual ~RemoveSubscriptionInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ;
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()
{
this->correlationId = NULL ;
this->correlationId = 0 ;
}
Response::~Response()

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

@ -18,16 +18,10 @@
#define Response_hpp_
#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/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -63,6 +58,7 @@ public:
Response() ;
virtual ~Response() ;
virtual int getCommandType() ;
virtual short getCorrelationId() ;
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()
{
this->connectionId = NULL ;
this->value = NULL ;
this->connectionId = 0 ;
this->value = 0 ;
}
SessionId::~SessionId()
@ -50,12 +50,12 @@ void SessionId::setConnectionId(p<string> connectionId)
}
long SessionId::getValue()
long long SessionId::getValue()
{
return value ;
}
void SessionId::setValue(long value)
void SessionId::setValue(long long value)
{
this->value = value ;
}

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

@ -18,16 +18,10 @@
#define SessionId_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,7 +50,7 @@ class SessionId : public AbstractCommand
{
private:
p<string> connectionId ;
long value ;
long long value ;
public:
const static int TYPE = 121;
@ -64,12 +59,13 @@ public:
SessionId() ;
virtual ~SessionId() ;
virtual int getCommandType() ;
virtual p<string> getConnectionId() ;
virtual void setConnectionId(p<string> connectionId) ;
virtual long getValue() ;
virtual void setValue(long value) ;
virtual long long getValue() ;
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()
{
this->sessionId = NULL ;
this->sessionId = 0 ;
}
SessionInfo::~SessionInfo()

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

@ -18,16 +18,11 @@
#define SessionInfo_hpp_
#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/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -63,6 +59,7 @@ public:
SessionInfo() ;
virtual ~SessionInfo() ;
virtual int getCommandType() ;
virtual p<SessionId> getSessionId() ;
virtual void setSessionId(p<SessionId> sessionId) ;

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

@ -18,16 +18,10 @@
#define ShutdownInfo_hpp_
#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/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -62,6 +57,7 @@ public:
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()
{
this->clientId = NULL ;
this->destination = NULL ;
this->selector = NULL ;
this->subcriptionName = NULL ;
this->clientId = 0 ;
this->destination = 0 ;
this->selector = 0 ;
this->subcriptionName = 0 ;
}
SubscriptionInfo::~SubscriptionInfo()
@ -52,12 +52,12 @@ void SubscriptionInfo::setClientId(p<string> clientId)
}
ActiveMQDestination SubscriptionInfo::getDestination()
p<ActiveMQDestination> SubscriptionInfo::getDestination()
{
return destination ;
}
void SubscriptionInfo::setDestination(ActiveMQDestination destination)
void SubscriptionInfo::setDestination(p<ActiveMQDestination> destination)
{
this->destination = destination ;
}

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

@ -18,16 +18,11 @@
#define SubscriptionInfo_hpp_
#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/ActiveMQDestination.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +34,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,7 +51,7 @@ class SubscriptionInfo : public AbstractCommand
{
private:
p<string> clientId ;
ActiveMQDestination destination ;
p<ActiveMQDestination> destination ;
p<string> selector ;
p<string> subcriptionName ;
@ -66,12 +62,13 @@ public:
SubscriptionInfo() ;
virtual ~SubscriptionInfo() ;
virtual int getCommandType() ;
virtual p<string> getClientId() ;
virtual void setClientId(p<string> clientId) ;
virtual ActiveMQDestination getDestination() ;
virtual void setDestination(ActiveMQDestination destination) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<string> getSelector() ;
virtual void setSelector(p<string> selector) ;

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

@ -18,16 +18,10 @@
#define TransactionId_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -62,6 +57,7 @@ public:
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()
{
this->connectionId = NULL ;
this->transactionId = NULL ;
this->type = NULL ;
this->connectionId = 0 ;
this->transactionId = 0 ;
this->type = 0 ;
}
TransactionInfo::~TransactionInfo()
@ -62,12 +62,12 @@ void TransactionInfo::setTransactionId(p<TransactionId> transactionId)
}
byte TransactionInfo::getType()
char TransactionInfo::getType()
{
return type ;
}
void TransactionInfo::setType(byte type)
void TransactionInfo::setType(char type)
{
this->type = type ;
}

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

@ -18,16 +18,12 @@
#define TransactionInfo_hpp_
#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/BaseCommand.hpp"
#include "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +35,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -56,7 +53,7 @@ class TransactionInfo : public BaseCommand
private:
p<ConnectionId> connectionId ;
p<TransactionId> transactionId ;
byte type ;
char type ;
public:
const static int TYPE = 7;
@ -65,6 +62,7 @@ public:
TransactionInfo() ;
virtual ~TransactionInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ;
@ -72,8 +70,8 @@ public:
virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ;
virtual byte getType() ;
virtual void setType(byte type) ;
virtual char getType() ;
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()
{
this->magic = NULL ;
this->version = NULL ;
this->cacheEnabled = NULL ;
this->stackTraceEnabled = NULL ;
this->tcpNoDelayEnabled = NULL ;
this->prefixPacketSize = NULL ;
this->tightEncodingEnabled = NULL ;
this->magic = 0 ;
this->version = 0 ;
this->cacheEnabled = 0 ;
this->stackTraceEnabled = 0 ;
this->tcpNoDelayEnabled = 0 ;
this->prefixPacketSize = 0 ;
this->tightEncodingEnabled = 0 ;
}
WireFormatInfo::~WireFormatInfo()
@ -44,12 +44,12 @@ WireFormatInfo::~WireFormatInfo()
}
byte[] WireFormatInfo::getMagic()
ap<char> WireFormatInfo::getMagic()
{
return magic ;
}
void WireFormatInfo::setMagic(byte[] magic)
void WireFormatInfo::setMagic(ap<char> magic)
{
this->magic = magic ;
}

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

@ -18,16 +18,10 @@
#define WireFormatInfo_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -54,7 +49,7 @@ namespace apache
class WireFormatInfo : public AbstractCommand
{
private:
byte[] magic ;
ap<char> magic ;
int version ;
bool cacheEnabled ;
bool stackTraceEnabled ;
@ -69,9 +64,10 @@ public:
WireFormatInfo() ;
virtual ~WireFormatInfo() ;
virtual int getCommandType() ;
virtual byte[] getMagic() ;
virtual void setMagic(byte[] magic) ;
virtual ap<char> getMagic() ;
virtual void setMagic(ap<char> magic) ;
virtual int getVersion() ;
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()
{
this->formatId = NULL ;
this->globalTransactionId = NULL ;
this->branchQualifier = NULL ;
this->formatId = 0 ;
this->globalTransactionId = 0 ;
this->branchQualifier = 0 ;
}
XATransactionId::~XATransactionId()
@ -51,23 +51,23 @@ void XATransactionId::setFormatId(int formatId)
}
byte[] XATransactionId::getGlobalTransactionId()
ap<char> XATransactionId::getGlobalTransactionId()
{
return globalTransactionId ;
}
void XATransactionId::setGlobalTransactionId(byte[] globalTransactionId)
void XATransactionId::setGlobalTransactionId(ap<char> globalTransactionId)
{
this->globalTransactionId = globalTransactionId ;
}
byte[] XATransactionId::getBranchQualifier()
ap<char> XATransactionId::getBranchQualifier()
{
return branchQualifier ;
}
void XATransactionId::setBranchQualifier(byte[] branchQualifier)
void XATransactionId::setBranchQualifier(ap<char> branchQualifier)
{
this->branchQualifier = branchQualifier ;
}

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

@ -18,16 +18,10 @@
#define XATransactionId_hpp_
#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 "util/ifr/ap"
#include "util/ifr/p"
namespace apache
@ -39,6 +33,7 @@ namespace apache
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
@ -55,8 +50,8 @@ class XATransactionId : public TransactionId
{
private:
int formatId ;
byte[] globalTransactionId ;
byte[] branchQualifier ;
ap<char> globalTransactionId ;
ap<char> branchQualifier ;
public:
const static int TYPE = 112;
@ -65,15 +60,16 @@ public:
XATransactionId() ;
virtual ~XATransactionId() ;
virtual int getCommandType() ;
virtual int getFormatId() ;
virtual void setFormatId(int formatId) ;
virtual byte[] getGlobalTransactionId() ;
virtual void setGlobalTransactionId(byte[] globalTransactionId) ;
virtual ap<char> getGlobalTransactionId() ;
virtual void setGlobalTransactionId(ap<char> globalTransactionId) ;
virtual byte[] getBranchQualifier() ;
virtual void setBranchQualifier(byte[] branchQualifier) ;
virtual ap<char> getBranchQualifier() ;
virtual void setBranchQualifier(ap<char> branchQualifier) ;
} ;