use Q_Q/Q_D from Qt rather than P_Q/P_D, style cleanups for Qt coding style

delete exception-related code, as Qt does not officially support them anymore

src/qamqp/amqp.cpp

@@ -7,6 +7,7 @@
 #include "amqp_exchange_p.h"
 #include "amqp_queue.h"
 #include "amqp_queue_p.h"
+#include "amqp_connection_p.h"
 #include "amqp_authenticator.h"
 
 using namespace QAMQP;
@@ -31,56 +32,47 @@ struct ClientExceptionCleaner
 
 //////////////////////////////////////////////////////////////////////////
 
-ClientPrivate::ClientPrivate( Client * q ) : 
+ClientPrivate::ClientPrivate(Client * q)
-	 port(AMQPPORT)
+    : port(AMQPPORT),
-	 , host(QString::fromLatin1(AMQPHOST))
+      host(QString::fromLatin1(AMQPHOST)),
-	 , virtualHost(QString::fromLatin1(AMQPVHOST))
+      virtualHost(QString::fromLatin1(AMQPVHOST)),
-	 , pq_ptr(q)
+      q_ptr(q)
 {
-	
 }
 
-
 ClientPrivate::~ClientPrivate()
 {
-
 }
 
-void ClientPrivate::init(QObject * parent)
+void ClientPrivate::init(QObject *parent)
 {
-	pq_func()->setParent(parent);
+    Q_Q(QAMQP::Client);
-	if(!network_)
+    q->setParent(parent);
-	{
+    if (!network_)
-		network_ = new QAMQP::Network(pq_func());
+        network_ = new QAMQP::Network(q);
-	}
-
-	if(!connection_)
-	{
-		connection_ = new QAMQP::Connection(pq_func());
-	}
 
+    if (!connection_)
+        connection_ = new QAMQP::Connection(q);
     network_->setMethodHandlerConnection(connection_);
 
     setAuth(new AMQPlainAuthenticator(QString::fromLatin1(AMQPLOGIN), QString::fromLatin1(AMQPPSWD)));
 
-	QObject::connect(connection_, SIGNAL(connected()), pq_func(), SIGNAL(connected()));
+    QObject::connect(connection_, SIGNAL(connected()), q, SIGNAL(connected()));
-	QObject::connect(connection_, SIGNAL(disconnected()), pq_func(), SIGNAL(disconnected()));
+    QObject::connect(connection_, SIGNAL(disconnected()), q, SIGNAL(disconnected()));
 }
 
-void ClientPrivate::init(QObject * parent, const QUrl & con)
+void ClientPrivate::init(QObject *parent, const QUrl &connectionString)
 {
     init(parent);
-	parseCnnString(con);
+    parseConnectionString(connectionString);
-	ClientPrivate::connect();
+    connect();
 }
 
-
+void ClientPrivate::setAuth(Authenticator *auth)
-void ClientPrivate::setAuth( Authenticator* auth )
 {
     auth_ = QSharedPointer<Authenticator>(auth);
 }
 
