diff --git a/src/amqp_channel_p.h b/src/amqp_channel_p.h
index 556dd9a..22997c3 100644
--- a/src/amqp_channel_p.h
+++ b/src/amqp_channel_p.h
@@ -25,8 +25,7 @@ public:
         csRunning
     };
 
-    enum BasicMethod
-    {
+    enum BasicMethod {
         METHOD_ID_ENUM(bmQos, 10),
         METHOD_ID_ENUM(bmConsume, 20),
         METHOD_ID_ENUM(bmCancel, 30),
@@ -54,18 +53,18 @@ public:
 
     //////////////////////////////////////////////////////////////////////////
 
-    void openOk(const QAMQP::Frame::Method &frame);
-    void flow(const QAMQP::Frame::Method &frame);
-    void flowOk(const QAMQP::Frame::Method &frame);
-    void close(const QAMQP::Frame::Method &frame);
-    void closeOk(const QAMQP::Frame::Method &frame);
+    void openOk(const Frame::Method &frame);
+    void flow(const Frame::Method &frame);
+    void flowOk(const Frame::Method &frame);
+    void close(const Frame::Method &frame);
+    void closeOk(const Frame::Method &frame);
 
-    virtual bool _q_method(const QAMQP::Frame::Method &frame);
+    virtual bool _q_method(const Frame::Method &frame);
     virtual void _q_disconnected();
     void _q_open();
 
     void setQOS(qint32 prefetchSize, quint16 prefetchCount);
-    void sendFrame(const QAMQP::Frame::Base &frame);
+    void sendFrame(const Frame::Base &frame);
 
     QPointer<Client> client_;
 
@@ -76,7 +75,7 @@ public:
     bool opened;
     bool needOpen;
 
-    Q_DECLARE_PUBLIC(QAMQP::Channel)
+    Q_DECLARE_PUBLIC(Channel)
     Channel * const q_ptr;
 };
 
diff --git a/src/amqp_client.cpp b/src/amqp_client.cpp
index 543cc57..2017146 100644
--- a/src/amqp_client.cpp
+++ b/src/amqp_client.cpp
@@ -26,13 +26,13 @@ ClientPrivate::~ClientPrivate()
 
 void ClientPrivate::init(QObject *parent)
 {
-    Q_Q(QAMQP::Client);
+    Q_Q(Client);
     q->setParent(parent);
     if (!network_)
-        network_ = new QAMQP::Network(q);
+        network_ = new Network(q);
 
     if (!connection_)
-        connection_ = new QAMQP::Connection(q);
+        connection_ = new Connection(q);
     network_->setMethodHandlerConnection(connection_);
 
     setAuth(new AMQPlainAuthenticator(QString::fromLatin1(AMQPLOGIN), QString::fromLatin1(AMQPPSWD)));
@@ -75,7 +75,7 @@ void ClientPrivate::connect()
 
 void ClientPrivate::parseConnectionString(const QUrl &connectionString)
 {
-    Q_Q(QAMQP::Client);
+    Q_Q(Client);
     if (connectionString.scheme() != AMQPSCHEME &&
         connectionString.scheme() != AMQPSSCHEME) {
         qDebug() << Q_FUNC_INFO << "invalid scheme: " << connectionString.scheme();
@@ -103,7 +103,7 @@ void ClientPrivate::login()
 
 Exchange *ClientPrivate::createExchange(int channelNumber, const QString &name)
 {
-    Q_Q(QAMQP::Client);
+    Q_Q(Client);
     Exchange * exchange_ = new Exchange(channelNumber, q);
 
     network_->addMethodHandlerForChannel(exchange_->channelNumber(), exchange_);
@@ -118,7 +118,7 @@ Exchange *ClientPrivate::createExchange(int channelNumber, const QString &name)
 
 Queue *ClientPrivate::createQueue(int channelNumber, const QString &name )
 {
-    Q_Q(QAMQP::Client);
+    Q_Q(Client);
     Queue *queue_ = new Queue(channelNumber, q);
 
     network_->addMethodHandlerForChannel(queue_->channelNumber(), queue_);
@@ -135,7 +135,7 @@ Queue *ClientPrivate::createQueue(int channelNumber, const QString &name )
 
 void ClientPrivate::disconnect()
 {
-    Q_Q(QAMQP::Client);
+    Q_Q(Client);
     if (network_->state() != QAbstractSocket::UnconnectedState) {
         network_->disconnect();
         connection_->d_func()->connected = false;
@@ -145,62 +145,62 @@ void ClientPrivate::disconnect()
 
 //////////////////////////////////////////////////////////////////////////
 
-QAMQP::Client::Client(QObject *parent)
+Client::Client(QObject *parent)
     : QObject(parent),
       d_ptr(new ClientPrivate(this))
 {
     d_ptr->init(parent);
 }
 
-QAMQP::Client::Client(const QUrl & connectionString, QObject * parent)
+Client::Client(const QUrl & connectionString, QObject * parent)
     : d_ptr(new ClientPrivate(this))
 {
     d_ptr->init(parent, connectionString);
 }
 
-QAMQP::Client::~Client()
+Client::~Client()
 {
 }
 
-quint16 QAMQP::Client::port() const
+quint16 Client::port() const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     return d->port;
 }
 
-void QAMQP::Client::setPort(quint16 port)
+void Client::setPort(quint16 port)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     d->port = port;
 }
 
-QString QAMQP::Client::host() const
+QString Client::host() const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     return d->host;
 }
 
-void QAMQP::Client::setHost( const QString & host )
+void Client::setHost( const QString & host )
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     d->host = host;
 }
 
-QString QAMQP::Client::virtualHost() const
+QString Client::virtualHost() const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     return d->virtualHost;
 }
 
-void QAMQP::Client::setVirtualHost(const QString &virtualHost)
+void Client::setVirtualHost(const QString &virtualHost)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     d->virtualHost = virtualHost;
 }
 
-QString QAMQP::Client::user() const
+QString Client::user() const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     const Authenticator * auth = d->auth_.data();
     if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
         const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth);
@@ -210,9 +210,9 @@ QString QAMQP::Client::user() const
     return QString();
 }
 
