jessequ
/
qamqp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

missed a few namespace cleanups

This commit is contained in:
Matt Broadstone 2014-05-28 16:28:45 -04:00
parent 7a708cc39a
commit 8f39b2a367
6 changed files with 117 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/amqp_channel_p.h
View File

@ -25,8 +25,7 @@ public:
csRunning csRunning
}; };
enum BasicMethod enum BasicMethod {
{
METHOD_ID_ENUM(bmQos, 10), METHOD_ID_ENUM(bmQos, 10),
METHOD_ID_ENUM(bmConsume, 20), METHOD_ID_ENUM(bmConsume, 20),
METHOD_ID_ENUM(bmCancel, 30), METHOD_ID_ENUM(bmCancel, 30),
@ -54,18 +53,18 @@ public:
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
void openOk(const QAMQP::Frame::Method &frame); void openOk(const Frame::Method &frame);
void flow(const QAMQP::Frame::Method &frame); void flow(const Frame::Method &frame);
void flowOk(const QAMQP::Frame::Method &frame); void flowOk(const Frame::Method &frame);
void close(const QAMQP::Frame::Method &frame); void close(const Frame::Method &frame);
void closeOk(const QAMQP::Frame::Method &frame); void closeOk(const Frame::Method &frame);
virtual bool _q_method(const QAMQP::Frame::Method &frame); virtual bool _q_method(const Frame::Method &frame);
virtual void _q_disconnected(); virtual void _q_disconnected();
void _q_open(); void _q_open();
void setQOS(qint32 prefetchSize, quint16 prefetchCount); void setQOS(qint32 prefetchSize, quint16 prefetchCount);
void sendFrame(const QAMQP::Frame::Base &frame); void sendFrame(const Frame::Base &frame);
QPointer<Client> client_; QPointer<Client> client_;
@ -76,7 +75,7 @@ public:
bool opened; bool opened;
bool needOpen; bool needOpen;
Q_DECLARE_PUBLIC(QAMQP::Channel) Q_DECLARE_PUBLIC(Channel)
Channel * const q_ptr; Channel * const q_ptr;
}; };

134
src/amqp_client.cpp
View File