-
 void ClientPrivate::printConnect() const
 {
     QTextStream stream(stdout);
@@ -88,176 +80,161 @@ void ClientPrivate::printConnect() const
     stream <<  "host  = " << host << endl;
     stream <<  "vhost = " << virtualHost << endl;
 
-	if(auth_ && auth_->type() == "AMQPLAIN")
+    if (auth_ && auth_->type() == QLatin1String("AMQPLAIN")) {
-	{
         QSharedPointer<AMQPlainAuthenticator> a = auth_.staticCast<AMQPlainAuthenticator>();
         stream <<  "user  = " << a->login() << endl;
         stream <<  "passw = " << a->password() << endl;
     }
-	
 }
 
 void ClientPrivate::connect()
 {
-	ClientPrivate::sockConnect();
+    sockConnect();
-	ClientPrivate::login();
+    login();
 }
 
-void ClientPrivate::parseCnnString( const QUrl & con )
+void ClientPrivate::parseConnectionString(const QUrl &connectionString)
 {
-	P_Q(QAMQP::Client);
+    Q_Q(QAMQP::Client);
-	if(con.scheme() == AMQPSCHEME || con.scheme() == AMQPSSCHEME )
+    if (connectionString.scheme() != AMQPSCHEME &&
-	{
+        connectionString.scheme() != AMQPSSCHEME) {
-		q->setSsl(con.scheme() == AMQPSSCHEME);
+        qDebug() << Q_FUNC_INFO << "invalid scheme: " << connectionString.scheme();
-		q->setPassword(con.password());
+        return;
-		q->setUser(con.userName());
-		q->setPort(con.port(AMQPPORT));
-		q->setHost(con.host());				
-		q->setVirtualHost(con.path());
     }
+
+    q->setSsl(connectionString.scheme() == AMQPSSCHEME);
+    q->setPassword(connectionString.password());
+    q->setUser(connectionString.userName());
+    q->setPort(connectionString.port(AMQPPORT));
+    q->setHost(connectionString.host());
+    q->setVirtualHost(connectionString.path());
 }
 
 void ClientPrivate::sockConnect()
 {
-	if(network_->state() != QAbstractSocket::UnconnectedState )
+    if (network_->state() != QAbstractSocket::UnconnectedState)
-	{
         disconnect();
-	}
     network_->connectTo(host, port);
 }
 
 void ClientPrivate::login()
 {
-
 }
 
-Exchange * ClientPrivate::createExchange(int channelNumber, const QString &name )
+Exchange *ClientPrivate::createExchange(int channelNumber, const QString &name)
 {
-	Exchange * exchange_ = new Exchange(channelNumber, pq_func());
+    Q_Q(QAMQP::Client);
+    Exchange * exchange_ = new Exchange(channelNumber, q);
 
     network_->addMethodHandlerForChannel(exchange_->channelNumber(), exchange_);
 
     QObject::connect(connection_, SIGNAL(connected()), exchange_, SLOT(_q_open()));
-	exchange_->pd_func()->open();
+    exchange_->d_func()->open();
-	QObject::connect(pq_func(), SIGNAL(disconnected()), exchange_, SLOT(_q_disconnected()));
+    QObject::connect(q, SIGNAL(disconnected()), exchange_, SLOT(_q_disconnected()));
     exchange_->setName(name);
 
     return exchange_;
 }
 
-Queue * ClientPrivate::createQueue(int channelNumber, const QString &name )
+Queue *ClientPrivate::createQueue(int channelNumber, const QString &name )
 {
-	Queue * queue_ = new Queue(channelNumber, pq_func());
+    Q_Q(QAMQP::Client);
+    Queue *queue_ = new Queue(channelNumber, q);
 
     network_->addMethodHandlerForChannel(queue_->channelNumber(), queue_);
     network_->addContentHandlerForChannel(queue_->channelNumber(), queue_);
     network_->addContentBodyHandlerForChannel(queue_->channelNumber(), queue_);
 
     QObject::connect(connection_, SIGNAL(connected()), queue_, SLOT(_q_open()));
-	queue_->pd_func()->open();
+    queue_->d_func()->open();
-	QObject::connect(pq_func(), SIGNAL(disconnected()), queue_, SLOT(_q_disconnected()));
+    QObject::connect(q, SIGNAL(disconnected()), queue_, SLOT(_q_disconnected()));
     queue_->setName(name);
 
     return queue_;
 }
 
-
 void ClientPrivate::disconnect()
 {
-	P_Q(QAMQP::Client);
+    Q_Q(QAMQP::Client);
-	Q_UNUSED(q);
+    if (network_->state() != QAbstractSocket::UnconnectedState) {
-	if(network_->state() != QAbstractSocket::UnconnectedState)
+        network_->disconnect();
-	{
+        connection_->d_func()->connected = false;
-		network_->QAMQP::Network::disconnect();	
+        Q_EMIT q->disconnected();
-		connection_->pd_func()->connected = false;
-		emit pq_func()->disconnected();
     }
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 
-
+QAMQP::Client::Client(QObject *parent)
-QAMQP::Client::Client( QObject * parent /*= 0*/ )
+    : QObject(parent),
-	: pd_ptr(new ClientPrivate(this))
+      d_ptr(new ClientPrivate(this))
 {
-	QT_TRY {
+    d_ptr->init(parent);
-		pd_func()->init(parent);
-	} QT_CATCH(...) {
-		ClientExceptionCleaner::cleanup(this, pd_func());
-		QT_RETHROW;
-	}
 }
 
-QAMQP::Client::Client( const QUrl & connectionString, QObject * parent /*= 0*/ )
+QAMQP::Client::Client(const QUrl & connectionString, QObject * parent)
-	: pd_ptr(new ClientPrivate(this))
+    : d_ptr(new ClientPrivate(this))
 {
-	QT_TRY {
+    d_ptr->init(parent, connectionString);
-		pd_func()->init(parent, connectionString);
-	} QT_CATCH(...) {
-		ClientExceptionCleaner::cleanup(this, pd_func());
-		QT_RETHROW;
-	}
 }
 
 QAMQP::Client::~Client()
 {
-	QT_TRY {
-		QEvent e(QEvent::Destroy);
-		QCoreApplication::sendEvent(this, &e);
-	} QT_CATCH(const std::exception&) {
-		// if this fails we can't do anything about it but at least we are not allowed to throw.
-	}
 }
 
-quint32 QAMQP::Client::port() const
+quint16 QAMQP::Client::port() const
 {
-	return pd_func()->port;
+    Q_D(const QAMQP::Client);
+    return d->port;
 }
 
-void QAMQP::Client::setPort( quint32 port )
+void QAMQP::Client::setPort(quint16 port)
 {
-	pd_func()->port = port;
+    Q_D(QAMQP::Client);
+    d->port = port;
 }
 
 QString QAMQP::Client::host() const
 {
-	return pd_func()->host;
+    Q_D(const QAMQP::Client);
+    return d->host;
 }
 
 void QAMQP::Client::setHost( const QString & host )
 {
-	pd_func()->host = host;
+    Q_D(QAMQP::Client);
+    d->host = host;
 }
 
 QString QAMQP::Client::virtualHost() const
 {
-	return pd_func()->virtualHost;
+    Q_D(const QAMQP::Client);
+    return d->virtualHost;
 }
 
-void QAMQP::Client::setVirtualHost( const QString & virtualHost )
+void QAMQP::Client::setVirtualHost(const QString &virtualHost)
 {
-	pd_func()->virtualHost = virtualHost;
+    Q_D(QAMQP::Client);
+    d->virtualHost = virtualHost;
 }
 
 QString QAMQP::Client::user() const
 {
-	const Authenticator * auth = pd_func()->auth_.data();
+    Q_D(const QAMQP::Client);
-
+    const Authenticator * auth = d->auth_.data();
-	if(auth && auth->type() == "AMQPLAIN")
+    if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
-	{
         const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth);
         return a->login();
     }
+
     return QString();
 }
 
-void QAMQP::Client::setUser( const QString & user )
+void QAMQP::Client::setUser(const QString &user)
 {
-	Authenticator * auth = pd_func()->auth_.data();
+    Q_D(const QAMQP::Client);
-
+    Authenticator * auth = d->auth_.data();
-	if(auth && auth->type() == "AMQPLAIN")
+    if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
-	{
         AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth);
         a->setLogin(user);
     }
@@ -265,22 +242,21 @@ void QAMQP::Client::setUser( const QString & user )
 
 QString QAMQP::Client::password() const
 {
-	const Authenticator * auth = pd_func()->auth_.data();
+    Q_D(const QAMQP::Client);
-
+    const Authenticator * auth = d->auth_.data();
-	if(auth && auth->type() == "AMQPLAIN")
+    if (auth && auth->type() == "AMQPLAIN") {
-	{
         const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth);
         return a->password();
     }
+
     return QString();
 }
 
-void QAMQP::Client::setPassword( const QString & password )
+void QAMQP::Client::setPassword(const QString &password)
 {
-	Authenticator * auth = pd_func()->auth_.data();
+    Q_D(QAMQP::Client);
-
+    Authenticator *auth = d->auth_.data();
-	if(auth && auth->type() == "AMQPLAIN")
+    if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
-	{
         AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth);
         a->setPassword(password);
     }
@@ -289,98 +265,116 @@ void QAMQP::Client::setPassword( const QString & password )
 void QAMQP::Client::printConnect() const
 {
 #ifdef _DEBUG
-	pd_func()->printConnect();
+    Q_D(const QAMQP::Client);
+    d->printConnect();
 #endif // _DEBUG
 }
 
 void QAMQP::Client::closeChannel()
 {
-
 }
 
-Exchange * QAMQP::Client::createExchange(int channelNumber)
+Exchange *QAMQP::Client::createExchange(int channelNumber)
 {
-	return pd_func()->createExchange(channelNumber, QString());
+    Q_D(QAMQP::Client);
+    return d->createExchange(channelNumber, QString());
 }
 
-Exchange * QAMQP::Client::createExchange( const QString &name, int channelNumber )
+Exchange *QAMQP::Client::createExchange( const QString &name, int channelNumber )
 {
-	return pd_func()->createExchange(channelNumber, name);
+    Q_D(QAMQP::Client);
+    return d->createExchange(channelNumber, name);
 }
 
-Queue * QAMQP::Client::createQueue(int channelNumber)
+Queue *QAMQP::Client::createQueue(int channelNumber)
 {
-	return pd_func()->createQueue(channelNumber, QString());
+    Q_D(QAMQP::Client);
+    return d->createQueue(channelNumber, QString());
 }
 
-Queue * QAMQP::Client::createQueue( const QString &name, int channelNumber )
+Queue *QAMQP::Client::createQueue( const QString &name, int channelNumber )
 {
-	return pd_func()->createQueue(channelNumber, name);
+    Q_D(QAMQP::Client);
+    return d->createQueue(channelNumber, name);
 }
 
 void QAMQP::Client::open()
 {
-	return pd_func()->connect();
+    Q_D(QAMQP::Client);
+    return d->connect();
 }
 
-void QAMQP::Client::open( const QUrl & connectionString )
+void QAMQP::Client::open(const QUrl &connectionString)
 {
-	pd_func()->parseCnnString(connectionString);
+    Q_D(QAMQP::Client);
+    d->parseConnectionString(connectionString);
     open();
 }
 
 void QAMQP::Client::close()
 {
-	return pd_func()->disconnect();
+    Q_D(QAMQP::Client);
+    return d->disconnect();
 }
 
 void QAMQP::Client::reopen()
 {
-	pd_func()->disconnect();
+    Q_D(QAMQP::Client);
-	pd_func()->connect();	
+    d->disconnect();
+    d->connect();
 }
 
-void QAMQP::Client::setAuth( Authenticator * auth )
+void QAMQP::Client::setAuth(Authenticator *auth)
 {
-	pd_func()->setAuth(auth);
+    Q_D(QAMQP::Client);
+    d->setAuth(auth);
 }
 
-Authenticator * QAMQP::Client::auth() const
+Authenticator *QAMQP::Client::auth() const
 {
-	return pd_func()->auth_.data();
+    Q_D(const QAMQP::Client);
+    return d->auth_.data();
 }
 
 bool QAMQP::Client::isSsl() const
 {
-	return pd_func()->network_->isSsl();
+    Q_D(const QAMQP::Client);
+    return d->network_->isSsl();
 }
 
-void QAMQP::Client::setSsl( bool value )
+void QAMQP::Client::setSsl(bool value)
 {
-	pd_func()->network_->setSsl(value);
+    Q_D(QAMQP::Client);
+    d->network_->setSsl(value);
 }
 
 bool QAMQP::Client::autoReconnect() const
 {
-	return pd_func()->network_->autoReconnect();
+    Q_D(const QAMQP::Client);
+    return d->network_->autoReconnect();
 }
 
-void QAMQP::Client::setAutoReconnect( bool value )
+void QAMQP::Client::setAutoReconnect(bool value)
 {
-	pd_func()->network_->setAutoReconnect(value);
+    Q_D(QAMQP::Client);
+    d->network_->setAutoReconnect(value);
 }
 
 bool QAMQP::Client::isConnected() const
 {
-	return pd_func()->connection_->isConnected();
+    Q_D(const QAMQP::Client);
+    return d->connection_->isConnected();
 }
 
-void QAMQP::Client::addCustomProperty( const QString & name, const QString & value )
+void QAMQP::Client::addCustomProperty(const QString &name, const QString &value)
 {
-	return pd_func()->connection_->addCustomProperty(name, value);
+    Q_D(QAMQP::Client);
+    return d->connection_->addCustomProperty(name, value);
 }
 
-QString QAMQP::Client::customProperty( const QString & name ) const
+QString QAMQP::Client::customProperty(const QString &name) const
 {
-	return pd_func()->connection_->customProperty(name);
+    Q_D(const QAMQP::Client);
+    return d->connection_->customProperty(name);
 }
+

src/qamqp/amqp.h

@@ -1,73 +1,68 @@
-#ifndef qamqp_amqp_h__
+#ifndef QAMQP_H
-#define qamqp_amqp_h__
+#define QAMQP_H
 
 #include <QObject>
 #include <QUrl>
+
 #include "amqp_global.h"
 
 namespace QAMQP
 {
-	class Exchange;
+
-	class Queue;
+class Exchange;
-	class ClientPrivate;
+class Queue;
-	class Authenticator;
+class ClientPrivate;
-	class ConnectionPrivate;
+class Authenticator;
-	class Client : public QObject
+class ConnectionPrivate;
-	{
+class Client : public QObject
+{
     Q_OBJECT
+    Q_PROPERTY(quint32 port READ port WRITE setPort)
+    Q_PROPERTY(QString host READ host WRITE setHost)
+    Q_PROPERTY(QString virtualHost READ virtualHost WRITE setVirtualHost)
+    Q_PROPERTY(QString user READ user WRITE setUser)
+    Q_PROPERTY(QString password READ password WRITE setPassword)
+    Q_PROPERTY(bool ssl READ isSsl WRITE setSsl)
+    Q_PROPERTY(bool autoReconnect READ autoReconnect WRITE setAutoReconnect)
+    Q_PROPERTY(bool connected READ isConnected )
 
-		Q_PROPERTY(quint32 port READ port WRITE setPort);
+public:
-		Q_PROPERTY(QString host READ host WRITE setHost);
+    Client(QObject *parent = 0);
-		Q_PROPERTY(QString virtualHost READ virtualHost WRITE setVirtualHost);
+    Client(const QUrl &connectionString, QObject *parent = 0);
-		Q_PROPERTY(QString user READ user WRITE setUser);
-		Q_PROPERTY(QString password READ password WRITE setPassword);
-		Q_PROPERTY(bool ssl READ isSsl WRITE setSsl);
-		Q_PROPERTY(bool autoReconnect READ autoReconnect WRITE setAutoReconnect);
-		Q_PROPERTY(bool connected READ isConnected );
-
-		Q_DISABLE_COPY(Client)
-
-		P_DECLARE_PRIVATE(QAMQP::Client)
-		
-		friend class ConnectionPrivate;
-		friend class ChannelPrivate;
-
-	public:
-		Client(QObject * parent = 0);
-		Client(const QUrl & connectionString, QObject * parent = 0);
     ~Client();
 
     void printConnect() const;
     void closeChannel();
 
-		void addCustomProperty(const QString & name, const QString & value);
+    void addCustomProperty(const QString &name, const QString &value);
-		QString customProperty(const QString & name) const;
+    QString customProperty(const QString &name) const;
 
-		Exchange * createExchange(int channelNumber = -1);
+    Exchange *createExchange(int channelNumber = -1);
-		Exchange * createExchange(const QString &name, int channelNumber = -1);
+    Exchange *createExchange(const QString &name, int channelNumber = -1);
 
-		Queue * createQueue(int channelNumber = -1);
+    Queue *createQueue(int channelNumber = -1);
-		Queue * createQueue(const QString &name, int channelNumber = -1);
+    Queue *createQueue(const QString &name, int channelNumber = -1);
 
-		quint32 port() const;
+    quint16 port() const;
-		void setPort(quint32 port);
+    void setPort(quint16 port);
 
     QString host() const;
-		void setHost(const QString & host);
+    void setHost(const QString &host);
 
     QString virtualHost() const;
-		void setVirtualHost(const QString & virtualHost);
+    void setVirtualHost(const QString &virtualHost);
 
     QString user() const;
-		void setUser(const QString & user);
+    void setUser(const QString &user);
 
     QString password() const;
-		void setPassword(const QString & password);
+    void setPassword(const QString &password);
+
+    void setAuth(Authenticator *auth);
+    Authenticator *auth() const;
 
-		void setAuth(Authenticator * auth);
-		Authenticator * auth() const;
     void open();
-		void open(const QUrl & connectionString);
+    void open(const QUrl &connectionString);
     void close();
     void reopen();
 
@@ -79,19 +74,20 @@ namespace QAMQP
 
     bool isConnected() const;
 
-	signals:
+signals:
     void connected();
     void disconnected();
 
+private:
+    Q_DISABLE_COPY(Client)
+    Q_DECLARE_PRIVATE(QAMQP::Client)
+    QScopedPointer<ClientPrivate> d_ptr;
 
-	protected:
+    friend class ConnectionPrivate;
-		ClientPrivate * const pd_ptr;
+    friend class ChannelPrivate;
-
-	private:
     friend struct ClientExceptionCleaner;
+};
 
-		//void chanalConnect();
+} // namespace QAMQP
-	};
-}
 
-#endif // qamqp_amqp_h__
+#endif // QAMQP

src/qamqp/amqp_authenticator.cpp

@@ -1,43 +1,44 @@
 #include "amqp_authenticator.h"
 #include "amqp_frame.h"
 
-QString QAMQP::AMQPlainAuthenticator::login() const
+using namespace QAMQP;
+
+AMQPlainAuthenticator::AMQPlainAuthenticator(const QString &l, const QString &p)
+    : login_(l),
+      password_(p)
+{
+}
+
+AMQPlainAuthenticator::~AMQPlainAuthenticator()
+{
+}
+
+QString AMQPlainAuthenticator::login() const
 {
     return login_;
 }
 
-QString QAMQP::AMQPlainAuthenticator::password() const
+QString AMQPlainAuthenticator::password() const
 {
     return password_;
 }
 
-QAMQP::AMQPlainAuthenticator::AMQPlainAuthenticator( const QString & l /*= QString()*/, const QString & p /*= QString()*/ )
+QString AMQPlainAuthenticator::type() const
-{
-	login_ = l;
-	password_ = p;
-}
-
-QAMQP::AMQPlainAuthenticator::~AMQPlainAuthenticator()
-{
-
-}
-
-QString QAMQP::AMQPlainAuthenticator::type() const
 {
     return "AMQPLAIN";
 }
 
-void QAMQP::AMQPlainAuthenticator::setLogin( const QString& l )
+void AMQPlainAuthenticator::setLogin(const QString &l)
 {
     login_ = l;
 }
 
-void QAMQP::AMQPlainAuthenticator::setPassword( const QString &p )
+void AMQPlainAuthenticator::setPassword(const QString &p)
 {
     password_ = p;
 }
 
-void QAMQP::AMQPlainAuthenticator::write( QDataStream & out )
+void AMQPlainAuthenticator::write(QDataStream &out)
 {
     QAMQP::Frame::writeField('s', out, type());
     QAMQP::Frame::TableField response;

src/qamqp/amqp_authenticator.h

@@ -1,33 +1,42 @@
 #ifndef amqp_authenticator_h__
 #define amqp_authenticator_h__
 
-#include "amqp_global.h"
 #include <QString>
 #include <QDataStream>
 
+#include "amqp_global.h"
+
 namespace QAMQP
 {
-	class Authenticator
-	{
-	public:
-		virtual ~Authenticator(){};
-		virtual QString type() const = 0;
-		virtual void write(QDataStream & out) = 0;
-	};
 
-	class AMQPlainAuthenticator : public Authenticator
+class Authenticator
-	{
+{
-		QString login_, password_;
+public:
-	public:
+    virtual ~Authenticator() {}
-		AMQPlainAuthenticator(const QString & login = QString(), const QString & password = QString());
+    virtual QString type() const = 0;
+    virtual void write(QDataStream &out) = 0;
+};
+
+class AMQPlainAuthenticator : public Authenticator
+{
+public:
+    AMQPlainAuthenticator(const QString &login = QString(), const QString &password = QString());
     virtual ~AMQPlainAuthenticator();
+
     QString login() const;
-		void setLogin(const QString& l);
+    void setLogin(const QString &l);
+
     QString password() const;
     void setPassword(const QString &p);
+
     virtual QString type() const;
-		virtual void write(QDataStream & out);
+    virtual void write(QDataStream &out);
-	};
+
+private:
+    QString login_;
+    QString password_;
+
+};
 
 }
 #endif // amqp_authenticator_h__

src/qamqp/amqp_channel.cpp

@@ -1,5 +1,6 @@
 #include "amqp_channel.h"
 #include "amqp_channel_p.h"
+#include "amqp_connection_p.h"
 
 #include "amqp.h"
 #include "amqp_p.h"
@@ -10,90 +11,63 @@
 
 using namespace QAMQP;
 
-namespace QAMQP
-{
-	int ChannelPrivate::nextChannelNumber_ = 0;
-	struct ChannelExceptionCleaner
-	{
-		/* this cleans up when the constructor throws an exception */
-		static inline void cleanup(Channel *that, ChannelPrivate *d)
-		{
-#ifdef QT_NO_EXCEPTIONS
-			Q_UNUSED(that);
-			Q_UNUSED(d);
-#else
-			Q_UNUSED(that);
-			Q_UNUSED(d);	
-#endif
-		}
-	};
-}
-
-
 //////////////////////////////////////////////////////////////////////////
 
-QAMQP::Channel::Channel(int channelNumber /*= -1*/, Client * parent /*= 0*/ )
+QAMQP::Channel::Channel(int channelNumber, Client *parent)
-	: pd_ptr(new ChannelPrivate(this))
+    : QObject(parent),
+      d_ptr(new ChannelPrivate(this))
 {
-	QT_TRY {
+    Q_D(QAMQP::Channel);
-		pd_func()->init(channelNumber, parent);
+    d->init(channelNumber, parent);
-	} QT_CATCH(...) {
-		ChannelExceptionCleaner::cleanup(this, pd_func());
-		QT_RETHROW;
-	}
 }
 
-QAMQP::Channel::Channel( ChannelPrivate * d )
+QAMQP::Channel::Channel(ChannelPrivate *dd, Client *parent)
-	: pd_ptr(d)
+    : QObject(parent),
+      d_ptr(dd)
 {
-
 }
 
 QAMQP::Channel::~Channel()
 {
-
-	QT_TRY {
-		QEvent e(QEvent::Destroy);
-		QCoreApplication::sendEvent(this, &e);
-	} QT_CATCH(const std::exception&) {
-		// if this fails we can't do anything about it but at least we are not allowed to throw.
-	}
 }
 
 void QAMQP::Channel::closeChannel()
 {
-	P_D(Channel);
+    Q_D(QAMQP::Channel);
     d->needOpen = true;
-	if(d->opened)
+    if (d->opened)
         d->close(0, QString(), 0,0);
 
 }
 
 void QAMQP::Channel::reopen()
 {
+    Q_D(QAMQP::Channel);
     closeChannel();
-	pd_func()->open();
+    d->open();
 }
 
-QString QAMQP::Channel::name()
+QString QAMQP::Channel::name() const
 {
-	return pd_func()->name;
+    Q_D(const QAMQP::Channel);
+    return d->name;
 }
 
-int QAMQP::Channel::channelNumber()
+int QAMQP::Channel::channelNumber() const
 {
-	return pd_func()->number;
+    Q_D(const QAMQP::Channel);
+    return d->number;
 }
 
-void QAMQP::Channel::setName( const QString &name )
+void QAMQP::Channel::setName(const QString &name)
 {
-	pd_func()->name = name;
+    Q_D(QAMQP::Channel);
+    d->name = name;
 }
 
-void QAMQP::Channel::stateChanged( int state )
+void QAMQP::Channel::stateChanged(int state)
 {
-	switch(ChannelPrivate::State(state))
+    switch(ChannelPrivate::State(state)) {
-	{
     case ChannelPrivate::csOpened:
         emit opened();
         break;
@@ -111,67 +85,68 @@ void QAMQP::Channel::stateChanged( int state )
 
 void QAMQP::Channel::_q_method(const Frame::Method &frame)
 {
-	pd_func()->_q_method(frame);
+    Q_D(QAMQP::Channel);
+    d->_q_method(frame);
 }
 
 bool QAMQP::Channel::isOpened() const
 {
-	return pd_func()->opened;
+    Q_D(const QAMQP::Channel);
+    return d->opened;
 }
 
 void QAMQP::Channel::onOpen()
 {
-
 }
 
 void QAMQP::Channel::onClose()
 {
-
 }
 
-void QAMQP::Channel::setQOS( qint32 prefetchSize, quint16 prefetchCount )
+void QAMQP::Channel::setQOS(qint32 prefetchSize, quint16 prefetchCount)
 {
-	pd_func()->setQOS(prefetchSize, prefetchCount);
+    Q_D(QAMQP::Channel);
+    d->setQOS(prefetchSize, prefetchCount);
 }
+
 //////////////////////////////////////////////////////////////////////////
 
+int ChannelPrivate::nextChannelNumber_ = 0;
 ChannelPrivate::ChannelPrivate(Channel * q)
-	: number(0)
+    : number(0),
-	, opened(false)
+      opened(false),
-	, needOpen(true)
+      needOpen(true),
-	, pq_ptr(q)
+      q_ptr(q)
 {
-
 }
 
 ChannelPrivate::~ChannelPrivate()
 {
-
 }
 
-void ChannelPrivate::init(int channelNumber, Client * parent)
+void ChannelPrivate::init(int channelNumber, Client *parent)
 {
+    Q_Q(QAMQP::Channel);
     needOpen = channelNumber == -1 ? true : false;
     number = channelNumber == -1 ? ++nextChannelNumber_ : channelNumber;
     nextChannelNumber_ = qMax(channelNumber, (nextChannelNumber_ + 1));
-	pq_func()->setParent(parent);
+    q->setParent(parent);
     client_ = parent;
 }
 
 
-bool ChannelPrivate::_q_method( const QAMQP::Frame::Method & frame )
+bool ChannelPrivate::_q_method(const QAMQP::Frame::Method &frame)
 {
     Q_ASSERT(frame.channel() == number);
-	if(frame.channel() != number )
+    if (frame.channel() != number)
         return true;
 
-	if(frame.methodClass() != QAMQP::Frame::fcChannel)
+    if (frame.methodClass() != QAMQP::Frame::fcChannel)
         return false;
 
     qDebug("Channel#%d:", number);
 
-	switch(frame.id())
+    switch (frame.id()) {
-	{
     case miOpenOk:
         openOk(frame);
         break;
@@ -197,22 +172,21 @@ void ChannelPrivate::_q_open()
 }
 
 
-void ChannelPrivate::sendFrame( const QAMQP::Frame::Base & frame )
+void ChannelPrivate::sendFrame(const QAMQP::Frame::Base &frame)
 {
-	if(client_)
+    if (client_) {
-	{
+        client_->d_func()->network_->sendFrame(frame);
-		client_->pd_func()->network_->sendFrame(frame);
     }
 }
 
-
 void ChannelPrivate::open()
 {
-	if(!needOpen || opened)
+    if (!needOpen || opened)
         return;
 
-	if(!client_->pd_func()->connection_->isConnected())
+    if (!client_->d_func()->connection_->isConnected())
         return;
+
     qDebug("Open channel #%d", number);
     QAMQP::Frame::Method frame(QAMQP::Frame::fcChannel, miOpen);
     frame.setChannel(number);
@@ -223,28 +197,25 @@ void ChannelPrivate::open()
     sendFrame(frame);
 }
 
-
 void ChannelPrivate::flow()
 {
-
 }
 
-void ChannelPrivate::flow( const QAMQP::Frame::Method & frame )
+void ChannelPrivate::flow(const QAMQP::Frame::Method &frame)
 {
     Q_UNUSED(frame);
 }
 
 void ChannelPrivate::flowOk()
 {
-
 }
 
-void ChannelPrivate::flowOk( const QAMQP::Frame::Method & frame )
+void ChannelPrivate::flowOk(const QAMQP::Frame::Method &frame)
 {
     Q_UNUSED(frame);
 }
 
-void ChannelPrivate::close(int code, const QString & text, int classId, int methodId)
+void ChannelPrivate::close(int code, const QString &text, int classId, int methodId)
 {
     QAMQP::Frame::Method frame(QAMQP::Frame::fcChannel, miClose);
     QByteArray arguments_;
@@ -258,12 +229,13 @@ void ChannelPrivate::close(int code, const QString & text, int classId, int meth
     stream << qint16(methodId);
 
     frame.setArguments(arguments_);
-	client_->pd_func()->network_->sendFrame(frame);
+    client_->d_func()->network_->sendFrame(frame);
 }
 
-void ChannelPrivate::close( const QAMQP::Frame::Method & frame )
+void ChannelPrivate::close(const QAMQP::Frame::Method &frame)
 {
-	pq_func()->stateChanged(csClosed);
+    Q_Q(QAMQP::Channel);
+    q->stateChanged(csClosed);
 
     qDebug(">> CLOSE");
     QByteArray data = frame.arguments();
@@ -278,7 +250,6 @@ void ChannelPrivate::close( const QAMQP::Frame::Method & frame )
     qDebug(">> text: %s", qPrintable(text));
     qDebug(">> class-id: %d", classId);
     qDebug(">> method-id: %d", methodId);
-
 }
 
 void ChannelPrivate::closeOk()
@@ -287,34 +258,36 @@ void ChannelPrivate::closeOk()
     sendFrame(frame);
 }
 
-void ChannelPrivate::closeOk( const QAMQP::Frame::Method & frame )
+void ChannelPrivate::closeOk(const QAMQP::Frame::Method &frame)
 {
-	Q_UNUSED(frame);
+    Q_UNUSED(frame)
-	P_Q(Channel);
+    Q_Q(QAMQP::Channel);
+
     q->stateChanged(csClosed);
     q->onClose();
     opened = false;
 }
 
-void ChannelPrivate::openOk( const QAMQP::Frame::Method & frame )
+void ChannelPrivate::openOk(const QAMQP::Frame::Method &frame)
 {
-	Q_UNUSED(frame);
+    Q_UNUSED(frame)
-	P_Q(Channel);
+    Q_Q(QAMQP::Channel);
+
     qDebug(">> OpenOK");
     opened = true;
     q->stateChanged(csOpened);
     q->onOpen();
-	
 }
 
-void ChannelPrivate::setQOS( qint32 prefetchSize, quint16 prefetchCount )
+void ChannelPrivate::setQOS(qint32 prefetchSize, quint16 prefetchCount)
 {
-	client_->pd_func()->connection_->pd_func()->setQOS(prefetchSize, prefetchCount, number, false);
+    client_->d_func()->connection_->d_func()->setQOS(prefetchSize, prefetchCount, number, false);
 }
 
-
 void ChannelPrivate::_q_disconnected()
 {
     nextChannelNumber_ = 0;
     opened = false;
 }
+
+#include "moc_amqp_channel.cpp"

src/qamqp/amqp_channel.h

@@ -7,54 +7,52 @@
 
 namespace QAMQP
 {
-	class ChannelPrivate;
+
-	class Client;
+class Client;
-	class Channel : public QObject, public Frame::MethodHandler
+class ChannelPrivate;
-	{
+class Channel : public QObject, public Frame::MethodHandler
+{
     Q_OBJECT
+    Q_PROPERTY(int number READ channelNumber)
+    Q_PROPERTY(QString name READ name WRITE setName)
 
-		Q_PROPERTY(int number READ channelNumber);
+public:
-		Q_PROPERTY(QString name READ name WRITE setName);		
-
-		P_DECLARE_PRIVATE(QAMQP::Channel)
-		Q_DISABLE_COPY(Channel)		
-	public:		
     ~Channel();
 
     void closeChannel();
     void reopen();
 
-		QString name();
+    QString name() const;
-		int channelNumber();		
+    int channelNumber() const;
 
     void setName(const QString &name);
     void setQOS(qint32 prefetchSize, quint16 prefetchCount);
     bool isOpened() const;
 
-	signals:
+signals:
     void opened();
     void closed();
     void flowChanged(bool enabled);
 
-	protected:
+protected:
-		Channel(int channelNumber = -1, Client * parent = 0);
+    Q_DISABLE_COPY(Channel)
-		Channel(ChannelPrivate * d);
+    Q_DECLARE_PRIVATE(QAMQP::Channel)
+
+    Channel(int channelNumber = -1, Client *parent = 0);
+    Channel(ChannelPrivate *dd, Client *parent = 0);
+    QScopedPointer<ChannelPrivate> d_ptr;
+
+    Q_PRIVATE_SLOT(d_func(), void _q_open())
+    Q_PRIVATE_SLOT(d_func(), void _q_disconnected())
+
     virtual void onOpen();
     virtual void onClose();
-
-		ChannelPrivate * const pd_ptr;
-
-	private:
     void stateChanged(int state);
-		friend class ClientPrivate;
+    void _q_method(const QAMQP::Frame::Method &frame);
-		void _q_method(const QAMQP::Frame::Method & frame);
+
+    friend class ClientPrivate;
+};
 
-		Q_PRIVATE_SLOT(pd_func(), void _q_open())
-		Q_PRIVATE_SLOT(pd_func(), void _q_disconnected())
-	};
 }
 
-#ifdef QAMQP_P_INCLUDE
-# include "amqp_channel_p.h"
 #endif
-#endif // amqp_channel_h__

src/qamqp/amqp_channel_p.h

@@ -8,14 +8,12 @@
 
 namespace QAMQP
 {
-	class Client;
+class Client;
-	class ClientPrivate;
+class ClientPrivate;
-	class ChannelPrivate 
+class ChannelPrivate
-	{
+{
-		P_DECLARE_PUBLIC(QAMQP::Channel)
+public:
-	public:
+    enum MethodId {
-		enum MethodId
-		{
          METHOD_ID_ENUM(miOpen, 10),
          METHOD_ID_ENUM(miFlow, 20),
          METHOD_ID_ENUM(miClose, 40)
@@ -47,28 +45,28 @@ namespace QAMQP
     ChannelPrivate(Channel * q);
     virtual ~ChannelPrivate();
 
-		void init(int channelNumber, Client * parent);
+    void init(int channelNumber, Client *parent);
 
     void open();
     void flow();
     void flowOk();
-		void close(int code, const QString & text, int classId, int methodId);
+    void close(int code, const QString &text, int classId, int methodId);
     void closeOk();
 
     //////////////////////////////////////////////////////////////////////////
 
-		void openOk(const QAMQP::Frame::Method & frame);
+    void openOk(const QAMQP::Frame::Method &frame);
-		void flow(const QAMQP::Frame::Method & frame);
+    void flow(const QAMQP::Frame::Method &frame);
-		void flowOk(const QAMQP::Frame::Method & frame);
+    void flowOk(const QAMQP::Frame::Method &frame);
-		void close(const QAMQP::Frame::Method & frame);
+    void close(const QAMQP::Frame::Method &frame);
-		void closeOk(const QAMQP::Frame::Method & frame);
+    void closeOk(const QAMQP::Frame::Method &frame);
 
-		virtual bool _q_method(const QAMQP::Frame::Method & frame);
+    virtual bool _q_method(const QAMQP::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 QAMQP::Frame::Base &frame);
 
     QPointer<Client> client_;
 
@@ -79,7 +77,9 @@ namespace QAMQP
     bool opened;
     bool needOpen;
 
-		Channel * const pq_ptr;
+    Q_DECLARE_PUBLIC(QAMQP::Channel)
-	};
+    Channel * const q_ptr;
+};
+
 }
 #endif // amqp_channel_p_h__

src/qamqp/amqp_connection.cpp

@@ -12,50 +12,24 @@
 
 using namespace QAMQP;
 
-namespace QAMQP
+ConnectionPrivate::ConnectionPrivate(Connection * q)
+    : closed_(false),
+      connected(false),
+      q_ptr(q)
 {
-	struct ConnectionExceptionCleaner
-	{
-		/* this cleans up when the constructor throws an exception */
-		static inline void cleanup(Connection *that, ConnectionPrivate *d)
-		{
-#ifdef QT_NO_EXCEPTIONS
-			Q_UNUSED(that);
-			Q_UNUSED(d);
-#else
-			Q_UNUSED(that);
-			Q_UNUSED(d);	
-#endif
-		}
-	};
-
-	
-
-
-}
-//////////////////////////////////////////////////////////////////////////
-
-
-ConnectionPrivate::ConnectionPrivate( Connection * q)
-	: closed_(false)
-	, connected(false)
-	, pq_ptr(q)
-{
-
 }
 
 ConnectionPrivate::~ConnectionPrivate()
 {
-
 }
 
 void ConnectionPrivate::init(Client * parent)
 {
-	pq_func()->setParent(parent);
+    Q_Q(QAMQP::Connection);
+    q->setParent(parent);
     client_ = parent;
     heartbeatTimer_ = new QTimer(parent);
-	QObject::connect(heartbeatTimer_, SIGNAL(timeout()), 
+    QObject::connect(heartbeatTimer_, SIGNAL(timeout()), q, SLOT(_q_heartbeat()));
-		pq_func(), SLOT(_q_heartbeat()));
 }
 
 void ConnectionPrivate::startOk()
@@ -71,19 +45,14 @@ void ConnectionPrivate::startOk()
     clientProperties.unite(customProperty);
     QAMQP::Frame::serialize(stream, clientProperties);
 
-	client_->pd_func()->auth_->write(stream);
+    client_->d_func()->auth_->write(stream);
-
     QAMQP::Frame::writeField('s', stream, "en_US");
-
     frame.setArguments(arguments_);
-
+    client_->d_func()->network_->sendFrame(frame);
-	client_->pd_func()->network_->sendFrame(frame);	
 }
 
 void ConnectionPrivate::secureOk()
 {
-
-
 }
 
 void ConnectionPrivate::tuneOk()
@@ -97,7 +66,7 @@ void ConnectionPrivate::tuneOk()
     stream << qint16(heartbeatTimer_->interval() / 1000); //heartbeat
 
     frame.setArguments(arguments_);
-	client_->pd_func()->network_->sendFrame(frame);
+    client_->d_func()->network_->sendFrame(frame);
 }
 
 void ConnectionPrivate::open()
@@ -112,10 +81,10 @@ void ConnectionPrivate::open()
     stream << qint8(0);
 
     frame.setArguments(arguments_);
-	client_->pd_func()->network_->sendFrame(frame);
+    client_->d_func()->network_->sendFrame(frame);
 }
 
-void ConnectionPrivate::start( const QAMQP::Frame::Method & frame )
+void ConnectionPrivate::start(const QAMQP::Frame::Method &frame)
 {
     qDebug(">> Start");
     QByteArray data = frame.arguments();
@@ -142,12 +111,12 @@ void ConnectionPrivate::start( const QAMQP::Frame::Method & frame )
     startOk();
 }
 
-void ConnectionPrivate::secure( const QAMQP::Frame::Method & frame )
+void ConnectionPrivate::secure(const QAMQP::Frame::Method &frame)
 {
-	Q_UNUSED(frame);	
+    Q_UNUSED(frame)
 }
 
-void ConnectionPrivate::tune( const QAMQP::Frame::Method & frame )
+void ConnectionPrivate::tune(const QAMQP::Frame::Method &frame)
 {
     qDebug(">> Tune");
     QByteArray data = frame.arguments();
@@ -165,30 +134,32 @@ void ConnectionPrivate::tune( const QAMQP::Frame::Method & frame )
     qDebug(">> frame_max: %d", frame_max);
     qDebug(">> heartbeat: %d", heartbeat);
 
-	if(heartbeatTimer_)
+    if (heartbeatTimer_) {
-	{
         heartbeatTimer_->setInterval(heartbeat * 1000);
-		if(heartbeatTimer_->interval())
+        if (heartbeatTimer_->interval())
-		{
             heartbeatTimer_->start();
-		} else {
+        else
             heartbeatTimer_->stop();
     }
-	}
+
     tuneOk();
     open();
 }
 
-void ConnectionPrivate::openOk( const QAMQP::Frame::Method & frame )
+void ConnectionPrivate::openOk(const QAMQP::Frame::Method &frame)
 {
-	Q_UNUSED(frame);
+    Q_UNUSED(frame)
+    Q_Q(QAMQP::Connection);
+
     qDebug(">> OpenOK");
     connected = true;
-	pq_func()->openOk();
+    q->openOk();
 }
 
-void ConnectionPrivate::close( const QAMQP::Frame::Method & frame )
+void ConnectionPrivate::close(const QAMQP::Frame::Method &frame)
 {
+    Q_Q(QAMQP::Connection);
+
     qDebug(">> CLOSE");
     QByteArray data = frame.arguments();
     QDataStream stream(&data, QIODevice::ReadOnly);
@@ -203,11 +174,11 @@ void ConnectionPrivate::close( const QAMQP::Frame::Method & frame )
     qDebug(">> class-id: %d", classId);
     qDebug(">> method-id: %d", methodId);
     connected = false;
-	client_->pd_func()->network_->error(QAbstractSocket::RemoteHostClosedError);
+    client_->d_func()->network_->error(QAbstractSocket::RemoteHostClosedError);
-	QMetaObject::invokeMethod(pq_func(), "disconnected");
+    QMetaObject::invokeMethod(q, "disconnected");
 }
 
-void ConnectionPrivate::close(int code, const QString & text, int classId, int methodId)
+void ConnectionPrivate::close(int code, const QString &text, int classId, int methodId)
 {
     QAMQP::Frame::Method frame(QAMQP::Frame::fcConnection, miClose);
     QByteArray arguments_;
@@ -221,29 +192,30 @@ void ConnectionPrivate::close(int code, const QString & text, int classId, int m
     stream << qint16(methodId);
 
     frame.setArguments(arguments_);
-	client_->pd_func()->network_->sendFrame(frame);
+    client_->d_func()->network_->sendFrame(frame);
 }
 
 void ConnectionPrivate::closeOk()
 {
     QAMQP::Frame::Method frame(QAMQP::Frame::fcConnection, miCloseOk);
     connected = false;
-	client_->pd_func()->network_->sendFrame(frame);
+    client_->d_func()->network_->sendFrame(frame);
 
 }
 
-void ConnectionPrivate::closeOk( const QAMQP::Frame::Method & )
+void ConnectionPrivate::closeOk(const QAMQP::Frame::Method &frame)
 {
+    Q_UNUSED(frame)
+    Q_Q(QAMQP::Connection);
+
     connected = false;
-	QMetaObject::invokeMethod(pq_func(), "disconnected");
+    QMetaObject::invokeMethod(q, "disconnected");
-	if(heartbeatTimer_)
+    if (heartbeatTimer_)
-	{
         heartbeatTimer_->stop();
-	}
 }
 
 
-void ConnectionPrivate::setQOS( qint32 prefetchSize, quint16 prefetchCount, int channel, bool global )
+void ConnectionPrivate::setQOS(qint32 prefetchSize, quint16 prefetchCount, int channel, bool global)
 {
     QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, 10);
     frame.setChannel(channel);
@@ -255,26 +227,25 @@ void ConnectionPrivate::setQOS( qint32 prefetchSize, quint16 prefetchCount, int
     out << qint8(global ? 1 : 0);
 
     frame.setArguments(arguments_);
-	client_->pd_func()->network_->sendFrame(frame);	
+    client_->d_func()->network_->sendFrame(frame);
 }
 
-bool ConnectionPrivate::_q_method( const QAMQP::Frame::Method & frame )
+bool ConnectionPrivate::_q_method(const QAMQP::Frame::Method &frame)
 {
     Q_ASSERT(frame.methodClass() == QAMQP::Frame::fcConnection);
-	if(frame.methodClass() != QAMQP::Frame::fcConnection)
+    if (frame.methodClass() != QAMQP::Frame::fcConnection)
         return true;
 
     qDebug() << "Connection:";
 
-	if (closed_)
+    if (closed_) {
-	{
+        if (frame.id() == miCloseOk)
-		if( frame.id() == miCloseOk)
             closeOk(frame);
+
         return true;
     }
 
-	switch(MethodId(frame.id()))
+    switch (MethodId(frame.id())) {
-	{
     case miStart:
         start(frame);
         break;
@@ -297,101 +268,102 @@ bool ConnectionPrivate::_q_method( const QAMQP::Frame::Method & frame )
         qWarning("Unknown method-id %d", frame.id());
         return false;
     }
+
     return true;
 }
 
 void ConnectionPrivate::_q_heartbeat()
 {
     QAMQP::Frame::Heartbeat frame;
-	client_->pd_func()->network_->sendFrame(frame);
+    client_->d_func()->network_->sendFrame(frame);
 }
 
 //////////////////////////////////////////////////////////////////////////
 
-Connection::Connection( Client * parent /*= 0*/ )
+Connection::Connection(Client *parent)
-	: pd_ptr(new ConnectionPrivate(this))
+    : QObject(parent),
+      d_ptr(new ConnectionPrivate(this))
 {
-	QT_TRY {
+    Q_D(QAMQP::Connection);
-		pd_func()->init(parent);
+    d->init(parent);
-	} QT_CATCH(...) {
-		ConnectionExceptionCleaner::cleanup(this, pd_func());
-		QT_RETHROW;
-	}
 }
 
 Connection::~Connection()
 {
-	QT_TRY {
-		QEvent e(QEvent::Destroy);
-		QCoreApplication::sendEvent(this, &e);
-	} QT_CATCH(const std::exception&) {
-		// if this fails we can't do anything about it but at least we are not allowed to throw.
-	}
 }
 
 void Connection::startOk()
 {
-	pd_func()->startOk();
+    Q_D(QAMQP::Connection);
+    d->startOk();
 }
 
 void Connection::secureOk()
 {
-	pd_func()->secureOk();
+    Q_D(QAMQP::Connection);
+    d->secureOk();
 }
 
 void Connection::tuneOk()
 {
-	pd_func()->tuneOk();
+    Q_D(QAMQP::Connection);
+    d->tuneOk();
 }
 
 void Connection::open()
 {
-	pd_func()->open();
+    Q_D(QAMQP::Connection);
+    d->open();
 }
 
-void Connection::close(int code, const QString & text, int classId , int methodId)
+void Connection::close(int code, const QString &text, int classId , int methodId)
 {
-	pd_func()->close(code, text, classId, methodId);
+    Q_D(QAMQP::Connection);
+    d->close(code, text, classId, methodId);
 }
 
 void Connection::closeOk()
 {
-	pd_func()->closeOk();
+    Q_D(QAMQP::Connection);
-	emit disconnect();
+    d->closeOk();
+    Q_EMIT disconnect();
 }
 
 void Connection::openOk()
 {
-	emit connected();
+    Q_EMIT connected();
 }
 
-void Connection::_q_method(const QAMQP::Frame::Method & frame)
+void Connection::_q_method(const QAMQP::Frame::Method &frame)
 {
-	pd_func()->_q_method(frame);
+    Q_D(QAMQP::Connection);
+    d->_q_method(frame);
 }
 
 bool Connection::isConnected() const
 {
-	return pd_func()->connected;
+    Q_D(const QAMQP::Connection);
+    return d->connected;
 }
 
-
+void Connection::setQOS(qint32 prefetchSize, quint16 prefetchCount)
-void Connection::setQOS( qint32 prefetchSize, quint16 prefetchCount )
 {
-	pd_func()->setQOS(prefetchSize, prefetchCount, 0, true);
+    Q_D(QAMQP::Connection);
+    d->setQOS(prefetchSize, prefetchCount, 0, true);
 }
 
-
+void Connection::addCustomProperty(const QString &name, const QString &value)
-void Connection::addCustomProperty( const QString & name, const QString & value )
 {
-	pd_func()->customProperty[name] = value;
+    Q_D(QAMQP::Connection);
+    d->customProperty[name] = value;
 }
 
-QString Connection::customProperty( const QString & name ) const
+QString Connection::customProperty(const QString &name) const
 {
-	if(pd_func()->customProperty.contains(name))
+    Q_D(const QAMQP::Connection);
-	{
+    if (d->customProperty.contains(name))
-		return pd_func()->customProperty.value(name).toString();
+        return d->customProperty.value(name).toString();
-	}
     return QString();
 }
+
+#include "moc_amqp_connection.cpp"

src/qamqp/amqp_connection.h

@@ -7,53 +7,50 @@
 
 namespace QAMQP
 {
-	class ConnectionPrivate;
+
-	class ChannelPrivate;
+class Client;
-	class ClientPrivate;
+class ClientPrivate;
-	class Client;
+class ChannelPrivate;
-	class Connection : public QObject, public Frame::MethodHandler
+class ConnectionPrivate;
-	{
+class Connection : public QObject, public Frame::MethodHandler
+{
     Q_OBJECT
-		P_DECLARE_PRIVATE(QAMQP::Connection)
+public:
-		Q_DISABLE_COPY(Connection)
+    virtual ~Connection();
-		Connection(Client * parent = 0);
-	public:		
-		~Connection();
 
-
+    void addCustomProperty(const QString &name, const QString &value);
-		void addCustomProperty(const QString & name, const QString & value);
+    QString customProperty(const QString &name) const;
-		QString customProperty(const QString & name) const;
 
     void startOk();
     void secureOk();
     void tuneOk();
     void open();
-		void close(int code, const QString & text, int classId = 0, int methodId = 0);
+    void close(int code, const QString &text, int classId = 0, int methodId = 0);
     void closeOk();
 
     bool isConnected() const;
 
     void setQOS(qint32 prefetchSize, quint16 prefetchCount);
 
-	Q_SIGNALS:
+Q_SIGNALS:
     void disconnected();
     void connected();
-	protected:
-		ConnectionPrivate * const pd_ptr;
 
-	private:
+private:
+    Q_DISABLE_COPY(Connection)
+    Q_DECLARE_PRIVATE(Connection)
+    QScopedPointer<ConnectionPrivate> d_ptr;
+
+    Connection(Client * parent = 0);
+
     void openOk();
     friend class ClientPrivate;
     friend class ChannelPrivate;
 
-		void _q_method(const QAMQP::Frame::Method & frame);
+    void _q_method(const QAMQP::Frame::Method &frame);
-		Q_PRIVATE_SLOT(pd_func(), void _q_heartbeat());
+    Q_PRIVATE_SLOT(d_func(), void _q_heartbeat())
-	};
+};
+
 }
 
-// Include private header so MOC won't complain
-#ifdef QAMQP_P_INCLUDE
-# include "amqp_connection_p.h"
-#endif
-
 #endif // amqp_connection_h__

src/qamqp/amqp_connection_p.h

@@ -9,14 +9,13 @@ class QTimer;
 
 namespace QAMQP
 {
-	class Client;
+class Client;
-	class ClientPrivate;
+class ClientPrivate;
-	class ConnectionPrivate
+class Connection;
-	{
+class ConnectionPrivate
-		P_DECLARE_PUBLIC(QAMQP::Connection)
+{
-	public:
+public:
-		enum MethodId
+    enum MethodId {
-		{
         METHOD_ID_ENUM(miStart, 10),
         METHOD_ID_ENUM(miSecure, 20),
         METHOD_ID_ENUM(miTune, 30),
@@ -24,9 +23,10 @@ namespace QAMQP
         METHOD_ID_ENUM(miClose, 50)
     };
 
-		ConnectionPrivate(Connection * q);
+    ConnectionPrivate(Connection *q);
     ~ConnectionPrivate();
-		void init(Client * parent);
+
+    void init(Client *parent);
     void startOk();
     void secureOk();
     void tuneOk();
@@ -34,13 +34,14 @@ namespace QAMQP
     void close(int code, const QString & text, int classId = 0, int methodId = 0);
     void closeOk();
 
-		void start(const QAMQP::Frame::Method & frame);
+    void start(const QAMQP::Frame::Method &frame);
-		void secure(const QAMQP::Frame::Method & frame);
+    void secure(const QAMQP::Frame::Method &frame);
-		void tune(const QAMQP::Frame::Method & frame);
+    void tune(const QAMQP::Frame::Method &frame);
-		void openOk(const QAMQP::Frame::Method & frame);
+    void openOk(const QAMQP::Frame::Method &frame);
-		void close(const QAMQP::Frame::Method & frame);
+    void close(const QAMQP::Frame::Method &frame);
-		void closeOk(const QAMQP::Frame::Method & frame);
+    void closeOk(const QAMQP::Frame::Method &frame);
-		bool _q_method(const QAMQP::Frame::Method & frame);
+
+    bool _q_method(const QAMQP::Frame::Method &frame);
     void _q_heartbeat();
 
     void setQOS(qint32 prefetchSize, quint16 prefetchCount, int channel, bool global);
@@ -50,10 +51,12 @@ namespace QAMQP
     bool connected;
     QPointer<QTimer> heartbeatTimer_;
 
-		Connection * const pq_ptr;
-
     QAMQP::Frame::TableField customProperty;
 
-	};
+    Q_DECLARE_PUBLIC(QAMQP::Connection)
+    Connection * const q_ptr;
+};
+
 }
+
 #endif // amqp_connection_p_h__

src/qamqp/amqp_exchange.cpp

@@ -9,36 +9,11 @@ using namespace QAMQP::Frame;
 #include <QDebug>
 #include <QDataStream>
 
-
+Exchange::Exchange(int channelNumber, Client *parent)
-namespace QAMQP
+    : Channel(new ExchangePrivate(this), parent)
 {
-	struct ExchangeExceptionCleaner
+    Q_D(QAMQP::Exchange);
-	{
+    d->init(channelNumber, parent);
-		/* this cleans up when the constructor throws an exception */
-		static inline void cleanup(Exchange *that, ExchangePrivate *d)
-		{
-#ifdef QT_NO_EXCEPTIONS
-			Q_UNUSED(that);
-			Q_UNUSED(d);
-#else
-			Q_UNUSED(that);
-			Q_UNUSED(d);	
-#endif
-		}
-	};	
-
-
-}
-
-Exchange::Exchange(int channelNumber, Client * parent /*= 0*/ )
-: Channel(new ExchangePrivate(this))
-{
-	QT_TRY {
-		pd_func()->init(channelNumber, parent);
-	} QT_CATCH(...) {
-		ExchangeExceptionCleaner::cleanup(this, pd_func());
-		QT_RETHROW;
-	}
 }
 
 Exchange::~Exchange()
@@ -48,105 +23,106 @@ Exchange::~Exchange()
 
 void Exchange::onOpen()
 {
-	P_D(Exchange);
+    Q_D(QAMQP::Exchange);
-	if(d->delayedDeclare)
+    if (d->delayedDeclare)
-	{
         d->declare();
-	}
 }
 
 void Exchange::onClose()
 {
-	pd_func()->remove(true, true);
+    Q_D(QAMQP::Exchange);
+    d->remove(true, true);
 }
 
 Exchange::ExchangeOptions Exchange::option() const
 {
-	return pd_func()->options;
+    Q_D(const QAMQP::Exchange);
+    return d->options;
 }
 
 QString Exchange::type() const
 {
-	return pd_func()->type;
+    Q_D(const QAMQP::Exchange);
+    return d->type;
 }
 
-
+void Exchange::declare(const QString &type, ExchangeOptions option , const TableField &arg)
-void Exchange::declare(const QString &type, ExchangeOptions option ,  const TableField & arg)
 {
-	P_D(Exchange);
+    Q_D(QAMQP::Exchange);
     d->options = option;
     d->type = type;
     d->arguments = arg;
     d->declare();
 }
 
-void Exchange::remove( bool ifUnused /*= true*/, bool noWait /*= true*/ )
+void Exchange::remove(bool ifUnused, bool noWait)
 {
-	pd_func()->remove(ifUnused, noWait);
+    Q_D(QAMQP::Exchange);
+    d->remove(ifUnused, noWait);
 }
 
-
+void Exchange::bind(QAMQP::Queue *queue)
-void Exchange::bind( QAMQP::Queue * queue )
 {
-	queue->bind(this, pd_func()->name);
+    Q_D(QAMQP::Exchange);
+    queue->bind(this, d->name);
 }
 
-void Exchange::bind( const QString & queueName )
+void Exchange::bind(const QString &queueName)
 {
     Q_UNUSED(queueName);
-	qWarning("Not implement");
+    qWarning("Not implemented");
 }
 
-void Exchange::bind( const QString & queueName, const QString &key )
+void Exchange::bind(const QString &queueName, const QString &key)
 {
     Q_UNUSED(queueName);
     Q_UNUSED(key);
-	qWarning("Not implement");
+    qWarning("Not implemented");
 }
 
-void Exchange::publish( const QString & message, const QString & key, const MessageProperties &prop )
+void Exchange::publish(const QString &message, const QString &key, const MessageProperties &prop)
 {
-	pd_func()->publish(message.toUtf8(), key, QString::fromLatin1("text.plain"), QVariantHash(), prop);
+    Q_D(QAMQP::Exchange);
+    d->publish(message.toUtf8(), key, QLatin1String("text.plain"), QVariantHash(), prop);
 }
 
-
+void Exchange::publish(const QByteArray &message, const QString &key,
-void Exchange::publish( const QByteArray & message, const QString & key, const QString &mimeType, const MessageProperties &prop )
+                       const QString &mimeType, const MessageProperties &prop)
 {
-	pd_func()->publish(message, key, mimeType, QVariantHash(), prop);
+    Q_D(QAMQP::Exchange);
+    d->publish(message, key, mimeType, QVariantHash(), prop);
 }
 
-void Exchange::publish( const QByteArray & message, const QString & key, const QVariantHash &headers, const QString &mimeType, const MessageProperties &prop )
+void Exchange::publish(const QByteArray &message, const QString &key,
+                       const QVariantHash &headers, const QString &mimeType,
+                       const MessageProperties &prop)
 {
-	pd_func()->publish(message, key, mimeType, headers, prop);
+    Q_D(QAMQP::Exchange);
+    d->publish(message, key, mimeType, headers, prop);
 }
 
 //////////////////////////////////////////////////////////////////////////
 
-
 ExchangePrivate::ExchangePrivate(Exchange * q)
-	:ChannelPrivate(q)
+    : ChannelPrivate(q),
-	,  delayedDeclare(false)
+      delayedDeclare(false),
-	,  declared(false)
+      declared(false)
 {
 }
 
-
 ExchangePrivate::~ExchangePrivate()
 {
-
 }
 
-
+bool ExchangePrivate::_q_method(const QAMQP::Frame::Method &frame)
-bool ExchangePrivate::_q_method( const QAMQP::Frame::Method & frame )
 {
-	if(ChannelPrivate::_q_method(frame))
+    if (ChannelPrivate::_q_method(frame))
         return true;
 
-	if(frame.methodClass() != QAMQP::Frame::fcExchange)
+    if (frame.methodClass() != QAMQP::Frame::fcExchange)
         return false;
 
-	switch(frame.id())
+    switch(frame.id()) {
-	{
     case miDeclareOk:
         declareOk(frame);
         break;
@@ -156,32 +132,36 @@ bool ExchangePrivate::_q_method( const QAMQP::Frame::Method & frame )
     default:
         break;
     }
+
     return true;
 }
 
-void ExchangePrivate::declareOk( const QAMQP::Frame::Method &  )
+void ExchangePrivate::declareOk(const QAMQP::Frame::Method &frame)
 {
+    Q_UNUSED(frame)
+    Q_Q(QAMQP::Exchange);
     qDebug() << "Declared exchange: " << name;
     declared = true;
-	QMetaObject::invokeMethod(pq_func(), "declared");
+    QMetaObject::invokeMethod(q, "declared");
 }
 
-void ExchangePrivate::deleteOk( const QAMQP::Frame::Method &  )
+void ExchangePrivate::deleteOk(const QAMQP::Frame::Method &frame)
 {
+    Q_UNUSED(frame)
+    Q_Q(QAMQP::Exchange);
     qDebug() << "Deleted exchange: " << name;
     declared = false;
-	QMetaObject::invokeMethod(pq_func(), "removed");
+    QMetaObject::invokeMethod(q, "removed");
 }
 
-void ExchangePrivate::declare( )
+void ExchangePrivate::declare()
 {
-	if(!opened)
+    if (!opened) {
-	{
         delayedDeclare = true;
         return;
     }
 
-	if(name.isEmpty())
+    if (name.isEmpty())
         return;
 
     QAMQP::Frame::Method frame(QAMQP::Frame::fcExchange, miDeclare);
@@ -200,7 +180,7 @@ void ExchangePrivate::declare( )
     delayedDeclare = false;
 }
 
-void ExchangePrivate::remove( bool ifUnused /*= true*/, bool noWait /*= true*/ )
+void ExchangePrivate::remove(bool ifUnused, bool noWait)
 {
     QAMQP::Frame::Method frame(QAMQP::Frame::fcExchange, miDelete);
     frame.setChannel(number);
@@ -221,7 +201,9 @@ void ExchangePrivate::remove( bool ifUnused /*= true*/, bool noWait /*= true*/ )
     sendFrame(frame);
 }
 
-void ExchangePrivate::publish( const QByteArray & message, const QString & key, const QString &mimeType /*= QString::fromLatin1("text/plain")*/, const QVariantHash & headers, const Exchange::MessageProperties & prop )
+void ExchangePrivate::publish(const QByteArray &message, const QString &key,
+                              const QString &mimeType, const QVariantHash & headers,
+                              const Exchange::MessageProperties &prop)
 {
     QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, bmPublish);
     frame.setChannel(number);
@@ -236,7 +218,6 @@ void ExchangePrivate::publish( const QByteArray & message, const QString & key,
     frame.setArguments(arguments_);
     sendFrame(frame);
 
-	
     QAMQP::Frame::Content content(QAMQP::Frame::fcBasic);
     content.setChannel(number);
     content.setProperty(Content::cpContentType, mimeType);
@@ -246,27 +227,22 @@ void ExchangePrivate::publish( const QByteArray & message, const QString & key,
 
     Exchange::MessageProperties::ConstIterator i;
 
-	for(i = prop.begin(); i != prop.end(); ++i)
+    for (i = prop.begin(); i != prop.end(); ++i)
-	{
         content.setProperty(i.key(), i.value());
-	}
 
     content.setBody(message);
     sendFrame(content);
 
     int fullSize = message.size();
-	for (int sended_ = 0; sended_ < fullSize; sended_+= (FRAME_MAX - 7))
+    for (int sended_ = 0; sended_ < fullSize; sended_+= (FRAME_MAX - 7)) {
-	{
         QAMQP::Frame::ContentBody body;
         QByteArray partition_ = message.mid(sended_, (FRAME_MAX - 7));
         body.setChannel(number);
         body.setBody(partition_);
         sendFrame(body);
     }
-	
 }
 
-
 void ExchangePrivate::_q_disconnected()
 {
     ChannelPrivate::_q_disconnected();

src/qamqp/amqp_exchange.h

@@ -2,31 +2,24 @@
 #define amqp_exchange_h__
 
 #include "amqp_channel.h"
+
 namespace QAMQP
 {
-	class Client;
-	class Queue;
-	class ClientPrivate;
-	class ExchangePrivate;
 
-	using namespace QAMQP::Frame;
+using namespace QAMQP::Frame;
-	class Exchange : public Channel
-	{
-		Q_OBJECT;
-		Exchange(int channelNumber = -1, Client * parent = 0);
 
-		Q_PROPERTY(QString type READ type);
+class Client;
-		Q_PROPERTY(ExchangeOptions option READ option );
+class Queue;
-
+class ClientPrivate;
-		P_DECLARE_PRIVATE(QAMQP::Exchange)
+class ExchangePrivate;
-		Q_DISABLE_COPY(Exchange);	
+class Exchange : public Channel
-		friend class ClientPrivate;
+{
-	protected:
+    Q_OBJECT
-		void onOpen();
+    Q_PROPERTY(QString type READ type)
-		void onClose();
+    Q_PROPERTY(ExchangeOptions option READ option)
-
+    Q_ENUMS(ExchangeOption)
-	public:		
 
+public:
     enum ExchangeOption {
         NoOptions = 0x0,
         Passive = 0x01,
@@ -39,26 +32,45 @@ namespace QAMQP
 
     typedef QHash<QAMQP::Frame::Content::Property, QVariant> MessageProperties;
 
-		~Exchange();
+    virtual ~Exchange();
 
     QString type() const;
     ExchangeOptions option() const;
 
-		void declare(const QString &type = QString::fromLatin1("direct"), ExchangeOptions option = NoOptions,  const TableField & arg = TableField());
+    void declare(const QString &type = QLatin1String("direct"),
+                 ExchangeOptions option = NoOptions,
+                 const TableField &arg = TableField());
     void remove(bool ifUnused = true, bool noWait = true);
 
-		void bind(QAMQP::Queue * queue);
+    void bind(QAMQP::Queue *queue);
-		void bind(const QString & queueName);
+    void bind(const QString &queueName);
-		void bind(const QString & queueName, const QString &key);
+    void bind(const QString &queueName, const QString &key);
 
-		void publish(const QString & message, const QString & key, const MessageProperties &property = MessageProperties() );
+    void publish(const QString &message, const QString &key,
-		void publish(const QByteArray & message, const QString & key, const QString &mimeType, const MessageProperties &property = MessageProperties());
+                 const MessageProperties &property = MessageProperties());
-		void publish(const QByteArray & message, const QString & key, const QVariantHash &headers, const QString &mimeType, const MessageProperties &property = MessageProperties());
+    void publish(const QByteArray &message, const QString &key,
+                 const QString &mimeType, const MessageProperties &property = MessageProperties());
+    void publish(const QByteArray &message, const QString &key, const QVariantHash &headers,
+                 const QString &mimeType, const MessageProperties &property = MessageProperties());
 
-	Q_SIGNALS:
+Q_SIGNALS:
     void declared();
     void removed();
-	};
+
+protected:
+    void onOpen();
+    void onClose();
+
+private:
+    Q_DISABLE_COPY(Exchange)
+    Q_DECLARE_PRIVATE(QAMQP::Exchange)
+    Exchange(int channelNumber = -1, Client * parent = 0);
+    friend class ClientPrivate;
+
+};
+
 }
+
 Q_DECLARE_OPERATORS_FOR_FLAGS(QAMQP::Exchange::ExchangeOptions)
+
 #endif // amqp_exchange_h__

src/qamqp/amqp_exchange_p.h

@@ -1,16 +1,15 @@
 #include "amqp_channel_p.h"
+
 #define METHOD_ID_ENUM(name, id) name = id, name ## Ok
 
 namespace QAMQP
 {
-	using namespace QAMQP::Frame;
-	class ExchangePrivate: public ChannelPrivate
-	{
-		P_DECLARE_PUBLIC(QAMQP::Exchange)
-	public:
 
-		enum MethodId
+using namespace QAMQP::Frame;
-		{
+class ExchangePrivate: public ChannelPrivate
+{
+public:
+    enum MethodId {
         METHOD_ID_ENUM(miDeclare, 10),
         METHOD_ID_ENUM(miDelete, 20)
     };
@@ -21,20 +20,25 @@ namespace QAMQP
     void declare();
     void remove(bool ifUnused = true, bool noWait = true);
 
-		void declareOk(const QAMQP::Frame::Method & frame);
+    void declareOk(const QAMQP::Frame::Method &frame);
-		void deleteOk(const QAMQP::Frame::Method & frame);
+    void deleteOk(const QAMQP::Frame::Method &frame);
 
-		void publish(const QByteArray & message, const QString & key, const QString &mimeType = QString::fromLatin1("text/plain"), const QVariantHash & headers = QVariantHash(), const Exchange::MessageProperties & properties = Exchange::MessageProperties());
+    void publish(const QByteArray &message, const QString &key,
+                 const QString &mimeType = QLatin1String("text/plain"),
+                 const QVariantHash &headers = QVariantHash(),
+                 const Exchange::MessageProperties &properties = Exchange::MessageProperties());
 
     QString type;
     Exchange::ExchangeOptions options;
     TableField arguments;
 
-		bool _q_method(const QAMQP::Frame::Method & frame);
+    bool _q_method(const QAMQP::Frame::Method &frame);
     void _q_disconnected();
 
     bool delayedDeclare;
     bool declared;
 
-	};	
+    Q_DECLARE_PUBLIC(QAMQP::Exchange)
+};
+
 }

src/qamqp/amqp_frame.cpp

@@ -1,14 +1,20 @@
 #include "amqp_frame.h"
 
+#include <float.h>
+
 #include <QDateTime>
 #include <QList>
 #include <QDebug>
-#include <float.h>
 
 using namespace QAMQP::Frame;
-Base::Base( Type type ) : size_(0), type_(type), channel_(0) {}
+Base::Base(Type type)
+    : size_(0),
+      type_(type),
+      channel_(0)
+{
+}
 
-Base::Base( QDataStream& raw )
+Base::Base(QDataStream &raw)
 {
     readHeader(raw);
 }
@@ -21,7 +27,7 @@ Type Base::type() const
 Base::~Base()
 {}
 
-void Base::setChannel( qint16 channel )
+void Base::setChannel(qint16 channel)
 {
     channel_ = channel;
 }
@@ -36,15 +42,14 @@ qint32 Base::size() const
     return 0;
 }
 
-void QAMQP::Frame::Base::writeHeader( QDataStream & stream ) const
+void QAMQP::Frame::Base::writeHeader(QDataStream &stream) const
 {
     stream << type_;
     stream << channel_;
     stream << qint32(size());
-
 }
 
-void QAMQP::Frame::Base::writeEnd( QDataStream & stream ) const
+void QAMQP::Frame::Base::writeEnd(QDataStream &stream) const
 {
     stream << qint8(FRAME_END);
 }
@@ -56,25 +61,23 @@ void QAMQP::Frame::Base::readHeader( QDataStream & stream )
     stream >> type_;
     stream >> channel_;
     stream >> size_;
-	
 }
 
-void QAMQP::Frame::Base::readEnd( QDataStream & stream )
+void QAMQP::Frame::Base::readEnd(QDataStream &stream)
 {
     unsigned char end_  = 0;
     stream.readRawData(reinterpret_cast<char*>(&end_), sizeof(end_));
-	if(end_ != FRAME_END )
+    if (end_ != FRAME_END) {
-	{
         qWarning("Wrong end of frame");
     }
 }
 
-void QAMQP::Frame::Base::readPayload( QDataStream & stream )
+void QAMQP::Frame::Base::readPayload(QDataStream &stream)
 {
     stream.skipRawData(size_);
 }
 
-void QAMQP::Frame::Base::toStream( QDataStream & stream ) const
+void QAMQP::Frame::Base::toStream(QDataStream &stream) const
 {
     writeHeader(stream);
     writePayload(stream);
@@ -83,22 +86,19 @@ void QAMQP::Frame::Base::toStream( QDataStream & stream ) const
 
 //////////////////////////////////////////////////////////////////////////
 
-
+QAMQP::Frame::Method::Method(MethodClass methodClass, qint16 id)
-QAMQP::Frame::Method::Method( MethodClass methodClass, qint16 id )
+    : Base(ftMethod), methodClass_(methodClass), id_(id)
-: Base(ftMethod), methodClass_(methodClass), id_(id)
 {
-
 }
 
-QAMQP::Frame::Method::Method( QDataStream& raw )
+QAMQP::Frame::Method::Method(QDataStream &raw)
-: Base(raw)
+    : Base(raw)
 {
     readPayload(raw);
 }
 
 QAMQP::Frame::Method::Method(): Base(ftMethod)
 {
-
 }
 
 MethodClass QAMQP::Frame::Method::methodClass() const
@@ -116,7 +116,7 @@ qint32 QAMQP::Frame::Method::size() const
     return sizeof(id_) + sizeof(methodClass_) + arguments_.size();
 }
 
-void QAMQP::Frame::Method::setArguments( const QByteArray & data )
+void QAMQP::Frame::Method::setArguments(const QByteArray &data)
 {
     arguments_ = data;
 }
@@ -126,7 +126,7 @@ QByteArray QAMQP::Frame::Method::arguments() const
     return arguments_;
 }
 
-void QAMQP::Frame::Method::readPayload( QDataStream & stream )
+void QAMQP::Frame::Method::readPayload(QDataStream &stream)
 {
     stream >> methodClass_;
     stream >> id_;
@@ -135,26 +135,23 @@ void QAMQP::Frame::Method::readPayload( QDataStream & stream )
     stream.readRawData(arguments_.data(), arguments_.size());
 }
 
-void QAMQP::Frame::Method::writePayload( QDataStream & stream ) const
+void QAMQP::Frame::Method::writePayload(QDataStream &stream) const
 {
     stream << quint16(methodClass_);
     stream << quint16(id_);
     stream.writeRawData(arguments_.data(), arguments_.size());
 }
 
-
 //////////////////////////////////////////////////////////////////////////
 
-
+QVariant QAMQP::Frame::readField(qint8 valueType, QDataStream &s)
-QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
 {
     QVariant value;
     QByteArray tmp;
     qint8 nameSize_ = 0;
     char octet = 0;
 
-	switch(valueType)
+    switch(valueType) {
-	{
     case 't':
         s.readRawData(&octet, sizeof(octet));
         value = QVariant::fromValue<bool>(octet > 0);
@@ -237,11 +234,7 @@ QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
         s >> nameSize_;
         tmp.resize(nameSize_);
         s.readRawData(tmp.data(), tmp.size());
-		#if QT_VERSION < 0x050000
-		value = QString::fromAscii(tmp.data(), nameSize_);
-		#else // For Qt5
         value = QString::fromLatin1(tmp.data(), nameSize_);
-		#endif
         break;
     case 'S':
     {
@@ -251,11 +244,7 @@ QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
         tmp.resize(length_);
     }
         s.readRawData(tmp.data(), tmp.size());
-		#if QT_VERSION < 0x050000
-		value = QString::fromAscii(tmp.data(), tmp.size());
-		#else // For Qt5
         value = QString::fromLatin1(tmp.data(), tmp.size());
-		#endif
         break;
     case 'A':
     {
@@ -263,8 +252,7 @@ QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
         qint8 type = 0;
         s >> length_;
         QList<QVariant> array_;
-			for (int i =0; i < length_; ++i)
+        for (int i =0; i < length_; ++i) {
-			{				
             s >> type;
             array_ << readField(type, s);
         }
@@ -293,16 +281,14 @@ QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
     return value;
 }
 
-QDataStream & QAMQP::Frame::deserialize( QDataStream & stream, QAMQP::Frame::TableField & f )
+QDataStream & QAMQP::Frame::deserialize(QDataStream &stream, QAMQP::Frame::TableField &f)
 {
     QByteArray data;
     stream >> data;
     QDataStream s(&data, QIODevice::ReadOnly);
 
-	while(!s.atEnd())
+    while(!s.atEnd()) {
-	{
         qint8 valueType = 0;
-
         QString name = readField('s', s).toString();
         s >> valueType;
         f[name] = readField(valueType, s);
@@ -311,18 +297,17 @@ QDataStream & QAMQP::Frame::deserialize( QDataStream & stream, QAMQP::Frame::Tab
     return stream;
 }
 
-QDataStream & QAMQP::Frame::serialize( QDataStream & stream, const TableField & f )
+QDataStream & QAMQP::Frame::serialize(QDataStream &stream, const TableField &f)
 {
     QByteArray data;
     QDataStream s(&data, QIODevice::WriteOnly);
     TableField::ConstIterator i;
-	for(i = f.begin(); i != f.end(); ++i)
+    for (i = f.begin(); i != f.end(); ++i) {
-	{
         writeField('s', s, i.key());
         writeField(s, i.value());
     }
-	if(data.isEmpty())
+
-	{
+    if (data.isEmpty()) {
         stream << qint32(0);
     } else {
         stream << data;
@@ -331,13 +316,11 @@ QDataStream & QAMQP::Frame::serialize( QDataStream & stream, const TableField &
     return stream;
 }
 
-void QAMQP::Frame::print( const TableField & f )
+void QAMQP::Frame::print(const TableField &f)
 {
     TableField::ConstIterator i;
-	for(i = f.begin(); i != f.end(); ++i)
+    for (i = f.begin(); i != f.end(); ++i) {
-	{
+        switch(i.value().type()) {
-		switch(i.value().type())
-		{
         case  QVariant::Hash:
             qDebug() << "\t" << qPrintable(i.key()) << ": FIELD_TABLE";
             break;
@@ -350,14 +333,13 @@ void QAMQP::Frame::print( const TableField & f )
     }
 }
 
-void QAMQP::Frame::writeField( qint8 valueType, QDataStream &s, const QVariant & value, bool withType )
+void QAMQP::Frame::writeField(qint8 valueType, QDataStream &s, const QVariant &value, bool withType)
 {
     QByteArray tmp;
-	if(withType)
+    if (withType)
         s << valueType;
 
-	switch(valueType)
+    switch (valueType) {
-	{
     case 't':
         s << (value.toBool() ? qint8(1) : qint8(0));
         break;
@@ -402,22 +384,14 @@ void QAMQP::Frame::writeField( qint8 valueType, QDataStream &s, const QVariant &
     {
         QString str = value.toString();
         s << quint8(str.length());
-			#if QT_VERSION < 0x050000
-			s.writeRawData(str.toAscii().data(), str.length());
-			#else // For Qt5
         s.writeRawData(str.toLatin1().data(), str.length());
-			#endif			
     }
         break;
     case 'S':
     {
         QString str = value.toString();
         s << quint32(str.length());
-			#if QT_VERSION < 0x050000
-			s.writeRawData(str.toAscii().data(), str.length());
-			#else // For Qt5
         s.writeRawData(str.toLatin1().data(), str.length());
-			#endif
     }
         break;
     case 'A':
@@ -425,10 +399,8 @@ void QAMQP::Frame::writeField( qint8 valueType, QDataStream &s, const QVariant &
         QList<QVariant> array_(value.toList());
         s << quint32(array_.count());
         for (int i =0; i < array_.count(); ++i)
-			{				
             writeField(s, array_.at(i));
     }
-		}
         break;
     case 'T':
         s << qulonglong(value.toDateTime().toMSecsSinceEpoch());
@@ -446,11 +418,10 @@ void QAMQP::Frame::writeField( qint8 valueType, QDataStream &s, const QVariant &
     }
 }
 
-void QAMQP::Frame::writeField( QDataStream &s, const QVariant & value )
+void QAMQP::Frame::writeField(QDataStream &s, const QVariant &value)
 {
     char type = 0;
-	switch(value.type())
+    switch (value.type()) {
-	{
     case QVariant::Bool:
         type = 't';
         break;
@@ -460,11 +431,11 @@ void QAMQP::Frame::writeField( QDataStream &s, const QVariant & value )
     case QVariant::Int:
     {
         int i = qAbs(value.toInt());
-			if(i <= qint8(0xFF)) {
+        if (i <= qint8(0xFF)) {
             type = 'b';
-			} else if(i <= qint16(0xFFFF)) {
+        } else if (i <= qint16(0xFFFF)) {
             type = 'U';
-			} else if(i <= qint16(0xFFFFFFFF)) {
+        } else if (i <= qint16(0xFFFFFFFF)) {
             type = 'I';
         }
     }
@@ -472,11 +443,11 @@ void QAMQP::Frame::writeField( QDataStream &s, const QVariant & value )
     case QVariant::UInt:
     {
         int i = value.toInt();
-			if(i <= qint8(0xFF)) {
+        if (i <= qint8(0xFF)) {
             type = 'B';
-			} else if(i <= qint16(0xFFFF)) {
+        } else if (i <= qint16(0xFFFF)) {
             type = 'u';
-			} else if(i <= qint16(0xFFFFFFFF)) {
+        } else if (i <= qint16(0xFFFFFFFF)) {
             type = 'i';
         }
     }
@@ -502,26 +473,30 @@ void QAMQP::Frame::writeField( QDataStream &s, const QVariant & value )
     case QVariant::List:
         type = 'A';
         break;
-	default:;
+
+    default:
+        qDebug() << Q_FUNC_INFO << "unhandled variant type: " << value.type();
     }
 
-	if(type)
+    if (type)
         writeField(type, s, value, true);
 }
 
 //////////////////////////////////////////////////////////////////////////
 
-QAMQP::Frame::Content::Content():Base(ftHeader)
+QAMQP::Frame::Content::Content()
+    : Base(ftHeader)
 {
-
 }
 
-QAMQP::Frame::Content::Content( MethodClass methodClass ):Base(ftHeader)
+QAMQP::Frame::Content::Content(MethodClass methodClass)
+    : Base(ftHeader)
 {
     methodClass_ = methodClass;
 }
 
-QAMQP::Frame::Content::Content( QDataStream& raw ): Base(raw)
+QAMQP::Frame::Content::Content(QDataStream &raw)
+    : Base(raw)
 {
     readPayload(raw);
 }
@@ -541,58 +516,55 @@ qint32 QAMQP::Frame::Content::size() const
 
     qint16 prop_ = 0;
     foreach (int p, properties_.keys())
-	{
         prop_ |= p;
-	}
-
     out << prop_;
 
-	if(prop_ & cpContentType)
+    if (prop_ & cpContentType)
         writeField('s', out, properties_[cpContentType]);
 
-	if(prop_ & cpContentEncoding)
+    if (prop_ & cpContentEncoding)
         writeField('s', out, properties_[cpContentEncoding]);
 
-	if(prop_ & cpHeaders)
+    if (prop_ & cpHeaders)
         writeField('F', out, properties_[cpHeaders]);
 
-	if(prop_ & cpDeliveryMode)
+    if (prop_ & cpDeliveryMode)
         writeField('b', out, properties_[cpDeliveryMode]);
 
-	if(prop_ & cpPriority)
+    if (prop_ & cpPriority)
         writeField('b', out, properties_[cpPriority]);
 
-	if(prop_ & cpCorrelationId)
+    if (prop_ & cpCorrelationId)
         writeField('s', out, properties_[cpCorrelationId]);
 
-	if(prop_ & cpReplyTo)
+    if (prop_ & cpReplyTo)
         writeField('s', out, properties_[cpReplyTo]);
 
-	if(prop_ & cpExpiration)
+    if (prop_ & cpExpiration)
         writeField('s', out, properties_[cpExpiration]);
 
-	if(prop_ & cpMessageId)
+    if (prop_ & cpMessageId)
         writeField('s', out, properties_[cpMessageId]);
 
-	if(prop_ & cpTimestamp)
+    if (prop_ & cpTimestamp)
         writeField('T', out, properties_[cpTimestamp]);
 
-	if(prop_ & cpType)
+    if (prop_ & cpType)
         writeField('s', out, properties_[cpType]);
 
-	if(prop_ & cpUserId)
+    if (prop_ & cpUserId)
         writeField('s', out, properties_[cpUserId]);
 
-	if(prop_ & cpAppId)
+    if (prop_ & cpAppId)
         writeField('s', out, properties_[cpAppId]);
 
-	if(prop_ & cpClusterID)
+    if (prop_ & cpClusterID)
         writeField('s', out, properties_[cpClusterID]);
 
     return buffer_.size();
 }
 
-void QAMQP::Frame::Content::setBody( const QByteArray & data )
+void QAMQP::Frame::Content::setBody(const QByteArray &data)
 {
     body_ = data;
 }
@@ -602,68 +574,68 @@ QByteArray QAMQP::Frame::Content::body() const
     return body_;
 }
 
-void QAMQP::Frame::Content::setProperty( Property prop, const QVariant & value )
+void QAMQP::Frame::Content::setProperty(Property prop, const QVariant &value)
 {
     properties_[prop] = value;
 }
 
-QVariant QAMQP::Frame::Content::property( Property prop ) const
+QVariant QAMQP::Frame::Content::property(Property prop) const
 {
     return properties_.value(prop);
 }
 
-void QAMQP::Frame::Content::writePayload( QDataStream & out ) const
+void QAMQP::Frame::Content::writePayload(QDataStream &out) const
 {
     out.writeRawData(buffer_.data(), buffer_.size());
 }
 
-void QAMQP::Frame::Content::readPayload( QDataStream & in )
+void QAMQP::Frame::Content::readPayload(QDataStream &in)
 {
     in >> methodClass_;
     in.skipRawData(2); //weight
     in >> bodySize_;
     qint16 flags_ = 0;
     in >> flags_;
-	if(flags_ & cpContentType)
+    if (flags_ & cpContentType)
         properties_[cpContentType] = readField('s', in);
 
-	if(flags_ & cpContentEncoding)
+    if (flags_ & cpContentEncoding)
         properties_[cpContentEncoding] = readField('s', in);
 
-	if(flags_ & cpHeaders)
+    if (flags_ & cpHeaders)
         properties_[cpHeaders] = readField('F', in);
 
-	if(flags_ & cpDeliveryMode)
+    if (flags_ & cpDeliveryMode)
         properties_[cpDeliveryMode] = readField('b', in);
 
-	if(flags_ & cpPriority)
+    if (flags_ & cpPriority)
         properties_[cpPriority] = readField('b', in);
 
-	if(flags_ & cpCorrelationId)
+    if (flags_ & cpCorrelationId)
         properties_[cpCorrelationId] = readField('s', in);
 
-	if(flags_ & cpReplyTo)
+    if (flags_ & cpReplyTo)
         properties_[cpReplyTo] = readField('s', in);
 
-	if(flags_ & cpExpiration)
+    if (flags_ & cpExpiration)
         properties_[cpExpiration] = readField('s', in);
 
-	if(flags_ & cpMessageId)
+    if (flags_ & cpMessageId)
         properties_[cpMessageId] = readField('s', in);
 
-	if(flags_ & cpTimestamp)
+    if (flags_ & cpTimestamp)
         properties_[cpTimestamp] = readField('T', in);
 
-	if(flags_ & cpType)
+    if (flags_ & cpType)
         properties_[cpType] = readField('s', in);
 
-	if(flags_ & cpUserId)
+    if (flags_ & cpUserId)
         properties_[cpUserId] = readField('s', in);
 
-	if(flags_ & cpAppId)
+    if (flags_ & cpAppId)
         properties_[cpAppId] = readField('s', in);
 
-	if(flags_ & cpClusterID)
+    if (flags_ & cpClusterID)
         properties_[cpClusterID] = readField('s', in);
 }
 
@@ -673,15 +645,18 @@ qlonglong QAMQP::Frame::Content::bodySize() const
 }
 //////////////////////////////////////////////////////////////////////////
 
-ContentBody::ContentBody() : Base(ftBody)
+ContentBody::ContentBody()
-{}
+    : Base(ftBody)
+{
+}
 
-QAMQP::Frame::ContentBody::ContentBody( QDataStream& raw ): Base(raw)
+QAMQP::Frame::ContentBody::ContentBody(QDataStream &raw)
+    : Base(raw)
 {
     readPayload(raw);
 }
 
-void QAMQP::Frame::ContentBody::setBody( const QByteArray & data )
+void QAMQP::Frame::ContentBody::setBody(const QByteArray &data)
 {
     body_ = data;
 }
@@ -691,12 +666,12 @@ QByteArray QAMQP::Frame::ContentBody::body() const
     return body_;
 }
 
-void QAMQP::Frame::ContentBody::writePayload( QDataStream & out ) const
+void QAMQP::Frame::ContentBody::writePayload(QDataStream &out) const
 {
     out.writeRawData(body_.data(), body_.size());
 }
 
-void QAMQP::Frame::ContentBody::readPayload( QDataStream & in )
+void QAMQP::Frame::ContentBody::readPayload(QDataStream &in)
 {
     body_.resize(size_);
     in.readRawData(body_.data(), body_.size());
@@ -709,8 +684,10 @@ qint32 QAMQP::Frame::ContentBody::size() const
 
 //////////////////////////////////////////////////////////////////////////
 
-QAMQP::Frame::Heartbeat::Heartbeat() : Base(ftHeartbeat) {}
+QAMQP::Frame::Heartbeat::Heartbeat()
-
+    : Base(ftHeartbeat)
-void QAMQP::Frame::Heartbeat::readPayload(QDataStream & ) {}
+{
-void QAMQP::Frame::Heartbeat::writePayload(QDataStream & ) const {}
+}
 
+void QAMQP::Frame::Heartbeat::readPayload(QDataStream &) {}
+void QAMQP::Frame::Heartbeat::writePayload(QDataStream &) const {}

src/qamqp/amqp_frame.h

@@ -20,36 +20,36 @@
 #define AMQP_BASIC_APP_ID_FLAG (1 << 3)
 #define AMQP_BASIC_CLUSTER_ID_FLAG (1 << 2)
 
-/*!
+/**
-Library namespace
+ *  Library namespace
-@namespace QAMQP
+ *  @namespace QAMQP
-*/
+ */
 namespace QAMQP
 {
-	class QueuePrivate;
+
-	/*!
+class QueuePrivate;
-	Frame namespace
+
-	@namespace Frame
+namespace Frame
-	*/
+{
-	namespace Frame
-	{
     typedef quint16 channel_t;
-		/*!
+
-		@brief Header size in bytes
+    /*
+     * @brief Header size in bytes
      */
     static const qint64 HEADER_SIZE = 7;
-		/*!
+
-		@brief Frame end indicator size in bytes
+    /*
+     * @brief Frame end indicator size in bytes
     */
     static const qint64 FRAME_END_SIZE = 1;
 
-		/*!
+    /*
-		@brief Frame end marker
+     * @brief Frame end marker
      */
     static const quint8 FRAME_END = 0xCE;
 
-		/*!
+    /*
-		@brief Frame type
+     * @brief Frame type
      */
     enum Type
     {
@@ -59,17 +59,17 @@ namespace QAMQP
         ftHeartbeat = 8 /*!< Used define heartbeat frame */
     };
 
-		/*!
+    /*
-		@brief Frame method class
+     * @brief Frame method class
-		@enum MethodClass
+     * @enum MethodClass
      */
     enum MethodClass
     {
-			fcConnection = 10, /*!< Define class of methods related to connection  */
+        fcConnection = 10,  // Define class of methods related to connection
-			fcChannel = 20,  /*!< Define class of methods related to channel  */
+        fcChannel = 20,     // Define class of methods related to channel
-			fcExchange = 40, /*!< Define class of methods related to exchange  */
+        fcExchange = 40,    // Define class of methods related to exchange
-			fcQueue = 50, /*!< Define class of methods related to queue  */
+        fcQueue = 50,       // Define class of methods related to queue
-			fcBasic = 60, /*!< Define class of methods related to basic command  */
+        fcBasic = 60,       // Define class of methods related to basic command
         fcTx = 90,
     };
 
@@ -77,13 +77,12 @@ namespace QAMQP
     {
         qint8 scale;
         quint32 value;
-
     };
 
-		/*!
+    /*
-		@brief Definition implementation of TableField type
+     * @brief Definition implementation of TableField type
-		@detailed Define implementation TableField type in builtin Qt types. Key contains field name, value contains field data.
+     * @detailed Define implementation TableField type in builtin Qt types. Key contains field name, value contains field data.
-		It can by any type witch support serialization in AMQP types.
+     * It can by any type witch support serialization in AMQP types.
      */
     typedef QHash<QString, QVariant> TableField;
 
@@ -94,146 +93,146 @@ namespace QAMQP
     void writeField( qint8 valueType, QDataStream &s, const QVariant & value, bool withType = false );
     void print( const QAMQP::Frame::TableField & f );
 
-		/*!
+    /*
-		@brief Base class for any frames.
+     * @brief Base class for any frames.
-		@detailed Implement main methods for serialize and deserialize raw frame data.
+     * @detailed Implement main methods for serialize and deserialize raw frame data.
-		All frames start with a 7-octet header composed of a type field (octet), a channel field (short integer) and a
+     * All frames start with a 7-octet header composed of a type field (octet), a channel field (short integer) and a
-		size field (long integer):
+     * size field (long integer):
-		@code Frame struct
+     * @code Frame struct
-		  0	  1		 3	   7				  size+7	size+8
+     *     0	  1		 3	   7				  size+7	size+8
-		  +------+---------+---------+ +-------------+ +-----------+
+     *     +------+---------+---------+ +-------------+ +-----------+
-		  | type | channel | size	| | payload	 | | frame-end |
+     *     | type | channel | size	| | payload	 | | frame-end |
-		  +------+---------+---------+ +-------------+ +-----------+
+     *     +------+---------+---------+ +-------------+ +-----------+
-		@endcode
+     *   @endcode
-		octet short long 'size' octets octet
+     *   octet short long 'size' octets octet
      */
     class Base
     {
     public:
-			/*!
+        /*
-			Base class constructor.
+         * Base class constructor.
-			@detailed Construct frame class for sending.
+         * @detailed Construct frame class for sending.
-			@param type Define type of constructed frame.
+         * @param type Define type of constructed frame.
          */
         Base(Type type);
 
-			/*!
+        /*
-			Base class constructor.
+         * Base class constructor.
-			@detailed Construct frame class from received raw data.
+         * @detailed Construct frame class from received raw data.
-			@param raw Data stream for reading source data.
+         * @param raw Data stream for reading source data.
          */
         Base(QDataStream& raw);
 
-			/*!
+        /*
-			Base class virtual destructor
+         * Base class virtual destructor
          */
         virtual ~Base();
 
-			/*!
+        /*
-			Frame type
+         * Frame type
-			@detailed Return type of current frame.
+         * @detailed Return type of current frame.
          */
         Type type() const;
 
-			/*!
+        /*
-			Set number of associated channel.
+         * Set number of associated channel.
-			@param channel Number of channel.
+         * @param channel Number of channel.
-			@sa channel()
+         * @sa channel()
          */
         void setChannel(qint16 channel);
 
-			/*!
+        /*
-			Return number of associated channel.
+         * Return number of associated channel.
-			@sa setChannel()
+         * @sa setChannel()
          */
         qint16 channel() const;
 
-			/*!
+        /*
-			Return size of frame.
+         * Return size of frame.
          */
         virtual qint32 size() const;
 
-			/*!
+        /*
-			Output frame to stream.
+         * Output frame to stream.
-			@param stream Stream for serilize frame.
+         * @param stream Stream for serilize frame.
          */
-			void toStream(QDataStream & stream) const;
+        void toStream(QDataStream &stream) const;
 
     protected:
-			void writeHeader(QDataStream & stream) const;
+        void writeHeader(QDataStream &stream) const;
-			virtual void writePayload(QDataStream & stream) const;
+        virtual void writePayload(QDataStream &stream) const;
-			void writeEnd(QDataStream & stream) const;
+        void writeEnd(QDataStream &stream) const;
 
-			void readHeader(QDataStream & stream);
+        void readHeader(QDataStream &stream);
-			virtual void readPayload(QDataStream & stream);
+        virtual void readPayload(QDataStream &stream);
-			void readEnd(QDataStream & stream);
+        void readEnd(QDataStream &stream);
 
         qint32 size_;
+
     private:
         qint8 type_;
-
         qint16 channel_;
 
     };
 
-		/*!
+    /*
-		@brief Class for working with method frames.
+     * @brief Class for working with method frames.
-		@detailed Implement main methods for serialize and deserialize raw method frame data.
+     * @detailed Implement main methods for serialize and deserialize raw method frame data.
-		Method frame bodies consist of an invariant list of data fields, called "arguments". All method bodies start
+     * Method frame bodies consist of an invariant list of data fields, called "arguments". All method bodies start
-		with identifier numbers for the class and method:
+     * with identifier numbers for the class and method:
-		@code Frame struct
+     * @code Frame struct
-		0		   2		   4
+     * 0		   2		   4
-		+----------+-----------+-------------- - -
+     * +----------+-----------+-------------- - -
-		| class-id | method-id | arguments...
+     * | class-id | method-id | arguments...
-		+----------+-----------+-------------- - -
+     * +----------+-----------+-------------- - -
-			short	  short	...
+     *     short	  short	...
-		@endcode
+     * @endcode
      */
     class Method : public Base
     {
     public:
-			/*!
+        /*
-			Method class constructor.
+         * Method class constructor.
-			@detailed Construct frame class for sending.
+         * @detailed Construct frame class for sending.
          */
         Method();
 
-			/*!
+        /*
-			Method class constructor.
+         * Method class constructor.
-			@detailed Construct frame class for sending.
+         * @detailed Construct frame class for sending.
-			@param methodClass Define method class id of constructed frame.
+         * @param methodClass Define method class id of constructed frame.
-			@param id Define method id of constructed frame.
+         * @param id Define method id of constructed frame.
          */
         Method(MethodClass methodClass, qint16 id);
 
-			/*!
+        /*
-			Method class constructor.
+         * Method class constructor.
-			@detailed Construct frame class from received raw data.
+         * @detailed Construct frame class from received raw data.
-			@param raw Data stream for reading source data.
+         * @param raw Data stream for reading source data.
          */
-			Method(QDataStream& raw);
+        Method(QDataStream &raw);
 
-			/*!
+        /*
-			Method class type.
+         * Method class type.
          */
         MethodClass methodClass() const;
 
-			/*!
+        /*
-			Method id.
+         * Method id.
          */
         qint16 id() const;
         qint32 size() const;
 
-			/*!
+        /*
-			Set arguments for method.
+         * Set arguments for method.
-			@param data Serialized method arguments.
+         * @param data Serialized method arguments.
-			@sa arguments
+         * @sa arguments
          */
-			void setArguments(const QByteArray & data);
+        void setArguments(const QByteArray &data);
 
-			/*!
+        /*
-			Return arguments for method.
+         * Return arguments for method.
-			@sa setArguments
+         * @sa setArguments
          */
         QByteArray arguments() const;
 
@@ -243,49 +242,49 @@ namespace QAMQP
         short methodClass_;
         qint16 id_;
         QByteArray arguments_;
+
     };
 
 
-		/*!
+    /*
-		@brief Class for working with content frames.
+     * @brief Class for working with content frames.
-		@detailed Implement main methods for serialize and deserialize raw content frame data.
+     * @detailed Implement main methods for serialize and deserialize raw content frame data.
-		A content header payload has this format:
+     * A content header payload has this format:
-		@code Frame struct
+     * @code Frame struct
-		+----------+--------+-----------+----------------+------------- - -
+     * +----------+--------+-----------+----------------+------------- - -
-		| class-id | weight | body size | property flags | property list...
+     * | class-id | weight | body size | property flags | property list...
-		+----------+--------+-----------+----------------+------------- - -
+     * +----------+--------+-----------+----------------+------------- - -
-		   short	 short   long long		short		remainder...
+     *     short     short   long long       short          remainder...
-		@endcode
+     * @endcode
-		
+     *
-		| Property | Description |
+     * | Property | Description |
-		| ---------- | ----------- |
+     * | ---------- | ----------- |
-		|cpContentType | MIME content type |
+     * |cpContentType | MIME content type |
-		| ocpContentEncoding | MIME content encoding |
+     * | ocpContentEncoding | MIME content encoding |
-		| cpHeaders | message header field table |
+     * | cpHeaders | message header field table |
-		| cpDeliveryMode| nonpersistent (1) or persistent (2) |
+     * | cpDeliveryMode| nonpersistent (1) or persistent (2) |
-		| cpPriority | message priority, 0 to 9 |
+     * | cpPriority | message priority, 0 to 9 |
-		| cpCorrelationId | application correlation identifier |
+     * | cpCorrelationId | application correlation identifier |
-		| cpReplyTo | address to reply to |
+     * | cpReplyTo | address to reply to |
-		| cpExpiration | message expiration specification |
+     * | cpExpiration | message expiration specification |
-		| cpMessageId | application message identifier |
+     * | cpMessageId | application message identifier |
-		| cpTimestamp | message timestamp |
+     * | cpTimestamp | message timestamp |
-		| cpType | message type name |
+     * | cpType | message type name |
-		| cpUserId | creating user id |
+     * | cpUserId | creating user id |
-		| cpAppId | creating application id |
+     * | cpAppId | creating application id |
-		| cpClusterID| cluster ID | 	
+     * | cpClusterID| cluster ID |
-
+     *
-		Default property:
+     * Default property:
-		@sa setProperty
+     * @sa setProperty
-		@sa property
+     * @sa property
-
      */
     class Content : public Base
     {
         friend class QAMQP::QueuePrivate;
+
     public:
-
+        /*
-			/*! Default content frame property
+         *  Default content frame property
-			
          */
         enum Property
         {
@@ -304,55 +303,54 @@ namespace QAMQP
             cpAppId = AMQP_BASIC_APP_ID_FLAG,
             cpClusterID = AMQP_BASIC_CLUSTER_ID_FLAG
         };
-			Q_DECLARE_FLAGS(Properties, Property);
+        Q_DECLARE_FLAGS(Properties, Property)
 
-			/*!
+        /*
-			Content class constructor.
+         * Content class constructor.
-			@detailed Construct frame content header class for sending.
+         * @detailed Construct frame content header class for sending.
          */
         Content();
 
-			/*!
+        /*
-			Content class constructor.
+         * Content class constructor.
-			@detailed Construct frame content header class for sending.
+         * @detailed Construct frame content header class for sending.
-			@param methodClass Define method class id of constructed frame.
+         * @param methodClass Define method class id of constructed frame.
          */
         Content(MethodClass methodClass);
 
-			/*!
+        /*
-			Content class constructor.
+         * Content class constructor.
-			@detailed Construct frame content header class for sending.
+         * @detailed Construct frame content header class for sending.
-			@param raw Data stream for reading source data.
+         * @param raw Data stream for reading source data.
          */
-			Content(QDataStream& raw);
+        Content(QDataStream &raw);
 
-			/*!
+        /*
-			Method class type.
+         * Method class type.
          */
         MethodClass methodClass() const;
         qint32 size() const;
 
-			/*!
+        /*
-			Set default content header property
+         * Set default content header property
-			@param prop Any default content header property
+         * @param prop Any default content header property
-			@param value Associated data
+         * @param value Associated data
          */
-			void setProperty(Property prop, const QVariant & value);
+        void setProperty(Property prop, const QVariant &value);
 
-			/*!
+        /*
-			Return associated with property value
+         * Return associated with property value
-			@param prop Any default content header property
+         * @param prop Any default content header property
          */
         QVariant property(Property prop) const;
 
-	
+        void setBody(const QByteArray &data);
-			void setBody(const QByteArray & data);
         QByteArray body() const;
         qlonglong bodySize() const;
 
     protected:
-			void writePayload(QDataStream & stream) const;
+        void writePayload(QDataStream &stream) const;
-			void readPayload(QDataStream & stream);
+        void readPayload(QDataStream &stream);
         short methodClass_;
         qint16 id_;
         QByteArray body_;
@@ -365,40 +363,42 @@ namespace QAMQP
     {
     public:
         ContentBody();
-			ContentBody(QDataStream& raw);
+        ContentBody(QDataStream &raw);
-			void setBody(const QByteArray & data);
+
+        void setBody(const QByteArray &data);
         QByteArray body() const;
+
         qint32 size() const;
     protected:
-			void writePayload(QDataStream & stream) const;
+        void writePayload(QDataStream &stream) const;
-			void readPayload(QDataStream & stream);
+        void readPayload(QDataStream &stream);
 
     private:
         QByteArray body_;
     };
 
-		/*!
+    /*
-		@brief Class for working with heartbeat frames.
+     * @brief Class for working with heartbeat frames.
-		@detailed Implement frame for heartbeat send.		
+     * @detailed Implement frame for heartbeat send.
      */
     class Heartbeat : public Base
     {
     public:
-			/*!
+        /*
-			Heartbeat class constructor.
+         * Heartbeat class constructor.
-			@detailed Construct frame class for sending.
+         * @detailed Construct frame class for sending.
          */
         Heartbeat();
 
     protected:
-			void writePayload(QDataStream & stream) const;
+        void writePayload(QDataStream &stream) const;
-			void readPayload(QDataStream & stream);
+        void readPayload(QDataStream &stream);
     };
 
     class MethodHandler
     {
     public:
-			virtual void _q_method(const QAMQP::Frame::Method & frame) = 0;
+        virtual void _q_method(const QAMQP::Frame::Method &frame) = 0;
     };
 
     class ContentHandler
@@ -412,10 +412,10 @@ namespace QAMQP
     public:
         virtual void _q_body(const QAMQP::Frame::ContentBody & frame) = 0;
     };
-	}
+}
 }
 
-Q_DECLARE_METATYPE(QAMQP::Frame::decimal);
+Q_DECLARE_METATYPE(QAMQP::Frame::decimal)
-Q_DECLARE_METATYPE(QAMQP::Frame::TableField);
+Q_DECLARE_METATYPE(QAMQP::Frame::TableField)
 
 #endif // amqp_frame_h__

src/qamqp/amqp_global.h

@@ -1,8 +1,6 @@
 #ifndef qamqp_global_h__
 #define qamqp_global_h__
 
-#include <QtCore/qglobal.h>
-
 #define QAMQP_P_INCLUDE
 #define AMQPSCHEME "amqp"
 #define AMQPSSCHEME "amqps"
@@ -15,23 +13,6 @@
 
 #define QAMQP_VERSION "0.2.0"
 
-
-
 #define AMQP_CONNECTION_FORCED 320
 
-#define P_DECLARE_PRIVATE(Class) \
-	friend class Class##Private; \
-	inline Class##Private* pd_func() { return reinterpret_cast<Class##Private *>(this->pd_ptr); } \
-	inline const Class##Private* pd_func() const { return reinterpret_cast<const Class##Private *>(this->pd_ptr); } 	
-	
-
-#define P_DECLARE_PUBLIC(Class) \
-	inline Class* pq_func() { return static_cast<Class *>(this->pq_ptr); } \
-	inline const Class* pq_func() const { return static_cast<const Class *>(this->pq_ptr); } \
-	friend class Class; 
-
-
-#define P_D(Class) Class##Private * const d = this->pd_func()
-#define P_Q(Class) Class * const q = this->pq_func()
-
 #endif // qamqp_global_h__

src/qamqp/amqp_message.cpp

@@ -0,0 +1,15 @@
+#include "amqp_message.h"
+
+using namespace QAMQP;
+
+Message::Message()
+{
+    qDebug("Message create");
+    leftSize = 0;
+    deliveryTag = 0;
+}
+
+Message::~Message()
+{
+    qDebug("Message release");
+}

src/qamqp/amqp_message.h

@@ -5,20 +5,14 @@
 
 namespace QAMQP
 {
-	struct Message
+
-	{		
+struct Message
-		Message()
+{
-		{
+    Message();
-			qDebug("Message create");
+    virtual ~Message();
-			leftSize = 0;
+
-			deliveryTag = 0;
-		}
-		~Message()
-		{
-			qDebug("Message release");
-		}
     typedef QAMQP::Frame::Content::Property MessageProperty;
-		Q_DECLARE_FLAGS(MessageProperties, MessageProperty);
+    Q_DECLARE_FLAGS(MessageProperties, MessageProperty)
 
     qlonglong deliveryTag;
     QByteArray payload;
@@ -27,7 +21,8 @@ namespace QAMQP
     QString routeKey;
     QString exchangeName;
     int leftSize;
-	};
+};
+
+typedef QSharedPointer<QAMQP::Message> MessagePtr;
 
-	typedef QSharedPointer<QAMQP::Message> MessagePtr;
 }

src/qamqp/amqp_network.cpp

@@ -3,7 +3,8 @@
 #include <QTimer>
 #include <QtEndian>
 
-QAMQP::Network::Network( QObject * parent /*= 0*/ ):QObject(parent)
+QAMQP::Network::Network( QObject * parent)
+    : QObject(parent)
 {
     qRegisterMetaType<QAMQP::Frame::Method>("QAMQP::Frame::Method");
 
@@ -19,23 +20,22 @@ QAMQP::Network::~Network()
     disconnect();
 }
 
-void QAMQP::Network::connectTo( const QString & host, quint32 port )
+void QAMQP::Network::connectTo(const QString & host, quint16 port)
 {
-	if(!socket_)
+    if(!socket_) {
-	{
         qWarning("AMQP: Socket didn't create.");
         return;
     }
+
     QString h(host);
     int p(port);
     connect_ = true;
-	if(host.isEmpty())
+    if (host.isEmpty())
         h = lastHost_ ;
-	if(port == 0)
+    if (port == 0)
         p = lastPort_;
 
-	if (isSsl())
+    if (isSsl()) {
-	{
 #ifndef QT_NO_SSL
         static_cast<QSslSocket *>(socket_.data())->connectToHostEncrypted(h, p);
 #else
@@ -52,25 +52,20 @@ void QAMQP::Network::connectTo( const QString & host, quint32 port )
 void QAMQP::Network::disconnect()
 {
     connect_ = false;
-	if(socket_)
+    if (socket_)
         socket_->close();
 }
 
-void QAMQP::Network::error( QAbstractSocket::SocketError socketError )
+void QAMQP::Network::error(QAbstractSocket::SocketError socketError)
 {
-	if(timeOut_ == 0)
+    if (timeOut_ == 0) {
-	{
         timeOut_ = 1000;
     } else {
-		if(timeOut_ < 120000)
+        if (timeOut_ < 120000)
-		{
             timeOut_ *= 5;
     }
-	}
 
-	Q_UNUSED(socketError);
+    switch(socketError) {
-	switch(socketError)
-	{
     case QAbstractSocket::ConnectionRefusedError:
     case QAbstractSocket::RemoteHostClosedError:
     case QAbstractSocket::SocketTimeoutError:
@@ -84,90 +79,69 @@ void QAMQP::Network::error( QAbstractSocket::SocketError socketError )
         break;
     }
 
-	if( autoReconnect_ && connect_ )
+    if (autoReconnect_ && connect_)
-	{
         QTimer::singleShot(timeOut_, this, SLOT(connectTo()));
-	}
-
 }
 
 void QAMQP::Network::readyRead()
 {
-	while(socket_->bytesAvailable() >= Frame::HEADER_SIZE)
+    while (socket_->bytesAvailable() >= Frame::HEADER_SIZE) {
-	{
+        char *headerData = buffer_.data();
-		char* headerData = buffer_.data();
         socket_->peek(headerData, Frame::HEADER_SIZE);
         const quint32 payloadSize = qFromBigEndian<quint32>(*(quint32*)&headerData[3]);
         const qint64 readSize = Frame::HEADER_SIZE+payloadSize+Frame::FRAME_END_SIZE;
-		if(socket_->bytesAvailable() >= readSize)
+
-		{
+        if (socket_->bytesAvailable() >= readSize) {
             buffer_.resize(readSize);
             socket_->read(buffer_.data(), readSize);
             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 != QAMQP::Frame::FRAME_END)
-			{
                 qWarning() << "Wrong end frame";
-			}
 
             QDataStream streamB(&buffer_, QIODevice::ReadOnly);
-			switch(QAMQP::Frame::Type(type))
+            switch(QAMQP::Frame::Type(type)) {
-			{
             case QAMQP::Frame::ftMethod:
             {
                 QAMQP::Frame::Method frame(streamB);
-					if(frame.methodClass() == QAMQP::Frame::fcConnection)
+                if (frame.methodClass() == QAMQP::Frame::fcConnection) {
-					{
                     m_pMethodHandlerConnection->_q_method(frame);
-					}
+                } else {
-					else
-					{
                     foreach(Frame::MethodHandler* pMethodHandler, m_methodHandlersByChannel[frame.channel()])
-						{
                         pMethodHandler->_q_method(frame);
                 }
             }
-				}
                 break;
             case QAMQP::Frame::ftHeader:
             {
                 QAMQP::Frame::Content frame(streamB);
                 foreach(Frame::ContentHandler* pMethodHandler, m_contentHandlerByChannel[frame.channel()])
-					{
                     pMethodHandler->_q_content(frame);
             }
-				}
                 break;
             case QAMQP::Frame::ftBody:
             {
                 QAMQP::Frame::ContentBody frame(streamB);
                 foreach(Frame::ContentBodyHandler* pMethodHandler, m_bodyHandlersByChannel[frame.channel()])
-					{
                     pMethodHandler->_q_body(frame);
             }
-				}
                 break;
             case QAMQP::Frame::ftHeartbeat:
-				{
                 qDebug("AMQP: Heartbeat");
-				}
                 break;
             default:
                 qWarning() << "AMQP: Unknown frame type: " << type;
             }
-		}
+        } else {
-		else
-		{
             break;
         }
     }
 }
 
-void QAMQP::Network::sendFrame( const QAMQP::Frame::Base & frame )
+void QAMQP::Network::sendFrame(const QAMQP::Frame::Base &frame)
 {
-	if(socket_->state() == QAbstractSocket::ConnectedState)	
+    if (socket_->state() == QAbstractSocket::ConnectedState) {
-	{
         QDataStream stream(socket_);
         frame.toStream(stream);
     }
@@ -175,31 +149,29 @@ void QAMQP::Network::sendFrame( const QAMQP::Frame::Base & frame )
 
 bool QAMQP::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;
 }
 
-void QAMQP::Network::setSsl( bool value )
+void QAMQP::Network::setSsl(bool value)
 {
     initSocket(value);
 }
 
-void QAMQP::Network::initSocket( bool ssl /*= false*/ )
+void QAMQP::Network::initSocket(bool ssl)
 {
-	if(socket_)
+    if (socket_) {
-		delete socket_;
+        socket_->deleteLater();
+        socket_ = 0;
+    }
 
-	if(ssl)
+    if (ssl) {
-	{		
 #ifndef QT_NO_SSL
         socket_ = new QSslSocket(this);
         QSslSocket * ssl_= static_cast<QSslSocket*> (socket_.data());
         ssl_->setProtocol(QSsl::AnyProtocol);
         connect(socket_, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors()));
-
         connect(socket_, SIGNAL(connected()), this, SLOT(conectionReady()));
 #else
         qWarning("AMQP: You library has builded with QT_NO_SSL option.");
@@ -209,27 +181,26 @@ void QAMQP::Network::initSocket( bool ssl /*= false*/ )
         connect(socket_, SIGNAL(connected()), this, SLOT(conectionReady()));
     }
 
-	if(socket_)
+    if (socket_) {
-	{
         connect(socket_, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
         connect(socket_, SIGNAL(readyRead()), this, SLOT(readyRead()));
-		connect(socket_, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(error(QAbstractSocket::SocketError)));	
+        connect(socket_, SIGNAL(error(QAbstractSocket::SocketError)),
+                   this, SLOT(error(QAbstractSocket::SocketError)));
     }
 }
 
-
+void QAMQP::Network::sslErrors()
-void QAMQP::Network::sslErrors( )
 {
-	#ifndef QT_NO_SSL
+#ifndef QT_NO_SSL
     static_cast<QSslSocket*>(socket_.data())->ignoreSslErrors();
-	#endif
+#endif
 }
 
-
 void QAMQP::Network::conectionReady()
 {
-	emit connected();
+    Q_EMIT connected();
     timeOut_ = 0;
+
     char header_[8] = {'A', 'M', 'Q', 'P', 0,0,9,1};
     socket_->write(header_, 8);
 }
@@ -239,38 +210,34 @@ bool QAMQP::Network::autoReconnect() const
     return autoReconnect_;
 }
 
-void QAMQP::Network::setAutoReconnect( bool value )
+void QAMQP::Network::setAutoReconnect(bool value)
 {
     autoReconnect_ = value;
 }
 
 QAbstractSocket::SocketState QAMQP::Network::state() const
 {
-	if(socket_)
+    if (socket_)
-	{
         return socket_->state();
-	} else {
     return QAbstractSocket::UnconnectedState;
-	}
-	
 }
 
-void QAMQP::Network::setMethodHandlerConnection(Frame::MethodHandler* pMethodHandlerConnection)
+void QAMQP::Network::setMethodHandlerConnection(Frame::MethodHandler *pMethodHandlerConnection)
 {
     m_pMethodHandlerConnection = pMethodHandlerConnection;
 }
 
-void QAMQP::Network::addMethodHandlerForChannel(Channel channel, Frame::MethodHandler* pHandler)
+void QAMQP::Network::addMethodHandlerForChannel(Channel channel, Frame::MethodHandler *pHandler)
 {
     m_methodHandlersByChannel[channel].append(pHandler);
 }
 
-void QAMQP::Network::addContentHandlerForChannel(Channel channel, Frame::ContentHandler* pHandler)
+void QAMQP::Network::addContentHandlerForChannel(Channel channel, Frame::ContentHandler *pHandler)
 {
     m_contentHandlerByChannel[channel].append(pHandler);
 }
 
-void QAMQP::Network::addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler* pHandler)
+void QAMQP::Network::addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler *pHandler)
 {
     m_bodyHandlersByChannel[channel].append(pHandler);
 }

src/qamqp/amqp_network.h

@@ -4,7 +4,7 @@
 #include <QObject>
 #include <QTcpSocket>
 #ifndef QT_NO_SSL
-#include <QSslSocket>
+#   include <QSslSocket>
 #endif
 #include <QPointer>
 #include <QBuffer>
@@ -13,20 +13,18 @@
 
 namespace QAMQP
 {
-	class Network : public QObject
-	{
-		Q_OBJECT
-		Q_DISABLE_COPY(Network)
-	public:
-		typedef qint16 Channel;
 
-		Network(QObject * parent = 0);
+class Network : public QObject
+{
+    Q_OBJECT
+public:
+    Network(QObject *parent = 0);
     ~Network();
 
     void disconnect();
     void sendFrame();
 
-		void sendFrame(const QAMQP::Frame::Base & frame);
+    void sendFrame(const QAMQP::Frame::Base &frame);
 
     bool isSsl() const;
     void setSsl(bool value);
@@ -36,28 +34,28 @@ namespace QAMQP
 
     QAbstractSocket::SocketState state() const;
 
-		void setMethodHandlerConnection(Frame::MethodHandler* pMethodHandlerConnection);
+    typedef qint16 Channel;
-		void addMethodHandlerForChannel(Channel channel, Frame::MethodHandler* pHandler);
+    void setMethodHandlerConnection(Frame::MethodHandler *pMethodHandlerConnection);
-		void addContentHandlerForChannel(Channel channel, Frame::ContentHandler* pHandler);
+    void addMethodHandlerForChannel(Channel channel, Frame::MethodHandler *pHandler);
-		void addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler* pHandler);
+    void addContentHandlerForChannel(Channel channel, Frame::ContentHandler *pHandler);
+    void addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler *pHandler);
 
-	public slots:
+public slots:
-		void connectTo(const QString & host = QString(), quint32 port = 0);
+    void connectTo(const QString &host = QString(), quint16 port = 0);
-		void error( QAbstractSocket::SocketError socketError );
+    void error(QAbstractSocket::SocketError socketError);
 
-	signals:		
+Q_SIGNALS:
     void connected();
     void disconnected();
 
-	private slots:		
+private Q_SLOTS:
     void readyRead();
-
+    void sslErrors();
-		void sslErrors ( );
-
-
     void conectionReady();
 
-	private:
+private:
+    Q_DISABLE_COPY(Network)
+
     void initSocket(bool ssl = false);
     QPointer<QTcpSocket> socket_;
     QByteArray buffer_;
@@ -67,11 +65,12 @@ namespace QAMQP
     int timeOut_;
     bool connect_;
 
-		Frame::MethodHandler* m_pMethodHandlerConnection;
+    Frame::MethodHandler *m_pMethodHandlerConnection;
 
     QHash<Channel, QList<Frame::MethodHandler*> > m_methodHandlersByChannel;
     QHash<Channel, QList<Frame::ContentHandler*> > m_contentHandlerByChannel;
     QHash<Channel, QList<Frame::ContentBodyHandler*> > m_bodyHandlersByChannel;
-	};
+};
+
 }
 #endif // amqp_network_h__

src/qamqp/amqp_p.h

@@ -1,5 +1,5 @@
-#ifndef qamqp_amqp_p_h__
+#ifndef QAMQP_P_H
-#define qamqp_amqp_p_h__
+#define QAMQP_P_H
 
 #include <QSharedPointer>
 
@@ -10,26 +10,27 @@
 
 namespace QAMQP
 {
-	class ClientPrivate
-	{
-		P_DECLARE_PUBLIC(QAMQP::Client)
 
-	public:
+class Queue;
-		ClientPrivate(Client * q ) ;
+class Exchange;
+class ClientPrivate
+{
+public:
+    ClientPrivate(Client *q);
     ~ClientPrivate();
 
+    void init(QObject *parent);
+    void init(QObject *parent, const QUrl &connectionString);
 
-		void init(QObject * parent);
-		void init(QObject * parent, const QUrl & connectionString);
     void printConnect() const;
     void connect();
     void disconnect();
-		void parseCnnString( const QUrl & connectionString);
+    void parseConnectionString( const QUrl &connectionString);
     void sockConnect();
     void login();
     void setAuth(Authenticator* auth);
-		Exchange * createExchange(int channelNumber, const QString &name);
+    Exchange *createExchange(int channelNumber, const QString &name);
-		Queue * createQueue(int channelNumber, const QString &name);
+    Queue *createQueue(int channelNumber, const QString &name);
 
     quint32 port;
     QString host;
@@ -41,11 +42,10 @@ namespace QAMQP
 
     bool isSSl() const;
 
+    Client * const q_ptr;
+    Q_DECLARE_PUBLIC(QAMQP::Client)
 
-
+};
-		Client * const pq_ptr;
-
-	};
 
 }
 #endif // amqp_p_h__

src/qamqp/amqp_queue.cpp

@@ -10,34 +10,11 @@ using namespace QAMQP::Frame;
 #include <QDataStream>
 #include <QFile>
 
-namespace QAMQP
+Queue::Queue(int channelNumber, Client *parent)
+    : Channel(new QueuePrivate(this), parent)
 {
-	struct QueueExceptionCleaner
+    Q_D(QAMQP::Queue);
-	{
+    d->init(channelNumber, parent);
-		/* this cleans up when the constructor throws an exception */
-		static inline void cleanup(Queue *that, QueuePrivate *d)
-		{
-#ifdef QT_NO_EXCEPTIONS
-			Q_UNUSED(that);
-			Q_UNUSED(d);
-#else
-			Q_UNUSED(that);
-			Q_UNUSED(d);	
-#endif
-		}
-	};	
-
-}
-
-Queue::Queue( int channelNumber, Client * parent /*= 0*/ )
-: Channel(new QueuePrivate(this))
-{
-	QT_TRY {
-		pd_func()->init(channelNumber, parent);
-	} QT_CATCH(...) {
-		QueueExceptionCleaner::cleanup(this, pd_func());
-		QT_RETHROW;
-	}
 }
 
 Queue::~Queue()
@@ -47,169 +24,176 @@ Queue::~Queue()
 
 void Queue::onOpen()
 {
-	P_D(Queue);
+    Q_D(QAMQP::Queue);
-	if(d->delayedDeclare)
+    if (d->delayedDeclare)
-	{
         d->declare();
-	}
+
-	if(!d->delayedBindings.isEmpty())
+    if (!d->delayedBindings.isEmpty()) {
-	{
         typedef QPair<QString, QString> BindingPair;
         foreach(BindingPair binding, d->delayedBindings)
-		{
             d->bind(binding.first, binding.second);
-		}
         d->delayedBindings.clear();
     }
 }
 
 void Queue::onClose()
 {
-	pd_func()->remove(true, true);
+    Q_D(QAMQP::Queue);
+    d->remove(true, true);
 }
 
 Queue::QueueOptions Queue::option() const
 {
-	return pd_func()->options;
+    Q_D(const QAMQP::Queue);
+    return d->options;
 }
 
-void Queue::setNoAck( bool noAck )
+void Queue::setNoAck(bool noAck)
 {
-	pd_func()->noAck = noAck;
+    Q_D(QAMQP::Queue);
+    d->noAck = noAck;
 }
 
 bool Queue::noAck() const
 {
-	return pd_func()->noAck;
+    Q_D(const QAMQP::Queue);
+    return d->noAck;
 }
 
 void Queue::declare()
 {
-	P_D(Queue);
+    Q_D(QAMQP::Queue);
     declare(d->name, QueueOptions(Durable | AutoDelete));
 }
 
-void Queue::declare( const QString &name, QueueOptions options )
+void Queue::declare(const QString &name, QueueOptions options)
 {
-	P_D(Queue);
+    Q_D(QAMQP::Queue);
     setName(name);
     d->options = options;
     d->declare();
 }
 
-void Queue::remove( bool ifUnused /*= true*/, bool ifEmpty /*= true*/, bool noWait /*= true*/ )
+void Queue::remove(bool ifUnused, bool ifEmpty, bool noWait)
 {
-	pd_func()->remove(ifUnused, ifEmpty, noWait);
+    Q_D(QAMQP::Queue);
+    d->remove(ifUnused, ifEmpty, noWait);
 }
 
 void Queue::purge()
 {
-	pd_func()->purge();
+    Q_D(QAMQP::Queue);
+    d->purge();
 }
 
-void Queue::bind( const QString & exchangeName, const QString & key )
+void Queue::bind(const QString &exchangeName, const QString &key)
 {
-	pd_func()->bind(exchangeName, key);
+    Q_D(QAMQP::Queue);
+    d->bind(exchangeName, key);
 }
 
-void Queue::bind( Exchange * exchange, const QString & key )
+void Queue::bind(Exchange *exchange, const QString &key)
 {
-	if(exchange)
+    Q_D(QAMQP::Queue);
-		pd_func()->bind(exchange->name(), key);
+    if (exchange)
+        d->bind(exchange->name(), key);
 }
 
-void Queue::unbind( const QString & exchangeName, const QString & key )
+void Queue::unbind(const QString &exchangeName, const QString &key)
 {
-	pd_func()->unbind(exchangeName, key);
+    Q_D(QAMQP::Queue);
+    d->unbind(exchangeName, key);
 }
 
-void Queue::unbind( Exchange * exchange, const QString & key )
+void Queue::unbind(Exchange *exchange, const QString &key)
 {
-	if(exchange)
+    Q_D(QAMQP::Queue);
-		pd_func()->unbind(exchange->name(), key);
+    if (exchange)
+        d->unbind(exchange->name(), key);
 }
 
 void Queue::_q_content(const Content &frame)
 {
-	pd_func()->_q_content(frame);
+    Q_D(QAMQP::Queue);
+    d->_q_content(frame);
 }
 
 void Queue::_q_body(const ContentBody &frame)
 {
-	pd_func()->_q_body(frame);
+    Q_D(QAMQP::Queue);
+    d->_q_body(frame);
 }
 
 QAMQP::MessagePtr Queue::getMessage()
 {
-	return pd_func()->messages_.dequeue();
+    Q_D(QAMQP::Queue);
+    return d->messages_.dequeue();
 }
 
 bool Queue::hasMessage() const
 {
-
+    Q_D(const QAMQP::Queue);
-	if(pd_func()->messages_.isEmpty())
+    if (d->messages_.isEmpty())
-	{
         return false;
-	}
+
-	const MessagePtr &q = pd_func()->messages_.head();
+    const MessagePtr &q = d->messages_.head();
     return q->leftSize == 0;
 }
 
 void Queue::consume(ConsumeOptions options)
 {
-	pd_func()->consume(options);
+    Q_D(QAMQP::Queue);
+    d->consume(options);
 }
 
-void Queue::setConsumerTag( const QString &consumerTag )
+void Queue::setConsumerTag(const QString &consumerTag)
 {
-	pd_func()->consumerTag = consumerTag;
+    Q_D(QAMQP::Queue);
+    d->consumerTag = consumerTag;
 }
 
 QString Queue::consumerTag() const
 {
-	return pd_func()->consumerTag;
+    Q_D(const QAMQP::Queue);
+    return d->consumerTag;
 }
 
-
 void Queue::get()
 {
-	pd_func()->get();
+    Q_D(QAMQP::Queue);
+    d->get();
 }
 
-
+void Queue::ack(const MessagePtr &message)
-void Queue::ack( const MessagePtr & message )
 {
-	pd_func()->ack(message);
+    Q_D(QAMQP::Queue);
+    d->ack(message);
 }
 
 //////////////////////////////////////////////////////////////////////////
 
 
 QueuePrivate::QueuePrivate(Queue * q)
-	:ChannelPrivate(q)
+    : ChannelPrivate(q),
-	,  delayedDeclare(false)
+      delayedDeclare(false),
-	,  declared(false)
+      declared(false),
-	,  noAck(true)
+      noAck(true),
-	,  recievingMessage(false)
+      recievingMessage(false)
 {
-
 }
 
 QueuePrivate::~QueuePrivate()
 {
-	
 }
 
-
+bool QueuePrivate::_q_method(const QAMQP::Frame::Method &frame)
-bool QueuePrivate::_q_method( const QAMQP::Frame::Method & frame )
 {
-	if(ChannelPrivate::_q_method(frame))
+    Q_Q(QAMQP::Queue);
+    if (ChannelPrivate::_q_method(frame))
         return true;
 
-	if(frame.methodClass() == QAMQP::Frame::fcQueue)
+    if (frame.methodClass() == QAMQP::Frame::fcQueue) {
-	{
+        switch (frame.id()) {
-		switch(frame.id())
-		{
         case miDeclareOk:
             declareOk(frame);
             break;
@@ -228,13 +212,12 @@ bool QueuePrivate::_q_method( const QAMQP::Frame::Method & frame )
         default:
             break;
         }
+
         return true;
     }
 
-	if(frame.methodClass() == QAMQP::Frame::fcBasic)
+    if (frame.methodClass() == QAMQP::Frame::fcBasic) {
-	{
+        switch(frame.id()) {
-		switch(frame.id())
-		{
         case bmConsumeOk:
             consumeOk(frame);
             break;
@@ -245,7 +228,7 @@ bool QueuePrivate::_q_method( const QAMQP::Frame::Method & frame )
             getOk(frame);
             break;
         case bmGetEmpty:
-			QMetaObject::invokeMethod(pq_func(), "empty");
+            QMetaObject::invokeMethod(q, "empty");
             break;
         default:
             break;
@@ -253,14 +236,12 @@ bool QueuePrivate::_q_method( const QAMQP::Frame::Method & frame )
         return true;
     }
 
-
-
     return false;
 }
 
-void QueuePrivate::declareOk( const QAMQP::Frame::Method & frame )
+void QueuePrivate::declareOk(const QAMQP::Frame::Method &frame)
 {
-
+    Q_Q(QAMQP::Queue);
     qDebug() << "Declared queue: " << name;
     declared = true;
 
@@ -272,11 +253,12 @@ void QueuePrivate::declareOk( const QAMQP::Frame::Method & frame )
     stream >> messageCount >> consumerCount;
     qDebug("Message count %d\nConsumer count: %d", messageCount, consumerCount);
 
-	QMetaObject::invokeMethod(pq_func(), "declared");
+    QMetaObject::invokeMethod(q, "declared");
 }
 
-void QueuePrivate::deleteOk( const QAMQP::Frame::Method & frame )
+void QueuePrivate::deleteOk(const QAMQP::Frame::Method &frame)
 {
+    Q_Q(QAMQP::Queue);
     qDebug() << "Deleted or purged queue: " << name;
     declared = false;
 
@@ -285,26 +267,30 @@ void QueuePrivate::deleteOk( const QAMQP::Frame::Method & frame )
     qint32 messageCount = 0;
     stream >> messageCount;
     qDebug("Message count %d", messageCount);
-	QMetaObject::invokeMethod(pq_func(), "removed");
+    QMetaObject::invokeMethod(q, "removed");
 }
 
-
+void QueuePrivate::bindOk(const QAMQP::Frame::Method &frame)
-void QueuePrivate::bindOk( const QAMQP::Frame::Method &  )
 {
+    Q_UNUSED(frame)
+    Q_Q(QAMQP::Queue);
+
     qDebug() << "Binded to queue: " << name;
-	QMetaObject::invokeMethod(pq_func(), "binded", Q_ARG(bool, true));
+    QMetaObject::invokeMethod(q, "binded", Q_ARG(bool, true));
 }
 
-void QueuePrivate::unbindOk( const QAMQP::Frame::Method &  )
+void QueuePrivate::unbindOk(const QAMQP::Frame::Method &frame)
 {
+    Q_UNUSED(frame)
+    Q_Q(QAMQP::Queue);
+
     qDebug() << "Unbinded queue: " << name;
-	QMetaObject::invokeMethod(pq_func(), "binded", Q_ARG(bool, false));
+    QMetaObject::invokeMethod(q, "binded", Q_ARG(bool, false));
 }
 
 void QueuePrivate::declare()
 {
-	if(!opened)
+    if (!opened) {
-	{
         delayedDeclare = true;
         return;
     }
@@ -321,13 +307,11 @@ void QueuePrivate::declare()
     frame.setArguments(arguments_);
     sendFrame(frame);
     delayedDeclare = false;
-	
-
 }
 
-void QueuePrivate::remove( bool ifUnused /*= true*/, bool ifEmpty /*= true*/, bool noWait /*= true*/ )
+void QueuePrivate::remove(bool ifUnused, bool ifEmpty, bool noWait)
 {
-	if(!declared)
+    if (!declared)
         return;
 
     QAMQP::Frame::Method frame(QAMQP::Frame::fcQueue, miDelete);
@@ -348,15 +332,12 @@ void QueuePrivate::remove( bool ifUnused /*= true*/, bool ifEmpty /*= true*/, bo
 
     frame.setArguments(arguments_);
     sendFrame(frame);
-
 }
 
 void QueuePrivate::purge()
 {
-	if(!opened)
+    if (!opened)
-	{
         return;
-	}
 
     QAMQP::Frame::Method frame(QAMQP::Frame::fcQueue, miPurge);
     frame.setChannel(number);
@@ -367,13 +348,11 @@ void QueuePrivate::purge()
     out << qint8(0); // no-wait
     frame.setArguments(arguments_);
     sendFrame(frame);
-
 }
 
-void QueuePrivate::bind( const QString & exchangeName, const QString & key )
+void QueuePrivate::bind(const QString & exchangeName, const QString &key)
 {
-	if(!opened)
+    if (!opened) {
-	{
         delayedBindings.append(QPair<QString,QString>(exchangeName, key));
         return;
     }
@@ -391,15 +370,12 @@ void QueuePrivate::bind( const QString & exchangeName, const QString & key )
 
     frame.setArguments(arguments_);
     sendFrame(frame);
-
 }
 
-void QueuePrivate::unbind( const QString & exchangeName, const QString & key )
+void QueuePrivate::unbind(const QString &exchangeName, const QString &key)
 {
-	if(!opened)
+    if (!opened)
-	{
         return;
-	}
 
     QAMQP::Frame::Method frame(QAMQP::Frame::fcQueue, miUnbind);
     frame.setChannel(number);
@@ -413,16 +389,12 @@ void QueuePrivate::unbind( const QString & exchangeName, const QString & key )
 
     frame.setArguments(arguments_);
     sendFrame(frame);
-
 }
 
-
 void QueuePrivate::get()
 {
-	if(!opened)
+    if (!opened)
-	{
         return;
-	}
 
     QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, bmGet);
     frame.setChannel(number);
@@ -436,8 +408,7 @@ void QueuePrivate::get()
     sendFrame(frame);
 }
 
-
+void QueuePrivate::getOk(const QAMQP::Frame::Method &frame)
-void QueuePrivate::getOk( const QAMQP::Frame::Method & frame )
 {
     QByteArray data = frame.arguments();
     QDataStream in(&data, QIODevice::ReadOnly);
@@ -456,13 +427,10 @@ void QueuePrivate::getOk( const QAMQP::Frame::Method & frame )
     messages_.enqueue(newMessage);
 }
 
-
+void QueuePrivate::ack(const MessagePtr &Message)
-void QueuePrivate::ack( const MessagePtr & Message )
 {
-	if(!opened)
+    if (!opened)
-	{
         return;
-	}
 
     QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, bmAck);
     frame.setChannel(number);
@@ -475,12 +443,10 @@ void QueuePrivate::ack( const MessagePtr & Message )
     sendFrame(frame);
 }
 
-void QueuePrivate::consume( Queue::ConsumeOptions options )
+void QueuePrivate::consume(Queue::ConsumeOptions options)
 {
-	if(!opened)
+    if (!opened)
-	{
         return;
-	}
 
     QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, bmConsume);
     frame.setChannel(number);
@@ -494,13 +460,10 @@ void QueuePrivate::consume( Queue::ConsumeOptions options )
 
     frame.setArguments(arguments_);
     sendFrame(frame);
-
 }
 
-
+void QueuePrivate::consumeOk(const QAMQP::Frame::Method &frame)
-void QueuePrivate::consumeOk( const QAMQP::Frame::Method & frame )
 {
-
     qDebug() << "Consume ok: " << name;
     declared = false;
 
@@ -510,17 +473,13 @@ void QueuePrivate::consumeOk( const QAMQP::Frame::Method & frame )
     qDebug("Consumer tag = %s", qPrintable(consumerTag));
 }
 
-
+void QueuePrivate::deliver(const QAMQP::Frame::Method &frame)
-void QueuePrivate::deliver( const QAMQP::Frame::Method & frame )
 {
-
     QByteArray data = frame.arguments();
     QDataStream in(&data, QIODevice::ReadOnly);
     QString consumer_ = readField('s',in).toString();
-	if(consumer_ != consumerTag)
+    if (consumer_ != consumerTag)
-	{
         return;
-	}
 
     qlonglong deliveryTag = readField('L',in).toLongLong();
     bool redelivered = readField('t',in).toBool();
@@ -534,45 +493,42 @@ void QueuePrivate::deliver( const QAMQP::Frame::Method & frame )
     newMessage->exchangeName = exchangeName;
     newMessage->deliveryTag = deliveryTag;
     messages_.enqueue(newMessage);
-
 }
 
-void QueuePrivate::_q_content( const QAMQP::Frame::Content & frame )
+void QueuePrivate::_q_content(const QAMQP::Frame::Content &frame)
 {
     Q_ASSERT(frame.channel() == number);
-	if(frame.channel() != number)
+    if (frame.channel() != number)
         return;
-	if(messages_.isEmpty())
+
-	{
+    if (messages_.isEmpty()) {
         qErrnoWarning("Received content-header without method frame before");
         return;
     }
+
     MessagePtr &message = messages_.last();
     message->leftSize = frame.bodySize();
     QHash<int, QVariant>::ConstIterator i;
     for (i = frame.properties_.begin(); i != frame.properties_.end(); ++i)
-	{
         message->property[Message::MessageProperty(i.key())]= i.value();
-	}
 }
 
-void QueuePrivate::_q_body(const QAMQP::Frame::ContentBody & frame)
+void QueuePrivate::_q_body(const QAMQP::Frame::ContentBody &frame)
 {
+    Q_Q(QAMQP::Queue);
     Q_ASSERT(frame.channel() == number);
-	if(frame.channel() != number)
+    if (frame.channel() != number)
         return;
 
-	if(messages_.isEmpty())
+    if (messages_.isEmpty()) {
-	{
         qErrnoWarning("Received content-body without method frame before");
         return;
     }
+
     MessagePtr &message = messages_.last();
     message->payload.append(frame.body());
     message->leftSize -= frame.body().size();
 
-	if(message->leftSize == 0 && messages_.size() == 1)
+    if (message->leftSize == 0 && messages_.size() == 1)
-	{
+        Q_EMIT q->messageReceived(q);
-		emit pq_func()->messageReceived(pq_func());
-	}
 }

src/qamqp/amqp_queue.h

@@ -6,28 +6,20 @@
 
 namespace QAMQP
 {
-	class Client;
-	class ClientPrivate;
-	class Exchange;
-	class QueuePrivate;
-	class Queue : public Channel, public Frame::ContentHandler, public Frame::ContentBodyHandler
-	{
-		Q_OBJECT
-		Queue(int channelNumber = -1, Client * parent = 0);
 
-		Q_PROPERTY(QueueOptions option READ option );
+class Client;
+class ClientPrivate;
+class Exchange;
+class QueuePrivate;
+class Queue : public Channel, public Frame::ContentHandler, public Frame::ContentBodyHandler
+{
+    Q_OBJECT
+    Q_ENUMS(QueueOptions)
+    Q_PROPERTY(QueueOptions option READ option)
     Q_PROPERTY(QString consumerTag READ consumerTag WRITE setConsumerTag)
     Q_PROPERTY(bool noAck READ noAck WRITE setNoAck)
 
-		P_DECLARE_PRIVATE(QAMQP::Queue)
+public:
-		Q_DISABLE_COPY(Queue);	
-		friend class ClientPrivate;
-
-	protected:
-		void onOpen();
-		void onClose();
-	
-	public:
     enum QueueOption {
         NoOptions = 0x0,
         Passive = 0x01,
@@ -47,7 +39,6 @@ namespace QAMQP
     Q_DECLARE_FLAGS(ConsumeOptions, ConsumeOption)
 
     ~Queue();
-
     QueueOptions option() const;
 
     void declare();
@@ -73,17 +64,30 @@ namespace QAMQP
     void setNoAck(bool noAck);
     bool noAck() const;
 
-	Q_SIGNALS:
+Q_SIGNALS:
     void declared();
     void binded(bool);
     void removed();
-		void messageReceived(QAMQP::Queue* pQueue);
+    void messageReceived(QAMQP::Queue *pQueue);
     void empty();
 
-	private:
+protected:
+    void onOpen();
+    void onClose();
+
+private:
+    Queue(int channelNumber = -1, Client * parent = 0);
+
     void _q_content(const QAMQP::Frame::Content & frame);
     void _q_body(const QAMQP::Frame::ContentBody & frame);
-	};
+
+    Q_DISABLE_COPY(Queue)
+    Q_DECLARE_PRIVATE(QAMQP::Queue)
+
+    friend class ClientPrivate;
+
+};
+
 }
 #ifdef QAMQP_P_INCLUDE
 # include "amqp_queue_p.h"

src/qamqp/amqp_queue_p.h

@@ -7,14 +7,13 @@
 
 namespace QAMQP
 {
-	using namespace QAMQP::Frame;
-	class QueuePrivate: public ChannelPrivate
-	{
-		P_DECLARE_PUBLIC(QAMQP::Queue)
-	public:
 
-		enum MethodId
+using namespace QAMQP::Frame;
-		{
+
+class QueuePrivate: public ChannelPrivate
+{
+public:
+    enum MethodId {
         METHOD_ID_ENUM(miDeclare, 10),
         METHOD_ID_ENUM(miBind, 20),
         METHOD_ID_ENUM(miUnbind, 50),
@@ -22,36 +21,36 @@ namespace QAMQP
         METHOD_ID_ENUM(miDelete, 40)
     };
 
-		QueuePrivate(Queue * q);
+    QueuePrivate(Queue *q);
     ~QueuePrivate();
 
     void declare();
     void remove(bool ifUnused = true, bool ifEmpty = true, bool noWait = true);
     void purge();
-		void bind(const QString & exchangeName, const QString & key);
+    void bind(const QString &exchangeName, const QString &key);
-		void unbind(const QString & exchangeName, const QString & key);
+    void unbind(const QString &exchangeName, const QString &key);
 
-		void declareOk(const QAMQP::Frame::Method & frame);
+    void declareOk(const QAMQP::Frame::Method &frame);
-		void deleteOk(const QAMQP::Frame::Method & frame);
+    void deleteOk(const QAMQP::Frame::Method &frame);
-		void bindOk(const QAMQP::Frame::Method & frame);
+    void bindOk(const QAMQP::Frame::Method &frame);
-		void unbindOk(const QAMQP::Frame::Method & frame);
+    void unbindOk(const QAMQP::Frame::Method &frame);
 
     /************************************************************************/
     /* CLASS BASIC METHODS                                                  */
     /************************************************************************/
 
     void consume(Queue::ConsumeOptions options);
-		void consumeOk(const QAMQP::Frame::Method & frame);		
+    void consumeOk(const QAMQP::Frame::Method &frame);
-		void deliver(const QAMQP::Frame::Method & frame);
+    void deliver(const QAMQP::Frame::Method &frame);
 
     void get();
-		void getOk(const QAMQP::Frame::Method & frame);
+    void getOk(const QAMQP::Frame::Method &frame);
-		void ack(const MessagePtr & Message);
+    void ack(const MessagePtr &Message);
 
     QString type;
     Queue::QueueOptions options;
 
-		bool _q_method(const QAMQP::Frame::Method & frame);
+    bool _q_method(const QAMQP::Frame::Method &frame);
 
     bool delayedDeclare;
     bool declared;
@@ -63,8 +62,12 @@ namespace QAMQP
 
     bool recievingMessage;
 
-		void _q_content(const QAMQP::Frame::Content & frame);
+    void _q_content(const QAMQP::Frame::Content &frame);
-		void _q_body(const QAMQP::Frame::ContentBody & frame);
+    void _q_body(const QAMQP::Frame::ContentBody &frame);
-	};	
+
+    Q_DECLARE_PUBLIC(QAMQP::Queue)
+
+};
+
 }
 #endif // amqp_queue_p_h__

src/qamqp/qamqp.pri

@@ -24,5 +24,6 @@ SOURCES += $$PWD/amqp.cpp \
            $$PWD/amqp_connection.cpp \
            $$PWD/amqp_exchange.cpp \
            $$PWD/amqp_frame.cpp \
+           $$PWD/amqp_message.cpp \
            $$PWD/amqp_network.cpp \
            $$PWD/amqp_queue.cpp \