-void QAMQP::Client::setUser(const QString &user)
+void Client::setUser(const QString &user)
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     Authenticator * auth = d->auth_.data();
     if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
         AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth);
@@ -220,9 +220,9 @@ void QAMQP::Client::setUser(const QString &user)
     }
 }
 
-QString QAMQP::Client::password() const
+QString Client::password() const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     const Authenticator * auth = d->auth_.data();
     if (auth && auth->type() == "AMQPLAIN") {
         const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth);
@@ -232,9 +232,9 @@ QString QAMQP::Client::password() const
     return QString();
 }
 
-void QAMQP::Client::setPassword(const QString &password)
+void Client::setPassword(const QString &password)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     Authenticator *auth = d->auth_.data();
     if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
         AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth);
@@ -242,119 +242,119 @@ void QAMQP::Client::setPassword(const QString &password)
     }
 }
 
-void QAMQP::Client::printConnect() const
+void Client::printConnect() const
 {
 #ifdef _DEBUG
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     d->printConnect();
 #endif // _DEBUG
 }
 
-void QAMQP::Client::closeChannel()
+void Client::closeChannel()
 {
 }
 
-Exchange *QAMQP::Client::createExchange(int channelNumber)
+Exchange *Client::createExchange(int channelNumber)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     return d->createExchange(channelNumber, QString());
 }
 
-Exchange *QAMQP::Client::createExchange( const QString &name, int channelNumber )
+Exchange *Client::createExchange( const QString &name, int channelNumber )
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     return d->createExchange(channelNumber, name);
 }
 
-Queue *QAMQP::Client::createQueue(int channelNumber)
+Queue *Client::createQueue(int channelNumber)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     return d->createQueue(channelNumber, QString());
 }
 