@ -26,13 +26,13 @@ ClientPrivate::~ClientPrivate()
void ClientPrivate::init(QObject *parent) void ClientPrivate::init(QObject *parent)
{ {
Q_Q(QAMQP::Client); Q_Q(Client);
q->setParent(parent); q->setParent(parent);
if (!network_) if (!network_)
network_ = new QAMQP::Network(q); network_ = new Network(q);
if (!connection_) if (!connection_)
connection_ = new QAMQP::Connection(q); connection_ = new Connection(q);
network_->setMethodHandlerConnection(connection_); network_->setMethodHandlerConnection(connection_);
setAuth(new AMQPlainAuthenticator(QString::fromLatin1(AMQPLOGIN), QString::fromLatin1(AMQPPSWD))); setAuth(new AMQPlainAuthenticator(QString::fromLatin1(AMQPLOGIN), QString::fromLatin1(AMQPPSWD)));
@ -75,7 +75,7 @@ void ClientPrivate::connect()
void ClientPrivate::parseConnectionString(const QUrl &connectionString) void ClientPrivate::parseConnectionString(const QUrl &connectionString)
{ {
Q_Q(QAMQP::Client); Q_Q(Client);
if (connectionString.scheme() != AMQPSCHEME && if (connectionString.scheme() != AMQPSCHEME &&
connectionString.scheme() != AMQPSSCHEME) { connectionString.scheme() != AMQPSSCHEME) {
qDebug() << Q_FUNC_INFO << "invalid scheme: " << connectionString.scheme(); qDebug() << Q_FUNC_INFO << "invalid scheme: " << connectionString.scheme();
@ -103,7 +103,7 @@ void ClientPrivate::login()
Exchange *ClientPrivate::createExchange(int channelNumber, const QString &name) Exchange *ClientPrivate::createExchange(int channelNumber, const QString &name)
{ {
Q_Q(QAMQP::Client); Q_Q(Client);
Exchange * exchange_ = new Exchange(channelNumber, q); Exchange * exchange_ = new Exchange(channelNumber, q);
network_->addMethodHandlerForChannel(exchange_->channelNumber(), exchange_); network_->addMethodHandlerForChannel(exchange_->channelNumber(), exchange_);
@ -118,7 +118,7 @@ Exchange *ClientPrivate::createExchange(int channelNumber, const QString &name)
Queue *ClientPrivate::createQueue(int channelNumber, const QString &name ) Queue *ClientPrivate::createQueue(int channelNumber, const QString &name )
{ {
Q_Q(QAMQP::Client); Q_Q(Client);
Queue *queue_ = new Queue(channelNumber, q); Queue *queue_ = new Queue(channelNumber, q);
network_->addMethodHandlerForChannel(queue_->channelNumber(), queue_); network_->addMethodHandlerForChannel(queue_->channelNumber(), queue_);
@ -135,7 +135,7 @@ Queue *ClientPrivate::createQueue(int channelNumber, const QString &name )
void ClientPrivate::disconnect() void ClientPrivate::disconnect()
{ {
Q_Q(QAMQP::Client); Q_Q(Client);
if (network_->state() != QAbstractSocket::UnconnectedState) { if (network_->state() != QAbstractSocket::UnconnectedState) {
network_->disconnect(); network_->disconnect();
connection_->d_func()->connected = false; connection_->d_func()->connected = false;
@ -145,62 +145,62 @@ void ClientPrivate::disconnect()
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
QAMQP::Client::Client(QObject *parent) Client::Client(QObject *parent)
: QObject(parent), : QObject(parent),
d_ptr(new ClientPrivate(this)) d_ptr(new ClientPrivate(this))
{ {
d_ptr->init(parent); d_ptr->init(parent);
} }
QAMQP::Client::Client(const QUrl & connectionString, QObject * parent) Client::Client(const QUrl & connectionString, QObject * parent)
: d_ptr(new ClientPrivate(this)) : d_ptr(new ClientPrivate(this))
{ {
d_ptr->init(parent, connectionString); d_ptr->init(parent, connectionString);
} }
QAMQP::Client::~Client() Client::~Client()
{ {
} }
quint16 QAMQP::Client::port() const quint16 Client::port() const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
return d->port; return d->port;
} }
void QAMQP::Client::setPort(quint16 port) void Client::setPort(quint16 port)
{ {
Q_D(QAMQP::Client); Q_D(Client);
d->port = port; d->port = port;
} }
QString QAMQP::Client::host() const QString Client::host() const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
return d->host; return d->host;
} }
void QAMQP::Client::setHost( const QString & host ) void Client::setHost( const QString & host )
{ {
Q_D(QAMQP::Client); Q_D(Client);
d->host = host; d->host = host;
} }
QString QAMQP::Client::virtualHost() const QString Client::virtualHost() const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
return d->virtualHost; return d->virtualHost;
} }
void QAMQP::Client::setVirtualHost(const QString &virtualHost) void Client::setVirtualHost(const QString &virtualHost)
{ {
Q_D(QAMQP::Client); Q_D(Client);
d->virtualHost = virtualHost; d->virtualHost = virtualHost;
} }
QString QAMQP::Client::user() const QString Client::user() const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
const Authenticator * auth = d->auth_.data(); const Authenticator * auth = d->auth_.data();
if (auth && auth->type() == QLatin1String("AMQPLAIN")) { if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth); const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth);
@ -210,9 +210,9 @@ QString QAMQP::Client::user() const
return QString(); return QString();
} }
void QAMQP::Client::setUser(const QString &user) void Client::setUser(const QString &user)
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
Authenticator * auth = d->auth_.data(); Authenticator * auth = d->auth_.data();
if (auth && auth->type() == QLatin1String("AMQPLAIN")) { if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth); AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth);
@ -220,9 +220,9 @@ void QAMQP::Client::setUser(const QString &user)
} }
} }
QString QAMQP::Client::password() const QString Client::password() const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
const Authenticator * auth = d->auth_.data(); const Authenticator * auth = d->auth_.data();
if (auth && auth->type() == "AMQPLAIN") { if (auth && auth->type() == "AMQPLAIN") {
const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth); const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth);
@ -232,9 +232,9 @@ QString QAMQP::Client::password() const
return QString(); return QString();
} }
void QAMQP::Client::setPassword(const QString &password) void Client::setPassword(const QString &password)
{ {
Q_D(QAMQP::Client); Q_D(Client);
Authenticator *auth = d->auth_.data(); Authenticator *auth = d->auth_.data();
if (auth && auth->type() == QLatin1String("AMQPLAIN")) { if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth); AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth);
@ -242,119 +242,119 @@ void QAMQP::Client::setPassword(const QString &password)
} }
} }
void QAMQP::Client::printConnect() const void Client::printConnect() const
{ {
#ifdef _DEBUG #ifdef _DEBUG
Q_D(const QAMQP::Client); Q_D(const Client);
d->printConnect(); d->printConnect();
#endif // _DEBUG #endif // _DEBUG
} }
void QAMQP::Client::closeChannel() void Client::closeChannel()
{ {
} }
Exchange *QAMQP::Client::createExchange(int channelNumber) Exchange *Client::createExchange(int channelNumber)
{ {
Q_D(QAMQP::Client); Q_D(Client);
return d->createExchange(channelNumber, QString()); return d->createExchange(channelNumber, QString());
} }
Exchange *QAMQP::Client::createExchange( const QString &name, int channelNumber ) Exchange *Client::createExchange( const QString &name, int channelNumber )
{ {
Q_D(QAMQP::Client); Q_D(Client);
return d->createExchange(channelNumber, name); return d->createExchange(channelNumber, name);
} }
Queue *QAMQP::Client::createQueue(int channelNumber) Queue *Client::createQueue(int channelNumber)
{ {
Q_D(QAMQP::Client); Q_D(Client);
return d->createQueue(channelNumber, QString()); return d->createQueue(channelNumber, QString());
} }
Queue *QAMQP::Client::createQueue( const QString &name, int channelNumber ) Queue *Client::createQueue( const QString &name, int channelNumber )
{ {
Q_D(QAMQP::Client); Q_D(Client);
return d->createQueue(channelNumber, name); return d->createQueue(channelNumber, name);
} }
void QAMQP::Client::open() void Client::open()
{ {
Q_D(QAMQP::Client); Q_D(Client);
return d->connect(); return d->connect();
} }
void QAMQP::Client::open(const QUrl &connectionString) void Client::open(const QUrl &connectionString)
{ {
Q_D(QAMQP::Client); Q_D(Client);
d->parseConnectionString(connectionString); d->parseConnectionString(connectionString);
open(); open();
} }
void QAMQP::Client::close() void Client::close()
{ {
Q_D(QAMQP::Client); Q_D(Client);
return d->disconnect(); return d->disconnect();
} }
void QAMQP::Client::reopen() void Client::reopen()
{ {
Q_D(QAMQP::Client); Q_D(Client);
d->disconnect(); d->disconnect();
d->connect(); d->connect();
} }
void QAMQP::Client::setAuth(Authenticator *auth) void Client::setAuth(Authenticator *auth)
{ {
Q_D(QAMQP::Client); Q_D(Client);
d->setAuth(auth); d->setAuth(auth);
} }
Authenticator *QAMQP::Client::auth() const Authenticator *Client::auth() const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
return d->auth_.data(); return d->auth_.data();
} }
bool QAMQP::Client::isSsl() const bool Client::isSsl() const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
return d->network_->isSsl(); return d->network_->isSsl();
} }
void QAMQP::Client::setSsl(bool value) void Client::setSsl(bool value)
{ {
Q_D(QAMQP::Client); Q_D(Client);
d->network_->setSsl(value); d->network_->setSsl(value);
} }
bool QAMQP::Client::autoReconnect() const bool Client::autoReconnect() const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
return d->network_->autoReconnect(); return d->network_->autoReconnect();
} }
void QAMQP::Client::setAutoReconnect(bool value) void Client::setAutoReconnect(bool value)
{ {
Q_D(QAMQP::Client); Q_D(Client);
d->network_->setAutoReconnect(value); d->network_->setAutoReconnect(value);
} }
bool QAMQP::Client::isConnected() const bool Client::isConnected() const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
return d->connection_->isConnected(); return d->connection_->isConnected();
} }
void QAMQP::Client::addCustomProperty(const QString &name, const QString &value) void Client::addCustomProperty(const QString &name, const QString &value)
{ {
Q_D(QAMQP::Client); Q_D(Client);
return d->connection_->addCustomProperty(name, value); return d->connection_->addCustomProperty(name, value);
} }
QString QAMQP::Client::customProperty(const QString &name) const QString Client::customProperty(const QString &name) const
{ {
Q_D(const QAMQP::Client); Q_D(const Client);
return d->connection_->customProperty(name); return d->connection_->customProperty(name);
} }

