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

134
src/amqp_client.cpp
View File

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

5
src/amqp_client.h
View File

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

6
src/amqp_client_p.h
View File

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

4
src/amqp_queue.h
View File

@ -12,7 +12,9 @@ class Client;
class ClientPrivate;
class Exchange;
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_ENUMS(QueueOptions)