-Queue *QAMQP::Client::createQueue( const QString &name, int channelNumber )
+Queue *Client::createQueue( const QString &name, int channelNumber )
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     return d->createQueue(channelNumber, name);
 }
 
-void QAMQP::Client::open()
+void Client::open()
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     return d->connect();
 }
 
-void QAMQP::Client::open(const QUrl &connectionString)
+void Client::open(const QUrl &connectionString)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     d->parseConnectionString(connectionString);
     open();
 }
 
-void QAMQP::Client::close()
+void Client::close()
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     return d->disconnect();
 }
 
-void QAMQP::Client::reopen()
+void Client::reopen()
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     d->disconnect();
     d->connect();
 }
 
-void QAMQP::Client::setAuth(Authenticator *auth)
+void Client::setAuth(Authenticator *auth)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     d->setAuth(auth);
 }
 
-Authenticator *QAMQP::Client::auth() const
+Authenticator *Client::auth() const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     return d->auth_.data();
 }
 
-bool QAMQP::Client::isSsl() const
+bool Client::isSsl() const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     return d->network_->isSsl();
 }
 
-void QAMQP::Client::setSsl(bool value)
+void Client::setSsl(bool value)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     d->network_->setSsl(value);
 }
 
-bool QAMQP::Client::autoReconnect() const
+bool Client::autoReconnect() const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     return d->network_->autoReconnect();
 }
 
-void QAMQP::Client::setAutoReconnect(bool value)
+void Client::setAutoReconnect(bool value)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     d->network_->setAutoReconnect(value);
 }
 
-bool QAMQP::Client::isConnected() const
+bool Client::isConnected() const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     return d->connection_->isConnected();
 }
 
-void QAMQP::Client::addCustomProperty(const QString &name, const QString &value)
+void Client::addCustomProperty(const QString &name, const QString &value)
 {
-    Q_D(QAMQP::Client);
+    Q_D(Client);
     return d->connection_->addCustomProperty(name, value);
 }
 
-QString QAMQP::Client::customProperty(const QString &name) const
+QString Client::customProperty(const QString &name) const
 {
-    Q_D(const QAMQP::Client);
+    Q_D(const Client);
     return d->connection_->customProperty(name);
 }
 
diff --git a/src/amqp_client.h b/src/amqp_client.h
index f9107d8..8094a9c 100644
--- a/src/amqp_client.h
+++ b/src/amqp_client.h
@@ -3,6 +3,7 @@
 
 #include <QObject>
 #include <QUrl>
+#include <QHostAddress>
 
 #include "amqp_global.h"
 
@@ -74,13 +75,13 @@ public:
 
     bool isConnected() const;
 
-signals:
+Q_SIGNALS:
     void connected();
     void disconnected();
 
 private:
     Q_DISABLE_COPY(Client)
-    Q_DECLARE_PRIVATE(QAMQP::Client)
+    Q_DECLARE_PRIVATE(Client)
     QScopedPointer<ClientPrivate> d_ptr;
 
     friend class ConnectionPrivate;
diff --git a/src/amqp_client_p.h b/src/amqp_client_p.h
index 6a33c60..6604736 100644
--- a/src/amqp_client_p.h
+++ b/src/amqp_client_p.h
@@ -35,14 +35,14 @@ public:
     QString host;
     QString virtualHost;
 
-    QPointer<QAMQP::Network> network_;
-    QPointer<QAMQP::Connection> connection_;
+    QPointer<Network> network_;
+    QPointer<Connection> connection_;
     QSharedPointer<Authenticator> auth_;
 
     bool isSSl() const;
 
     Client * const q_ptr;
-    Q_DECLARE_PUBLIC(QAMQP::Client)
+    Q_DECLARE_PUBLIC(Client)
 
 };
 
diff --git a/src/amqp_network.cpp b/src/amqp_network.cpp
index 7d8ccf9..ff004f9 100644
--- a/src/amqp_network.cpp
+++ b/src/amqp_network.cpp
@@ -3,10 +3,12 @@
 #include <QTimer>
 #include <QtEndian>
 