5
src/amqp_client.h
View File

@ -3,6 +3,7 @@
#include <QObject> #include <QObject>
#include <QUrl> #include <QUrl>
#include <QHostAddress>
#include "amqp_global.h" #include "amqp_global.h"
@ -74,13 +75,13 @@ public:
bool isConnected() const; bool isConnected() const;
signals: Q_SIGNALS:
void connected(); void connected();
void disconnected(); void disconnected();
private: private:
Q_DISABLE_COPY(Client) Q_DISABLE_COPY(Client)
Q_DECLARE_PRIVATE(QAMQP::Client) Q_DECLARE_PRIVATE(Client)
QScopedPointer<ClientPrivate> d_ptr; QScopedPointer<ClientPrivate> d_ptr;
friend class ConnectionPrivate; friend class ConnectionPrivate;

6
src/amqp_client_p.h
View File

@ -35,14 +35,14 @@ public:
QString host; QString host;
QString virtualHost; QString virtualHost;
QPointer<QAMQP::Network> network_; QPointer<Network> network_;
QPointer<QAMQP::Connection> connection_; QPointer<Connection> connection_;
QSharedPointer<Authenticator> auth_; QSharedPointer<Authenticator> auth_;
bool isSSl() const; bool isSSl() const;
Client * const q_ptr; Client * const q_ptr;
Q_DECLARE_PUBLIC(QAMQP::Client) Q_DECLARE_PUBLIC(Client)
}; };

62
src/amqp_network.cpp
View File

@ -3,10 +3,12 @@
#include <QTimer> #include <QTimer>
#include <QtEndian> #include <QtEndian>
QAMQP::Network::Network( QObject * parent) using namespace QAMQP;
Network::Network( QObject * parent)
: QObject(parent) : QObject(parent)
{ {
qRegisterMetaType<QAMQP::Frame::Method>("QAMQP::Frame::Method"); qRegisterMetaType<Frame::Method>("QAMQP::Frame::Method");
buffer_.reserve(Frame::HEADER_SIZE); buffer_.reserve(Frame::HEADER_SIZE);
timeOut_ = 1000; timeOut_ = 1000;
@ -15,12 +17,12 @@ QAMQP::Network::Network( QObject * parent)
initSocket(false); initSocket(false);
} }
QAMQP::Network::~Network() Network::~Network()
{ {
disconnect(); disconnect();
} }
void QAMQP::Network::connectTo(const QString & host, quint16 port) void Network::connectTo(const QString & host, quint16 port)
{ {
if(!socket_) { if(!socket_) {
qWarning("AMQP: Socket didn't create."); qWarning("AMQP: Socket didn't create.");
@ -49,14 +51,14 @@ void QAMQP::Network::connectTo(const QString & host, quint16 port)
lastPort_ = p; lastPort_ = p;
} }
void QAMQP::Network::disconnect() void Network::disconnect()
{ {
connect_ = false; connect_ = false;
if (socket_) if (socket_)
socket_->close(); socket_->close();
} }
void QAMQP::Network::error(QAbstractSocket::SocketError socketError) void Network::error(QAbstractSocket::SocketError socketError)
{ {
if (timeOut_ == 0) { if (timeOut_ == 0) {
timeOut_ = 1000; timeOut_ = 1000;
@ -83,7 +85,7 @@ void QAMQP::Network::error(QAbstractSocket::SocketError socketError)
QTimer::singleShot(timeOut_, this, SLOT(connectTo())); QTimer::singleShot(timeOut_, this, SLOT(connectTo()));
} }
void QAMQP::Network::readyRead() void Network::readyRead()
{ {
while (socket_->bytesAvailable() >= Frame::HEADER_SIZE) { while (socket_->bytesAvailable() >= Frame::HEADER_SIZE) {
char *headerData = buffer_.data(); char *headerData = buffer_.data();
@ -97,15 +99,15 @@ void QAMQP::Network::readyRead()
const char* bufferData = buffer_.constData(); const char* bufferData = buffer_.constData();
const quint8 type = *(quint8*)&bufferData[0]; const quint8 type = *(quint8*)&bufferData[0];
const quint8 magic = *(quint8*)&bufferData[Frame::HEADER_SIZE+payloadSize]; const quint8 magic = *(quint8*)&bufferData[Frame::HEADER_SIZE+payloadSize];
if (magic != QAMQP::Frame::FRAME_END) if (magic != Frame::FRAME_END)
qWarning() << "Wrong end frame"; qWarning() << "Wrong end frame";
QDataStream streamB(&buffer_, QIODevice::ReadOnly); QDataStream streamB(&buffer_, QIODevice::ReadOnly);
switch(QAMQP::Frame::Type(type)) { switch(Frame::Type(type)) {
case QAMQP::Frame::ftMethod: case Frame::ftMethod:
{ {
QAMQP::Frame::Method frame(streamB); Frame::Method frame(streamB);
if (frame.methodClass() == QAMQP::Frame::fcConnection) { if (frame.methodClass() == Frame::fcConnection) {
m_pMethodHandlerConnection->_q_method(frame); m_pMethodHandlerConnection->_q_method(frame);
} else { } else {
foreach(Frame::MethodHandler* pMethodHandler, m_methodHandlersByChannel[frame.channel()]) foreach(Frame::MethodHandler* pMethodHandler, m_methodHandlersByChannel[frame.channel()])
@ -113,21 +115,21 @@ void QAMQP::Network::readyRead()
} }
} }
break; break;
case QAMQP::Frame::ftHeader: case Frame::ftHeader:
{ {
QAMQP::Frame::Content frame(streamB); Frame::Content frame(streamB);
foreach(Frame::ContentHandler* pMethodHandler, m_contentHandlerByChannel[frame.channel()]) foreach(Frame::ContentHandler* pMethodHandler, m_contentHandlerByChannel[frame.channel()])
pMethodHandler->_q_content(frame); pMethodHandler->_q_content(frame);
} }
break; break;
case QAMQP::Frame::ftBody: case Frame::ftBody:
{ {
QAMQP::Frame::ContentBody frame(streamB); Frame::ContentBody frame(streamB);
foreach(Frame::ContentBodyHandler* pMethodHandler, m_bodyHandlersByChannel[frame.channel()]) foreach(Frame::ContentBodyHandler* pMethodHandler, m_bodyHandlersByChannel[frame.channel()])
pMethodHandler->_q_body(frame); pMethodHandler->_q_body(frame);
} }
break; break;
case QAMQP::Frame::ftHeartbeat: case Frame::ftHeartbeat:
qDebug("AMQP: Heartbeat"); qDebug("AMQP: Heartbeat");
break; break;
default: default:
@ -139,7 +141,7 @@ void QAMQP::Network::readyRead()
} }
} }
void QAMQP::Network::sendFrame(const QAMQP::Frame::Base &frame) void Network::sendFrame(const Frame::Base &frame)
{ {
if (socket_->state() == QAbstractSocket::ConnectedState) { if (socket_->state() == QAbstractSocket::ConnectedState) {
QDataStream stream(socket_); QDataStream stream(socket_);
@ -147,19 +149,19 @@ void QAMQP::Network::sendFrame(const QAMQP::Frame::Base &frame)
} }
} }
bool QAMQP::Network::isSsl() const bool Network::isSsl() const
{ {
if (socket_) if (socket_)
return QString(socket_->metaObject()->className()).compare("QSslSocket", Qt::CaseInsensitive) == 0; return QString(socket_->metaObject()->className()).compare("QSslSocket", Qt::CaseInsensitive) == 0;
return false; return false;
} }
void QAMQP::Network::setSsl(bool value) void Network::setSsl(bool value)
{ {
initSocket(value); initSocket(value);
} }
void QAMQP::Network::initSocket(bool ssl) void Network::initSocket(bool ssl)
{ {
if (socket_) { if (socket_) {
socket_->deleteLater(); socket_->deleteLater();
@ -189,14 +191,14 @@ void QAMQP::Network::initSocket(bool ssl)
} }
} }
void QAMQP::Network::sslErrors() void Network::sslErrors()
{ {
#ifndef QT_NO_SSL #ifndef QT_NO_SSL
static_cast<QSslSocket*>(socket_.data())->ignoreSslErrors(); static_cast<QSslSocket*>(socket_.data())->ignoreSslErrors();
#endif #endif
} }
void QAMQP::Network::conectionReady() void Network::conectionReady()
{ {
Q_EMIT connected(); Q_EMIT connected();
timeOut_ = 0; timeOut_ = 0;
@ -205,39 +207,39 @@ void QAMQP::Network::conectionReady()
socket_->write(header_, 8); socket_->write(header_, 8);
} }
bool QAMQP::Network::autoReconnect() const bool Network::autoReconnect() const
{ {
return autoReconnect_; return autoReconnect_;
} }
void QAMQP::Network::setAutoReconnect(bool value) void Network::setAutoReconnect(bool value)
{ {
autoReconnect_ = value; autoReconnect_ = value;
} }
QAbstractSocket::SocketState QAMQP::Network::state() const QAbstractSocket::SocketState Network::state() const
{ {
if (socket_) if (socket_)
return socket_->state(); return socket_->state();
return QAbstractSocket::UnconnectedState; return QAbstractSocket::UnconnectedState;
} }
void QAMQP::Network::setMethodHandlerConnection(Frame::MethodHandler *pMethodHandlerConnection) void Network::setMethodHandlerConnection(Frame::MethodHandler *pMethodHandlerConnection)
{ {
m_pMethodHandlerConnection = pMethodHandlerConnection; m_pMethodHandlerConnection = pMethodHandlerConnection;
} }
void QAMQP::Network::addMethodHandlerForChannel(Channel channel, Frame::MethodHandler *pHandler) void Network::addMethodHandlerForChannel(Channel channel, Frame::MethodHandler *pHandler)
{ {
m_methodHandlersByChannel[channel].append(pHandler); m_methodHandlersByChannel[channel].append(pHandler);
} }
void QAMQP::Network::addContentHandlerForChannel(Channel channel, Frame::ContentHandler *pHandler) void Network::addContentHandlerForChannel(Channel channel, Frame::ContentHandler *pHandler)
{ {
m_contentHandlerByChannel[channel].append(pHandler); m_contentHandlerByChannel[channel].append(pHandler);
} }
void QAMQP::Network::addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler *pHandler) void Network::addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler *pHandler)
{ {
m_bodyHandlersByChannel[channel].append(pHandler); m_bodyHandlersByChannel[channel].append(pHandler);
} }

4
src/amqp_queue.h
View File

@ -12,7 +12,9 @@ class Client;
class ClientPrivate; class ClientPrivate;
class Exchange; class Exchange;
class QueuePrivate; class QueuePrivate;
class QAMQP_EXPORT Queue : public Channel, public Frame::ContentHandler, public Frame::ContentBodyHandler class QAMQP_EXPORT Queue : public Channel,
public Frame::ContentHandler,
public Frame::ContentBodyHandler
{ {
Q_OBJECT Q_OBJECT
Q_ENUMS(QueueOptions) Q_ENUMS(QueueOptions)