-QAMQP::Network::Network( QObject * parent)
+using namespace QAMQP;
+
+Network::Network( QObject * parent)
     : QObject(parent)
 {
-    qRegisterMetaType<QAMQP::Frame::Method>("QAMQP::Frame::Method");
+    qRegisterMetaType<Frame::Method>("QAMQP::Frame::Method");
 
     buffer_.reserve(Frame::HEADER_SIZE);
     timeOut_ = 1000;
@@ -15,12 +17,12 @@ QAMQP::Network::Network( QObject * parent)
     initSocket(false);
 }
 
-QAMQP::Network::~Network()
+Network::~Network()
 {
     disconnect();
 }
 
-void QAMQP::Network::connectTo(const QString & host, quint16 port)
+void Network::connectTo(const QString & host, quint16 port)
 {
     if(!socket_) {
         qWarning("AMQP: Socket didn't create.");
@@ -49,14 +51,14 @@ void QAMQP::Network::connectTo(const QString & host, quint16 port)
     lastPort_ = p;
 }
 
-void QAMQP::Network::disconnect()
+void Network::disconnect()
 {
     connect_ = false;
     if (socket_)
         socket_->close();
 }
 
-void QAMQP::Network::error(QAbstractSocket::SocketError socketError)
+void Network::error(QAbstractSocket::SocketError socketError)
 {
     if (timeOut_ == 0) {
         timeOut_ = 1000;
@@ -83,7 +85,7 @@ void QAMQP::Network::error(QAbstractSocket::SocketError socketError)
         QTimer::singleShot(timeOut_, this, SLOT(connectTo()));
 }
 
-void QAMQP::Network::readyRead()
+void Network::readyRead()
 {
     while (socket_->bytesAvailable() >= Frame::HEADER_SIZE) {
         char *headerData = buffer_.data();
@@ -97,15 +99,15 @@ void QAMQP::Network::readyRead()
             const char* bufferData = buffer_.constData();
             const quint8 type = *(quint8*)&bufferData[0];
             const quint8 magic = *(quint8*)&bufferData[Frame::HEADER_SIZE+payloadSize];
-            if (magic != QAMQP::Frame::FRAME_END)
+            if (magic != Frame::FRAME_END)
                 qWarning() << "Wrong end frame";
 
             QDataStream streamB(&buffer_, QIODevice::ReadOnly);
-            switch(QAMQP::Frame::Type(type)) {
-            case QAMQP::Frame::ftMethod:
+            switch(Frame::Type(type)) {
+            case Frame::ftMethod:
             {
-                QAMQP::Frame::Method frame(streamB);
-                if (frame.methodClass() == QAMQP::Frame::fcConnection) {
+                Frame::Method frame(streamB);
+                if (frame.methodClass() == Frame::fcConnection) {
                     m_pMethodHandlerConnection->_q_method(frame);
                 } else {
                     foreach(Frame::MethodHandler* pMethodHandler, m_methodHandlersByChannel[frame.channel()])
@@ -113,21 +115,21 @@ void QAMQP::Network::readyRead()
                 }
             }
                 break;
-            case QAMQP::Frame::ftHeader:
+            case Frame::ftHeader:
             {
-                QAMQP::Frame::Content frame(streamB);
+                Frame::Content frame(streamB);
                 foreach(Frame::ContentHandler* pMethodHandler, m_contentHandlerByChannel[frame.channel()])
                     pMethodHandler->_q_content(frame);
             }
                 break;
-            case QAMQP::Frame::ftBody:
+            case Frame::ftBody:
             {
-                QAMQP::Frame::ContentBody frame(streamB);
+                Frame::ContentBody frame(streamB);
                 foreach(Frame::ContentBodyHandler* pMethodHandler, m_bodyHandlersByChannel[frame.channel()])
                     pMethodHandler->_q_body(frame);
             }
                 break;
-            case QAMQP::Frame::ftHeartbeat:
+            case Frame::ftHeartbeat:
                 qDebug("AMQP: Heartbeat");
                 break;
             default:
@@ -139,7 +141,7 @@ void QAMQP::Network::readyRead()
     }
 }
 
-void QAMQP::Network::sendFrame(const QAMQP::Frame::Base &frame)
+void Network::sendFrame(const Frame::Base &frame)
 {
     if (socket_->state() == QAbstractSocket::ConnectedState) {
         QDataStream stream(socket_);
@@ -147,19 +149,19 @@ void QAMQP::Network::sendFrame(const QAMQP::Frame::Base &frame)
     }
 }
 
-bool QAMQP::Network::isSsl() const
+bool Network::isSsl() const
 {
     if (socket_)
         return QString(socket_->metaObject()->className()).compare("QSslSocket", Qt::CaseInsensitive) == 0;
     return false;
 }
 
-void QAMQP::Network::setSsl(bool value)
+void Network::setSsl(bool value)
 {
     initSocket(value);
 }
 
-void QAMQP::Network::initSocket(bool ssl)
+void Network::initSocket(bool ssl)
 {
     if (socket_) {
         socket_->deleteLater();
@@ -189,14 +191,14 @@ void QAMQP::Network::initSocket(bool ssl)
     }
 }
 
-void QAMQP::Network::sslErrors()
+void Network::sslErrors()
 {
 #ifndef QT_NO_SSL
     static_cast<QSslSocket*>(socket_.data())->ignoreSslErrors();
 #endif
 }
 
-void QAMQP::Network::conectionReady()
+void Network::conectionReady()
 {
     Q_EMIT connected();
     timeOut_ = 0;
@@ -205,39 +207,39 @@ void QAMQP::Network::conectionReady()
     socket_->write(header_, 8);
 }
 
-bool QAMQP::Network::autoReconnect() const
+bool Network::autoReconnect() const
 {
     return autoReconnect_;
 }
 
-void QAMQP::Network::setAutoReconnect(bool value)
+void Network::setAutoReconnect(bool value)
 {
     autoReconnect_ = value;
 }
 
-QAbstractSocket::SocketState QAMQP::Network::state() const
+QAbstractSocket::SocketState Network::state() const
 {
     if (socket_)
         return socket_->state();
     return QAbstractSocket::UnconnectedState;
 }
 
-void QAMQP::Network::setMethodHandlerConnection(Frame::MethodHandler *pMethodHandlerConnection)
+void Network::setMethodHandlerConnection(Frame::MethodHandler *pMethodHandlerConnection)
 {
     m_pMethodHandlerConnection = pMethodHandlerConnection;
 }
 
-void QAMQP::Network::addMethodHandlerForChannel(Channel channel, Frame::MethodHandler *pHandler)
+void Network::addMethodHandlerForChannel(Channel channel, Frame::MethodHandler *pHandler)
 {
     m_methodHandlersByChannel[channel].append(pHandler);
 }
 
-void QAMQP::Network::addContentHandlerForChannel(Channel channel, Frame::ContentHandler *pHandler)
+void Network::addContentHandlerForChannel(Channel channel, Frame::ContentHandler *pHandler)
 {
     m_contentHandlerByChannel[channel].append(pHandler);
 }
 
-void QAMQP::Network::addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler *pHandler)
+void Network::addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler *pHandler)
 {
     m_bodyHandlersByChannel[channel].append(pHandler);
 }
diff --git a/src/amqp_queue.h b/src/amqp_queue.h
index 0c46f9e..a09eea4 100644
--- a/src/amqp_queue.h
+++ b/src/amqp_queue.h
@@ -12,7 +12,9 @@ class Client;
 class ClientPrivate;
 class Exchange;
 class QueuePrivate;
-class QAMQP_EXPORT Queue : public Channel, public Frame::ContentHandler, public Frame::ContentBodyHandler
+class QAMQP_EXPORT Queue : public Channel,
+                           public Frame::ContentHandler,
+                           public Frame::ContentBodyHandler
 {
     Q_OBJECT
     Q_ENUMS(QueueOptions)